serialization
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 72
Faster Java Serialization 0.22
Faster Java Serializations goal of the project is to enable faster serialization by generating bytecodes on the fly. more>>
Faster Java Serializations goal of the project is to enable faster serialization by generating bytecodes on the fly to serialize objects.
When an object is serialized, its class is inspected and a class that implements the Serializer interface is generated. This class is tailor made to serialize the fields of the given objects class directly.
To serialize objects to a ByteBuffer, all you have to do is add jserial.jar to the classpath and use the SerializationContext class:
...
SerializationContext context = new SerializationContext();
ByteBuffer buffer = ByteBuffer.allocate(1024);
context.serialize(myObject, buffer);
...
Serializes myObject. Note that, in order to be serialized, objects must implement java.io.Serializable
To reconstruct the object, all you have to do is use the DeserializationContext class:
...
DeserializationContext context = new DeserializationContext();
MyObject reconstructedObject = (MyObject)context.deserialize(buffer);
...
Reads the reconstructedObject. In the meantime, the data in the ByteBuffer can easily be written to a file or sent through a network using Java NIO.
This project uses a modified version of Javassist-3.3 to perform code-generation on-the-fly.
Version restrictions:
- Custom serialization through java.io.Externalizable
- Custom serialization through writeObject, readObject, writeReplace, readResolve or any other special serialization method.
- Inner/Local/Anonymous class serialization.
- Serialization of non-static final fields, though no error will arise when serializing objects that have such fields.
<<lessWhen an object is serialized, its class is inspected and a class that implements the Serializer interface is generated. This class is tailor made to serialize the fields of the given objects class directly.
To serialize objects to a ByteBuffer, all you have to do is add jserial.jar to the classpath and use the SerializationContext class:
...
SerializationContext context = new SerializationContext();
ByteBuffer buffer = ByteBuffer.allocate(1024);
context.serialize(myObject, buffer);
...
Serializes myObject. Note that, in order to be serialized, objects must implement java.io.Serializable
To reconstruct the object, all you have to do is use the DeserializationContext class:
...
DeserializationContext context = new DeserializationContext();
MyObject reconstructedObject = (MyObject)context.deserialize(buffer);
...
Reads the reconstructedObject. In the meantime, the data in the ByteBuffer can easily be written to a file or sent through a network using Java NIO.
This project uses a modified version of Javassist-3.3 to perform code-generation on-the-fly.
Version restrictions:
- Custom serialization through java.io.Externalizable
- Custom serialization through writeObject, readObject, writeReplace, readResolve or any other special serialization method.
- Inner/Local/Anonymous class serialization.
- Serialization of non-static final fields, though no error will arise when serializing objects that have such fields.
Download (1.1MB)
Added: 2006-10-24 License: GPL (GNU General Public License) Price:
1097 downloads
Data::Serializer 0.41
Data::Serializer package contains modules that serialize data structures. more>>
Data::Serializer package contains modules that serialize data structures.
SYNOPSIS
use Data::Serializer;
$obj = Data::Serializer->new();
$obj = Data::Serializer->new(
serializer => Storable,
digester => MD5,
cipher => DES,
secret => my secret,
compress => 1,
);
$serialized = $obj->serialize({a => [1,2,3],b => 5});
$deserialized = $obj->deserialize($serialized);
print "$deserialized->{b}n";
Provides a unified interface to the various serializing modules currently available. Adds the functionality of both compression and encryption.
EXAMPLES
Please see Data::Serializer::Cookbook(3)
METHODS
new - constructor
$obj = Data::Serializer->new();
$obj = Data::Serializer->new(
serializer => Data::Dumper,
digester => SHA-256,
cipher => Blowfish,
secret => undef,
portable => 1,
compress => 0,
serializer_token => 1,
options => {},
);
new is the constructor object for Data::Serializer objects.
The default serializer is Data::Dumper
The default digester is SHA-256
The default cipher is Blowfish
The default secret is undef
The default portable is 1
The default encoding is hex
The default compress is 0
The default compressor is Compress::Zlib
The default serializer_token is 1
The default options is {} (pass nothing on to serializer)
serialize - serialize reference
$serialized = $obj->serialize({a => [1,2,3],b => 5});
Serializes the reference specified.
Will compress if compress is a true value.
Will encrypt if secret is defined.
deserialize - deserialize reference
$deserialized = $obj->deserialize($serialized);
Reverses the process of serialization and returns a copy of the original serialized reference.
freeze - synonym for serialize
$serialized = $obj->freeze({a => [1,2,3],b => 5});
thaw - synonym for deserialize
$deserialized = $obj->thaw($serialized);
raw_serialize - serialize reference in raw form
$serialized = $obj->raw_serialize({a => [1,2,3],b => 5});
This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)
raw_deserialize - deserialize reference in raw form
$deserialized = $obj->raw_deserialize($serialized);
This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)
secret - specify secret for use with encryption
$obj->secret(mysecret);
Changes setting of secret for the Data::Serializer object. Can also be set in the constructor. If specified than the object will utilize encryption.
portable - encodes/decodes serialized data
Uses encoding method to ascii armor serialized data
Aids in the portability of serialized data.
compress - compression of data
Compresses serialized data. Default is not to use it. Will compress if set to a true value $obj->compress(1);
serializer - change the serializer
Currently have 8 supported serializers: Storable, FreezeThaw, Data::Denter, Config::General, YAML, PHP::Serialization, XML::Dumper, and Data::Dumper.
Default is to use Data::Dumper.
Each serializer has its own caveats about usage especially when dealing with cyclical data structures or CODE references. Please see the appropriate documentation in those modules for further information.
cipher - change the cipher method
Utilizes Crypt::CBC and can support any cipher method that it supports.
digester - change digesting method
Uses Digest so can support any digesting method that it supports. Digesting function is used internally by the encryption routine as part of data verification.
compressor - changes compresing module
This method is included for possible future inclusion of alternate compression method Currently Compress::Zlib is the only supported compressor.
encoding - change encoding method
Encodes data structure in ascii friendly manner. Currently the only valid options are hex, or b64.
The b64 option uses Base64 encoding provided by MIME::Base64, but strips out newlines.
serializer_token - add usage hint to data
Data::Serializer prepends a token that identifies what was used to process its data. This is used internally to allow runtime determination of how to extract Serialized data. Disabling this feature is not recommended.
options - pass options through to underlying serializer
Currently is only supported by Config::General, and XML::Dumper.
my $obj = Data::Serializer->new(serializer => Config::General,
options => {
-LowerCaseNames => 1,
-UseApacheInclude => 1,
-MergeDuplicateBlocks => 1,
-AutoTrue => 1,
-InterPolateVars => 1
},
) or die "$!n";
or
my $obj = Data::Serializer->new(serializer => XML::Dumper,
options => { dtd => 1, }
) or die "$!n";
store - serialize data and write it to a file (or file handle)
$obj->store({a => [1,2,3],b => 5},$file, [$mode, $perm]);
or
$obj->store({a => [1,2,3],b => 5},$fh);
Serializes the reference specified using the serialize method and writes it out to the specified file or filehandle.
If a file path is specified you may specify an optional mode and permission as the next two arguments. See IO::File for examples.
Trips an exception if it is unable to write to the specified file.
retrieve - read data from file (or file handle) and return it after deserialization
my $ref = $obj->retrieve($file);
or
my $ref = $obj->retrieve($fh);
Reads first line of supplied file or filehandle and returns it deserialized.
<<lessSYNOPSIS
use Data::Serializer;
$obj = Data::Serializer->new();
$obj = Data::Serializer->new(
serializer => Storable,
digester => MD5,
cipher => DES,
secret => my secret,
compress => 1,
);
$serialized = $obj->serialize({a => [1,2,3],b => 5});
$deserialized = $obj->deserialize($serialized);
print "$deserialized->{b}n";
Provides a unified interface to the various serializing modules currently available. Adds the functionality of both compression and encryption.
EXAMPLES
Please see Data::Serializer::Cookbook(3)
METHODS
new - constructor
$obj = Data::Serializer->new();
$obj = Data::Serializer->new(
serializer => Data::Dumper,
digester => SHA-256,
cipher => Blowfish,
secret => undef,
portable => 1,
compress => 0,
serializer_token => 1,
options => {},
);
new is the constructor object for Data::Serializer objects.
The default serializer is Data::Dumper
The default digester is SHA-256
The default cipher is Blowfish
The default secret is undef
The default portable is 1
The default encoding is hex
The default compress is 0
The default compressor is Compress::Zlib
The default serializer_token is 1
The default options is {} (pass nothing on to serializer)
serialize - serialize reference
$serialized = $obj->serialize({a => [1,2,3],b => 5});
Serializes the reference specified.
Will compress if compress is a true value.
Will encrypt if secret is defined.
deserialize - deserialize reference
$deserialized = $obj->deserialize($serialized);
Reverses the process of serialization and returns a copy of the original serialized reference.
freeze - synonym for serialize
$serialized = $obj->freeze({a => [1,2,3],b => 5});
thaw - synonym for deserialize
$deserialized = $obj->thaw($serialized);
raw_serialize - serialize reference in raw form
$serialized = $obj->raw_serialize({a => [1,2,3],b => 5});
This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)
raw_deserialize - deserialize reference in raw form
$deserialized = $obj->raw_deserialize($serialized);
This is a straight pass through to the underlying serializer, nothing else is done. (no encoding, encryption, compression, etc)
secret - specify secret for use with encryption
$obj->secret(mysecret);
Changes setting of secret for the Data::Serializer object. Can also be set in the constructor. If specified than the object will utilize encryption.
portable - encodes/decodes serialized data
Uses encoding method to ascii armor serialized data
Aids in the portability of serialized data.
compress - compression of data
Compresses serialized data. Default is not to use it. Will compress if set to a true value $obj->compress(1);
serializer - change the serializer
Currently have 8 supported serializers: Storable, FreezeThaw, Data::Denter, Config::General, YAML, PHP::Serialization, XML::Dumper, and Data::Dumper.
Default is to use Data::Dumper.
Each serializer has its own caveats about usage especially when dealing with cyclical data structures or CODE references. Please see the appropriate documentation in those modules for further information.
cipher - change the cipher method
Utilizes Crypt::CBC and can support any cipher method that it supports.
digester - change digesting method
Uses Digest so can support any digesting method that it supports. Digesting function is used internally by the encryption routine as part of data verification.
compressor - changes compresing module
This method is included for possible future inclusion of alternate compression method Currently Compress::Zlib is the only supported compressor.
encoding - change encoding method
Encodes data structure in ascii friendly manner. Currently the only valid options are hex, or b64.
The b64 option uses Base64 encoding provided by MIME::Base64, but strips out newlines.
serializer_token - add usage hint to data
Data::Serializer prepends a token that identifies what was used to process its data. This is used internally to allow runtime determination of how to extract Serialized data. Disabling this feature is not recommended.
options - pass options through to underlying serializer
Currently is only supported by Config::General, and XML::Dumper.
my $obj = Data::Serializer->new(serializer => Config::General,
options => {
-LowerCaseNames => 1,
-UseApacheInclude => 1,
-MergeDuplicateBlocks => 1,
-AutoTrue => 1,
-InterPolateVars => 1
},
) or die "$!n";
or
my $obj = Data::Serializer->new(serializer => XML::Dumper,
options => { dtd => 1, }
) or die "$!n";
store - serialize data and write it to a file (or file handle)
$obj->store({a => [1,2,3],b => 5},$file, [$mode, $perm]);
or
$obj->store({a => [1,2,3],b => 5},$fh);
Serializes the reference specified using the serialize method and writes it out to the specified file or filehandle.
If a file path is specified you may specify an optional mode and permission as the next two arguments. See IO::File for examples.
Trips an exception if it is unable to write to the specified file.
retrieve - read data from file (or file handle) and return it after deserialization
my $ref = $obj->retrieve($file);
or
my $ref = $obj->retrieve($fh);
Reads first line of supplied file or filehandle and returns it deserialized.
Download (0.025MB)
Added: 2007-07-12 License: Perl Artistic License Price:
834 downloads
App::Serializer::Properties 0.965
App::Serializer::Properties is a Perl interface for serialization and deserialization. more>>
App::Serializer::Properties is a Perl interface for serialization and deserialization.
SYNOPSIS
use App;
$context = App->context();
$serializer = $context->service("Serializer"); # or ...
$serializer = $context->serializer();
$data = {
an => arbitrary,
collection => [ of, data, ],
of => {
arbitrary => depth,
},
};
$propdata = $serializer->serialize($data);
$data = $serializer->deserialize($propdata);
print $serializer->dump($data), "n";
<<lessSYNOPSIS
use App;
$context = App->context();
$serializer = $context->service("Serializer"); # or ...
$serializer = $context->serializer();
$data = {
an => arbitrary,
collection => [ of, data, ],
of => {
arbitrary => depth,
},
};
$propdata = $serializer->serialize($data);
$data = $serializer->deserialize($propdata);
print $serializer->dump($data), "n";
Download (0.12MB)
Added: 2007-06-21 License: Perl Artistic License Price:
856 downloads
SOAP::Lite 0.69
SOAP::Lite is a client and server side SOAP implementation. more>>
SOAP::Lite is a client and server side SOAP implementation.
SOAP::Lite is a collection of Perl modules which provides a simple and lightweight interface to the Simple Object Access Protocol (SOAP) both on client and server side.
Main features:
- Supports SOAP 1.1 spec.
- Interoperability tests with different implementations: Apache SOAP, Apache Axis, Frontier, Microsoft SOAP, Microsoft .NET, DevelopMentor, XMethods, 4s4c, Phalanx, PocketSOAP, Kafka, SQLData, Lucin (in Java, Perl, C++, Python, VB, COM, XSLT).
- Provides COM interface. Single dll (standalone [2.5MB] or minimal [32kB]). Works on Windows 9x/Me/NT/2K. Doesnt require ROPE or MSXML. Examples in VB, Excel/VBA, C#, ASP, JavaScript, PerlScript and Perl.
- Provides transparent compression support for HTTP transport.
- Provides mod_soap module. Make SOAP server with a few lines in .htaccess or .conf file.
- Includes XML::Parser::Lite (regexp-based XML parser) which runs instead of XML::Parser where Perl 5.6 runs (even on WinCE) with some limitations.
- Includes XMLRPC::Lite, implementation of XML-RPC protocol on client and server side. All transports and features of SOAP::Lite are available.
- Supports multipart/form-data MIME attachments.
- Supports circular linked lists and multiple references.
- Supports Map datatype (encoding of maps/hashes with arbitrary keys).
- Supports HTTPS protocol.
- Provides proxy support.
- Provides CGI/daemon/mod_perl/Apache::Registry server implementations.
- Provides TCP server implementation.
- Provides IO (STDIN/STDOUT/File) server implementation.
- Provides FTP client implementation.
- Supports single/multipart MIME attachment (parsing side only).
- Supports SMTP protocol.
- Provides POP3 server implementation.
- Supports M-POST and redirects in HTTP transport.
- Supports Basic/Digest server authentication.
- Works with CGI accelerators, like VelociGen and PerlEx.
- Supports UDDI interface on client side. See UDDI::Lite for details.
- Supports UDDI publishing API. Examples and documentation provided.
- Supports WSDL schema with stub and run-time access.
- Supports blessed object references.
- Supports arrays (both serialization and deserialization with autotyping).
- Supports custom serialization.
- Provides exception transport with custom exceptions
- Supports Base64 encoding.
- Supports XML entity encoding.
- Supports header attributes.
- Supports dynamic and static class/method binding.
- Supports objects-by-reference with simple garbage collection and activation.
- Provides shell for interactive SOAP sessions.
- Supports out parameters binding.
- Supports transparent SOAP calls with autodispatch feature.
- Provides easy services deployment. Put module in specified directory and itll be accessible.
- Has tests, examples and documentation to let you be up and running in no time.
<<lessSOAP::Lite is a collection of Perl modules which provides a simple and lightweight interface to the Simple Object Access Protocol (SOAP) both on client and server side.
Main features:
- Supports SOAP 1.1 spec.
- Interoperability tests with different implementations: Apache SOAP, Apache Axis, Frontier, Microsoft SOAP, Microsoft .NET, DevelopMentor, XMethods, 4s4c, Phalanx, PocketSOAP, Kafka, SQLData, Lucin (in Java, Perl, C++, Python, VB, COM, XSLT).
- Provides COM interface. Single dll (standalone [2.5MB] or minimal [32kB]). Works on Windows 9x/Me/NT/2K. Doesnt require ROPE or MSXML. Examples in VB, Excel/VBA, C#, ASP, JavaScript, PerlScript and Perl.
- Provides transparent compression support for HTTP transport.
- Provides mod_soap module. Make SOAP server with a few lines in .htaccess or .conf file.
- Includes XML::Parser::Lite (regexp-based XML parser) which runs instead of XML::Parser where Perl 5.6 runs (even on WinCE) with some limitations.
- Includes XMLRPC::Lite, implementation of XML-RPC protocol on client and server side. All transports and features of SOAP::Lite are available.
- Supports multipart/form-data MIME attachments.
- Supports circular linked lists and multiple references.
- Supports Map datatype (encoding of maps/hashes with arbitrary keys).
- Supports HTTPS protocol.
- Provides proxy support.
- Provides CGI/daemon/mod_perl/Apache::Registry server implementations.
- Provides TCP server implementation.
- Provides IO (STDIN/STDOUT/File) server implementation.
- Provides FTP client implementation.
- Supports single/multipart MIME attachment (parsing side only).
- Supports SMTP protocol.
- Provides POP3 server implementation.
- Supports M-POST and redirects in HTTP transport.
- Supports Basic/Digest server authentication.
- Works with CGI accelerators, like VelociGen and PerlEx.
- Supports UDDI interface on client side. See UDDI::Lite for details.
- Supports UDDI publishing API. Examples and documentation provided.
- Supports WSDL schema with stub and run-time access.
- Supports blessed object references.
- Supports arrays (both serialization and deserialization with autotyping).
- Supports custom serialization.
- Provides exception transport with custom exceptions
- Supports Base64 encoding.
- Supports XML entity encoding.
- Supports header attributes.
- Supports dynamic and static class/method binding.
- Supports objects-by-reference with simple garbage collection and activation.
- Provides shell for interactive SOAP sessions.
- Supports out parameters binding.
- Supports transparent SOAP calls with autodispatch feature.
- Provides easy services deployment. Put module in specified directory and itll be accessible.
- Has tests, examples and documentation to let you be up and running in no time.
Download (0.23MB)
Added: 2006-09-09 License: Perl Artistic License Price:
1146 downloads
Object::Relation::DataType 0.1.0
Object::Relation::DataType is a Perl module with complex data types for TKP. more>>
Object::Relation::DataType is a Perl module with complex data types for TKP.
The Object::Relation::DataType name space is set aside for the creation of complex data types for TKP. By "complex" I mean serializable objects, such as dates, durations, states, etc. It also is designed to create a distinction from simpler data types, which are defined in Object::Relation::Meta::DataTypes.
What creates the distinction? Well, first and foremost is that fact that it doesnt usually take much to create the simple data types, while the complex data types might need more code to handle serialization and deserialization, overloading, etc.
But another criterion is that, while the data types in Object::Relation::Meta::DataTypes are always loaded by TKP, since it uses them for its own classes, the complex data types in the Object::Relation::DataType name space tend to be loaded only as needed by the Object::Relation business classes that need them.
Okay, so its somewhat arbitrary, but you get the idea. The remainder of this document is dedicated to documenting how to add new data types to TKP.
<<lessThe Object::Relation::DataType name space is set aside for the creation of complex data types for TKP. By "complex" I mean serializable objects, such as dates, durations, states, etc. It also is designed to create a distinction from simpler data types, which are defined in Object::Relation::Meta::DataTypes.
What creates the distinction? Well, first and foremost is that fact that it doesnt usually take much to create the simple data types, while the complex data types might need more code to handle serialization and deserialization, overloading, etc.
But another criterion is that, while the data types in Object::Relation::Meta::DataTypes are always loaded by TKP, since it uses them for its own classes, the complex data types in the Object::Relation::DataType name space tend to be loaded only as needed by the Object::Relation business classes that need them.
Okay, so its somewhat arbitrary, but you get the idea. The remainder of this document is dedicated to documenting how to add new data types to TKP.
Download (0.23MB)
Added: 2006-09-18 License: Perl Artistic License Price:
1131 downloads
libt2n 0.3
libt2n (talk to neighbor) is a C++ library for inter-process communication (IPC) with an additional code generator. more>>
libt2n project is a C++ library for inter-process communication (IPC) with an additional code generator (libt2n-codegen).
Before inventing our own IPC library, we checked a lot of other IPC frameworks like CORBA, D-BUS and ICE. But they werent easy to use (you need many lines of code to export or use a method, let alone good error handling) and did not allow passing complex C++ objects like vectors, maps and your own classes. To get all this we had to develop our own framework.
Heres a list of goals we had in mind while developing:
- easy to use, mimimum of code-lines needed to export and use methods
- handles complex C++ structures like maps of vectors, etc.
- passes exceptions from the server back to the caller
- easy integration into autotools and pkg-config
Of course we had to limit the feature set, so libt2n currently has these restrictions:
C++ only
- Synchronous, blocking, no callbacks
- no server-side objects, just functions you can call
- no threads or multiple server processes for handling multiple requests at once
Communication between client and server is currently done using Unix domain sockets (named pipes) or TCP. But the library is designed transport-independent, so it can be expanded to shared memory or other mechanisms.
Serializing all the complex objects is done with Boost serialization.
<<lessBefore inventing our own IPC library, we checked a lot of other IPC frameworks like CORBA, D-BUS and ICE. But they werent easy to use (you need many lines of code to export or use a method, let alone good error handling) and did not allow passing complex C++ objects like vectors, maps and your own classes. To get all this we had to develop our own framework.
Heres a list of goals we had in mind while developing:
- easy to use, mimimum of code-lines needed to export and use methods
- handles complex C++ structures like maps of vectors, etc.
- passes exceptions from the server back to the caller
- easy integration into autotools and pkg-config
Of course we had to limit the feature set, so libt2n currently has these restrictions:
C++ only
- Synchronous, blocking, no callbacks
- no server-side objects, just functions you can call
- no threads or multiple server processes for handling multiple requests at once
Communication between client and server is currently done using Unix domain sockets (named pipes) or TCP. But the library is designed transport-independent, so it can be expanded to shared memory or other mechanisms.
Serializing all the complex objects is done with Boost serialization.
Download (0.88MB)
Added: 2007-05-08 License: LGPL (GNU Lesser General Public License) Price:
899 downloads
mfGraph Library 0.4.2
mfGraph is a graph rendering library for interactive applications. more>>
mfGraph is a graph rendering library for interactive applications. Written in C++ and Python, mfGraph parses GraphViz DOT and XDOT files and provides rendering and hit-testing facilities. Supports Microsoft Windows natively, GNU/Linux through wxPython.
Main features:
- An object model for manipulating graphs and their attributes
- As a serialization format, the GraphViz DOT language is used
- The DOT tool can be used to calculate the layout, then mfGraph is used to build a list of primitive drawing commands by interpreting the XDOT attributes
- For each platform, all that is needed are basic drawing functions (text, lines, ellipses, Bezier curves, and the like) to do the actual rendering
- Zooming and hit-testing are supported
Enhancements:
- Added Visual Studio 2005 project files (".vcproj", ".sln")
- Minor code fixes to resolve compiler errors and warnings in Visual Studio 2005
<<lessMain features:
- An object model for manipulating graphs and their attributes
- As a serialization format, the GraphViz DOT language is used
- The DOT tool can be used to calculate the layout, then mfGraph is used to build a list of primitive drawing commands by interpreting the XDOT attributes
- For each platform, all that is needed are basic drawing functions (text, lines, ellipses, Bezier curves, and the like) to do the actual rendering
- Zooming and hit-testing are supported
Enhancements:
- Added Visual Studio 2005 project files (".vcproj", ".sln")
- Minor code fixes to resolve compiler errors and warnings in Visual Studio 2005
Download (1.2MB)
Added: 2006-05-20 License: GPL (GNU General Public License) Price:
1253 downloads
Chaotic Domain 0.0.0pre2
Chaotic Domain project is a combination of all strategy games with a new look on steroids. more>>
Chaotic Domain project is a combination of all strategy games with a new look on steroids.
Chaotic Domain aims to revolutionize the RTS industry. Made up a team of "elite gamers" (not to mention great programmers and 3D modelers) were combining the greatest features we like in other strategy games, fixes for some of the "annoying" parts of those games, and many new ideas of our own.
With a full 3D galaxy that allows you to micro- or macro-manage and very customizable games, it should appeal to every user.
Enhancements:
- Galaxy client
- Galaxy server
- Brand new network protocol with custom-built serialization
- Generator for network protocol
- 3d engine
- Stone age tech tree
- Beginnings of the "simple client"
<<lessChaotic Domain aims to revolutionize the RTS industry. Made up a team of "elite gamers" (not to mention great programmers and 3D modelers) were combining the greatest features we like in other strategy games, fixes for some of the "annoying" parts of those games, and many new ideas of our own.
With a full 3D galaxy that allows you to micro- or macro-manage and very customizable games, it should appeal to every user.
Enhancements:
- Galaxy client
- Galaxy server
- Brand new network protocol with custom-built serialization
- Generator for network protocol
- 3d engine
- Stone age tech tree
- Beginnings of the "simple client"
Download (3.0MB)
Added: 2007-01-02 License: GPL (GNU General Public License) Price:
1030 downloads
CSer 0.0.1
CSer is a library for C++ serialization, also called persistence. more>>
CSer is a library for C++ serialization, also called persistence. This isnt quite a simple as you might think, since one object may be pointed to by multiple other objects.
How does it work?
Writing out integers and character strings is fairly straightforward. The trick is dealing with objects, and pointers to them. Serialization of these involves assigning a unique ID # to each object as it is written, and in keeping a lookup table that maps each object to its ID.
That way, when an object is encountered a second time (because something else is pointing to it), only its ID is written. And when the network is read back in, CSer knows to only recreate the object once, and to use its pointer when its ID is encountered thereafter.
How do I use it?
Sorry for the lack of documentation. For a quick start, see the test1.cc example included in the source. Here is a brief list of the steps you need to take (also listed in the README):
1. #include "CSer.h"
2. Derive from "Serializable".
3. Add a "CSER_DECLARE(Myclass);" in the public part of class MyClass.
4. Add a "CSER_REGISTER(Myclass);" in the .cc file for your class.
5. Add methods "void write(CSer_out&) and void read(CSer_in&) to your class.
NOTE: If an object instance is part of another object
(composition), then you must write/read the object itself before
writing/reading any pointers to it. See ClassC in test1.cc as
an example.
6. Your class must also have a constructor taking no arguments.
<<lessHow does it work?
Writing out integers and character strings is fairly straightforward. The trick is dealing with objects, and pointers to them. Serialization of these involves assigning a unique ID # to each object as it is written, and in keeping a lookup table that maps each object to its ID.
That way, when an object is encountered a second time (because something else is pointing to it), only its ID is written. And when the network is read back in, CSer knows to only recreate the object once, and to use its pointer when its ID is encountered thereafter.
How do I use it?
Sorry for the lack of documentation. For a quick start, see the test1.cc example included in the source. Here is a brief list of the steps you need to take (also listed in the README):
1. #include "CSer.h"
2. Derive from "Serializable".
3. Add a "CSER_DECLARE(Myclass);" in the public part of class MyClass.
4. Add a "CSER_REGISTER(Myclass);" in the .cc file for your class.
5. Add methods "void write(CSer_out&) and void read(CSer_in&) to your class.
NOTE: If an object instance is part of another object
(composition), then you must write/read the object itself before
writing/reading any pointers to it. See ClassC in test1.cc as
an example.
6. Your class must also have a constructor taking no arguments.
Download (0.11MB)
Added: 2006-08-16 License: LGPL (GNU Lesser General Public License) Price:
1165 downloads
Sajax 0.12
Sajax is a simple toolkit to expose functions in your PHP scripts as JavaScript stubs. more>>
Sajax is a simple toolkit to expose functions in your PHP scripts as JavaScript stubs. This can be called by the browser to do work on the server without refreshing the page.
It utilizes XMLHttpRequest to make the magic happen. This kind of technology, generally known as remote scripting or "Ajax," is becoming popular and is used extensively by Google (GMail, Google Suggests, Google Maps) and others to provide another level of interactivity within Web pages.
Enhancements:
- PHP: Many, many improvements to the serialization support and numerous bug fixes. ASP: Temporarily removed due to the security problems.
<<lessIt utilizes XMLHttpRequest to make the magic happen. This kind of technology, generally known as remote scripting or "Ajax," is becoming popular and is used extensively by Google (GMail, Google Suggests, Google Maps) and others to provide another level of interactivity within Web pages.
Enhancements:
- PHP: Many, many improvements to the serialization support and numerous bug fixes. ASP: Temporarily removed due to the security problems.
Download (0.016MB)
Added: 2006-01-31 License: BSD License Price:
1367 downloads
anextfs 0.2 Alpha
anextfs is a FUSE-based filesystem for serialization. more>>
anextfs is a FUSE-based filesystem for serialization. It enables serverside serialization and local file-caching.
<<less Download (0.030MB)
Added: 2007-08-17 License: LGPL (GNU Lesser General Public License) Price:
798 downloads
Simple XML Framework 1.4.2
Simple is an XML serialization framework for Java. more>>
Simple is an XML serialization framework for Java. Simple XML Framework goal is to provide an XML framework that enables rapid development of XML configuration and communication systems.
This framework aids the development of XML systems with minimal effort and reduced errors. The framework borrows ideas and concepts from existing XML tools such as C# XML serialization and other proprietary frameworks, and combines those ideas resulting in a simple yet extremely powerful tool for using and manipulating XML.
Simple framework with powerful capabilities
The framework used to provide XML serialization is simple to use and revolves around several annotations an a single persister object used to read and write objects to and from XML.
It requires absolutely no configuration
Unlike many of the XML frameworks for Java there are no mappings or configuration required to serialize objects regardless of its complexity. The XML schema is represented using field annotations.
Extremely rapid development with XML
Developing XML configuration and communication systems can be done much quicker that through the use of XML frameworks such as DOM, SAX, and even other frameworks such as Digester and XStream.
Converts to and from human editable XML
A primary goal for the framework is that the XML data used to deserialize a serialize objects is human readable. All XML elements and attributes take a simple structure that can be easily created with a text editor.
Enhancements:
- Concurrency and class loading improvements have been made in this release.
- The persister can now be used by multiple concurrent threads using any of the stock strategies.
- Class loading has been greatly improved so that it can be configured for use in a wide range of environments.
<<lessThis framework aids the development of XML systems with minimal effort and reduced errors. The framework borrows ideas and concepts from existing XML tools such as C# XML serialization and other proprietary frameworks, and combines those ideas resulting in a simple yet extremely powerful tool for using and manipulating XML.
Simple framework with powerful capabilities
The framework used to provide XML serialization is simple to use and revolves around several annotations an a single persister object used to read and write objects to and from XML.
It requires absolutely no configuration
Unlike many of the XML frameworks for Java there are no mappings or configuration required to serialize objects regardless of its complexity. The XML schema is represented using field annotations.
Extremely rapid development with XML
Developing XML configuration and communication systems can be done much quicker that through the use of XML frameworks such as DOM, SAX, and even other frameworks such as Digester and XStream.
Converts to and from human editable XML
A primary goal for the framework is that the XML data used to deserialize a serialize objects is human readable. All XML elements and attributes take a simple structure that can be easily created with a text editor.
Enhancements:
- Concurrency and class loading improvements have been made in this release.
- The persister can now be used by multiple concurrent threads using any of the stock strategies.
- Class loading has been greatly improved so that it can be configured for use in a wide range of environments.
Download (0.078MB)
Added: 2007-08-16 License: LGPL (GNU Lesser General Public License) Price:
805 downloads
Cell Electrophysiology Simulation Environment 1.4.6
Cell Electrophysiology Simulation Environment is a simulation environment for electrophysiology. more>>
Cell Electrophysiology Simulation Environment (CESE) is a comprehensive framework specifically designed to perform computational electrophysiological simulations, for example, simulations of cardiac myocyte electrical activity.
Cell Electrophysiology Simulation Environment is useful for simulations of action potentials, individual ionic currents, and changes in ionic concentrations.
CESE is a cross-platform program, it runs on any system that has Java runtime environment (JRE) version 1.4 or above. It was tested on Windows, Linux, Solaris, MacOS X, and AIX.
CESE users
CESE is an integrated environment for performing computational simulations using a variety of electrophysiological models.
At this stage CESE allows creation and execution of the single-cell models (containing both Hodgkin-Huxley (HH) and Markovian current formulations). Models of electrical activity of cardiac myocytes with source code are included in the CESE distribution. We hope to extend the number of available models, and add certain neuronal models in the future.
The main strength of CESE is in its uniformity ? a program interface remains the same for different types of models. You can easily switch between models and compare simulation outputs. Model parameters can be modified, selected for output and/or clamped in the same, standard way.
CESE extends the conventional electrophysiological meaning of the "voltage clamp". You can clamp virtually any model variable, including voltage (membrane potential), total or individual ionic currents, ionic concentrations, temperature, gating variables, etc. The clamping commands can be complex piece-wise functions, individually set for the model variable of interest. This opens endless possibilities for the exploration of complex model behavior.
CESE provides simple, but efficient data visualizations. Simulation results can be presented in the graphic and tabulated forms. Plots can be customized, and regions of interest zoomed.
Even though CESE was not designed to be a data analysis tool, you can generate current-voltage relationships (I-Vs) and calculate statistical parameters for a given signal within the program. You can export your data to ASCII, Axon Text File (ATF), and NetCDF formats to continue analysis in your favorite package.
CESE developers
CESE was created from the ground up to incorporate the best programming practices available to Java developers, both in terms of user interface consistency and code clarity and reuse. Wherever possible, CESE rely on available Java APIs (for example Java2D, JavaBeans, JAXP) to simplify the code.
Model creation requires a number of house-keeping functions to be coded ? these include ODE integrators, routines for handling model parameters, saving/restoring model state, visualizing simulation results, etc. CESE provides you with implementation for these routines, hence, you can concentrate on writing the code for concrete ionic current(s), and CESE will handle the rest.
CESE is not trying to create complicated programming frameworks on its own ? rather, it utilizes core Java APIs. For example, models are Java components conforming to the JavaBeans specification. We use XML to specify clamping commands, and Java object serialization to save/restore model parameters.
Enhancements:
- This release improves results printing, adds export to the scalable vector graphics (SVG) format, improves support for continuous simulations, and fixes many bugs in plot rendering and model switching.
<<lessCell Electrophysiology Simulation Environment is useful for simulations of action potentials, individual ionic currents, and changes in ionic concentrations.
CESE is a cross-platform program, it runs on any system that has Java runtime environment (JRE) version 1.4 or above. It was tested on Windows, Linux, Solaris, MacOS X, and AIX.
CESE users
CESE is an integrated environment for performing computational simulations using a variety of electrophysiological models.
At this stage CESE allows creation and execution of the single-cell models (containing both Hodgkin-Huxley (HH) and Markovian current formulations). Models of electrical activity of cardiac myocytes with source code are included in the CESE distribution. We hope to extend the number of available models, and add certain neuronal models in the future.
The main strength of CESE is in its uniformity ? a program interface remains the same for different types of models. You can easily switch between models and compare simulation outputs. Model parameters can be modified, selected for output and/or clamped in the same, standard way.
CESE extends the conventional electrophysiological meaning of the "voltage clamp". You can clamp virtually any model variable, including voltage (membrane potential), total or individual ionic currents, ionic concentrations, temperature, gating variables, etc. The clamping commands can be complex piece-wise functions, individually set for the model variable of interest. This opens endless possibilities for the exploration of complex model behavior.
CESE provides simple, but efficient data visualizations. Simulation results can be presented in the graphic and tabulated forms. Plots can be customized, and regions of interest zoomed.
Even though CESE was not designed to be a data analysis tool, you can generate current-voltage relationships (I-Vs) and calculate statistical parameters for a given signal within the program. You can export your data to ASCII, Axon Text File (ATF), and NetCDF formats to continue analysis in your favorite package.
CESE developers
CESE was created from the ground up to incorporate the best programming practices available to Java developers, both in terms of user interface consistency and code clarity and reuse. Wherever possible, CESE rely on available Java APIs (for example Java2D, JavaBeans, JAXP) to simplify the code.
Model creation requires a number of house-keeping functions to be coded ? these include ODE integrators, routines for handling model parameters, saving/restoring model state, visualizing simulation results, etc. CESE provides you with implementation for these routines, hence, you can concentrate on writing the code for concrete ionic current(s), and CESE will handle the rest.
CESE is not trying to create complicated programming frameworks on its own ? rather, it utilizes core Java APIs. For example, models are Java components conforming to the JavaBeans specification. We use XML to specify clamping commands, and Java object serialization to save/restore model parameters.
Enhancements:
- This release improves results printing, adds export to the scalable vector graphics (SVG) format, improves support for continuous simulations, and fixes many bugs in plot rendering and model switching.
Download (5.0MB)
Added: 2007-02-12 License: GPL (GNU General Public License) Price:
587 downloads
Json-lib 2.0
JSON (JavaScript Object Notation) is a lightweight data-interchange format. more>>
JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. Json-lib is easy for machines to parse and generate.
It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others.
These properties make JSON an ideal data-interchange language. This library is based on the work by Douglas Crockford in http://www.json.org/java , adding support for java arrays and object graphs. With this library it is possible to transform the following java structures to JSON: java beans, java arrays, collections, maps; composites of the 4 previous types.
The main driver for this library is to provide the means to transform data between a server and an AJAX enabled application.
Enhancements:
- This release includes major enhancements like custom serialization, Groovy/JRuby support, cycle detection. and better XML two-way serialization.
<<lessIt is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others.
These properties make JSON an ideal data-interchange language. This library is based on the work by Douglas Crockford in http://www.json.org/java , adding support for java arrays and object graphs. With this library it is possible to transform the following java structures to JSON: java beans, java arrays, collections, maps; composites of the 4 previous types.
The main driver for this library is to provide the means to transform data between a server and an AJAX enabled application.
Enhancements:
- This release includes major enhancements like custom serialization, Groovy/JRuby support, cycle detection. and better XML two-way serialization.
Download (MB)
Added: 2007-07-22 License: The Apache License 2.0 Price:
830 downloads
libxnm 0.1.1
libxnm project is a library for parsing and retrieving data from the XNM file format. more>>
libxnm project is a library for parsing and retrieving data from the XNM file format.
The prevailing meta-format used today for serialization is XML. XML was originally written as a markup language, and as such its original intent was to add additional information to free flowing text.
This is indeed what is needed in the context of text markup, e.g. for a web page or a word processor program. But using XML for general purpose object serialization generates very verbose serialization that are way larger than necessary.
Another shortcoming of XML is that there still is no support for binary objects. This again is partly based in its markup roots.
Main features:
- Recursively defined.
- Map to the scalar/table/hash structures of perl/python/ruby
- Not limited by preexisting language formats (JSON).
- Short, consise, visually appealing. Low signal to noise.
- No need to quote keys or one word values.
- Support binary data.
- Tables are enclosed by { } , arrays by [ ].
Examples of XNM
The following example shows a simple program configuration file:
fontsize: 16
fonts: { roman: Sans
italic: "Sans Italic"
bold: "Sans bold"
}
path: ["/usr/bin" "/bin" "/usr/local/bin"]
Here is another example copied from the wikipedia json page:
firstName: John
lastName: Smith
address: {
city: "New York, NY"
zipCode: 10021
streetAddress: "21 2nd Street"
}
phoneNumbers: [
"212 732-1234"
"646 123-4567"
]
The main (only) differences to JSON are:
Single words dont need quotes
Commas are not used between key/value pairs
Here is a third example translated from the gaim prefs file:
core => {
away => {
idle_reporting=>system
away_when_idle=>0
mins_before_way=>10
auto_reply=>awayidle
report_idle=>1
}
buddies => {}
contact => {
last_match => 0
offline_score => 2
away_score => 2
idle_score => 1
}
gaim => {
gtk=> {
browsers=> {
place=>F
command=>"xterm -e lynx %s"
browser=>firefox
new_window=>F
}
plugins => [
/usr/lib/gaim/gaimrc.so
/usr/lib/gaim/ssl-nss.so
/usr/lib/gaim/ssl.so
]
}
}
}
Note that the separater character used between keys and values is => combination like in perl.
<<lessThe prevailing meta-format used today for serialization is XML. XML was originally written as a markup language, and as such its original intent was to add additional information to free flowing text.
This is indeed what is needed in the context of text markup, e.g. for a web page or a word processor program. But using XML for general purpose object serialization generates very verbose serialization that are way larger than necessary.
Another shortcoming of XML is that there still is no support for binary objects. This again is partly based in its markup roots.
Main features:
- Recursively defined.
- Map to the scalar/table/hash structures of perl/python/ruby
- Not limited by preexisting language formats (JSON).
- Short, consise, visually appealing. Low signal to noise.
- No need to quote keys or one word values.
- Support binary data.
- Tables are enclosed by { } , arrays by [ ].
Examples of XNM
The following example shows a simple program configuration file:
fontsize: 16
fonts: { roman: Sans
italic: "Sans Italic"
bold: "Sans bold"
}
path: ["/usr/bin" "/bin" "/usr/local/bin"]
Here is another example copied from the wikipedia json page:
firstName: John
lastName: Smith
address: {
city: "New York, NY"
zipCode: 10021
streetAddress: "21 2nd Street"
}
phoneNumbers: [
"212 732-1234"
"646 123-4567"
]
The main (only) differences to JSON are:
Single words dont need quotes
Commas are not used between key/value pairs
Here is a third example translated from the gaim prefs file:
core => {
away => {
idle_reporting=>system
away_when_idle=>0
mins_before_way=>10
auto_reply=>awayidle
report_idle=>1
}
buddies => {}
contact => {
last_match => 0
offline_score => 2
away_score => 2
idle_score => 1
}
gaim => {
gtk=> {
browsers=> {
place=>F
command=>"xterm -e lynx %s"
browser=>firefox
new_window=>F
}
plugins => [
/usr/lib/gaim/gaimrc.so
/usr/lib/gaim/ssl-nss.so
/usr/lib/gaim/ssl.so
]
}
}
}
Note that the separater character used between keys and values is => combination like in perl.
Download (0.37MB)
Added: 2007-01-17 License: LGPL (GNU Lesser General Public License) Price:
1011 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 serialization 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
