MiddleKit.Core.Klass | index /usr/local/share/webware/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)
`` | `A 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`

viewitems(...)
  `D.viewitems() -> a set-like object providing a view on D's items`

viewkeys(...)
  `D.viewkeys() -> a set-like object providing a view on D's keys`

viewvalues(...)
  `D.viewvalues() -> an object providing a view on 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)