Free resultant software for linux

snmpmondb project can track network traffic usage for local and remote hosts via SNMP. A few simple Web pages are included to show the resultant data in various graphs.

Data Architects, DBAs, Analysts and Designers rely on Data Modeling tools to facilitate and simplify their data Modeling efforts, while maximizing the use of their resources. The Power*Architect allows these busy highly technical resources to perform this most intricate part of their job in a fraction of the time.
Power*Architect project is an innovative Java-based data modeling tool geared specifically for Data Warehouse and Data Mart design. It allows the designer to open multiple concurrent source Database connections, create and explore profiles of the source data, drag and drop source schemas, tables and columns into the data modeling playpen, and forward engineer the resultant target database and its associated ETL template.
Main features:
- Access any JDBC or ODBC accessible source database
- Quickly create profiles of source data, including information about the size of the data in each column, maximum and minimum values, frequency distribution of values in a column, and more.
- Profile information is saved with the project, so profile data can still be used to aid off-site design sessions when it is not possible to access the source databases.
- Design the target database Data Model (Data Warehouse)
- Compare the database structure of any two databases highlighting the structural differences and generating the required DDL to synchronize
- Compare the Data Model data structures to an existing target database
- Save a snapshot of all source systems data structures in the project file, allowing data warehouse designers to evolve their target data model remotely
- Forward engineer to Oracle, SQL Server, DB2, and PostgreSQL and more.
- Forward engineer ETL Templates containing source-to-target data mappings
- Invoke ETL Engine to load initial set of data into the target database
- Enable easy centralized installation and updates to many end users (Supports Java WebStart technology).
- The Power*Architect can open multiple source databases concurrently, even if they are from competing database vendors. Another key feature of the Power*Architect, that sets it apart from other data modeling tools, is that it remembers the origin of each column, and is capable of automatically generating the source-to-target data mappings.
- Whether youre building or maintaining your Data Warehouse data model, the Power*Architect will provide you a complete view of all required database structures and will expedite every aspect of your data warehouse design.
- Design your Data Warehouse in a fraction of the time with the Power*Architect.
- We look forward to showing you how!
- The Power*Architect is available now for download! The product is available for free to individuals for personal use. Commercial licensing and support are available at competitive prices. Please call us at 1-866-SQL-POWR to purchase.
Enhancements:
- This release fixes a bug that caused corrupt project files to be saved.
- The handling of automatic cascading primary keys in multi-level identifying relationships now works better.
- The profile manager is now even more stable.
- It is now possible to add new database connection types from within the GUI.

MMDS::Properties Perl module contains flexible properties handling for MMDS.
use MMDS::Properties;
my $cfg = new MMDS::Properties;
# Preset a property.
$cfg->set_property("config.version", "1.23");
# Parse a properties file.
$cfg->parsefile("config.prp");
# Get a property value
$version = $cfg->get_property("config.version");
# Same, but with a default value.
$version = $cfg->get_property("config.version", "1.23");
# Get the list of subkeys for a property, and process them.
my $aref = $cfg->get_property_keys("item.list");
foreach my $item ( @$aref ) {
if ( $cfg->get_property("item.list.$item") ) {
....
}
}
The property mechanism is modelled after the Java implementation of properties.
In general, a property is a string value that is associated with a key. A key is a series of names (identifiers) separated with periods. Names are treated case insensitive. Unlike in Java, the properties are really hierarchically organized. This means that for a given property you can fetch the list of its subkeys, and so on. Moreover, the list of subkeys is returned in the order the properties were defined.
Property lookup can use a preset property context. If a context ctx has been set using set_context(ctx), get_property(foo.bar) will first try ctx.foo.bar and then foo.bar. get_property(.foo.bar) (note the leading period) will only try ctx.foo.bar and raise an exception if no context was set.
Design goals:
- properties must be hierarchical of unlimited depth;
- manual editing of the property files (hence unambiguous syntax and lay out);
- it must be possible to locate all subkeys of a property in the order they appear in the property file(s);
- lightweight so shell scripts can use it to query properties.
METHODS
new
new is the standard constructor. new doesnt require any arguments, but you can pass it a list of initial properties to store in the resultant properties object.
new
clone is like new, but it takes an existing properties object as its invocant and returns a new object with the contents copied.
WARNING This is not yet a deep copy, so take care.
parsefile file [ , path [ , context ] ]
parsefile reads a properties file and adds the contents to the properties object.
file is the name of the properties file. This file is searched in all elements of path (an array reference) unless the name starts with a slash. Default path is . (current directory).
context can be used to designate an initial context where all properties from the file will be subkeys of.
For the detailed format of properties files see below.
get_property prop [ , default ]
Get the value for a given property prop.
If a context ctx has been set using set_context(ctx), get_property(foo.bar) will first try ctx.foo.bar and then foo.bar. get_property(.foo.bar) (note the leading period) will only try ctx.foo.bar and raise an exception if no context was set.
If no value can be found, default is used.
In either case, the resultant value is examined for references to other properties or environment variables. Such a reference looks like
${name}
${name:default}
name can be the name of an environment variable or property. If name is found in the environment, its value is substituted and the expansion process continues, re-examining the new contents, until no further substitutions can be made. If a non-empty value exists for the property name its value is used in a similar way. Hence an empty value for a property will be ignored. If no value can be found, the default string (not to be confused with the default parameter) will be returned.
As an additional service, a tilde ~ in what looks like a file name will be expanded to ${HOME}.
The method result_in_context can be used to determine how the result was obtained. It will return a non-empty string indicating the context in which the result was found, an emptry string indicating the result was found without context, or undef if no value was found at all.
get_property_noexpand prop [ , default ]
This is like get_property, but does not do any expansion.
gps prop [ , default ]
This is like get_property, but raises an exception if no value could be established.
This is probably the best and safest method to use.
get_property_keys prop
Returns an array reference with the names of the (sub)keys for the given property. The names are unqualified, e.g., when properties foo.bar and foo.blech exist, get_property_keys(foo) would return [bar, blech].
expand value [ , context ]
Perform the expansion as described with get_property.
set_property prop, value
Set the property to the given value.
set_properties prop1 => value1, ...
Add a hash (key/value pairs) of properties to the set of properties.
set_context context
Set the search context. Without argument, clears the current context.
get_context
Get the current search context.
result_in_context
Get the context status of the last search.
Empty means it was found out of context, a string indicates the context in which the result was found, and undef indicates search failure.
dump [ start [ , stream ] ]
Produce a listing of all properties from a given point in the hierarchy and write it to the stream.
stream defaults to *STDOUT.
dumpx [ start [ , stream ] ]
Like dump, but dumps with all values expanded.

NekoHTML is a simple HTML scanner and tag balancer that enables application programmers to parse HTML documents and access the information using standard XML interfaces.
The parser can scan HTML files and "fix up" many common mistakes that human (and computer) authors make in writing HTML documents. NekoHTML adds missing parent elements; automatically closes elements with optional end tags; and can handle mismatched inline element tags.
NekoHTML is written using the Xerces Native Interface (XNI) that is the foundation of the Xerces2 implementation. This enables you to use the NekoHTML parser with existing XNI tools without modification or rewriting code.
Version restrictions:
- There are HTML documents for which NekoHTML cannot properly generate a well-formed XML document event stream. For example, documents with multiple tags are inherently ill-formed because XML documents may only have a single root element.
- Code added to the core DOM implementation in Xerces-J 2.0.1 introduced a bug in the HTML DOM implementation based on it.
The bug causes the element nodes in the resultant HTML document object to be of type org.apache.xerces.dom.ElementNSImpl instead of the appropriate HTML DOM element objects.
The problem affects NekoHTML users who use the parser with Xerces-J 2.0.1 and anyone using the HTML DOM implementation in Xerces-J 2.0.1.
- There are no other known major limitations with this release. However, additional work can always be done to improve performance, fix bugs, and add functionality.

NA_WorkSheet project is a collective aggregation of algorithms written in Java that implements various numerical analysis solutions and techniques.
The worksheet has been designed to allow a simple user interface for accessing and executing each numerical method. Each numerical analysis algorithm will normally require some type of input. The input will normally come in the form of an input equation/data and parameters for controlling the execution of the algorithm. Output from each algorithm approximation is directly available as either a solution or combination solution and intermediate data. The NA_Worksheet also provides the capability to graph an input equation with the ability to both translate and scale the resultant plot.
Upon running the NA_Worksheet application/applet the user will be presented with a standard 800x600 pixel frame that will conform to the host workstations look and feel, theme. The frame can be resized to any desired dimension. The users interface for the worksheet is divided into a quadripartite. In the upper left quadrant is the graph panel. Here plots can be viewed of the equation that is input for analysis.
The upper right panel holds the main input, where various numerical methods can be selected and executed. The panel also provides a text box where the input equation for analysis can be entered. Two main buttons allow the user to either execute the selected approximation or graph the input equation.
The lower left panel houses several tabbed panes that allows data output to be viewed, function evaluation, or controls for the graph panel to be accessed. The graph tab also includes the present grid scaling on the graph and coordinate information. The final panel in the lower right quadrant is particular to each selected numerical approximation. This panel provides the parameter selection and input for each chosen numerical method. A condensed list of the panels and there names follows:
- Graph Panel - Upper left quadrant.
- Main Input Panel - Upper right quadrant
- Output/Graph Control Panel - Lower left quadrant
- Approximation Method Panel - Lower right quadrant

Tie::Proxy::Hash is a Perl module created to efficiently merge & translate hashes.

SYNOPSIS

my (%hash, $ref);
$ref = tie %hash, Tie::Proxy::Hash, (bart => +{a => 1,
b => 2},
maggie => +{a => 5,
c => 6,
e => 10},
);
$hash{a} == 1; # true
$hash{b} == 2; # true (bart supercedes maggie)
$hash{c} == 6; # true
! defined $hash{d}; # true
$hash{e} == 10; # true

$hash{c} = 9; # set in maggie
$hash{d} = 12; # set in default
$hash{f} = 11; # set in default

$ref->add_hash(lisa, +{d => 3, b => 4});
$hash{c} == 9; # true
$hash{b} == 2; # true (bart overrides lisa)
$hash{d} == 3; # true (lisa overrides default)
$hash{f} == 11; # true (only default knows f)

Proxy hash requests for one or more other hashes, with intermediate value translation.

Tie::Proxy::Hash merges hashes by maintaining a list of hashes to look up, and each key requested is looked up in each hash in order until a hit is found. Resultant values may be subject to a translating subr. In this way, hashes may be merged without the cost of by-value copying.

A default backing hash is provided to store values not present in other hashes.

Tying

$ref = tie %hash, Tie::Proxy::Hash,
bart => +{a => 1, b => 2},
maggie => +{a => 5, c => 6, e => 10} => sub {10*$_[0]},
;

Any arguments passed to tie are palmed off onto add_hash.

Retrieving Values

Values are retrieved by checking each hash in the order of insertion; the first hash found in which a given key exists supplies the value. The value is subject to translation if the given hash has an associated translator.

A7Xpg is a game where you collect all the gold, while avoiding the enemies. A7Xpg was created by Kenta Cho and ported to Linux by Evil Mr Henry.

Installation:

A7Xpg is entirely contained within this directory. There is no installation. To uninstall, simply delete this directory.

Running:

Type ./a7xpg from this directory to start the game. The command-line line switches listed in readme_e.txt should all work.

Compiling:

Install the OpenGL development libraries. (This is the hard part.)
Install the D compiler, version 0.106. (http://ftp.digitalmars.com/dmd.106.zip) Note that this is non-opensource, so if you cant run the binary, youre out of luck. If you dont like it, talk to digitalmars. I dont like it either. Also, any later versions of the D compiler will NOT work. 0.106 or earlier is needed. As a final note, the resultant binary will not work on other computers, due to problems in the D compiler.

Install SDL_mixer.

Compile with "make". The bulletML libraries will give a few warnings. Ignore them.

Known Issues:

The compiler is non-opensource.