rit_object
index
/usr/local/fac/src/python/rit_object/rit_object.py

$Id: rit_object.py,v 3.1 2015/08/05 16:04:38 jeh Exp $
 
An alternative to the namedtuple construct in the Python collections module.
This module creates classes with a fixed set of slots
 
For historical reasons, this library is known as the "quick class" library.
There are however two ways to build a quick class in this framework:
1. Inherit the rit_struct class defined here.
2. Create a class by calling the quickClass function.
 
The only differences between using a quick class and a normal class
definition are as follows.
 
1. A default constructor is provided that takes positional or keyword
   arguments to initialize the slots declared.
2. The methods __str__, __repr__, __eq__, and __ne__ are predefined.
3. The types of the class's slots (attributes) can optionally be defined
   (via the _slots class variable in a class declaration or additional
   arguments to the quickClass function) and checked at run time.
 
The differences between a class created through this package and one created
through collections.namedtuple are as follows.
 
1. Objects created via this library are not iterable.
2. The attributes in objects created by this library are writable.
 
NOTE: To disable type checking (for speed), add the following method
after and outside your class's definition. Substitute your class's name
for the name YOURCLASS
 
    YOURCLASS.__setattr__ = object.__setattr__

 
Modules
       
abc

 
Classes
       
builtins.object
rit_struct

 
class rit_struct(builtins.object)
    The base class for all classes created using this framework.
Note that the methods contained herein apply to classes inheriting
rit_struct; it is not expected that classes declared as inheriting
rit_struct would define their own methods, much less redefine
these.
That being said, since rit_struct's subclasses will not explicitly
contain their own constructors, programmers of those subclasses must
be familiar with the API for the constructor defined here.
 
rit_struct expects its subclasses to have one of the following
two class variables defined:
 
If __slots__ is defined, it is a tuple of names of class slots,
or attributes, represented as strings. These names are assumed
to be exactly the set of slots to be initialized, set, and
otherwise accessed. (Python enforces this.) However, the slots
can have any value; there is no type checking.
Example:
    class Student( rit_struct ):
        __slots__ = ( "age", "gpa" )
 
If _slots is defined, it is a tuple of tuples. The inner
tuples are all of length 2. The first value of each such
pair is either a type or a tuple of types. The second
value is the name of the slot, as in the __slots__ case above.
It works just like the first case with __slots__, but now
the values that may be assigned to the slots must be of
(one of) the type(s) associated with it.
Example:
    class Student( rit_struct ):
        _slots = ( (int,"age"), ((str,float),"gpa") )
 
The one exception is that, instead of a type one may use the string
name of the class being built. This is the way one refers to the
type one is building for structurally recursive types.
Note that mutually recursive types are not (yet) supported.
 
The class returned can be constructed using the provided name and
either positional or keyword arguments. See the __init__ method
for rit_struct
 
  Methods defined here:
__eq__(self, other)
(DO NOT call this function directly; access it via the '=='
 operator.)
Answer False if other is not the same type as self, or if
the values of the slots in the two objects are not all equal
(through the use of the '!=' operator, i.e., __ne__).
Answer True otherwise.
Precondition: the object must not contain circular references.
    If it does, this method must be redefined in the subclass.
__init__(self, *args, **kwargs)
Initialize a new instance of a subclass of rit_struct. The
constructor call argument list should contain a value for
each attribute of the class, presented either in the same
order as the _slots declaration (args), or with keyword names
that match the slot names (kwargs). These two approaches may
not be mixed; that is either args or kwargs must be empty.
 
args: a sequence of values for each slot declared in the subclass
kwargs: a dictionary of values for each slot declared in
        the subclass. The keys in the dictionary match the
        names of the slots.
__ne__(self, other)
(DO NOT call this function directly; access it via the '!='
 operator.)
Answer not ( self == other ), i.e., not __eq__( other ).
__repr__(self)
(DO NOT call this function directly; access it via the repr
 global function.)
Return a string that, if evaluated, would re-create this object.
If the object contains multiple references involving only
rit_structs, the returned string will be degraded to avoid
potential infinite recursion.
__setattr__(self, name, value)
This is a private function. Do NOT directly call it.
It checks attribute (slot) references for type validity.
__str__(self)
(DO NOT call this function directly; access it via the str
 global function.)
Return a string representation of the value of this object
using its class's name followed by a listing the values of
all of its slots.
If the object contains multiple references involving only
rit_structs, the returned string will be degraded to avoid
potential infinite recursion.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__hash__ = None

 
Functions
       
makeAbstractClass(className)
Create and return an abstract class.
This is used for the run-time type checking that rit_struct provides.
 
For more details on abstract base classes, see ABCMeta in package abc.
 
When this function returns, the created abstract class
has as yet no 'concrete' classes that conform to it.
Here is an example of how you use it:
    Master = makeAbstractClass( "Master" )
    ... Create classes C1, C2, and C3 using rit_struct or quickClass.
    ... On the other hand, any of them could be previously defined
        types, too.
    Master.addClasses( C1, C2, C3 )
    C1, C2, and C3 are now subclasses of Master.
    This means that if a quick class says that a slot must be
    of type Master, then an instance of C1, C2, or C2 will work.
quickClass(name, *slotDecls)
Return a new class that has the provided name and slots (attributes).
 
(This is an alternative to the explicit class declaration using the
 base class rit_struct.)
 
slotDecls: a sequence of slot declarations
Each slot declaration provided is a 2-tuple, with the slot's type
or tuple of types first and the slot's name second.
The one exception is that, instead of a type one may use the string
name of the class being built. This is the way one refers to the
type one is building for structurally recursive types.
 
Note that mutually recursive types are not (yet) supported.
 
The class returned can be constructed using the provided name and
either positional or keyword arguments. See the __init__ method
for rit_struct

 
Data
        REV = '$Revision: 3.1 $'
stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='ANSI_X3.4-1968'>