Free reflection software for linux

Devel::GDB::Reflect is a reflection API for GDB/C++.

SYNOPSIS

use Devel::GDB;
use Devel::GDB::Reflect;

my $gdb = new Devel::GDB( -file => $foo );
my $reflector = new Devel::GDB::Reflect( $gdb );

print $gdb->get( "b foo.c:123" );
$gdb->print( "myVariable" );

Devel::GDB::Reflect provides a reflection API for GDB/C++, which can be used to recursively print the contents of STL data structures (vector, set, map, etc.) within a GDB session. It is not limited to STL, however; you can write your own delegates for printing custom container types.

The module implements the functionality used by the gdb++ script, which serves as a wrapper around GDB. You should probably familiarize yourself with the basic functionality of this script first, before diving into the gory details presented here.

Global Variables

The following global variables control the behavior of the "print" method.

$Devel::GDB::Reflect::INDENT

The number of spaces to indent at each level of recursion. Defaults to 4.

$Devel::GDB::Reflect::MAX_DEPTH

The maximum recursion depth. Defaults to 5.

$Devel::GDB::Reflect::MAX_WIDTH

The maximum number of elements to show from a given container. Defaults to 10.

Blue Moon project is a Blue Moon solitaire for Unix.
This 52-card solitaire starts with the entire deck shuffled and dealt out in four rows.
The aces are then moved to the left end of the layout, making 4 initial free spaces.
You may move to a space only the card that matches the left neighbor in suit, and is one greater in rank. Kings are high, so no cards may be placed to their right (they create dead spaces).
When no moves can be made, cards still out of sequence are reshuffled and dealt face up after the ends of the partial sequences, leaving a card space after each sequence, so that each row looks like a partial sequence followed by a space, followed by enough cards to make a row of 14.
A moments reflection will show that this game cannot take more than 13 deals.
A good score is 1-3 deals, 4-7 is average, 8 or more is poor.
Enhancements:
- Changes since the initial release have been in the packaging.

WebComp is an experiment on how to compose and configure web-sites from various existing components (static HTML, Java Servlets, Java server pages and other), by scripting. It includes a scripting language, a component model/framework and a set of basic pluggable components to use with it.
The core of the WebComp implementation is a Java servlet that reads scripts and generates web-pages from them, using components referenced in the scripts.
Main features:
- Supports a basic pluggable component type (Functions) which are easily implemented as Java classes and instantiated and configured by scripts, using reflection techniques and functional programming concepts.
- Supports a high level of separation of concerns (aspect oriented design) by allowing flexible chaining of components to handle requests and responses. This leads to more reusable components.
- Supports easy re-use of website designs and components by scripting inheritance.
- Basic function-library supports automatic generation of menus from lists of components given in scripts, filtering of static HTML documents, nice framing of content, stylesheets, layout, composing etc.
- Can generate valid HTML (if components do).

Java Properties provides an efficient way to access bean-like properties of Java objects.

In a nutshell, provides an efficient way to access bean-like properties of java objects. Unlike java bean properties, a chain of properties can be specified efficiently, allowing convenient access to properties of nested domain objects.

Runtime class-generation and caching can be used very easily to obviate the need for reflection, without losing the flexibility it provides.

Class Properties It also provides classes which manipulate objects at runtime by using strings to address conceptual variables (think bean properties) in a similar fashion to the java reflection mechanisms.

Class Property example Say we have the following classes:

public class Order {
...
public Customer getCustomer() { ... }
...
}
public class Customer {
...
public Address getAddress() { ... }
...
}
public class Address {
...
public String getLine1() { ... }
public String getLine2() { ... }
...
}

Now, we could do this to access line 1 of the address:

result = order.getCustomer().getAddress().getLine1();

But what if there are nulls? What if we want to compare the first line of the address from two different orders? Whith properties this is really simple:

ClassProperty p = PropertyManager.getProperty(Order.class,"Customer:Address:Line1",true);
result = p.getValue(order);

The idea is simple enough - you use the string "Customer:Address:Line1" to specify a series of getXXX calls. Importantly, it the library handles nulls for you, returning null if any of the objects in the chain are null.

Note, this is not simply a wrapper around java reflection, since it includes non-reflective optimizations by making use of the cojen library to generate class files at runtime to acces these properties.

The real benefit lies in being able to specify which properties you wish to access at runtime. You can even pass this ability on to the users of your library or application. Unlike reflection, class files are generated for the properties, and these files are cached - which means once you have specified a property once, further uses of the same property dont use reflection and are very fast.

Property API vs Java Bean Properties. The property API models accessor/mutator method pairs as conceptual variables called properties. The approach used is similar to, but more flexible than java bean properties, and more performant than reflection if runtime class generation is used. Unlike java bean properties, a chain or path of properties can be specified (and more importantly, turned into bytecode using runtime generation) to traverse a complex tree of objects.
It is simple to create applications portable between different security environments - using runtime generation where allowed, and falling back to reflection where security is tighter.

Dynamic Class Management. The properties package also provides classes to handle the loading (and unloading/reloading) of classes at runtime. It provides a framework useful for dynamically loading runtime-generated classes, for example.
While the property API can happily ignore the dynamic loading framework, it can also make use of it to enable runtime class generation.

Stanford Exploration Project Library (or SEP, for short) is an industry-funded academic consortium whose purpose is to improve the theory and practice of constructing 3-D and 4-D images of the earth from seismic echo soundings.
Although most of our research is targeted at improvements in the geophysical survey contracting industry, about half of our sponsors and alumni are in the petroleum industry because we focus on overcoming technological limitations of the geophysical survey industry.
SEP pioneered innovations in migration imaging, velocity estimation, dip moveout and slant stack. Today our focus is on 3-D seismic applications such as velocity estimation, wavefield-continuation prestack migration, multidimensional image estimation, and 4-D (time-lapse) reservoir monitoring.
Besides 3-D reflection seismic data, we undertake small 2-D imaging projects with geophysical data of all kinds. The diversity of applications exercises our judgment and skill at combining fundamentals of statistical signal theory, optimization theory, numerical analysis, and wave propagation theory, and this has led us to numerous improvements and some breakthroughs.
We organize our research to facilitate technology transfer by using a formal method of makefile rules. With these, most of our research results are verified by someone other than the original researcher. Research progress reports at least four years old and all PhD theses are made available to the public through our web site.
Enhancements:
- Numerous major new features and major bugfixes.

Xephyrus File Upload Tag Library provides an easy way to process files uploaded from a web form from within JSP pages. It is a tag library wrapper around the Jakarta Commons FileUpload utility.
Enhancements:
- added keepPath attribute to remotePath tag to indicate whether to keep (if present) or remove remote path information
- added keepEmpty attribute to parse tag to indicate whether to include file items that do not include files
- fixed NullPointerException when localPath tag was used with an empty file item
- fixed ClassCastException when any accessor tag was used with an empty file item
- fixed EL functionality problem with boolean attributes
- fixed max size incompatibility from integers to longs
- fixed internal code to work with altered library architecture
- removed fileItemClassName attribute from parse tag because I dont think anybody would ever use it and the new architecture ditched their internal reflection for this which isnt really hard to rework but is just more than I want to deal with right now especially since it would render some of the other tags dysfunctional if it ever were actually used and if anybody ever did need it they could just make their own tag library anyhow
- reformatted documentation to be (much) more readable

Barter is an integration of the Bazaar revision control system into Nautilus.
Barter is an extension for the Nautilus file-manager. It provides a series of context-menu items and property panels to make management of Arch archives.
One of Barters chief aims is to be as intuitive as is feasible, integrating with the file-manager in a clean and natural fashion. It doesnt attempt to be a complete interface to this notoriously complete versioning system, it just aims to cover the functionality people will be using most often.
Please remember that this is an experimental project in its early stages so it isnt intended for general use yet (although by all means use it and let me know how you find it.) It uses several new and rough technologies, not least the python Extensions API itself. As such it is very much for the bleeding edge, experimenting user.
Main features:
- Context-menu support for add, remove, get, merge, branch, commit, update, new archive and new project
- Automatic generation of changelogs
- Able to forward to mirrors on commit
- Reflection of arch information into RDF for integration with common ontologies such as Dublin Core, FOAF, DOAP and Annotea (to do)
- File, archive and working tree property panels to display metadata (to do)
- Information and metadata reflection into the Frege information store (optional)