Get the flow value of this node based in the steepest path.

@return the value of flow.
979126
public int getFlow() {
        GridNode nextDown = goDownstreamSP();
        if (nextDown == null) {
            return HMConstants.intNovalue;
        }

        int dcol = nextDown.col - col;
        int drow = nextDown.row - row;

        Direction dir = Direction.getDir(dcol, drow);
        return dir.getFlow();
    }
522767
public FacesConfigFlowDefinitionType<FacesConfigType<T>> getOrCreateFlowDefinition()
   {
      List<Node> nodeList = childNode.get("flow-definition");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionTypeImpl<FacesConfigType<T>>(this, "flow-definition", childNode, nodeList.get(0));
      }
      return createFlowDefinition();
   }
1291580
public int getMaxBW(Node n1, Node n2) {
        int max = Integer.MAX_VALUE;
        for (Link inf : getPath(n1, n2)) {
            if (inf.getCapacity() < max) {
                max = inf.getCapacity();
            }
            Switch sw = inf.getSwitch();
            if (sw.getCapacity() >= 0 && sw.getCapacity() < max) {
                //The >= 0 stays for historical reasons
                max = sw.getCapacity();
            }

        }
        return max;
    }
288349
public function getWeightFlow()
    {
        $sum = 0;
        foreach ($this->set->getEdges() as $edge) {
            $sum += $edge->getFlow() * $edge->getWeight();
        }

        return $sum;
    }
63755
public int getFlowAt( Direction direction ) {
        switch( direction ) {
        case E:
            return eFlow;
        case W:
            return wFlow;
        case N:
            return nFlow;
        case S:
            return sFlow;
        case EN:
            return enFlow;
        case NW:
            return nwFlow;
        case WS:
            return wsFlow;
        case SE:
            return seFlow;
        default:
            throw new IllegalArgumentException();
        }
    }
202854
public Node<T> getMax() {
		if (size == 0) return null;
		Node<RedBlackTreeLong<T>> e = ranges.getMax();
		return e.getElement().getMax();
	}
229340
public int depth() {
		String path = uri.getPath();
		int depth = 0;
		int slash = path.length() == 1 && path.charAt(0) == '/' ? -1 : 0;
		while (slash != -1) {
			depth++;
			slash = path.indexOf(SEPARATOR, slash + 1);
		}
		return depth;
	}
918326
public final int getMaxArity() {
    Node params = getParametersNode();
    if (params != null) {
      Node lastParam = params.getLastChild();
      if (lastParam == null || !lastParam.isVarArgs()) {
        return params.getChildCount();
      }
    }

    return Integer.MAX_VALUE;
  }
1084209
public Flow<Flow<T>> getOrCreateFlow()
   {
      List<Node> nodeList = childNode.get("flow");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FlowImpl<Flow<T>>(this, "flow", childNode, nodeList.get(0));
      }
      return createFlow();
   }
1345826
public Stop<Flow<T>> getOrCreateStop()
   {
      List<Node> nodeList = childNode.get("stop");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new StopImpl<Flow<T>>(this, "stop", childNode, nodeList.get(0));
      }
      return createStop();
   }
319736
private IVarDef getDescendant( String[] path)
    {
    int       pathLength        = path == null? 0 : path.length;
    int       parentPathLength  = pathLength - 1;

    int       i;
    VarSet    parent;
    IVarDef   descendant;
    for( i = 0,
           parent = this,
           descendant = null;

         i < parentPathLength
           && (descendant = parent.getMember( StringUtils.trimToNull( path[i]))) != null
           && descendant.getClass().equals( getClass());

         i++,
           parent = (VarSet) descendant);

    return
      i == parentPathLength
      ? parent.getMember( StringUtils.trimToNull( path[i]))
      : null;
    }
261108
public function getStats()
    {
        $this->resetTotals();
        foreach ($this->flow->getNodes() as $node) {
            $nodeMap = $this->nodeMap[$node->getId()];
            foreach ($this->incrementTotals as $srcKey => $totalKey) {
                if (isset($nodeMap[$srcKey])) {
                    $this->flowStats[$totalKey] += $nodeMap[$srcKey];
                }
            }

            if ($node instanceof BranchNodeInterface) {
                $childFlowId                               = $node->getPayload()->getId();
                $this->flowStats['branches'][$childFlowId] = $node->getPayload()->getStats();
                foreach ($this->incrementTotals as $srcKey => $totalKey) {
                    if (isset($this->flowStats['branches'][$childFlowId][$totalKey])) {
                        $this->flowStats[$totalKey] += $this->flowStats['branches'][$childFlowId][$totalKey];
                    }
                }
            }
        }

        $flowStatus = $this->flow->getFlowStatus();
        if ($flowStatus !== null) {
            $this->flowStats['flow_status'] = $flowStatus->getStatus();
        }

        return $this->flowStats;
    }
92593
public static String getFlowContext() {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return null;
    }

    return instance.flowContext;
  }
818965
public Node getCurrentNode()
  {

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    int saved = m_next;
    Node n = (m_next < m_firstFree) ? elementAt(m_next) : null;
    m_next = saved; // HACK: I think this is a bit of a hack.  -sb
    return n;
  }
301873
public Stream<FlatTreeNode<T>> stream() {
		return IntStream.range(0, _nodes.size()).mapToObj(this::nodeAt);
	}
109768
public PathElement getLastElement() {
        final List<PathElement> list = pathAddressList;
        return list.size() == 0 ? null : list.get(list.size() - 1);
    }
47712
static int getNodeRangeLow(int nodeOrder) {
        int level = getLevelOfNode(nodeOrder);
        int leftMostLeafOrder = getLeftMostNodeOrderOnLevel(level);
        int levelHashStep = (int) getNodeHashRangeOnLevel(level);
        int leafOrderOnLevel = nodeOrder - leftMostLeafOrder;

        return Integer.MIN_VALUE + (leafOrderOnLevel * levelHashStep);
    }