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

 
Modules
       
re

 
Classes
       
MiddleKit.Core.ModelObject.ModelObject(__builtin__.object)
Klasses(__builtin__.dict, MiddleKit.Core.ModelObject.ModelObject)
__builtin__.dict(__builtin__.object)
Klasses(__builtin__.dict, MiddleKit.Core.ModelObject.ModelObject)

 
class Klasses(__builtin__.dict, MiddleKit.Core.ModelObject.ModelObject)
    Collection of class specifications.
 
Klasses object can read a list of class specifications that are
stored in a spreadsheet (.csv).
 
 
Method resolution order:
Klasses
__builtin__.dict
MiddleKit.Core.ModelObject.ModelObject
__builtin__.object

Methods defined here:
__getstate__(self)
For pickling, remove the back reference to the model that owns self.
__init__(self, model)
addKlass(self, klass)
Add a class definition.
 
Restrictions: Cannot add two classes with the same name.
assignClassIds(self, generator)
awakeFromRead(self, model)
Perform further initialization.
 
Expected to be invoked by the model.
classNames(self)
debugString(self)
dump(self)
Print each class.
filename(self)
initTypeMap(self)
Initialize the type map.
 
Initializes self._typeNamesToAttrClassNames which maps MiddleKit type
names (like int and enum) to the name of the attribute class that would
implement them. Mapping to class names rather than actual classes is key,
because in __init__, a different set of attribute classes can be passed in.
klassesInOrder(self)
Return a list of all the Klasses in the order they were declared.
 
Do not modify the list.
model(self)
pyClassNameForAttrDict(self, attrDict)
Return class for attribute definition.
 
Given a raw attribute definition (in the form of a dictionary),
this method returns the name of the Python class that should be
instantiated for it. This method relies primarily on dict['Type'].
read(self, filename)
setting(self, name, default=<class 'MiscUtils.NoDefault'>)
Return the value of a particular configuration setting taken from the model.

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

Methods inherited from __builtin__.dict:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__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:
__hash__ = None
__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)