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

fromkeys(...)
  `dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  v defaults to None.`

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 present and has a .keys() method, does: for k in E: D[k] = E[k]
  If E present and 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:

__hash__ = None

__new__ = <built-in method __new__ of type object>
  `T.__new__(S, ...) -> a new object with type S, a subtype of T`

Methods inherited from MiddleKit.Core.ModelObject.ModelObject:

printAttrs(self, out=None)