Free golden software for linux

ToolSet::SWC is a sample toolset with strict, warnings and Carp.

SYNOPSIS

use ToolSet::SWC;

# strict is on
# warnings are on
# Carp defaults are imported

carp "We know how to carp";

$name = "Igor"; # this will fail strict when compiling

ToolSet:SWC is a simple example of a ToolSet that enables strict and warnings and also imports all the basic Carp functions. See ToolSet for more details.

XML::RDB is a Perl extension to convert XML files into RDB schemas and populate, and unpopulate them. Works with XML Schemas too.

SYNOPSIS

use XML::RDB;

# Give our DBs DSN & username/password
my $rdb = new XML::RDB(config_file => db_config);

# Generate RDB Schema
$rdb->make_tables("my_xml_file.xml", "db_schema_output_file");

#
# Now import the generated db_schema_output_file into your DB
# (see t/1.t for an automated way to do this)
#

# Now populate our RDB
my($root_table_name, $primary_key) =
$rdb->populate_tables("my_xml_file.xml");

#
# Your XML file is now in your RDB!!!! Play as desired & when ready:
#
$rdb->unpopulate_tables($root_table_name, $primary_key,
new_xml_file.xml);


#
# Thats all fine & dandy but what if youve got an XML Schema???
#
# the first 2 calls are the same:
$rdb->make_tables("my_xsd_file.xsd", "db_schema_output_file");

#
# dont forget to put db_schema_output_file into your DB!
# then:
my($root_table_name, $primary_key) =
$rdb->populate_tables("my_xsd_file.xsd");

# note we only need the primary key for this next call
$rdb->unpopulate_schema($primary_key, fully_formed.xml);

#
# Now youve got fully_formed.xml - pass THAT to make_tables
# & yer golden:
#

$rdb->make_tables("fully_formed.xml", "REAL_RDB_schema");

#
# Now insert REAL_RDB_schema into yer DB & now any XML documents
# conforming to your original XML Schema (my_xsd_file.xsd) can be
# imported into your schema:
my ($rt, $pk) =
$rdb->populate_tables("xml_doc_conforming_to_my_xsd_file.xml");

# See the README file for a LOT more information...

ABSTRACT

XML::RDB - Perl extension to convert XML files into RDB schemas and populate, and unpopulate them. Works with XML Schemas too. Analyzes relationships within either an XML file or an XML Schema to create RDB tables to hold that document (or any XML document that conforms to the XML Schema).

gdWebSuite System is a script that is designed to be a full featured system for user registration, login, and administration on a Web site.
It also supports account activation and retrieving lost passwords. gdWebSuite System supports visual templates and different styles for each template.
Enhancements:
- New administration features for uploading avatars, a new avatar selection, and one new admin style were added.
- A private message system was started.
- Some changes and updates were made to various parts of the code.

Class::InsideOut::Manual::About is a guide to this and other implementations of the inside-out technique.
This manual provides an overview of the inside-out technique and its application within Class::InsideOut and other modules. It also provides a list of references for further study.
Inside-out object basics
Inside-out objects use the blessed reference as an index into lexical data structures holding object properties, rather than using the blessed reference itself as a data structure.
$self->{ name } = "Larry"; # classic, hash-based object
$name{ refaddr $self } = "Larry"; # inside-out
The inside-out approach offers three major benefits:
- Enforced encapsulation: object properties cannot be accessed directly from ouside the lexical scope that declared them
- Making the property name part of a lexical variable rather than a hash-key means that typos in the name will be caught as compile-time errors (if using strict)
- If the memory address of the blessed reference is used as the index, the reference can be of any type
In exchange for these benefits, robust implementation of inside-out objects can be quite complex. Class::InsideOut manages that complexity.
Philosophy of Class::InsideOut
Class::InsideOut provides a set of tools for building safe inside-out classes with maximum flexibility.
It aims to offer minimal restrictions beyond those necessary for robustness of the inside-out technique. All capabilities necessary for robustness should be automatic. Anything that can be optional should be. The design should not introduce new restrictions unrelated to inside-out objects, such as attributes and CHECK blocks that cause problems for mod_perl or the use of source filters for syntatic sugar.
As a result, only a few things are mandatory:
- Properties must be based on hashes and declared via property
- Property hashes must be keyed on the Scalar::Util::refaddr
- register must be called on all new objects
All other implementation details, including constructors, initializers and class inheritance management are left to the user (though a very simple constructor is available as a convenience). This does requires some additional work, but maximizes freedom. Class::InsideOut is intended to be a base class providing only fundamental features. Subclasses of Class::InsideOut could be written that build upon it to provide particular styles of constructor, destructor and inheritance support.

File::pushd is a Perl module to change directory temporarily for a limited scope.

SYNOPSIS

use File::pushd;

chdir $ENV{HOME};

# change directory again for a limited scope
{
my $dir = pushd( /tmp );
# working directory changed to /tmp
}
# working directory has reverted to $ENV{HOME}

# tempd() is equivalent to pushd( File::Temp::tempdir )
{
my $dir = tempd();
}

# object stringifies naturally as an absolute path
{
my $dir = pushd( /tmp );
my $filename = File::Spec->catfile( $dir, "somefile.txt" );
# gives /tmp/somefile.txt
}

File::pushd does a temporary chdir that is easily and automatically reverted, similar to pushd in some Unix command shells. It works by creating an object that caches the original working directory. When the object is destroyed, the destructor calls chdir to revert to the original working directory. By storing the object in a lexical variable with a limited scope, this happens automatically at the end of the scope.

This is very handy when working with temporary directories for tasks like testing; a function is provided to streamline getting a temporary directory from File::Temp.
For convenience, the object stringifies as the canonical form of the absolute pathname of the directory entered.

Pod::WikiDoc is a Perl module to generate Pod from inline wiki style text.
SYNOPSIS
In a source file, Pod format-block style:
=begin wikidoc
= POD FORMAT-BLOCK STYLE
Write documentation with *bold*, ~italic~ or {code}
markup. Create a link to [Pod::WikiDoc].
Substitute for user-defined %%KEYWORD%%.
Indent for verbatim paragraphs
- bullet
- point
- list
0 sequentially
0 numbered
0 list
= end wikidoc
In a source file, wikidoc comment-block style:
### = WIKIDOC COMMENT-BLOCK STYLE
###
### Optionally, [Pod::WikiDoc] can extract from
### specially-marked comment blocks
Generate Pod from wikidoc, programmatically:
use Pod::WikiDoc;
my $parser = Pod::WikiDoc->new( {
comment_blocks => 1,
keywords => { KEYWORD => "foo" },
} );
$parser->filter(
{ input => "my_module.pm", output => "my_module.pod" }
);
Generate Pod from wikidoc, via command line:
$ wikidoc -c my_module.pm my_module.pod
Pod works well, but writing it can be time-consuming and tedious. For example, commonly used layouts like lists require numerous lines of text to make just a couple of simple points. An alternative approach is to write documentation in a wiki-text shorthand (referred to here as wikidoc) and use Pod::WikiDoc to extract it and convert it into its corresponding Pod as a separate .pod file.
Documentation written in wikidoc may be embedded in Pod format blocks, or, optionally, in specially marked comment blocks. Wikidoc uses simple text-based markup like wiki websites to indicate formatting and links. (See "WIKIDOC MARKUP", below.)
Pod::WikiDoc processes text files (or text strings) by extracting both existing Pod and wikidoc, converting the wikidoc to Pod, and then writing the combined document back to a file or standard output.
Summary of major features of Pod::WikiDoc:
- Extracts and converts wikidoc from Pod format blocks or special wikidoc comment blocks
- Extracts and preserves existing Pod
- Provides bold, italic, code, and link markup
- Substitutes user-defined keywords
- Automatically converts special symbols in wikidoc to their Pod escape equivalents, e.g. E< lt >, E< gt >
- Preserves other Pod escape sequences, e.g. E< euro >
In addition, Pod::WikiDoc provides a command-line utility, wikidoc, to simplify wikidoc translation.
See the Pod::WikiDoc::Cookbook for more detailed usage examples, including how to automate .pod generation when using Module::Build.

Humai Trader is a free, open source stock technical analysis tool built on pure java. Humai Trader will also be a platform for custom indicators and charts. The main interest will be W.D. Ganns approach.
Main features:
- Indicators:
- MACD
- OBV
- ROC
- KD
- BIAS
- DMI
- RSI
- MTM
- WMS
- GANN IMPORTANT DATES
- Drawing lines:
- LINE
- PARALLEL LINE
- GANN ANGLE
- FIBONACCI LINE
- PERCENT
- GOLDEN RATE
- PERIODS
- GANN IMPORTANT PERIODS
- Retrieves quote data in parallel from Yahoo! Finance, or CSV files.
- Historical Chart
- Intra-Day Chart
- Real-Time Chart
- Ticker Board
- Candle/Bar/Line
- Changes indicators parameters
-
- Natural date / Trading date view
- Move left, right by [left], [right] key
- Zoom in, Zoom out by [up], [down] key
- Fast moving cursor / day by day moving cursor
- Save/restore parameters and drawing
- Carefully design for writing your own indicator easy, but in java (maybe will support scripts some day)
- Supports multi platforms, includes windows, linux, macos, solaris, etc. (Java JRE 1.5 required)
- More to be come ...