Facade_ComplicatedSubSystem.cs

Go to the documentation of this file.

 
 
using System.Collections.Generic;
 
namespace DesignPatternExamples_csharp
{
    public enum DeviceTypes
    {
        DEVICECONTROLLER,
        CORE, 
        GTE,
        PCH,
        PMC,
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public class DeviceNode
    {
        public bool Visible;
        
        public string Name;
 
        public uint Idcode;
 
        public DeviceTypes DeviceType;
 
        public DeviceNode(string name, uint idcode, DeviceTypes tapType, bool initiallyVisible)
        {
            Name = name;
            Idcode = idcode;
            DeviceType = tapType;
            Visible = initiallyVisible;
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public class DeviceChain
    {
        private List<DeviceNode> _nodes = new List<DeviceNode>();
 
        public string Name;
 
        public bool IsLocked;
 
        public DeviceChain(string name)
        {
            Name = name;
        }
 
        private void _ShowHideNodes(uint nodeSelectMask, bool makeVisible)
        {
            uint bitMask = 0x2; // bit 0 is always the DEVICECONTROLLER and is always selected
            int numNodes = _nodes.Count;
 
            // Start at the device after the DEVICECONTROLLER
            for (int index = 1; index < numNodes; ++index)
            {
                if ((bitMask & nodeSelectMask) != 0)
                {
                    _nodes[index].Visible = makeVisible;
                }
                bitMask <<= 1;
                if (bitMask == 0)
                {
                    // We don't allow more than 32 devices
                    break;
                }
            }
        }
 
 
        internal void AddNode(DeviceNode node)
        {
            if (_nodes.Count > 0 && node.DeviceType == DeviceTypes.DEVICECONTROLLER)
            {
                // DEVICECONTROLLER always goes at the start of the list.
                _nodes.Insert(0, node);
            }
            else
            {
                _nodes.Add(node);
            }
        }
 
 
        public void ResetVisibility()
        {
            foreach (DeviceNode node in _nodes)
            {
                if (node.DeviceType != DeviceTypes.DEVICECONTROLLER)
                {
                    node.Visible = false;
                }
            }
        }
 
        public void SelectNodes(uint nodeSelectMask)
        {
            _ShowHideNodes(nodeSelectMask, true);
        }
 
        public void DeselectNodes(uint nodeSelectMask)
        {
            _ShowHideNodes(nodeSelectMask, false);
        }
 
 
        public uint[] GetIdCodesForVisibleNodes()
        {
            List<uint> idcodes = new List<uint>();
 
            foreach(DeviceNode node in _nodes)
            {
                if (node.Visible)
                {
                    idcodes.Add(node.Idcode);
                }
            }
 
            return idcodes.ToArray();
        }
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public class Facade_ComplicatedSubSystem : IDeviceNetworkLowLevel, IDeviceNetworkHighLevel
    {
        private DeviceChain[] _deviceChains = { new DeviceChain("CHAIN0"), new DeviceChain("CHAIN1") };
 
        public static IDeviceNetworkLowLevel CreateInstance()
        {
            return new Facade_ComplicatedSubSystem();
        }
 
        private Facade_ComplicatedSubSystem()
        {
            _deviceChains[0].AddNode(new DeviceNode("DDD_DEVCTRL0", 0x10101010, DeviceTypes.DEVICECONTROLLER, true));
            _deviceChains[0].AddNode(new DeviceNode("DDD_CORE0", 0x20202020, DeviceTypes.CORE, false));
            _deviceChains[0].AddNode(new DeviceNode("DDD_GTE0", 0x30303030, DeviceTypes.GTE, false));
            
            _deviceChains[1].AddNode(new DeviceNode("DDD_DEVCTRL1", 0x10101011, DeviceTypes.DEVICECONTROLLER, true));
            _deviceChains[1].AddNode(new DeviceNode("DDD_PCH0", 0x40404040, DeviceTypes.PCH, false));
            _deviceChains[1].AddNode(new DeviceNode("DDD_PMC0", 0x50505050, DeviceTypes.PMC, false));
        }
 
 
        //====================================================================
        // IDeviceNetworkLowLevel methods
        //====================================================================
        #region IDeviceNetworkLowLevel methods
        int IDeviceNetworkLowLevel.GetNumChains()
        {
            return _deviceChains.Length;
        }
 
        bool IDeviceNetworkLowLevel.LockDeviceChain(int chainIndex)
        {
            bool locked = false;
 
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                if (!_deviceChains[chainIndex].IsLocked)
                {
                    _deviceChains[chainIndex].IsLocked = true;
                    locked = true;
                }
            }
 
            return locked;
        }
 
        bool IDeviceNetworkLowLevel.UnlockDeviceChain(int chainIndex)
        {
            bool unlocked = false;
 
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                if (_deviceChains[chainIndex].IsLocked)
                {
                    _deviceChains[chainIndex].IsLocked = false;
                    unlocked = true;
                }
            }
 
            return unlocked;
        }
 
        void IDeviceNetworkLowLevel.ResetDeviceChain(int chainIndex)
        {
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                _deviceChains[chainIndex].ResetVisibility();
            }
        }
 
        void IDeviceNetworkLowLevel.EnableDevicesInDeviceChain(int chainIndex, uint deviceselectMask)
        {
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                _deviceChains[chainIndex].SelectNodes(deviceselectMask);
            }
        }
 
        void IDeviceNetworkLowLevel.DisableDevicesInDeviceChain(int chainIndex, uint deviceselectMask)
        {
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                _deviceChains[chainIndex].DeselectNodes(deviceselectMask);
            }
        }
 
        uint[] IDeviceNetworkLowLevel.GetIdcodes(int chainIndex)
        {
            uint[] idcodes = new uint[0];
 
            if (chainIndex >= 0 && chainIndex < _deviceChains.Length)
            {
                idcodes = _deviceChains[chainIndex].GetIdCodesForVisibleNodes();
            }
            return idcodes;
        }
        #endregion
 
 
        //====================================================================
        // IDeviceNetworkHighLevel methods
        //====================================================================
        #region ITAPNetworkHighLevel methods
 
        int IDeviceNetworkHighLevel.NumChains
        {
            get
            {
                return ((IDeviceNetworkLowLevel)this).GetNumChains();
            }
        }
 
        uint[] IDeviceNetworkHighLevel.GetIdcodes(int chainIndex)
        {
            uint[] idcodes = new uint[0];
 
            if (((IDeviceNetworkLowLevel)this).LockDeviceChain(chainIndex))
            {
                idcodes = ((IDeviceNetworkLowLevel)this).GetIdcodes(chainIndex);
                ((IDeviceNetworkLowLevel)this).UnlockDeviceChain(chainIndex);
            }
            return idcodes;
        }
 
        void IDeviceNetworkHighLevel.EnableDevicesInDeviceChain(int chainIndex, uint selectMask)
        {
            if (((IDeviceNetworkLowLevel)this).LockDeviceChain(chainIndex))
            {
                ((IDeviceNetworkLowLevel)this).EnableDevicesInDeviceChain(chainIndex, selectMask);
                ((IDeviceNetworkLowLevel)this).UnlockDeviceChain(chainIndex);
            }
        }
 
        void IDeviceNetworkHighLevel.DisableDevicesInDeviceChain(int chainIndex)
        {
            if (((IDeviceNetworkLowLevel)this).LockDeviceChain(chainIndex))
            {
                ((IDeviceNetworkLowLevel)this).ResetDeviceChain(chainIndex);
                ((IDeviceNetworkLowLevel)this).UnlockDeviceChain(chainIndex);
            }
        }
        #endregion
    }
 
 
    //########################################################################
    //########################################################################
 
 
    public static class Facade_ComplicatedSubSystemFactory
    {
        static IDeviceNetworkLowLevel? _instance;
 
 
        public static IDeviceNetworkLowLevel CreateLowLevelInstance()
        {
            if (_instance == null)
            {
                _instance = Facade_ComplicatedSubSystem.CreateInstance();
            }
            return _instance;
        }
 
        public static IDeviceNetworkHighLevel CreateHighLevelInstance()
        {
            if (_instance == null)
            {
                _instance = Facade_ComplicatedSubSystem.CreateInstance();
            }
            return (IDeviceNetworkHighLevel)_instance;
        }
    }
}