Free scalar properties 0.12 software for linux

Scalar::Properties is a Perl module package that contains run-time properties on scalar variables.

SYNOPSIS

use Scalar::Properties;
my $val = 0->true;
if ($val && $val == 0) {
print "yup, its true alright...n";
}

my @text = (
hello world->greeting(1),
forget it,
hi there->greeting(1),
);
print grep { $_->is_greeting } @text;

my $l = hello world->length;

Scalar::Properties attempts to make Perl more object-oriented by taking an idea from Ruby: Everything you manipulate is an object, and the results of those manipulations are objects themselves.

hello world->length
(-1234)->abs
"oh my god, its full of properties"->index(g)

The first example asks a string to calculate its length. The second example asks a number to calculate its absolute value. And the third example asks a string to find the index of the letter g.

Using this module you can have run-time properties on initialized scalar variables and literal values. The word properties is used in the Perl 6 sense: out-of-band data, little sticky notes that are attached to the value. While attributes (as in Perl 5s attribute pragma, and see the Attribute::* family of modules) are handled at compile-time, properties are handled at run-time.
Internally properties are implemented by making their values into objects with overloaded operators. The actual properties are then simply hash entries.
Most properties are simply notes you attach to the value, but some may have deeper meaning. For example, the true and false properties plays a role in boolean context, as the first example of the Synopsis shows.

Properties can also be propagated between values. For details, see the EXPORTS section below. Here is an example why this might be desirable:

pass_on(approximate);
my $pi = 3->approximate(1);
my $circ = 2 * $rad * $pi;

# now $circ->approximate indicates that this value was derived
# from approximate values

Please dont use properties whose name start with an underscore; these are reserved for internal use.

You can set and query properties like this:

$var->myprop(1)

sets the property to a true value.

$var->myprop(0)

sets the property to a false value. Note that this doesnt delete the property (to do so, use the del_props method described below).

$var->is_myprop, $var->has_myprop

returns a true value if the property is set (i.e., defined and has a true value). The two alternate interfaces are provided to make querying attributes sound more natural. For example:

$foo->is_approximate;
$bar->has_history;

This is a plugin for the Konqueror file manager, which adds an additional tab to the file properties dialogue allowing the destination of a symbolic link to be viewed and changed.
The plugin is released under the GNU General Public Licence, see the file LICENSE within the distribution archive for further information.
The plugin is installed in much the same way as any other KDE or GNU application; you must have the Qt toolkit and KDE 3.1.2 or later already installed, of course. See the INSTALL file for detailed installation instructions. Once the plugin is installed, see the documentation in the KDE Help Centre for more information.
Enhancements:
- Accelerator key "&Symbolic Link" for tab now clashes with "&Share" (KDE 3.3.2).
- Change accelerator to "S&ymbolic Link".
- Fix download URL in documentation.

MMDS::Properties Perl module contains flexible properties handling for MMDS.
use MMDS::Properties;
my $cfg = new MMDS::Properties;
# Preset a property.
$cfg->set_property("config.version", "1.23");
# Parse a properties file.
$cfg->parsefile("config.prp");
# Get a property value
$version = $cfg->get_property("config.version");
# Same, but with a default value.
$version = $cfg->get_property("config.version", "1.23");
# Get the list of subkeys for a property, and process them.
my $aref = $cfg->get_property_keys("item.list");
foreach my $item ( @$aref ) {
if ( $cfg->get_property("item.list.$item") ) {
....
}
}
The property mechanism is modelled after the Java implementation of properties.
In general, a property is a string value that is associated with a key. A key is a series of names (identifiers) separated with periods. Names are treated case insensitive. Unlike in Java, the properties are really hierarchically organized. This means that for a given property you can fetch the list of its subkeys, and so on. Moreover, the list of subkeys is returned in the order the properties were defined.
Property lookup can use a preset property context. If a context ctx has been set using set_context(ctx), get_property(foo.bar) will first try ctx.foo.bar and then foo.bar. get_property(.foo.bar) (note the leading period) will only try ctx.foo.bar and raise an exception if no context was set.
Design goals:
- properties must be hierarchical of unlimited depth;
- manual editing of the property files (hence unambiguous syntax and lay out);
- it must be possible to locate all subkeys of a property in the order they appear in the property file(s);
- lightweight so shell scripts can use it to query properties.
METHODS
new
new is the standard constructor. new doesnt require any arguments, but you can pass it a list of initial properties to store in the resultant properties object.
new
clone is like new, but it takes an existing properties object as its invocant and returns a new object with the contents copied.
WARNING This is not yet a deep copy, so take care.
parsefile file [ , path [ , context ] ]
parsefile reads a properties file and adds the contents to the properties object.
file is the name of the properties file. This file is searched in all elements of path (an array reference) unless the name starts with a slash. Default path is . (current directory).
context can be used to designate an initial context where all properties from the file will be subkeys of.
For the detailed format of properties files see below.
get_property prop [ , default ]
Get the value for a given property prop.
If a context ctx has been set using set_context(ctx), get_property(foo.bar) will first try ctx.foo.bar and then foo.bar. get_property(.foo.bar) (note the leading period) will only try ctx.foo.bar and raise an exception if no context was set.
If no value can be found, default is used.
In either case, the resultant value is examined for references to other properties or environment variables. Such a reference looks like
${name}
${name:default}
name can be the name of an environment variable or property. If name is found in the environment, its value is substituted and the expansion process continues, re-examining the new contents, until no further substitutions can be made. If a non-empty value exists for the property name its value is used in a similar way. Hence an empty value for a property will be ignored. If no value can be found, the default string (not to be confused with the default parameter) will be returned.
As an additional service, a tilde ~ in what looks like a file name will be expanded to ${HOME}.
The method result_in_context can be used to determine how the result was obtained. It will return a non-empty string indicating the context in which the result was found, an emptry string indicating the result was found without context, or undef if no value was found at all.
get_property_noexpand prop [ , default ]
This is like get_property, but does not do any expansion.
gps prop [ , default ]
This is like get_property, but raises an exception if no value could be established.
This is probably the best and safest method to use.
get_property_keys prop
Returns an array reference with the names of the (sub)keys for the given property. The names are unqualified, e.g., when properties foo.bar and foo.blech exist, get_property_keys(foo) would return [bar, blech].
expand value [ , context ]
Perform the expansion as described with get_property.
set_property prop, value
Set the property to the given value.
set_properties prop1 => value1, ...
Add a hash (key/value pairs) of properties to the set of properties.
set_context context
Set the search context. Without argument, clears the current context.
get_context
Get the current search context.
result_in_context
Get the context status of the last search.
Empty means it was found out of context, a string indicates the context in which the result was found, and undef indicates search failure.
dump [ start [ , stream ] ]
Produce a listing of all properties from a given point in the hierarchy and write it to the stream.
stream defaults to *STDOUT.
dumpx [ start [ , stream ] ]
Like dump, but dumps with all values expanded.

Config::Properties is a Perl module to read and write property files.

SYNOPSIS

use Config::Properties;

# reading...

open PROPS, "< my_config.props"
or die "unable to open configuration file";

my $properties = new Config::Properties();
$properties->load(*PROPS);

$value = $properties->getProperty( $key );


# saving...

open PROPS, "> my_config.props"
or die "unable to open configuration file for writing";

$properties->setProperty( $key, $value );

$properties->format( %s => %s );
$properties->store(*PROPS, $header );

Config::Properties is a near implementation of the java.util.Properties API. It is designed to allow easy reading, writing and manipulation of Java-style property files.

The format of a Java-style property file is that of a key-value pair seperated by either whitespace, the colon (:) character, or the equals (=) character. Whitespace before the key and on either side of the seperator is ignored.
Lines that begin with either a hash (#) or a bang (!) are considered comment lines and ignored.

A backslash () at the end of a line signifies a continuation and the next line is counted as part of the current line (minus the backslash, any whitespace after the backslash, the line break, and any whitespace at the beginning of the next line).

The official references used to determine this format can be found in the Java API docs for java.util.Properties at http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html.
When a property file is saved it is in the format "key=value" for each line. This can be changed by setting the format attribute using either $object->format( $format_string ) or $object->setFormat( $format_string ) (they do the same thing). The format string is fed to printf and must contain exactly two %s format characters. The first will be replaced with the key of the property and the second with the value. The string can contain no other printf control characters, but can be anything else. A newline will be automatically added to the end of the string. You an get the current format string either by using $object->format() (with no arguments) or $object->getFormat().

If a recent version of module Text::Wrap is available, long lines are conveniently wrapped when saving.

WWW::Webrobot::Properties is a Perl module that implements a config format like java.util.Properties.

SYNOPSIS

my $config = WWW::Webrobot::Properties->new(
listmode => [qw(names auth_basic output http_header proxy no_proxy)],
key_value => [qw(names http_header proxy)],
multi_value => [qw(auth_basic)],
structurize => [qw(load mail)],
);
my $cfg = $config->load_file($cfg_name, $cmd_param);

This class implements a config format like java.util.Properties, see http://java.sun.com/j2se/1.3/docs/api/java/util/Properties.html for more docs.
Note: Some features are not implemented but there are some extensions for lists.

EXTENDED FORMAT

Listmode properties may be written

listprop=value0
listprop=value1
listprop=value2

or

listprop.0=value0
listprop.1=value1
listprop.2=value2

These properties are made available as perl-arrays.

Scalar::Number is a Perl module with numeric aspects of scalars.

SYNOPSIS

use Scalar::Number qw(scalar_num_part);

$num = scalar_num_part($scalar);

use Scalar::Number qw(sclnum_is_natint sclnum_is_float);

if(sclnum_is_natint($value)) { ...
if(sclnum_is_float($value)) { ...

use Scalar::Number qw(sclnum_val_cmp sclnum_id_cmp);

@sorted_nums = sort { sclnum_val_cmp($a, $b) } @floats;
@sorted_nums = sort { sclnum_id_cmp($a, $b) } @floats;

This module is about the numeric part of plain (string) Perl scalars. A scalar has a numeric value, which may be expressed in either the native integer type or the native floating point type. Many values are expressible both ways, in which case the exact representation is insignificant. To fully understand Perl arithmetic it is necessary to know about both of these representations, and the differing behaviours of numbers according to which way they are expressible.
This module provides functions to extract the numeric part of a scalar, classify a number by expressibility, and compare numbers across representations.

Framework for Contact properties offers quick access to your contacts and also view their status.
Short version:
Want quick access to your contacts, or see what their status is? Here you go: Have contact cards floating on the desktop, or list them on Kicker, so things like chatting or emailing to them is only one/two mouse clicks away. Or drop them a file/url!
Long version:
A framework for contacts and services upon them. It consists of two libs, libcontactpropertiescore and libcontactpropertiesgui.
The tarball has additionally some useful examples for services and two applications, a contact cards server and a kicker applet, based on the Contacts menu for kicker.
No translations available.
Please see http://frinring.wordpress.com/2006/07/05/framework-for-contacts-and-services-slowly-getting-shapes/
Then try it and create some own services, to be able to give feedback on the framework(!)
To have your property and services loaded, add a file named "contactpropertiesrc" to "$HOME/.kde/share/config" with this content:
[General]
Properties=birthday,imaddress,emailaddress,homepageurl,phonenumber,address,note,shellname,yourtype
[Property:yourtype]
ActionServices=youraction,youraction2
DefaultActionServices=youraction,youraction2
DataActionServices=yourdataaction,yourdataaction2
DefaultDataActionServices=yourdataaction2,yourdataaction2
StatusServices=yourstatus, yourstatus2
with "your*" adopted to your property and the optional services...
Enhancements:
- applet: sorting of contact lists can be configured

Scalar::Defer is a Perl module to calculate values on demand.

SYNOPSIS

use Scalar::Defer; # exports defer and lazy

my ($x, $y);
my $dv = defer { ++$x }; # a deferred value (not memoized)
my $lv = lazy { ++$y }; # a lazy value (memoized)

print "$dv $dv $dv"; # 1 2 3
print "$lv $lv $lv"; # 1 1 1

my $forced = force $dv; # force a normal value out of $dv

print "$forced $forced $forced"; # 4 4 4

This module exports two functions, defer and lazy, for building values that are evaluated on demand. It also exports a force function to force evaluation of a deferred value.

defer {...}

Takes a block or a code reference, and returns a deferred value. Each time that value is demanded, the block is evaluated again to yield a fresh result.

lazy {...}

Like defer, except the value is computed at most once. Subsequent evaluation will simply use the cached result.

force $value

Force evaluation of a deferred value to return a normal value. If $value was already normal value, then force simply returns it.

NOTES

Deferred values are not considered objects (ref on them returns 0), although you can still call methods on them, in which case the invocant is always the forced value.

Unlike the tie-based Data::Lazy, this module operates on values, not variables. Therefore, assigning into $dv and $lv above will simply replace the value, instead of triggering a STORE method call.

Also, thanks to the overload-based implementation, this module is about 2x faster than Data::Lazy.