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

 
Classes
       
MiddleKit.Core.Attr.Attr(MiddleKit.Core.MiddleDict.MiddleDict, MiddleKit.Core.ModelObject.ModelObject)
ListAttr

 
class ListAttr(MiddleKit.Core.Attr.Attr)
    This is an attribute that refers to a set of other user-defined objects.
 
It cannot include basic data types or instances of classes that are not part
of the object model.
 
 
Method resolution order:
ListAttr
MiddleKit.Core.Attr.Attr
MiddleKit.Core.MiddleDict.MiddleDict
__builtin__.dict
MiddleKit.Core.ModelObject.ModelObject
__builtin__.object

Methods defined here:
__init__(self, attr)
awakeFromRead(self)
Check that the target class and backRefAttr actually exist.
backRefAttrName(self)
Return the name of the back-reference attribute in the referenced class.
 
It is necessary to be able to override the default back ref     to create
data structures like trees, in which a Middle object might reference
a parent and multiple children, all of the same class as itself.
className(self)
Return the name of the base class that this obj ref attribute points to.

Methods inherited from MiddleKit.Core.Attr.Attr:
isRequired(self)
Return true if a value is required for this attribute.
 
In Python, that means the value cannot be None. In relational theory
terms, that means the value cannot be NULL.
klass(self)
Return the klass that this attribute is declared in and, therefore, belongs to.
model(self)
name(self)
printWarnings(self, out)
pyGetName(self)
Return the name that should be used for the Python "get" accessor method for this attribute.
pySetName(self)
Return the name that should be used for the Python "set" accessor method for this attribute.
setKlass(self, klass)
Set the klass that the attribute belongs to.
setting(self, name, default=<class 'MiscUtils.NoDefault'>)
Return the value of a particular configuration setting taken from the model.
 
Implementation note: Perhaps a future version should ask the klass and so on up the chain.

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:
__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)