|  |  | 
CppHeader
__builtin__.dict(__builtin__.object)
CppClass
CppEnum
CppMethod
CppVariable
exceptions.Exception(exceptions.BaseException)
CppParseError
 
 
| class CppClass(__builtin__.dict)
 |  |  | Takes a name stack and turns it into a class 
 Contains the following Keys:
 self['name'] - Name of the class
 self['doxygen'] - Doxygen comments associated with the class if they exist
 self['inherits'] - List of Classes that this one inherits where the values
 are of the form {"access": Anything in supportedAccessSpecifier
 "class": Name of the class
 self['methods'] - Dictionary where keys are from supportedAccessSpecifier
 and values are a lists of CppMethod's
 self['properties'] - Dictionary where keys are from supportedAccessSpecifier
 and values are lists of CppVariable's
 self['enums'] - Dictionary where keys are from supportedAccessSpecifier and
 values are lists of CppEnum's
 
 An example of how this could look is as follows:
 #self =
 {
 'name': ""
 'inherits':[]
 'methods':
 {
 'public':[],
 'protected':[],
 'private':[]
 },
 'properties':
 {
 'public':[],
 'protected':[],
 'private':[]
 },
 'enums':
 {
 'public':[],
 'protected':[],
 'private':[]
 }
 }
 
 |  |  | Method resolution order:CppClass__builtin__.dict__builtin__.object
 Methods defined here:
 
 __init__(self, nameStack)
 __repr__(self)Convert class to a string
 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
 __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 a2-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.
 |  
 
| class CppEnum(__builtin__.dict)
 |  |  | Takes a name stack and turns it into an Enum 
 Contains the following Keys:
 self['name'] - Name of the enum (ex. "ItemState")
 self['namespace'] - Namespace containing the enum
 self['values'] - List of values where the values are a dictionary of the
 form {"name": name of the key (ex. "PARSING_HEADER"),
 "value": Specified value of the enum, this key will only exist
 if a value for a given enum value was defined
 }
 
 |  |  | Method resolution order:CppEnum__builtin__.dict__builtin__.object
 Methods defined here:
 
 __init__(self, nameStack)
 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 a2-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.
 |  
 
 
| class CppMethod(__builtin__.dict)
 |  |  | Takes a name stack and turns it into a method 
 Contains the following Keys:
 self['rtnType'] - Return type of the method (ex. "int")
 self['name'] - Name of the method (ex. "getSize")
 self['doxygen'] - Doxygen comments associated with the method if they exist
 self['parameters'] - List of CppVariables
 
 |  |  | Method resolution order:CppMethod__builtin__.dict__builtin__.object
 Methods defined here:
 
 __init__(self, nameStack, curClass)
 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 a2-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.
 |  
 
 
| class CppVariable(__builtin__.dict)
 |  |  | Takes a name stack and turns it into a method 
 Contains the following Keys:
 self['type'] - Type for the variable (ex. "const string &")
 self['name'] - Name of the variable (ex. "numItems")
 self['namespace'] - Namespace containing the enum
 self['desc'] - Description of the variable if part of a method (optional)
 self['doxygen'] - Doxygen comments associated with the method if they exist
 self['defaltValue'] - Default value of the variable, this key will only
 exist if there is a default value
 
 |  |  | Method resolution order:CppVariable__builtin__.dict__builtin__.object
 Methods defined here:
 
 __init__(self, nameStack, **kwargs)
 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 a2-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.
 |  |