Free attributes software for linux

Class::Declare::Attributes is a Perl module with Class::Declare method types using Perl attributes.

SYNOPSIS

package My::Class;

use 5.006;
use strict;
use warnings;

use base qw( Class::Declare::Attributes );

# declare the class/instance attributes
__PACKAGE__->declare( ... );

#
# declare class/static/restricted/etc methods of this package
#

sub my_abstract : abstract { ... }
sub my_class : class { ... }
sub my_static : static { ... }
sub my_restricted : restricted { ... }
sub my_public : public { ... }
sub my_private : private { ... }
sub my_protected : protected { ... }

Class::Declare::Attributes extends Class::Declare by adding support for Perl attributes for specifying class method types. This extension was inspired by Damian Conways Attribute::Handlers module, and Tatsuhiko Miyagawas Attribute::Protected module. The original implementation used Attribute::Handlers, but now simply refers to attributes.

The addition of Perl attribute support (not to be confused with object attributes, which are entirely different, and also supported by Class::Declare) greatly simplifies the specification of Class::Declare-derived class and instance methods. This should aid in the porting of existing code (Perl, Java and C++) to a Class::Declare framework, as well as simplify the development of new modules.

With the addition of Perl attributes, Class::Declare methods can now be written as

sub method : public
{
my $self = shift;
...
}
instead of
sub method
{
my $self = __PACKAGE__->public( shift );
...
}

Extended attributes for Python is a Python module that can manipulate extended attributes in filesystems that support them.

Object::Relation::Meta::Attribute::Schema is a Perl module for Object::Relation database store builder.

Synopsis

# Assuming MyThingy was generated by Object::Relation::Meta and that were building
# a data store schema.
my $class = MyThingy->my_class;

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, $/;
print " Column: ", $attr->column, $/;
if (my $idx = $attr->index) {
print " Index: $idxn";
}
if (my $ref = $attr->references) {
print " References ", $ref->package, $/;
print " On Delete: ", $attr->on_delete, $/;
}
}

This module is provides metadata for all Object::Relation class attributes while building a storage schema. Loading Object::Relation::Schema causes it to be used instead of Object::Relation::Meta::Attribute. This is so that extra metadata methods are available that are useful in constructing the schema, but are not otherwise useful when an application is actually in use.

Tactical Rogue game aims to take the best of two very interesting concepts and merge them together, namely, the variety and endlessness of rogue and the strategic elements of Tactics Ogre/Final Fantasy Tactics.

Basically this means well be autogenerating vast amounts of items, weapons and armors, autogenerating dungeon labyrinths and autogenerating monsters based on set profiles. Then, we will use these autogenerated worlds and enforce a strategical/tactical engine based upon many simply attributes such as speed, movement, agility, strength, dexterity, wisdom, intelligence, hp, mp, level, class and experience. The game will run semi-realtime, in the sense that time progresses until someones wait-time reaches zero allowing them to move/act which will then reset their wait-time to its maximum value based upon the characters traits and attributes.

The game will be developed under linux using sdl and c++, using .png for graphical storage of sprites and aminations and .ogg (vorbis) for storage of sound effects and music. All files, be it code, music or sprites will be licenced in a license compatible with the GPL, most likely under the GPL.

Class::ObjectTemplate is a Perl extension for an optimized template builder base class.

SYNOPSIS

package Foo;
use Class::ObjectTemplate;
require Exporter;
@ISA = qw(Class::ObjectTemplate Exporter);

attributes(one, two, three);

# initialize will be called by new()
sub initialize {
my $self = shift;
$self->three(1) unless defined $self->three();
}

use Foo;
$foo = Foo->new();

# store 27 in the one attribute
$foo->one(27);

# check the value in the two attribute
die "should be undefined" if defined $foo->two();

# set using the utility method
$foo->set_attribute(one,27);

# check using the utility method
$two = $foo->get_attribute(two);

# set more than one attribute using the named parameter style
$foo->set_attributes(one=>27, two=>42);

# or using array references
$foo->set_attributes([one,two],[27,42]);

# get more than one attribute
@list = $foo->get_attributes(one, two);

# get a list of all attributes known by an object
@attrs = $foo->get_attribute_names();

# check that initialize() is called properly
die "initialize didnt set three()" unless $foo->three();

Class::ObjectTemplate is a utility class to assist in the building of other Object Oriented Perl classes.

It was described in detail in the OReilly book, "Advanced Perl Programming" by Sriram Srinivasam.

XML::DOM::Attr is an XML attribute in XML::DOM.

XML::DOM::Attr extends XML::DOM::Node.

The Attr nodes built by the XML::DOM::Parser always have one child node which is a Text node containing the expanded string value (i.e. EntityReferences are always expanded.) EntityReferences may be added when modifying or creating a new Document.

The Attr interface represents an attribute in an Element object. Typically the allowable values for the attribute are defined in a document type definition.

Attr objects inherit the Node interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the Node attributes parentNode, previousSibling, and nextSibling have a undef value for Attr objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type.

Furthermore, Attr nodes may not be immediate children of a DocumentFragment. However, they can be associated with Element nodes contained within a DocumentFragment. In short, users and implementors of the DOM need to be aware that Attr nodes have some things in common with other objects inheriting the Node interface, but they also are quite distinct.

The attributes effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attributes effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attributes effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the nodeValue attribute on the Attr instance can also be used to retrieve the string version of the attributes value(s).

In XML, where the value of an attribute can contain entity references, the child nodes of the Attr node provide a representation in which entity references are not expanded. These child nodes may be either Text or EntityReference nodes. Because the attribute type may be unknown, there are no tokenized attribute values.