Free classes software for linux

This profiler is intended to be used to identify areas of code that could be optimised in order to improve overall performance of an application. Typically I identify the areas of concern in an application and place profile timers around those sections and focus down to add timers around the areas that are taking the most time and look for ways to optimise those particular areas.
The items with the highest percentage time spent are usually the ones that can give the biggest improvements.
PHP Class to perform code profiling in order to aid locating areas of code that consume most processing time.
Provides information on number of calls to a code section, percentage and total of time spent on a section. Timing of nested code sections is possible.
Main features:
- Count the number of times a section of code is executed
- Calculate the total ammount of time spent executing a section of code
- Permit multiple timers to be set
- Allow nested timers to such that the parent timers are suspended whilst a child section of code is running.
- Output a report at the end of execution to show the percentage of time spent on an operation,
- the number of times the section was run, the overall time spent on the section.
Usage:
# include_once( profiler.inc);
$prof = new Profiler( profile_flag, trace_flag );
# Profile_flag = true enables output of the statistical information
# trace_flag = true enables output of the trace information
$prof->startTimer( "timer_name", "Description" );
# timer_name is a simple string to name the timer
# description is an optional string to describe the purpose of the timer in more detail
$prof->stopTimer( "timer_name" );
$prof->printTimers( flag );
Output the final report of the processing operation being run. Normally this would be called as one of the last statements on a page.
If flag=true is set then the output will be forced even if the profile_flag was set false when the profiler was initialised

The C++ Foundation Classes package contains a Fully Overloaded String object that works with other classes (even those not owned by CFC), a full (template) Matrix and Vector Object, some Data types like DateTime, Boolean, Integer, Real, and Complex, and Sets, Stack, Queues, etc. C++ Foundation Classes also has an LL-type Parser and Scanner for lexical reading.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Class::Date is a perl module, which provides a simple date type for perl.
You can create new Class::Date objects with a constructor from different scalar formats, array refs, and hash refs, and then you can easily manipulate it by the builtin "+" and "-" operators (e.g., $date=date([2001,03,15])+3Y 1s). Relative date types also available.
Enhancements:
- This release adds "ampm" and "meridiam" methods.

Rauls classes for PHP is an OOP database abstraction layer for PHP 5.1 or greater. Rauls classes for PHP provides abstract classes to access database servers and traverse result sets.
There are several implementation classes to access different types of databases: SQLite, MySQL, PostgreSQL, and MSSQL.
The classes provide functions to establish connections, execute queries, traverse result sets with pagination support, and retrieve the list of databases, tables and fields. Any possible error is signaled by throwing exceptions with specific message and error code.
Enhancements:
- A quickref.txt file was added to the project.
- A totalRows get property was included for SQL result objects.
- A third optional parameter was added to the printPageSelect method in order to return the page < select > code as an string instead of printing it.

Objective-C Foundation Classes is an Objective-C library.
It contains general purpose classes for easier development of applications, in areas such as data types, network, C library wrappers, collections, and compound classes.
The classes in the library are grouped in five clusters:
- DataTypes - integer, text string, fraction, bitarray, date/time, random generators, big integer, big double ...
- Collections - array, list, hash table, AVL and n-tree, circular array, graph ...
- Network - TCP/UDP server and client, HTTP client, Telnet client ...
- C-library wrappers - DBM, socket, MD5, regular expression, timer, file, directory, gzip and bzip2 file, text screen ...
- Compound - Argument parser, calendar, finite state machine, tokenizer, XML tree, discrete distribution, objective-c source tokenizer ...
Enhancements:
- A new class (DBigFraction) and a new protocol (DBitArithmetic) have been added to the library.
- There are also several bugfixes related to 64-bit platforms.
- The copy-constructor support has been improved, and as a result all collections can now be (deep) copied.
- There are some small bugfixes, and several classes have been extended with new methods.

DBIx::Class::FormTools is a utility module for building forms with multiple related DBIx::Class objects.

SYNOPSIS

In the examples I use 3 objects, a Film, an Actor and a Role. Role is a many to many relation between Film and Actor.

package MySchema;
use base DBIx::Class::Schema;
__PACKAGE__->load_classes(qw[
Film
Actor
Role
]);

package MySchema::Film;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
title
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, film_id);


package MySchema::Actor;
__PACKAGE__->table(films);
__PACKAGE__->add_columns(qw[
id
name
]);
__PACKAGE__->set_primary_key(id);
__PACKAGE__->has_many(roles => MySchema::Role, actor_id);

package MySchema::Role;
__PACKAGE__->table(roles);
__PACKAGE__->add_columns(qw[
film_id
actor_id
]);
__PACKAGE__->set_primary_key(qw[
film_id
actor_id
]);

__PACKAGE__->belongs_to(film_id => MySchema::Film);
__PACKAGE__->belongs_to(actor_id => MySchema::Actor);
In your Model class
use base qw/DBIx::Class/;
__PACKAGE__->load_components(qw/PK::Auto::Pg Core FormTools/);
In your view - HTML::Mason example
< %init >
my $film = $schema->resultset(Film)->find(42);
my $actor = $schema->resultset(Actor)->find(24);
< /%init >
< form >
< input
name="< % $film->form_fieldname(title, o1) => Title % >"
type="text"
value="< % $film->title % >"
/ >
< input
name="< % $film->form_fieldname(length, o1) % >"
type="text"
value="< % $film->length % >"
/ >
< input
name="< % $film->form_fieldname(comment, o1) % >"
type="text"
value="< % $film->comment % >"
/ >
< input
name="< % $actor->form_fieldname(name, o2) % >"
type="text"
value="< % $actor->name % >"
/ >


In your controller (or cool helper module, used in your controller)
my @objects = DBIx::Class::FormTools->formdata_to_objects($querystring);
foreach my $object ( @objects ) {
# Assert and Manupulate $object as you like
$object->insert_or_update;
}

Class::Std::Utils is a Perl module for utility subroutines for building "inside-out" objects.

SYNOPSIS

use Class::Std::Utils;

# Constructor for anonymous scalars...
my $new_object = bless anon_scalar(), $class;

# Convert an object reference into a unique ID number...
my $ID_num = ident $new_object;

# Extract class-specific arguments from a hash reference...
my %args = extract_initializers_from($arg_ref);

This module provides three utility subroutines that simplify the creation of "inside-out" classes. See Chapters 15 and 16 of "Perl Best Practices" (OReilly, 2005) for details.