Free bottomfeeders tuscaloosa al software for linux

Net::CSTA project is a perl-module for talking to an ECMA CSTA Phase I server.

ECMA CSTA is a ASN.1 based protocol for building CTI applications. Typical use include subscribing to events (aka moinitoring), placing and modifying calls.

This module only support CSTA Phase I (mainly because that is what I have access to). The module has been tested with Ericsson AL 4.0 (application link) with an MD110.

SYNOPSIS

use Net::CSTA;

# Connect to the CSTA server
my $csta = Net::CSTA->new(Host=>csta-server,Port=>csta-server-port);
# Create a monitor for 555
my $number = 555;
$csta->request(serviceID=>71,
serviceArgs=>{monitorObject=>{device=>{dialingNumber=>$number}}})

for (;;)
{
my $pdu = $csta->receive();
print $pdu->toXML();
}

Bio::Restriction::Enzyme is a single restriction endonuclease (cuts DNA at specific locations).

SYNOPSIS

# set up a single restriction enzyme. This contains lots of
# information about the enzyme that is generally parsed from a
# rebase file and can then be read back

use Bio::Restriction::Enzyme;

# define a new enzyme with the cut sequence
my $re=new Bio::Restriction::Enzyme
(-enzyme=>EcoRI, -seq=>G^AATTC);

# once the sequence has been defined a bunch of stuff is calculated
# for you:

#### PRECALCULATED

# find where the enzyme cuts after ...
my $ca=$re->cut;

# ... and where it cuts on the opposite strand
my $oca = $re->complementary_cut;

# get the cut sequence string back.
# Note that site will return the sequence with a caret
my $with_caret=$re->site; #returns G^AATTC;

# but it is also a Bio::PrimarySeq object ....
my $without_caret=$re->seq; # returns GAATTC;
# ... and so does string
$without_caret=$re->string; #returns GAATTC;

# what is the reverse complement of the cut site
my $rc=$re->revcom; # returns GAATTC;

# now the recognition length. There are two types:
# recognition_length() is the length of the sequence
# cutter() estimate of cut frequency

my $recog_length = $re->recognition_length; # returns 6
# also returns 6 in this case but would return
# 4 for GANNTC and 5 for RGATCY (BstX2I)!
$recog_length=$re->cutter;

# is the sequence a palindrome - the same forwards and backwards
my $pal= $re->palindromic; # this is a boolean

# is the sequence blunt (i.e. no overhang - the forward and reverse
# cuts are the same)
print "bluntn" if $re->overhang eq blunt;

# Overhang can have three values: "5", "3", "blunt", and undef
# Direction is very important if you use Klenow!
my $oh=$re->overhang;

# what is the overhang sequence
my $ohseq=$re->overhang_seq; # will return AATT;

# is the sequence ambiguous - does it contain non-GATC bases?
my $ambig=$re->is_ambiguous; # this is boolean

print "Stuff about the enzymenCuts after: $can",
"Complementary cut: $ocanSite:nt$with_caret orn",
"t$without_caretn";
print "Reverse of the sequence: $rcnRecognition length: $recog_lengthn",
"Is it palindromic? $paln";
print "The overhang is $oh with sequence $ohseqn",
"And is it ambiguous? $ambignn";


### THINGS YOU CAN SET, and get from rich REBASE file

# get or set the isoschizomers (enzymes that recognize the same
# site)
$re->isoschizomers(PvuII, SmaI); # not really true :)
print "Isoschizomers are ", join " ", $re->isoschizomers, "n";

# get or set the methylation sites
$re->methylation_sites(2); # not really true :)
print "Methylated at ", join " ", keys %{$re->methylation_sites},"n";

#Get or set the source microbe
$re->microbe(E. coli);
print "It came from ", $re->microbe, "n";

# get or set the person who isolated it
$re->source("Rob"); # not really true :)
print $re->source, " sent it to usn";

# get or set whether it is commercially available and the company
# that it can be bought at
$re->vendors(NEB); # my favorite
print "Is it commercially available :";
print $re->vendors ? "Yes" : "No";
print " and it can be got from ", join " ",
$re->vendors, "n";

# get or set a reference for this
$re->reference(Edwards et al. J. Bacteriology);
print "It was not published in ", $re->reference, "n";

# get or set the enzyme name
$re->name(BamHI);
print "The name of EcoRI is not really ", $re->name, "n";

This module defines a single restriction endonuclease. You can use it to make custom restriction enzymes, and it is used by Bio::Restriction::IO to define enzymes in the New England Biolabs REBASE collection.

Use Bio::Restriction::Analysis to figure out which enzymes are available and where they cut your sequence.

AutoLoader is a Perl module that can load subroutines only on demand.

SYNOPSIS

package Foo;
use AutoLoader AUTOLOAD; # import the default AUTOLOAD subroutine

package Bar;
use AutoLoader; # dont import AUTOLOAD, define our own
sub AUTOLOAD {
...
$AutoLoader::AUTOLOAD = "...";
goto &AutoLoader::AUTOLOAD;
}

The AutoLoader module works with the AutoSplit module and the __END__ token to defer the loading of some subroutines until they are used rather than loading them all at once.

To use AutoLoader, the author of a module has to place the definitions of subroutines to be autoloaded after an __END__ token. (See perldata.) The AutoSplit module can then be run manually to extract the definitions into individual files auto/funcname.al.

AutoLoader implements an AUTOLOAD subroutine. When an undefined subroutine in is called in a client module of AutoLoader, AutoLoaders AUTOLOAD subroutine attempts to locate the subroutine in a file with a name related to the location of the file from which the client module was read. As an example, if POSIX.pm is located in /usr/local/lib/perl5/POSIX.pm, AutoLoader will look for perl subroutines POSIX in /usr/local/lib/perl5/auto/POSIX/*.al, where the .al file has the same name as the subroutine, sans package. If such a file exists, AUTOLOAD will read and evaluate it, thus (presumably) defining the needed subroutine. AUTOLOAD will then goto the newly defined subroutine.
Once this process completes for a given function, it is defined, so future calls to the subroutine will bypass the AUTOLOAD mechanism.

Subroutine Stubs

In order for object method lookup and/or prototype checking to operate correctly even when methods have not yet been defined it is necessary to "forward declare" each subroutine (as in sub NAME;). See "SYNOPSIS" in perlsub. Such forward declaration creates "subroutine stubs", which are place holders with no code.

The AutoSplit and AutoLoader modules automate the creation of forward declarations. The AutoSplit module creates an index file containing forward declarations of all the AutoSplit subroutines. When the AutoLoader module is used it loads these declarations into its callers package.

Because of this mechanism it is important that AutoLoader is always used and not required.

Using AutoLoaders AUTOLOAD Subroutine

In order to use AutoLoaders AUTOLOAD subroutine you must explicitly import it:

use AutoLoader AUTOLOAD;

Overriding AutoLoaders AUTOLOAD Subroutine

Some modules, mainly extensions, provide their own AUTOLOAD subroutines. They typically need to check for some special cases (such as constants) and then fallback to AutoLoaders AUTOLOAD for the rest.

Such modules should not import AutoLoaders AUTOLOAD subroutine. Instead, they should define their own AUTOLOAD subroutines along these lines:

use AutoLoader;
use Carp;

sub AUTOLOAD {
my $sub = $AUTOLOAD;
(my $constname = $sub) =~ s/.*:://;
my $val = constant($constname, @_ ? $_[0] : 0);
if ($! != 0) {
if ($! =~ /Invalid/ || $!{EINVAL}) {
$AutoLoader::AUTOLOAD = $sub;
goto &AutoLoader::AUTOLOAD;
}
else {
croak "Your vendor has not defined constant $constname";
}
}
*$sub = sub { $val }; # same as: eval "sub $sub { $val }";
goto &$sub;
}

If any modules own AUTOLOAD subroutine has no need to fallback to the AutoLoaders AUTOLOAD subroutine (because it doesnt have any AutoSplit subroutines), then that module should not use AutoLoader at all.

Package Lexicals

Package lexicals declared with my in the main block of a package using AutoLoader will not be visible to auto-loaded subroutines, due to the fact that the given scope ends at the __END__ marker. A module using such variables as package globals will not work properly under the AutoLoader.

The vars pragma (see "vars" in perlmod) may be used in such situations as an alternative to explicitly qualifying all globals with the package namespace. Variables pre-declared with this pragma will be visible to any autoloaded routines (but will not be invisible outside the package, unfortunately).

Not Using AutoLoader

You can stop using AutoLoader by simply

no AutoLoader;

AutoLoader vs. SelfLoader

The AutoLoader is similar in purpose to SelfLoader: both delay the loading of subroutines.

SelfLoader uses the __DATA__ marker rather than __END__. While this avoids the use of a hierarchy of disk files and the associated open/close for each routine loaded, SelfLoader suffers a startup speed disadvantage in the one-time parsing of the lines after __DATA__, after which routines are cached. SelfLoader can also handle multiple packages in a file.

AutoLoader only reads code as it is requested, and in many cases should be faster, but requires a mechanism like AutoSplit be used to create the individual files. ExtUtils::MakeMaker will invoke AutoSplit automatically if AutoLoader is used in a module source file.

OpenDaemon (Formerly OpenXMLD) started as an open-source native XML database server, which aims at achieving the following special goals:
- Performant enough that it can eliminate all the performance problems related to XMLs nature (e.g the need to make a parse tree for each document). so it can offer XMLs extensibility in places where any other non-XML database server can be used.
- As much SQL-compliant as possible so it can replace the current non-XML servers easily and with a minimum of effort (e.g having ODBC and JDBC drivers with no SQL XML translation stuff.)
After about a year of development, it was found that its better to concentrate in the first place on the platform containing the server rather than the query parsing and data extraction functionaltiy, the decision was to do everything on its own, by creating a server platform that provides a generic and flexible model of work the same previous goals could be achieved easier and in a more open and distributed manner.
In this direction, OpenDaemon could reach the stage at which it can be a server of any protocol, and the protocol implementation can utilize a broad set of capabilities built inside the server.
Because portability is a concern, OpenDaemon contains well-defined interfaces between its modules, to allow for easy replacement of any part for portability or performance reasons. Last but not least - OpenDaemon is written with object orientation in mind in the C programming language.
OpenDaemon is an extension of the efforts formerly done in KXParse.
Enhancements:
- Generlized the engine interface so it is not XML-specific.
- Engine capability specification.
- Support for a broader range of functionality within the engine API.
- Configuration parser and API rewrite using bison and flex.
- Support for interface association to a particular port.
- Support for interface parameters and interface instances.
- Generic, more flexible storage API and associated walker.
- Multi-process multi-tasker cleanups.
- Initial support for engine association to file types using the file extension.
- Error reporting model across engines and interfaces.
- Improved and more efficient connection handling.
- Better organization for the source code tree.
- Renamed to OpenDaemon.