Free instance name software for linux

Workspace Name Applet is a Gnome panel applet to display and edit the name of the current workspace.

DNS name parser is a Java utility library for parsing dns names, ip and hw addresses.

Synopsis

import su.netdb.parser.*;

Parser parser = new Parser();

Hashtable result = parser.parse(str);

System.out.println("string: "+result.get("string"));
System.out.println("hw: "+result.get("hw"));
System.out.println("name: "+result.get("name"));
System.out.println("domain: "+result.get("domain"));
System.out.println("ip_low: "+result.get("ip_low"));
System.out.println("ip_high: "+result.get("ip_high"));

"DNS name parser" is an utility library created to be used in a search application. Given a single input field its function is to differentiate between several types of possible input strings. Namely if it a dns name, IP address (exact, ip range or ip with wildcards) or hardware address. The result of the parsing is a Hashtable with possible keys "string", "hw", "name", "domain", "ip_low" and "ip_high".

Bio::Genex::Software is Perl module with methods for processing data from the GeneX DB table: Software.

SYNOPSIS

use Bio::Genex::Software;

# instantiating an instance
my $Software = Bio::Genex::Software->new(id=>47);

# retrieve data from the DB for all columns
$Software->fetch();

# creating an instance, without pre-fetching all columns
my $Software = new Bio::Genex::Software(id=>47);

# creating an instance with pre-fetched data
my $Software = new Bio::Genex::Software(id=>47, fetch_all=>1);

# retrieving multiple instances via primary keys
my @objects = Bio::Genex::Software->get_objects(23,57,98)


# retrieving all instances from a table
my @objects = Bio::Genex::Software->get_all_objects();

# retrieving the primary key for an object, generically
my $primary_key = $Software->id();

# or specifically
my $sw_pk_val = $Software->sw_pk();

# retreving other DB column attributes
my $name_val = $Software->name();
$Software->name($value);

my $version_val = $Software->version();
$Software->version($value);

my $type_val = $Software->type();
$Software->type($value);

my $con_fk_val = $Software->con_fk();
$Software->con_fk($value);

Each Genex class has a one to one correspondence with a GeneX DB table of the same name (i.e. the corresponding table for Bio::Genex::Software is Software).
Most applications will first create an instance of Bio::Genex::Software and then fetch the data for the object from the DB by invoking fetch().

However, in cases where you may only be accessing a single value from an object the built-in delayed fetch mechanism can be used. All objects are created without pre-fetching any data from the DB. Whenever an attribute of the object is accessed via a getter method, the data for that attribute will be fetched from the DB if it has not already been. Delayed fetching happens transparently without the user needing to enable or disable any features.

Since data is not be fetched from the DB until it is accessed by the calling application, it could presumably save a lot of access time for large complicated objects when only a few attribute values are needed.

mod_include is a post processing of SSI variables, Apache module.

Doesnt sound too helpful ? Well, maybe not, but I found that during construction of this site that I was frequently replicating 5 lines of text with only a single word altered (the left menu). This was both inefficient and awkward to debug, and didnt lend itself to keeping a common look and feel for the site as a whole. This extension allows large blocks of text to be stored as a variable, and for the small changable part to be altered just before the result is displayed.

Whats wrong with set anyway ?

When a variable is used in the value entry of a set command the system searches for the current value of the variable and substitutes it immediately. This fixes the value of the variable created so that it never changes, which is good for some applications, but lousy for dynamic content.

Usage

This module is an extension of the normal Apache behaviour, and should be read as an addendum to the basic mod_include commands.

define

This command sets up a variable in the same way as the set directive, except that any variable names used are not parsed at this time, but stored as names until displayed with the macro directive.

var

The name of the variable (macro) to define.

value

The value of the variable (macro).

macro

This command will expand a previously defined variable and replace any instances of the variable named in var in the variable def with the value given in value. Note that like other mod_include commands, the order of the variables is important, and should be declared in the sequence shown below:

var

The name of the variable to replace inside the macro.

value

The value to replace the variable with.

def

The previously defined macro to seach through.

Image::ExifTool::TagNames is an ExifTool tag name documentation.

This document contains a complete list of ExifTool tag names, organized into tables based on information type. Tag names are used to indicate the specific meta information that is extracted or written in an image.

TAG TABLES

The tables listed below give the names of all tags recognized by ExifTool, excluding unknown tags.

A Tag ID or Index is given in the first column of each table. A Tag ID is the computer-readable equivalent of a tag name, and is the identifier that is actually stored in the file. An Index refers to the location of the information, and is used if the information is stored at a fixed position in a data block.

A Tag Name is the handle by which the information is accessed. In some instances, more than one name may correspond to a single tag ID. In these cases, the actual name used depends on the context in which the information is found. Case is not significant for tag names. A question mark after a tag name indicates that the information is either not understood, not verified, or not very useful -- these tags are not extracted by ExifTool unless the Unknown (-u) option is enabled. Be aware that some tag names are different than the descriptions printed out by default when extracting information with "exiftool". To see the tag names instead of the descriptions, use "exiftool -s".

The Writable column indicates whether the tag is writable by ExifTool. Anything but an "N" in this column means the tag is writable. A "Y" indicates writable information that is either unformatted or written using the existing format. Other expressions give details about the information format, and vary depending on the general type of information. The format name may be followed by a number in square brackets to indicate the number of values written, or the number of characters in a fixed-length string (including a null terminator which is added if required).

An asterisk (*) after an entry in the Writable column indicates a protected tag which is not writable directly, but is set via a Composite tag. A tilde (~) indicates a tag this is only writable when print conversion is disabled (by setting PrintConv to 0, or using the -n option). A slash (/) indicates an avoided tag that is not created unless the group is specified (due to name conflicts with other tags). An exclamation point (!) indicates a tag that is considered unsafe to write under normal circumstances.

These unsafe tags are not set when calling SetNewValuesFromFile() or when using the exiftool -TagsFromFile option unless specified explicitly, and care should be taken when editing them manually since they may affect the way an image is rendered. A plus sign (+) indicates a list tag which supports multiple instances.
The HTML version of this document also lists possible Values for all tags which have a discrete set of values, and gives Notes for some tags.

Note: If you are familiar with common meta-information tag names, you may find that some ExifTool tag names are different than expected. The usual reason for this is to make the tag names more consistent across different types of meta information. To determine a tag name, either consult this documentation or run "exiftool -s" on a file containing the information in question.

Tk::bindtags can determine which bindings apply to a window, and order of evaluation.

SYNOPSIS

$widget->bindtags([tagList]); @tags = $widget->bindtags;

When a binding is created with the bind command, it is associated either with a particular window such as $widget, a class name such as Tk::Button, the keyword all, or any other string. All of these forms are called binding tags. Each window has a list of binding tags that determine how events are processed for the window. When an event occurs in a window, it is applied to each of the windows tags in order: for each tag, the most specific binding that matches the given tag and event is executed. See the Tk::bind documentation for more information on the matching process.

By default, each window has four binding tags consisting of the the windows class name, name of the window, the name of the windows nearest toplevel ancestor, and all, in that order. Toplevel windows have only three tags by default, since the toplevel name is the same as that of the window.

Note that this order is different from order used by Tcl/Tk. Tcl/Tk has the window ahead of the class name in the binding order. This is because Tcl is procedural rather than object oriented and the normal way for Tcl/Tk applications to override class bindings is with an instance binding. However, with perl/Tk the normal way to override a class binding is to derive a class. The perl/Tk order causes instance bindings to execute after the class binding, and so instance bind callbacks can make use of state changes (e.g. changes to the selection) than the class bindings have made.

The bindtags command allows the binding tags for a window to be read and modified.

If $widget->bindtags is invoked without an argument, then the current set of binding tags for $widget is returned as a list. If the tagList argument is specified to bindtags, then it must be a reference to and array; the tags for $widget are changed to the elements of the array. (A reference to an anonymous array can be created by enclosin the elements in [ ].) The elements of tagList may be arbitrary strings or widget objects, if no window exists for an object at the time an event is processed, then the tag is ignored for that event. The order of the elements in tagList determines the order in which binding callbacks are executed in response to events. For example, the command

$b->bindtags([$b,ref($b),$b->toplevel,all])

applies the Tcl/Tk binding order which binding callbacks will be evaluated for a button (say) $b so that $bs instance bindings are invoked first, following by bindings for $bs class, followed by bindings for $bs toplevel, followed by all bindings.

If tagList is an empty list i.e. [], then the binding tags for $widget are returned to the perl/Tk default state described above.

The bindtags command may be used to introduce arbitrary additional binding tags for a window, or to remove standard tags. For example, the command

$b->bindtags([TrickyButton,$b->toplevel,all])

replaces the (say) Tk::Button tag for $b with TrickyButton. This means that the default widget bindings for buttons, which are associated with the Tk::Button tag, will no longer apply to $b, but any bindings associated with TrickyButton (perhaps some new button behavior) will apply.

CGIFeed is a CGI program that reads news feeds (via XML/RDF/RSS) and prepares HTML pages for them.

You can enter new feeds through the Web page, and edit the name and update interval for each feed.

Net::Amazon::EC2 is a Perl interface to the Amazon Elastic Compute Cloud (EC2) environment.

SYNOPSIS

use Net::Amazon::EC2;

my $ec2 = Net::Amazon::EC2->new(
AWSAccessKeyId => PUBLIC_KEY_HERE,
SecretAccessKey => SECRET_KEY_HERE
);

# Start 1 new instance from AMI: ami-XXXXXXXX
my $instance = $ec2->run_instances(ImageId => ami-XXXXXXXX, MinCount => 1, MaxCount => 1);

my $running_instances = $ec2->describe_instances();

foreach my $inst (@{$running_instances}) {
print "$inst->{instance}[0]{instanceId}n";
}

# Terminate instance

my $result = $ec2->terminate_instances(InstanceId => $instance->{instance}[0]{instanceId});

If an error occurs in communicating with EC2, the return value will be undef and $ec2->{error} will be populated with the message.