<p>
Indicates the direction of network traffic associated with a finding.
</p>

@param networkDirection
Indicates the direction of network traffic associated with a finding.
356845
public void setNetworkDirection(java.util.Collection<StringFilter> networkDirection) {
        if (networkDirection == null) {
            this.networkDirection = null;
            return;
        }

        this.networkDirection = new java.util.ArrayList<StringFilter>(networkDirection);
    }
1060668
protected final Direction getDirectionForType(final Class<S> sourceType, final Class<T> targetType, final Class<? extends NodeInterface> type) {

		// FIXME: this method will most likely not do what it's supposed to do..
		if (sourceType.equals(type) && targetType.equals(type)) {
			return Direction.BOTH;
		}

		if (sourceType.equals(type)) {
			return Direction.OUTGOING;
		}

		if (targetType.equals(type)) {
			return Direction.INCOMING;
		}

		/* one of these blocks is wrong...*/
		if (sourceType.isAssignableFrom(type) && targetType.isAssignableFrom(type)) {
			return Direction.BOTH;
		}

		if (sourceType.isAssignableFrom(type)) {
			return Direction.OUTGOING;
		}

		if (targetType.isAssignableFrom(type)) {
			return Direction.INCOMING;
		}

		/* one of these blocks is wrong...*/
		if (type.isAssignableFrom(sourceType) && type.isAssignableFrom(targetType)) {
			return Direction.BOTH;
		}

		if (type.isAssignableFrom(sourceType)) {
			return Direction.OUTGOING;
		}

		if (type.isAssignableFrom(targetType)) {
			return Direction.INCOMING;
		}

		return Direction.BOTH;
	}
275872
public static String getSessionDirection(IoSessionEx session) {
        IoServiceEx service = session.getService();
        String connectionDirection;

        if (service instanceof IoAcceptorEx || service instanceof AbstractBridgeAcceptor) {
            connectionDirection = ACCEPT_DIRECTION;
        } else if (service instanceof IoConnectorEx || service instanceof AbstractBridgeConnector) {
            connectionDirection = CONNECT_DIRECTION;
        } else {
            connectionDirection = UNKNOWN_DIRECTION;
        }

        return connectionDirection;
    }
521926
public boolean isConnectedInDirection(
      DiGraphNode<N, E> dNode1,
      Predicate<E> edgeMatcher,
      DiGraphNode<N, E>  dNode2) {
    // Verify the nodes.
    List<DiGraphEdge<N, E>> outEdges = dNode1.getOutEdges();
    int outEdgesLen = outEdges.size();
    List<DiGraphEdge<N, E>> inEdges = dNode2.getInEdges();
    int inEdgesLen = inEdges.size();
    // It is possible that there is a large assymmetry between the nodes, so pick the direction
    // to search based on the shorter list since the edge lists should be symmetric.
    if (outEdgesLen < inEdgesLen) {
      for (int i = 0; i < outEdgesLen; i++) {
        DiGraphEdge<N, E> outEdge = outEdges.get(i);
        if (outEdge.getDestination() == dNode2
            && edgeMatcher.apply(outEdge.getValue())) {
          return true;
        }
      }
    } else {
      for (int i = 0; i < inEdgesLen; i++) {
        DiGraphEdge<N, E> inEdge = inEdges.get(i);
        if (inEdge.getSource() == dNode1
            && edgeMatcher.apply(inEdge.getValue())) {
          return true;
        }
      }
    }

    return false;
  }
315089
public void seekBySpan(String direction, String seekAmount, String span) {
    if(span.startsWith(SEEK_PREFIX)) span = span.substring(3);
    int seekAmountInt = Integer.parseInt(seekAmount);
    assert(direction.equals(DIR_LEFT) || direction.equals(DIR_RIGHT));
    assert(span.equals(DAY) || span.equals(WEEK) || span.equals(MONTH) || 
        span.equals(YEAR) || span.equals(HOUR) || span.equals(MINUTE) || 
        span.equals(SECOND));
    
    boolean isDateSeek = span.equals(DAY) || span.equals(WEEK) || 
      span.equals(MONTH) || span.equals(YEAR);

    if(isDateSeek) {
      markDateInvocation();
    }
    else {
      markTimeInvocation(null);
    }
    
    int sign = direction.equals(DIR_RIGHT) ? 1 : -1;
    int field = 
      span.equals(DAY) ? Calendar.DAY_OF_YEAR : 
      span.equals(WEEK) ? Calendar.WEEK_OF_YEAR :
      span.equals(MONTH) ? Calendar.MONTH :
      span.equals(YEAR) ? Calendar.YEAR : 
      span.equals(HOUR) ? Calendar.HOUR: 
      span.equals(MINUTE) ? Calendar.MINUTE: 
      span.equals(SECOND) ? Calendar.SECOND:
      null;
    if(field > 0) _calendar.add(field, seekAmountInt * sign);
  }
292556
@Pure
	public Direction1D getSegmentDirectionAt(int index) {
		final RoadSegment sgmt = get(index);
		assert sgmt != null;
		final RoadConnection conn = getStartingPointFor(index);
		assert conn != null;
		if (conn.equals(sgmt.getBeginPoint())) {
			return Direction1D.SEGMENT_DIRECTION;
		}
		assert conn.equals(sgmt.getEndPoint());
		return Direction1D.REVERTED_DIRECTION;
	}
1303977
public void setDirection (float x, float y, float z)
    {
        if (_source != null) {
            _source.setDirection(x, y, z);
        }
        _dx = x;
        _dy = y;
        _dz = z;
    }
77800
def isDirect(self):
        """"""
        direct = (self._messageType == 0x00)
        if self.isDirectACK or self.isDirectNAK:
            direct = True
        return direct
818600
@Override
    protected boolean changeDirection(int currentIndex, int centerIndex, boolean inBounds) {
        boolean changed = false;
        if (getGravityInternal() == Gravity.CENTER &&
                currentIndex <= centerIndex &&
                currentIndex == 0 || !inBounds) {

            changed = true;
        }
        return changed;
    }
841172
def _tag_net_direction(data):
        """"""

        # IP or IPv6
        src = data['packet']['src_domain']
        dst = data['packet']['dst_domain']
        if src == 'internal':
            if dst == 'internal' or 'multicast' in dst or 'broadcast' in dst:
                return 'internal'
            else:
                return 'outgoing'
        elif dst == 'internal':
            return 'incoming'
        else:
            return None
413738
public static boolean isDirectTransport(String strTransportCode)
    {
        if ((MessageTransport.DIRECT.equalsIgnoreCase(strTransportCode))
            || (MessageTransport.SERVER.equalsIgnoreCase(strTransportCode))
            || (MessageTransport.CLIENT.equalsIgnoreCase(strTransportCode)))
                return true;    // These are the direct types
        return false;    // The others are not direct
    }
215301
public void setRunDirection(int runDirection) {
        if (runDirection < PdfWriter.RUN_DIRECTION_DEFAULT || runDirection > PdfWriter.RUN_DIRECTION_RTL)
            throw new RuntimeException("Invalid run direction: " + runDirection);
        this.runDirection = runDirection;
    }
179162
private boolean isPayloadIndirectOrDirect(final HttpServletRequest request) {
        return Collections.list(request.getHeaders("Link")).stream().map(Link::valueOf).map(Link::getUri)
                .anyMatch(l -> directOrIndirect.contains(l));
    }
491423
public void setNetworkSourceDomain(java.util.Collection<StringFilter> networkSourceDomain) {
        if (networkSourceDomain == null) {
            this.networkSourceDomain = null;
            return;
        }

        this.networkSourceDomain = new java.util.ArrayList<StringFilter>(networkSourceDomain);
    }
547101
public void setNetworkInterfacePermissionIds(java.util.Collection<String> networkInterfacePermissionIds) {
        if (networkInterfacePermissionIds == null) {
            this.networkInterfacePermissionIds = null;
            return;
        }

        this.networkInterfacePermissionIds = new com.amazonaws.internal.SdkInternalList<String>(networkInterfacePermissionIds);
    }
1051245
public void setNetworkLoadBalancerArns(java.util.Collection<String> networkLoadBalancerArns) {
        if (networkLoadBalancerArns == null) {
            this.networkLoadBalancerArns = null;
            return;
        }

        this.networkLoadBalancerArns = new com.amazonaws.internal.SdkInternalList<String>(networkLoadBalancerArns);
    }
740453
public void setNetworkDestinationDomain(java.util.Collection<StringFilter> networkDestinationDomain) {
        if (networkDestinationDomain == null) {
            this.networkDestinationDomain = null;
            return;
        }

        this.networkDestinationDomain = new java.util.ArrayList<StringFilter>(networkDestinationDomain);
    }