The Security Annotation Framework (SAF) is an instance-level access control framework driven by Java 5 annotations. It can be easily integrated into Spring applications which primarily use the SAF to control access to their domain object instances. SAF security annotations define locations in the source code where the SAF shall perform permission checks at runtime. An annotation-driven approach to instance-level access control promotes the separation of an application’s security logic from its business logic. This significantly increases the testability and reusability of application components. It further allows the implementation of instance-level access control features into existing applications without modifying existing business logic.
GridGain is a computational grid framework. Its goal is to improve general performance of processing intensive applications by splitting and parallelizing the workload. In many cases GridGain is used to achieve better overall throughput, better scalability or availability of services.
Following picture illustrates the basic idea behind processing grids:
Appistry Enterprise Application Fabric (EAF) is a grid-based application platform that dramatically simplifies the development and deployment of highly scalable applications in Java, Spring, .NET or C++.
Unlike traditional application servers, Appistry EAF is built from the ground up for scalability. And unlike traditional grid computing, it's extremely easy to fabric-enable your applications.
With Appistry EAF, customers are able to quickly and inexpensively bring new capabilities to market, with the agility, reliability and scale demanded by their businesses.
This open source software project connects the world of java with TWAIN.TWAIN is an application programming interface standard used to access scanners & digital cameras ... .
This package was developed to scan an image in order to turn it into an *.sff file and then fax it.
How does it work ? What happens ?
1. On loading: jtwain.java loads it's C++ counter part, the library jtwain.dll.
2. jtwain.dll will load "TWAIN_32.DLL" and get a function pointer to the DSM (Data Source Manager) entry point (twain state 2).
3. If loading was successful jtwain.java creates a new thread that calls nstart in jtwain.cpp.
4. Due to the fact that twain is signalling events through the OS-dependent event queues, we need to set up an application window including it's wndProc callback function.
5. After that ninitLib will open the DSM (twain state 3). Now the DSM is ready to handle device specific requests.
6. The native thread is then entering the event loop and calling jtwain.cbhandleGetMessage whenever it receives an event.
7. The twain entry function must be called from within the native thread. In order to do that a command can be initiated from arbitrary java threads by calling ntrigger. This will cause the native thread to call jtwain.cbexecute.
Two commands can be triggered:
1. Select: The DSM will pop up a select dialog and the user can select a data source.
2. Acquire: The data source will pop up a user dialog that allows the user to set various settings and then either scan or cancel the request. Once an image has been acquired by the twain data source as a DIB (Device Independent Bitmap) a BufferedImage object will be created and the DIB data copied to this BufferedImage. The jtwain object informs the ScannerListeners of the new image.
A meta-programming approach to general data modeling.
Introduction
Meta-JB is a MetaClass/MetaObject layer providing generic access to model implementations, decoupling application logic from underlying implementation details, and allowing user interfaces (Swing, HTML, etc.) to be dynamically generated at runtime. By wrapping model implementations in MetaObject adapters, applications can interact with the model layer in a homogenous way.
Description
Meta-JB extends the Java Beans-based meta-programming concept to provide more generic access to object attributes and descriptions for any model object with an appropriate adapter. The descriptions of a class's properties (the MetaClass) and access to an object's attributes are decoupled from actual implementations by adapters implementing a Map-like name/value interface (the MetaObject). Because the thin framework is built on generic interfaces, it is not tied directly to real Java bean implementations and can also be used for anything that can access values by name. (Some examples are SQL result sets, HTTP request data, or simple hash maps.) Once a "class" has been described, the information can even be applied to different underlying implementations.
The MetaClass/MetaObject layer is a foundation for dynamically generating user-level access to application object models. Toolkits are provided for generating Swing GUIs at runtime or dynamically rendering objects as XML using the class descriptions. On the drawing board is support for generating HTML forms and views as well. Future development may also extend to a collaborative data access layer.
easyb is a behavior driven development framework for the Java platform. By using a specification based Domain Specific Language, easyb aims to enable executable, yet readable documentation.
About XStream
XStream is a simple library to serialize objects to XML and back again.
Features
* Ease of use. A high level facade is supplied that simplifies common use cases.
* No mappings required. Most objects can be serialized without need for specifying mappings.
* Performance. Speed and low memory footprint are a crucial part of the design, making it suitable for large object graphs or systems with high message throughput.
* Clean XML. No information is duplicated that can be obtained via reflection. This results in XML that is easier to read for humans and more compact than native Java serialization.
* Requires no modifications to objects. Serializes internal fields, including private and final. Supports non-public and inner classes. Classes are not required to have default constructor.
* Full object graph support. Duplicate references encountered in the object-model will be maintained. Supports circular references.
* Integrates with other XML APIs. By implementing an interface, XStream can serialize directly to/from any tree structure (not just XML).
* Customizable conversion strategies. Strategies can be registered allowing customization of how particular types are represented as XML.
* Error messages. When an exception occurs due to malformed XML, detailed diagnostics are provided to help isolate and fix the problem.
* Alternative output format. The modular design allows other output formats. XStream ships currently with JSON support and morphing.
jPersist is an extremely powerful, light-weight, object-relational database persistence API that manages to avoid the need for configuration and annotation; mapping is automatic. jPersist uses JDBC and can work with any relational database and any type of connection resource. jPersist uses information obtained from the database to handle mapping between the database and Java objects, so mapping configuration is not needed, and annotation is not needed, in fact there is no configuration needed at all.