Facade_ComplicatedSubSystem.cpp

Go to the documentation of this file.

 
 
#include <memory>
#include <string>
 
#include "FacadeSubsystem_Interface.h"
#include "Facade_Interface.h"
 
 
namespace DesignPatternExamples_cpp
{
 
    struct DeviceNode
    {
        bool Visible;
 
        std::string Name;
 
        uint32_t Idcode;
 
        DeviceTypes DeviceType;
 
        DeviceNode(std::string name, uint32_t idcode, DeviceTypes tapType, bool initiallyVisible)
            : Visible(initiallyVisible)
            , Name(name)
            , Idcode(idcode)
            , DeviceType(tapType)
        {
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class DeviceChain
    {
    private:
        std::vector<DeviceNode> _nodes;
 
    public:
        std::string Name;
 
        bool IsLocked;
 
    private:
 
        void _ShowHideNodes(uint32_t nodeSelectMask, bool makeVisible)
        {
            uint32_t bitMask = 0x2; // bit 0 is always the DEVICECONTROLLER and is always selected
            size_t numNodes = _nodes.size();
 
            // Start at the device after the DEVICECONTROLLER
            for (size_t 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;
                }
            }
        }
 
    public:
        DeviceChain(std::string name)
            : Name(name)
            , IsLocked(false)
        {
        }
 
 
        void AddNode(DeviceNode node)
        {
            if (_nodes.size() > 0 && node.DeviceType == DeviceTypes::DEVICECONTROLLER)
            {
                // DEVICECONTROLLER always goes at the start of the list.
                _nodes.insert(std::begin(_nodes), node);
            }
            else
            {
                _nodes.push_back(node);
            }
        }
 
 
        void ResetVisibility()
        {
            for(DeviceNode node : _nodes)
            {
                if (node.DeviceType != DeviceTypes::DEVICECONTROLLER)
                {
                    node.Visible = false;
                }
            }
        }
 
        void SelectNodes(uint32_t nodeSelectMask)
        {
            _ShowHideNodes(nodeSelectMask, true);
        }
 
        void DeselectNodes(uint32_t nodeSelectMask)
        {
            _ShowHideNodes(nodeSelectMask, false);
        }
 
 
        std::vector<uint32_t> GetIdCodesForVisibleNodes()
        {
            std::vector<uint32_t> idcodes;
 
            for(DeviceNode node : _nodes)
            {
                if (node.Visible)
                {
                    idcodes.push_back(node.Idcode);
                }
            }
 
            return idcodes;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class Facade_ComplicatedSubSystem : public IDeviceNetworkLowLevel
    {
    public:
        std::vector<DeviceChain> _deviceChains { DeviceChain("CHAIN0"), DeviceChain("CHAIN1") };
 
        Facade_ComplicatedSubSystem()
        {
            _deviceChains[0].AddNode(DeviceNode("DDD_DEVCTRL0", 0x10101010, DeviceTypes::DEVICECONTROLLER, true));
            _deviceChains[0].AddNode(DeviceNode("DDD_CORE0", 0x20202020, DeviceTypes::CORE, false));
            _deviceChains[0].AddNode(DeviceNode("DDD_GTE0", 0x30303030, DeviceTypes::GTE, false));
 
            _deviceChains[1].AddNode(DeviceNode("DDD_DEVCTRL1", 0x10101011, DeviceTypes::DEVICECONTROLLER, true));
            _deviceChains[1].AddNode(DeviceNode("DDD_PCH0", 0x40404040, DeviceTypes::PCH, false));
            _deviceChains[1].AddNode(DeviceNode("DDD_PMC0", 0x50505050, DeviceTypes::PMC, false));
        }
 
    private:
        //====================================================================
        // IDeviceNetworkLowLevel methods
        //====================================================================
        int GetNumChains()
        {
            return static_cast<int>(_deviceChains.size());
        }
 
        bool LockDeviceChain(int chainIndex) override
        {
            bool locked = false;
 
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                if (!_deviceChains[chainIndex].IsLocked)
                {
                    _deviceChains[chainIndex].IsLocked = true;
                    locked = true;
                }
            }
 
            return locked;
        }
 
        bool UnlockDeviceChain(int chainIndex) override
        {
            bool unlocked = false;
 
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                if (_deviceChains[chainIndex].IsLocked)
                {
                    _deviceChains[chainIndex].IsLocked = false;
                    unlocked = true;
                }
            }
 
            return unlocked;
        }
 
        void ResetDeviceChain(int chainIndex) override
        {
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                _deviceChains[chainIndex].ResetVisibility();
            }
        }
 
        void EnableDevicesInDeviceChain(int chainIndex, uint32_t deviceselectMask) override
        {
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                _deviceChains[chainIndex].SelectNodes(deviceselectMask);
            }
        }
 
        void DisableDevicesInDeviceChain(int chainIndex, uint32_t deviceselectMask) override
        {
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                _deviceChains[chainIndex].DeselectNodes(deviceselectMask);
            }
        }
 
        std::vector<uint32_t> GetIdcodes(int chainIndex) override
        {
            std::vector<uint32_t> idcodes;
 
            if (chainIndex >= 0 && chainIndex < static_cast<int>(_deviceChains.size()))
            {
                idcodes = _deviceChains[chainIndex].GetIdCodesForVisibleNodes();
            }
            return idcodes;
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    static std::unique_ptr<Facade_ComplicatedSubSystem> _instance;
 
    IDeviceNetworkLowLevel* CreateLowLevelInstance()
    {
        if (!_instance)
        {
            _instance = std::make_unique<Facade_ComplicatedSubSystem>();
        }
        return _instance.get();
    }
 
} // end namespace