facade_complicatedsubsystem.py

Go to the documentation of this file.

 
 
from .facadesubsystem_interface import DeviceTypes, IDeviceNetworkLowLevel
 
#  <summary>
#  Represents a single device.
#  Part of the @ref facade_pattern "Facade pattern" example.
#  </summary>
class DeviceNode:
 
    #  <summary>
    #  Constructor.
    #  </summary>
    #  @param name">Name to use.
    #  @param idcode">idcode for the device.
    #  @param tapType">Value from the DeviceTypes enumeration.
    #  @param initiallyVisible">true if initially visible otherwise false.
    def __init__(self, name: str, idcode: int, tapType: DeviceTypes, initiallyVisible: bool) -> None:
        self.Visible = initiallyVisible
        self.Name = name
        self.Idcode = idcode
        self.DeviceType = tapType
 
    
 
 
 
 
 
 
class DeviceChain:
 
    
    def _ShowHideNodes(self, nodeSelectMask: int, makeVisible : bool) -> None:
        bitMask = 0x2 # bit 0 is always the DEVICECONTROLLER and is always selected
        numNodes = len(self._nodes)
 
        # Start at the device after the DEVICECONTROLLER
        for index in range(1, numNodes):
            if (bitMask & nodeSelectMask) != 0:
                self._nodes[index].Visible = makeVisible
            bitMask <<= 1
            if bitMask == 0:
                # We don't allow more than 32 devices
                break
 
 
    
    def __init__(self, name : str) -> None:
        self._nodes = []
        self.Name = name
        self.IsLocked = False
 
    
    
    
 
    
 
 
    
    def AddNode(self, node : DeviceNode) -> None:
        if self._nodes and node.DeviceType == DeviceTypes.DEVICECONTROLLER:
            # DEVICECONTROLLER always goes at the start of the list.
            self._nodes.insert(0, node)
        else:
            self._nodes.append(node)
 
 
 
    
    def ResetVisibility(self) -> None:
        for node in self._nodes:
            if node.DeviceType != DeviceTypes.DEVICECONTROLLER:
                node.Visible = False
 
 
    
    def SelectNodes(self, nodeSelectMask : int) -> None:
        self._ShowHideNodes(nodeSelectMask, True)
 
 
    
    def DeselectNodes(self, nodeSelectMask : int) -> None:
        self._ShowHideNodes(nodeSelectMask, False)
 
 
    
    def GetIdCodesForVisibleNodes(self) -> list:
        idcodes = []
 
        for node in self._nodes:
            if node.Visible:
                idcodes.append(node.Idcode)
 
        return idcodes
 
 
 
 
 
 
class Facade_ComplicatedSubSystem(IDeviceNetworkLowLevel):
 
    
    def __init__(self) -> None:
        self._deviceChains = [ DeviceChain("CHAIN0"), DeviceChain("CHAIN1") ]
        self._deviceChains[0].AddNode(DeviceNode("DDD_DEVCTRL0", 0x10101010, DeviceTypes.DEVICECONTROLLER, True))
        self._deviceChains[0].AddNode(DeviceNode("DDD_CORE0", 0x20202020, DeviceTypes.CORE, False))
        self._deviceChains[0].AddNode(DeviceNode("DDD_GTE0", 0x30303030, DeviceTypes.GTE, False))
 
        self._deviceChains[1].AddNode(DeviceNode("DDD_DEVCTRL1", 0x10101011, DeviceTypes.DEVICECONTROLLER, True))
        self._deviceChains[1].AddNode(DeviceNode("DDD_PCH0", 0x40404040, DeviceTypes.PCH, False))
        self._deviceChains[1].AddNode(DeviceNode("DDD_PMC0", 0x50505050, DeviceTypes.PMC, False))
 
    
 
    #====================================================================
    # IDeviceNetworkLowLevel methods
    #====================================================================
 
    
    def GetNumChains(self) -> int:
        return len(self._deviceChains)
 
 
    
    def LockDeviceChain(self, chainIndex : int) -> bool:
        locked = False
 
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            if not self._deviceChains[chainIndex].IsLocked:
                self._deviceChains[chainIndex].IsLocked = True
                locked = True
 
        return locked
 
 
    
    def UnlockDeviceChain(self, chainIndex : int) -> bool:
        unlocked = False
 
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            if self._deviceChains[chainIndex].IsLocked:
                self._deviceChains[chainIndex].IsLocked = False
                unlocked = True
 
        return unlocked
 
 
    
    def ResetDeviceChain(self, chainIndex : int) -> None:
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            self._deviceChains[chainIndex].ResetVisibility()
 
 
    
    def EnableDevicesInDeviceChain(self, chainIndex : int, deviceselectMask : int) -> None:
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            self._deviceChains[chainIndex].SelectNodes(deviceselectMask)
 
 
    
    def DisableDevicesInDeviceChain(self, chainIndex : int, deviceselectMask : int) -> None:
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            self._deviceChains[chainIndex].DeselectNodes(deviceselectMask)
 
 
    
    def GetIdcodes(self, chainIndex : int) -> list:
        idcodes = []
 
        if chainIndex >= 0 and chainIndex < len(self._deviceChains):
            idcodes = self._deviceChains[chainIndex].GetIdCodesForVisibleNodes()
        return idcodes
 
 
 
_instance = None # type: Facade_ComplicatedSubSystem
 
 
def  CreateLowLevelInstance() -> IDeviceNetworkLowLevel:
    global _instance
    if not _instance:
        _instance = Facade_ComplicatedSubSystem()
    return _instance