Пример #1
0
        bool IDirectedConnectedNode <T> .IsConnectedWith(IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            if (Helpers <T> .Check_IsConnectedWith_PreConditions(secondNode, this))
            {
                return(false);
            }
            var typedNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(secondNode);


            switch (direction)
            {
            case ConnectionDirection.To:
                return(connectedToNodesList.Contains(typedNode));

            case ConnectionDirection.From:
                return(connectedFromNodesList.Contains(typedNode));

            case ConnectionDirection.Both:
                return(connectedToNodesList.Contains(typedNode) &&
                       connectedFromNodesList.Contains(typedNode));

            case ConnectionDirection.Any:
                return(connectedToNodesList.Contains(typedNode) ||
                       connectedFromNodesList.Contains(typedNode));

            default:
                throw new NonExistentEnumCaseException <ConnectionDirection>(); //ncrunch: no coverage
            }
        }
Пример #2
0
        IEnumerable <IDirectedConnectedNode <T> > IDirectedConnectedNodeCollection <T> .GetNodesConnected(IDirectedConnectedNode <T> firstNode, ConnectionDirection direction)
        {
            Helpers <T> .Verify_GetNodesConnected_ConditionsAreSatisfied(firstNode, this);

            var typedNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(firstNode);

            return(this.InternalGetNodeConnectionsRequest(GetNodeIndex(typedNode), direction));
        }
Пример #3
0
        void IDirectedConnectedNodeCollection <T> .AddNode(IDirectedConnectedNode <T> newNode)
        {
            Helpers <T> .Verify_AddNode_ConditionsAreSatisfied(newNode);

            var typedNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(newNode);

            this.InternalAddNodeRequest(typedNode);
            typedNode.InternalSetParentCollectionRequest(this);
        }
Пример #4
0
        void IDirectedConnectedNode <T> .AddConnectionWith(IEnumerable <IDirectedConnectedNode <T> > secondNodes, ConnectionDirection direction)
        {
            Helpers <T> .VerifyNodeSetIsNotNull(secondNodes);

            foreach (PointerDCN <T> typedNode in secondNodes.Select(node => TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(node)))
            {
                AddConnectionWith(typedNode, direction);
            }
        }
Пример #5
0
        void IDirectedConnectedNode <T> .AddToCollection(IDirectedConnectedNodeCollection <T> newParentCollection)
        {
            Helpers <T> .Verify_AddToCollection_ConditionsAreSatisfied(this, newParentCollection);

            var typedCollection = TypedHelpers.GetCollectionAsValidType <PointerDCNC <T>, T>(newParentCollection);

            typedCollection.InternalAddNodeRequest(this);
            this.InternalSetParentCollectionRequest(typedCollection);
        }
Пример #6
0
        void IDirectedConnectedNodeCollection <T> .ConnectNodes(IDirectedConnectedNode <T> firstNode, IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            Helpers <T> .Verify_ConnectNodes_ConditionsAreSatisfied(firstNode, secondNode, this);

            var typedFirstNode  = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(firstNode);
            var typedSecondNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(secondNode);

            this.InternalSetNodeConnectRequest(GetNodeIndex(typedFirstNode), GetNodeIndex(typedSecondNode), direction, true);
        }
Пример #7
0
        void IDirectedConnectedNodeCollection <T> .ConnectNodes(IDirectedConnectedNode <T> firstNode, IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            Helpers <T> .Verify_ConnectNodes_ConditionsAreSatisfied(firstNode, secondNode, this);

            var typedFirstNode  = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(firstNode);
            var typedSecondNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(secondNode);

            typedFirstNode.InternalAddNodeConnectionRequest(typedSecondNode, direction);
            typedSecondNode.InternalAddNodeConnectionRequest(typedFirstNode, direction.Invert());
        }
Пример #8
0
        void IDirectedConnectedNodeCollection <T> .DisconnectNodes(IDirectedConnectedNode <T> firstNode, IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            if (Helpers <T> .CheckDisconnectNodesConditions(firstNode, secondNode, this))
            {
                return;
            }
            var typedFirstNode  = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(firstNode);
            var typedSecondNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(secondNode);

            this.InternalSetNodeConnectRequest(GetNodeIndex(typedFirstNode), GetNodeIndex(typedSecondNode), direction, false);
        }
Пример #9
0
        bool IDirectedConnectedNodeCollection <T> .NodesHaveConnection(IDirectedConnectedNode <T> firstNode, IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            if (Helpers <T> .CheckNodesHaveConnectionConditions(firstNode, secondNode, this))
            {
                return(false);
            }
            var typedFirstNode  = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(firstNode);
            var typedSecondNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(secondNode);

            return(this.InternalCheckNodeConnectRequest(GetNodeIndex(typedFirstNode), GetNodeIndex(typedSecondNode), direction));
        }
Пример #10
0
        void IDirectedConnectedNodeCollection <T> .DisconnectNodes(IDirectedConnectedNode <T> firstNode, IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            if (Helpers <T> .CheckDisconnectNodesConditions(firstNode, secondNode, this))
            {
                return;
            }
            var typedFirstNode  = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(firstNode);
            var typedSecondNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(secondNode);

            typedFirstNode.InternalRemoveNodeConnectionRequest(typedSecondNode, direction);
            typedSecondNode.InternalRemoveNodeConnectionRequest(typedFirstNode, direction.Invert());
        }
Пример #11
0
        void IDirectedConnectedNode <T> .RemoveConnectionWith(IEnumerable <IDirectedConnectedNode <T> > secondNodes, ConnectionDirection direction)
        {
            if (secondNodes == null)
            {
                return;
            }

            foreach (PointerDCN <T> typedNode in secondNodes.Select(node => TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(node)))
            {
                RemoveConnectionWith(typedNode, direction);
            }
        }
Пример #12
0
        void IDirectedConnectedNodeCollection <T> .RemoveNode(IDirectedConnectedNode <T> targetNode)
        {
            if (Helpers <T> .CheckWhether_RemoveNode_IsNeeded(targetNode, this))
            {
                return;
            }

            var typedNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(targetNode);

            this.InternalRemoveNodeRequest(typedNode);
            typedNode.InternalDeleteParentCollectionRequest();
        }
Пример #13
0
        void IDirectedConnectedNodeCollection <T> .RemoveNode(IDirectedConnectedNode <T> targetNode)
        {
            if (Helpers <T> .CheckWhether_RemoveNode_IsNeeded(targetNode, this))
            {
                return;
            }

            var typedNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(targetNode);

            foreach (var typedConnectedToNode in targetNode.GetNodesConnected(ConnectionDirection.Any).Select(node => TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(node)))
            {
                typedConnectedToNode.InternalRemoveNodeConnectionRequest(typedNode, ConnectionDirection.Any);
            }
            this.InternalRemoveNodeRequest(typedNode);
            typedNode.InternalDeleteParentCollectionRequest();
        }
Пример #14
0
        void IDirectedConnectedNode <T> .RemoveConnectionWith(IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            var typedNode = TypedHelpers.GetNodeAsValidType <PointerDCN <T>, T>(secondNode);

            RemoveConnectionWith(typedNode, direction);
        }
Пример #15
0
        void IDirectedConnectedNode <T> .AddConnectionWith(IDirectedConnectedNode <T> secondNode, ConnectionDirection direction)
        {
            var typedNode = TypedHelpers.GetNodeAsValidType <ArrayDCN <T>, T>(secondNode);

            AddConnectionWith(typedNode, direction);
        }