Free abstract details software for linux

Path::Abstract is a fast and featurefull class for UNIX-style path manipulation.

SYNOPSIS

use Path::Abstract;

my $path = Path::Abstract->new("/apple/banana");

# $parent is "/apple"
my $parent = $path->parent;

# $cherry is "/apple/banana/cherry.txt"
my $cherry = $path->child("cherry.txt");

Path::Abstract->new( < path> )
Path::Abstract->new( < part>, [ < part>, ..., < part> ] )

Create a new Path::Abstract object using < path> or by joining each < part> with "/"

Returns the new Path::Abstract object

Path::Abstract::path( < path> )
Path::Abstract::path( < part>, [ < part>, ..., < part> ] )

Create a new Path::Abstract object using < path> or by joining each < part> with "/"

Returns the new Path::Abstract object

$path->clone

Returns an exact copy of $path

$path->set( < path> )
$path->set( < part>, [ < part>, ..., < part> ] )

Set the path of $path to < path> or the concatenation of each < part> (separated by "/")

Returns $path

$path->is_nil
$path->is_empty

Returns true if $path is equal to ""

$path->is_root

Returns true if $path is equal to "/"

$path->is_tree

Returns true if $path begins with "/"

path("/a/b")->is_tree # Returns true
path("c/d")->is_tree # Returns false
$path->is_branch

Returns true if $path does NOT begin with a "/"

path("c/d")->is_branch # Returns true
path("/a/b")->is_branch # Returns false
$path->to_tree

Change $path by prefixing a "/" if it doesnt have one already

Returns $path

$path->to_branch

Change $path by removing a leading "/" if it has one

Returns $path

$path->list
$path->split

Returns the path in list form by splitting at each "/"

path("c/d")->list # Returns ("c", "d")
path("/a/b/")->last # Returns ("a", "b")
$path->first

Returns the first part of $path up to the first "/" (but not including the leading slash, if any)

path("c/d")->first # Returns "c"
path("/a/b")->first # Returns "a"
$path->last

Returns the last part of $path up to the last "/"

path("c/d")->last # Returns "d"
path("/a/b/")->last # Returns "b"
path

$path->get
$path->stringify

Returns the path in string or scalar form

path("c/d")->list # Returns "c/d"
path("/a/b/")->last # Returns "/a/b"

$path->push( < part>, [ < part>, ..., < part> ] )
$path->down( < part>, [ < part>, ..., < part> ] )

Modify $path by appending each < part> to the end of $path, separated by "/"

Returns $path

$path->child( < part>, [ < part>, ..., < part> ] )

Make a copy of $path and push each < part> to the end of the new path.

Returns the new child path

$path->pop( < count> )

Modify $path by removing < count> parts from the end of $path

Returns the removed path as a Path::Abstract object

$path->up( < count> )

Modify $path by removing < count> parts from the end of $path

Returns $path

$path->parent( < count> )

Make a copy of $path and pop < count> parts from the end of the new path

Returns the new parent path

$path->file
$path->file( < part>, [ < part>, ..., < part> ] )

Create a new Path::Class::File object using $path as a base, and optionally extending it by each < part>

Returns the new file object

$path->dir
$path->dir( < part>, [ < part>, ..., < part> ] )

Create a new Path::Class::Dir object using $path as a base, and optionally extending it by each < part>
Returns the new dir object

DBIx::SQL::Abstract is a Perl module that provides a convenient abstraction layer to a database.

SYNOPSIS

use DBIx::SQL::Abstract;

my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

Building SQL Abstractions.

my($query, @bind) = $dbh->select($table, @fields, %where, @order);
my($query, @bind) = $dbh->insert($table, %fieldvals || @values);
my($query, @bind) = $dbh->update($table, %fieldvals, %where);
my($query, @bind) = $dbh->delete($table, %where);

Using DBI methods

my $sth = $dbh->prepare($query);
$sth->execute(@bind_params);
...
my $rc = $dbh->begin_work;
my $rc = $dbh->commit;
my $rc = $dbh->rollback;
my $rc = $dbh->disconnect;

Anything else DBI method can be used, by Example:

my $err = $dbh->err;
my $err = $dbh->errstr;
my $rv = $dbh->state;
my $rc = $dbh->DESTROY;

The intention of this module is to join some methods from the DBI and the SQL::Abstract modules, for a convenient and easy use.

To begin, we create an object, but first we must create a hash which contains the database parameters as follows.

my %dbcfg = { PrintError => 1,
RaiseError => 0,
AutoCommit => 0,
ChopBlanks => 1
driver => Pg,
dbname => db,
host => undef,
port => undef,
user => user,
passwd => undef
};

Notice that this parameters are set as default unless you set your required values.
my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

This object automatically creates the connection with the database, and gets the methods listed above.

Libdatastruct is an ANSI C library for abstract data types (ADT) and common algorithms. Since it uses some compiler specific optimization methods, it is compatible for any GCC (or compatible) compiler.

This helps the programmer focus on other, usually more important, aspects of the program, and not have to reinvent the wheel.

Memory has been considered a vital factor, so problems in its management have been (or tried to) avoided, therefore memory leaks, use of uninitialized memory, reading/writing invalid blocks, etc. are a constant preoccupation.

These are not original algorithms, they have been used for years, and are a fundamental part of computer science.

Installation:

make
make install

Usage:

compilation: cc program.c -ldatastruct -Wall -o program

Boost::Graph is a Perl interface to the Boost-Graph C++ libraries.

SYNOPSIS

use Boost::Graph;
# Create an empty instance of a Graph
my $graph = new Boost::Graph(directed=>0, net_name=>Graph Name, net_id=>1000);

# add edges
$graph->add_edge(node1=>a, node2=>b, weight=>1.1, edge=>edge name);
$graph->add_edge(node1=>$node1, node2=>$node2, weight=>2.3, edge=>$edge_obj);

ABSTRACT

Boost::Graph is a perl interface to the Boost-Graph C++ libraries that offer
many efficient and peer reviewed algorithms.

Boost::Graph is a perl interface to the Boost-Graph C++ libraries that offer many efficient and peer reviewed algorithms.

Persistent::Base is an Abstract Persistent Base Class.

SYNOPSIS

### we are a subclass of ... ###
use Persistent::Base;
@ISA = qw(Persistent::Base);

ABSTRACT

This is an abstract class used by the Persistent framework of classes to implement persistence with various types of data stores. This class provides the methods and interface for implementing Persistent classes. Refer to the Persistent documentation for a very thorough introduction to using the Persistent framework of classes.

This class is part of the Persistent base package which is available from:

http://www.bigsnow.org/persistent
ftp://ftp.bigsnow.org/pub/persistent

Before we get started describing the methods in detail, it should be noted that all error handling in this class is done with exceptions. So you should wrap an eval block around all of your code. Please see the Persistent documentation for more information on exception handling in Perl.

ABSTRACT METHODS THAT NEED TO BE OVERRIDDEN IN THE SUBCLASS

datastore -- Sets/Returns the Data Store Parameters

eval {
### set the data store ###
$person->datastore(@args);

### get the data store ###
$href = $person->datastore();
};
croak "Exception caught: $@" if $@;

Returns (and optionally sets) the data store of the object. This method throws Perl execeptions so use it with an eval block.

Setting the data store can involve anything from initializing a connection to opening a file. Getting a data store usually means returning information pertaining to the data store in a useful form, such as a connection to a database or a location of a file.

UML::State is an object oriented module which draws simple state diagrams.

SYNOPSIS

use UML::State;

my $diagram = UML::State->new(
$node_array,
$start_list,
$accept_list,
$edges
);

# You may change these defaults (doing so may even work):
$UML::State::ROW_SPACING = 75; # all numbers are in pixels
$UML::State::LEFT_MARGIN = 20;
$UML::State::WIDTH = 800;
$UML::State::HEIGHT = 800;

print $diagram->draw();

ABSTRACT

Are you tired of pointing and clicking to make simple diagrams? Do your wrists hurt thinking about making the pretty UML your boss likes so well? Consider using UML::State and UML::Sequence to make your life easier.

UML::State together with drawstate.pl allows you to easily generate state diagrams. You enter them in something like a cross between ASCII art and school room algebra. They come out looking like something from a drawing program like Visio. See drawstate.pl in the distribution for details about the input format and the samples directory for some examples of input and output.

You will probably use this class by running drawstate.pl or drawstatexml.pl which are included in the distribution. But you can use this package directly to gain control over the appearance of your pictures.

The two methods you need are new and draw (see below). If you want, you may change the dimensions by setting the package global variables as shown in the SYNOPSIS. Obviously, no error checking is done, so be careful to use reasonable values (positive numbers are good). All numbers are in pixels (sorry by Beziers in SVG seem to require pixels). I have not tried changing the numbers, so I dont have any idea if doing so makes reasonable changes to the output.

radlib is a C language library developed to abstract details of interprocess communications and common linux/unix system facilities so that application developers can concentrate on application solutions.
It encourages developers (whether expert or novice) to use a proven paradigm of event-driven, asynchronous design.
By abstracting interprocess messaging, events, timers, and any I/O device that can be represented as a file descriptor, radlib simplifies the implementation of multi-purpose processes, as well as multi-process applications.
radlib greatly improves typical process performance through the use of shared memory buffers to avoid costly "malloc" and "free" library calls.
These buffers are also used for interprocess messages. radlib also utilizes shared memory constructs to provide global message queue management and global "Queue Groups" for increased interprocess communications flexibility.
All shared resources are semaphore protected to avoid issues with concurrent access.
In short, radlib is a sincere attempt to provide real-time OS capability on a non-real-time OS. It has been successfully deployed on linux, MacOSX and FreeBSD but there is no reason it would not build and run on any flavor of unix supporting System V IPC.
Specifically, radlib provides fast system buffers, a simple config file utility, events, doubly-linked lists, process logging through syslog, message queues, semaphores, shared memory utilities, timers, stacks, state machine utilities, a process framework, a process management utility to start/stop groups of processes, optional MySQL or PostgreSQL database API, straightforward TCP/streams socket API, and other assorted system utilities.
Enhancements:
- hanged some database field processing to comply with the postgresql changes made in version 8.