Collaboration diagram for python.Node.Node:

Public Member Functions
	__init__ (self, name="root", flags=None, root=None)
	lock (self, lockstate=_LOCKED)
	unlock (self)
	lock_forever (self)
	islocked (self)
	__setattr__ (self, name, value)
	__getattribute__ (self, name)
	__getattr__ (self, name)
	name (self)
	add (self, attr_name, value)
	addFlag (self, tag, value, flags=None)
	addNewNode (self, name, flags=None)
	addNode (self, node)
	has (self, name)
	hasFlag (self, name)
	nodes (self)
	hasNode (self, name)
	node (self, name)
	delete (self, name)
	rename (self, name, newname)
	clone (self, name=None)
	print (self, spacer="")
	dump (self)

Protected Member Functions
	_fail_if_locked_forever (self)
	_fail_if_locked (self)
	_loadflags (self, name)
	_addDynaFlags (self, name)
	_rootnode (self)
	_setrootnode (self, rootnode)
	_addFlagImpl (self, tag, value, flags=None, unlock=False)
	_addFlagUnlock (self, tag, value, flags=None)

Protected Attributes
	_lockstate = _LOCKED:
return self._children[name]	_children
return self._root._loadflags(name)	_root
	_name

Private Attributes
delattr(self, name)	__dict__

Detailed Description

Basic node class, so we can get all the egregious flags from a
flags object, and use, and pass round, the individual nodes, as
actual nodes without all the nonsense limitations of using the
flags directly

Definition at line 27 of file Node.py.

Constructor & Destructor Documentation

◆ init()

python.Node.Node.__init__	(	self,
		name = "root",
		flags = None,
		root = None )

Definition at line 35 of file Node.py.

    def __init__(self, name="root", flags=None, root=None ):
        object.__setattr__(self, "_lockstate", _UNLOCKED)
        object.__setattr__(self, "_name", name)
        object.__setattr__(self, "_children", {})
        object.__setattr__(self, "_flags", flags)
        object.__setattr__(self, "_root", root)
        

Member Function Documentation

◆ getattr()

python.Node.Node.__getattr__	(		self,
			name )

will attempt a dynamic load from flags if need be

Definition at line 77 of file Node.py.

    def __getattr__(self, name):
        """ will attempt a dynamic load from flags if need be """
        if name in self._children : return self._children[name]
        if self._root :
            if self._root._loadflags( f"{self.name()}.{name}" ) :
                if name in self._children : return self._children[name]
 
            if name in self._root._children : return self._root._children[name]
            if self._root._loadflags( name ) :
                if name in self._root._children : return self._root._children[name]
        else:
            if self._loadflags( name ) :
                if name in self._children : return self._children[name]
                
        raise AttributeError(f"no attribute {name}")
 
 

◆ getattribute()

python.Node.Node.__getattribute__	(		self,
			name )

Definition at line 69 of file Node.py.

    def __getattribute__(self, name):
        value = object.__getattribute__(self, name)        
        if isinstance(value, CfgFlag):
            flags = object.__getattribute__(self, "_flags")
            return value.get(flags)
        return value
 
 

◆ setattr()

python.Node.Node.__setattr__	(	self,
		name,
		value )

Definition at line 65 of file Node.py.

    def __setattr__(self, name, value):
        self._fail_if_locked()
        object.__setattr__(self, name, value) 
 

◆ _addDynaFlags()

python.Node.Node._addDynaFlags	(		self,
			name )

protected

Definition at line 113 of file Node.py.

    def _addDynaFlags(self, name) :
        flags = self._flags
        self._flags._loadDynaFlags(name)
        for key, val in self._flags._flagdict.items() :
            if key == name or key.startswith(name+".") : self._addFlagUnlock( key, val, flags )
        return True
        

◆ _addFlagImpl()

python.Node.Node._addFlagImpl	(	self,
		tag,
		value,
		flags = None,
		unlock = False )

protected

addFlag method like that in the egregious flags

Definition at line 136 of file Node.py.

    def _addFlagImpl(self, tag, value, flags=None, unlock=False):
        """ addFlag method like that in the egregious flags """
        node = self
        if flags is not None and self._flags is None : node._flags = flags
        names = tag.split(".")
        for name in names[:-1]:
            node = node.addNewNode(name, flags )
            if unlock : object.__setattr__( node, "_lockstate", _UNLOCKED )
        if flags is not None : node._flags = flags
        if names[-1] in node.__dict__ : return False
        setattr(node, names[-1], value)
        return True
 

◆ _addFlagUnlock()

python.Node.Node._addFlagUnlock	(	self,
		tag,
		value,
		flags = None )

protected

Definition at line 153 of file Node.py.

    def _addFlagUnlock(self, tag, value, flags=None):
        self._addFlagImpl( tag, value, flags, True )

◆ _fail_if_locked()

python.Node.Node._fail_if_locked ( self )

protected

Definition at line 61 of file Node.py.

    def _fail_if_locked(self):
        if self._lockstate == _LOCKED : raise RuntimeError(f"Node '{self._name}' is locked; ")
        if self._lockstate == _LOCKED_FOREVER : raise RuntimeError(f"Node '{self._name}' is permanently locked; ")
 

◆ _fail_if_locked_forever()

python.Node.Node._fail_if_locked_forever ( self )

protected

Definition at line 58 of file Node.py.

    def _fail_if_locked_forever(self):
        if self._lockstate == _LOCKED_FOREVER : raise RuntimeError(f"Node '{self._name}' is permanently locked; ")
 

◆ _loadflags()

python.Node.Node._loadflags	(		self,
			name )

protected

load dynamic flags - can only load flags on the root node

Definition at line 94 of file Node.py.

    def _loadflags(self, name ) :
        """ load dynamic flags - can only load flags on the root node """
 
        if self._root : return self._root._loadflags( name )
 
        flags = self._flags
        if flags is None : raise AttributeError(f"no attribute {name}")
        lockstate = self._lockstate
        object.__setattr__(self, "_lockstate", _UNLOCKED)
        try:
            if name in flags._dynaflags : return self._addDynaFlags(name)
            for key in flags._dynaflags :
                if name in key : return self._addDynaFlags(key)
            return False
        finally:
            # ensure the lock state is restored if something goes wrong ...
            if lockstate != _UNLOCKED : self.lock(lockstate)
 
        

◆ _rootnode()

python.Node.Node._rootnode ( self )

protected

Definition at line 120 of file Node.py.

    def _rootnode(self):
        if self._root : return self._root
        return self
 

◆ _setrootnode()

python.Node.Node._setrootnode	(		self,
			rootnode )

protected

Definition at line 124 of file Node.py.

    def _setrootnode(self, rootnode ):
        if self._root is rootnode : return 
        object.__setattr__(self, "_root", rootnode )
        for node in self.nodes() : node._setrootnode(rootnode)
            

◆ add()

python.Node.Node.add	(	self,
		attr_name,
		value )

add an attribute to this node

Definition at line 132 of file Node.py.

    def add(self, attr_name, value):
        """ add an attribute to this node """
        setattr(self, attr_name, value)
 

◆ addFlag()

python.Node.Node.addFlag	(	self,
		tag,
		value,
		flags = None )

Definition at line 149 of file Node.py.

    def addFlag(self, tag, value, flags=None):
        if not self._addFlagImpl( tag, value, flags, False ):
            raise  KeyError(f"node: {tag} already exists")
 

◆ addNewNode()

python.Node.Node.addNewNode	(	self,
		name,
		flags = None )

add a new child node

Definition at line 157 of file Node.py.

    def addNewNode(self, name, flags=None):
        """ add a new child node """
        self._fail_if_locked()
        rootnode = self._rootnode()
        if name not in self._children :
            self._children[name] = ( node := Node(name, root=rootnode) )
            if flags is not None : node._flags = flags
        return self._children[name]
 

◆ addNode()

python.Node.Node.addNode	(		self,
			node )

an en existing node as a child node

Definition at line 166 of file Node.py.

    def addNode(self, node):
        """ an en existing node as a child node """
        self._fail_if_locked()
        rootnode = self._rootnode()
        if node.name() not in self._children :
            if node._root and rootnode is not node.root :
                raise RuntimeError(f"cannot add node {node.name()} from a different tree")
            self._children[node.name()] = node
            if not node._root : node.setrootnode( rootnode )
        return self._children[node.name()]
 

◆ clone()

python.Node.Node.clone	(		self,
			name = None )

Return an independent copy" of this node

Definition at line 207 of file Node.py.

    def clone(self, name=None):
        """Return an independent copy" of this node"""
        
        if name is not None : newnode = Node(name)
        else:                 newnode = Node(self._name)
        
        for key, value in self.__dict__.items():
            if key in {"_name", "_children", "_lockstate", "_root" } : continue
            
            setattr(newnode, key, value)
            
        for node in self.nodes():
            newnode.addNode(node.clone())
                
        return newnode

◆ delete()

python.Node.Node.delete	(		self,
			name )

Definition at line 193 of file Node.py.

    def delete(self, name):
        self._fail_if_locked()
        if name in self._children  : del ( self._children[name] )
        elif name in self.__dict__ : delattr( self, name )
 

◆ dump()

python.Node.Node.dump ( self )

Definition at line 233 of file Node.py.

    def dump(self):
        self.print()

◆ has()

python.Node.Node.has	(		self,
			name )

Definition at line 177 of file Node.py.

    def has(self, name ):
        return hasattr( self, name )
 

◆ hasFlag()

python.Node.Node.hasFlag	(		self,
			name )

Definition at line 180 of file Node.py.

    def hasFlag(self, name ):
        return name in self.__dict__
             

◆ hasNode()

python.Node.Node.hasNode	(		self,
			name )

Definition at line 186 of file Node.py.

    def hasNode(self, name):
        return name in self._children
 

◆ islocked()

python.Node.Node.islocked ( self )

Definition at line 55 of file Node.py.

    def islocked(self):
        return self._lockstate != _UNLOCKED
 

◆ lock()

python.Node.Node.lock	(		self,
			lockstate = _LOCKED )

Definition at line 42 of file Node.py.

    def lock(self, lockstate=_LOCKED):
        for node in self.nodes() : node.lock(lockstate)
        object.__setattr__(self, "_lockstate", lockstate)
                           

◆ lock_forever()

python.Node.Node.lock_forever ( self )

Definition at line 52 of file Node.py.

    def lock_forever(self):
        self.lock(_LOCKED_FOREVER) 
 

◆ name()

python.Node.Node.name ( self )

Definition at line 129 of file Node.py.

    def name(self) :
        return self._name
 

◆ node()

python.Node.Node.node	(		self,
			name )

Definition at line 189 of file Node.py.

    def node(self, name):
        if self.hasNode(name) : return self._children[name]
        raise RuntimeError(f"So such child: {name}")
 

◆ nodes()

python.Node.Node.nodes ( self )

Definition at line 183 of file Node.py.

    def nodes(self):
        return self._children.values()
 

◆ print()

python.Node.Node.print	(		self,
			spacer = "" )

Definition at line 224 of file Node.py.

    def print(self, spacer=""):
        print( f"{spacer}", self._name, "(Node)" )
        if    spacer=="" : spacer = "|__"
        else: spacer=f"    {spacer}"
        for key, value in self.__dict__.items():
            if key in {"_name","_children","_lockstate", "_flags", "_root"} : continue
            print( spacer, key, " : ", value )
        for node in self.nodes() : node.print( spacer )
 

◆ rename()

python.Node.Node.rename	(	self,
		name,
		newname )

Definition at line 198 of file Node.py.

    def rename( self, name, newname ):
        if newname in self._children or newname in self.__dict__ :
            raise RuntimeError(f"name {newname} already in node")
 
        if name in self.__dict__: setattr(self, newname, self.__dict__.pop(name) )
        elif name in self._children :
            self._children[newname] = ( node := self._children.pop(name) )
            node._name = newname
    

◆ unlock()

python.Node.Node.unlock ( self )

Definition at line 46 of file Node.py.

    def unlock(self):
        self._fail_if_locked_forever()
        if self._lockstate == _LOCKED:
             object.__setattr__(self, "_lockstate", _UNLOCKED)
             for node in self.nodes(): node.unlock()
                     

Member Data Documentation

◆ dict

delattr( self, name ) python.Node.Node.__dict__

private

Definition at line 196 of file Node.py.

◆ _children

return self._children[name] python.Node.Node._children

protected

Definition at line 79 of file Node.py.

◆ _lockstate

python.Node.Node._lockstate = _LOCKED:

protected

Definition at line 48 of file Node.py.

◆ _name

python.Node.Node._name

protected

Definition at line 225 of file Node.py.

◆ _root

return self._root._loadflags( name ) python.Node.Node._root

protected

Definition at line 80 of file Node.py.

The documentation for this class was generated from the following file:

Node.py

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __getattr__()

◆ __getattribute__()

◆ __setattr__()

◆ _addDynaFlags()

◆ _addFlagImpl()

◆ _addFlagUnlock()

◆ _fail_if_locked()

◆ _fail_if_locked_forever()

◆ _loadflags()

◆ _rootnode()

◆ _setrootnode()

◆ add()

◆ addFlag()

◆ addNewNode()

◆ addNode()

◆ clone()

◆ delete()

◆ dump()

◆ has()

◆ hasFlag()

◆ hasNode()

◆ islocked()

◆ lock()

◆ lock_forever()

◆ name()

◆ node()

◆ nodes()

◆ print()

◆ rename()

◆ unlock()

Member Data Documentation

◆ __dict__

◆ _children

◆ _lockstate

◆ _name

◆ _root

◆ init()

◆ getattr()

◆ getattribute()

◆ setattr()

◆ dict