MiddleKit.Core.Klass
index
/var/www/docs/Webware-1.1.1/MiddleKit/Core/Klass.py

 
Classes
       
MiddleKit.Core.MiddleDict.MiddleDict(__builtin__.dict)
Klass(MiddleKit.Core.MiddleDict.MiddleDict, MiddleKit.Core.ModelObject.ModelObject)
MiddleKit.Core.ModelObject.ModelObject(__builtin__.object)
Klass(MiddleKit.Core.MiddleDict.MiddleDict, MiddleKit.Core.ModelObject.ModelObject)

 
class Klass(MiddleKit.Core.MiddleDict.MiddleDict, MiddleKit.Core.ModelObject.ModelObject)
    Klass represents a class specification.
 
It is consisting primarily of a name and a list of attributes.
 
 
Method resolution order:
Klass
MiddleKit.Core.MiddleDict.MiddleDict
__builtin__.dict
MiddleKit.Core.ModelObject.ModelObject
__builtin__.object

Methods defined here:
__cmp__(self, other)
__hash__(self)
__init__(self, klassContainer, rawDict=None)
Initialize a Klass definition with a raw dictionary.
 
This is typically read from a file. The 'Class' field contains the name
and can also contain the name of the superclass (like "Name : SuperName").
Multiple inheritance is not yet supported.
__str__(self)
addAttr(self, attr)
addSubklass(self, klass)
allAttrs(self)
Returns a list of all attributes.
 
This includes those attributes that are inherited and derived.
The order is top down; that is, ancestor attributes come first.
allDataAttrs(self)
Return a list of all data attributes.
 
This includes those attributes that are inherited.
The order is top down; that is, ancestor attributes come first.
Derived attributes are not included in the list.
allDataRefAttrs(self)
Return a list of all data referencing attributes.
 
Returns a list of all data attributes that are obj refs or lists,
including those that are inherited.
asShortString(self)
attr(self, name, default=<class 'MiscUtils.NoDefault'>)
Return the attribute with the given name.
 
If no such attribute exists, an exception is raised unless a default
was provided (which is then returned).
attrs(self)
Return a list of all the klass' attributes not including inheritance.
awakeFromRead(self, klasses)
Perform further initialization.
 
Invoked by Klasses after all basic Klass definitions have been read.
backObjRefAttrs(self)
Return a list of all potentially referencing attributes.
 
Returns a list of all ObjRefAttrs in the given object model that can
potentially refer to this object. The list does NOT include attributes
inherited from superclasses.
buildDependencies(self)
Build dependencies of the klass.
 
A klass' immediate dependencies are its ancestor classes (which may
have auxilliary tables such as enums), the target klasses of all its
obj ref attrs and their descendant classes.
descendants(self, init=1, memo=None)
Return all descendant klasses of this klass.
hasAttr(self, name)
id(self)
Return the id of the class, which is an integer.
 
Ids can be fundamental to storing object references in concrete object stores.
This method will throw an exception if setId() was not previously invoked.
isAbstract(self)
isKindOfKlassNamed(self, name)
Check whether the klass is from the given kind.
 
Returns true if the klass is the same as, or inherits from,
the klass with the given name.
klasses(self)
lookupAncestorKlass(self, name, default=<class 'MiscUtils.NoDefault'>)
Search for and return the ancestor klass with the given name.
 
Raises an exception if no such klass exists, unless a default
is specified (in which case it is returned).
lookupAttr(self, name, default=<class 'MiscUtils.NoDefault'>)
model(self)
name(self)
printWarnings(self, out)
pyClass(self)
Return the Python class that corresponds to this class.
 
This request will even result in the Python class' module being
imported if necessary. It will also set the Python class
attribute _mk_klass which is used by MiddleKit.Run.MiddleObject.
readDict(self, rawDict)
recordDependencyOrder(self, order, visited, indent=0)
setId(self, id)
setKlasses(self, klasses)
Set the klasses object of the klass. This is the klass' owner.
setSuperklass(self, klass)
setting(self, name, default=<class 'MiscUtils.NoDefault'>)
Return the value of a particular configuration setting taken from the model.
subklasses(self)
superklass(self)
supername(self)
willBuildDependencies(self)
Preps the klass for buildDependencies().

Methods inherited from MiddleKit.Core.MiddleDict.MiddleDict:
boolForKey(self, key, default=False)
Return True or False for the given key.
 
Returns False if the key does not even exist.
Raises a value error if the key exists, but cannot be parsed as a bool.

Data descriptors inherited from MiddleKit.Core.MiddleDict.MiddleDict:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from __builtin__.dict:
__contains__(...)
D.__contains__(k) -> True if D has a key k, else False
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
__sizeof__(...)
D.__sizeof__() -> size of D in memory, in bytes
clear(...)
D.clear() -> None.  Remove all items from D.
copy(...)
D.copy() -> a shallow copy of D
get(...)
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
has_key(...)
D.has_key(k) -> True if D has a key k, else False
items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples
iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D
iterkeys(...)
D.iterkeys() -> an iterator over the keys of D
itervalues(...)
D.itervalues() -> an iterator over the values of D
keys(...)
D.keys() -> list of D's keys
pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
setdefault(...)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
update(...)
D.update(E, **F) -> None.  Update D from dict/iterable E and F.
If E has a .keys() method, does:     for k in E: D[k] = E[k]
If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
values(...)
D.values() -> list of D's values

Data and other attributes inherited from __builtin__.dict:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
fromkeys = <built-in method fromkeys of type object>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.

Methods inherited from MiddleKit.Core.ModelObject.ModelObject:
printAttrs(self, out=None)