/* (non-Javadoc)
@see com.ibm.wsspi.sib.extension.ConsumerSet#getFlows()
484821
public Flow[] getFlows()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getFlows");
    }
    Flow[] flows = classifications.getFlows();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.exit(tc, "getFlows", flows);
    }    
    return flows;
  }
923071
@Override
    public Flow getFlow()
    {
        return new Flow()
        {
            @Override
            public boolean isHandled()
            {
                return false;
            }

            @Override
            public boolean is(Flow type)
            {
                return false;
            }
        };
    }
1368300
@Override
  public FlowConfig get(ComplexResourceKey<FlowId, EmptyRecord> key) {
    String flowGroup = key.getKey().getFlowGroup();
    String flowName = key.getKey().getFlowName();
    FlowId flowId = new FlowId().setFlowGroup(flowGroup).setFlowName(flowName);
    return this.flowConfigsResourceHandler.getFlowConfig(flowId);
  }
194808
private Map<Optional<Executor>, List<ExecutableFlow>> getFlowToExecutorMap() {
    final HashMap<Optional<Executor>, List<ExecutableFlow>> exFlowMap =
        new HashMap<>();

    for (final Pair<ExecutionReference, ExecutableFlow> runningFlow : this.runningExecutions.get()
        .values()) {
      final ExecutionReference ref = runningFlow.getFirst();
      final ExecutableFlow flow = runningFlow.getSecond();
      final Optional<Executor> executor = ref.getExecutor();

      // We can set the next check time to prevent the checking of certain
      // flows.
      if (ref.getNextCheckTime() >= DateTime.now().getMillis()) {
        continue;
      }

      List<ExecutableFlow> flows = exFlowMap.get(executor);
      if (flows == null) {
        flows = new ArrayList<>();
        exFlowMap.put(executor, flows);
      }

      flows.add(flow);
    }

    return exFlowMap;
  }
955514
public static appflowcollector[] get(nitro_service service) throws Exception{
		appflowcollector obj = new appflowcollector();
		appflowcollector[] response = (appflowcollector[])obj.get_resources(service);
		return response;
	}
397502
@ReadOperation
    public Map<?, ?> getReport(@Nullable final String flowId) {
        val jsonMap = new LinkedHashMap<String, Object>();
        val map = this.applicationContext.getBeansOfType(FlowDefinitionRegistry.class, false, true);

        map.forEach((k, v) -> Arrays.stream(v.getFlowDefinitionIds())
            .filter(currentId -> {
                if (StringUtils.isNotBlank(flowId)) {
                    return flowId.equalsIgnoreCase(currentId);
                }
                return true;
            })
            .forEach(id -> {
                val flowDetails = new LinkedHashMap<String, Object>();
                val def = Flow.class.cast(v.getFlowDefinition(id));
                flowDetails.put("startState", def.getStartState().getId());

                val states = new LinkedHashMap<String, Map>();
                Arrays.stream(def.getStateIds()).forEach(st -> {

                    val state = (State) def.getState(st);
                    val stateMap = new LinkedHashMap<String, Object>();

                    if (!state.getAttributes().asMap().isEmpty()) {
                        stateMap.put("attributes", CollectionUtils.wrap(state.getAttributes()));
                    }
                    if (StringUtils.isNotBlank(state.getCaption())) {
                        stateMap.put("caption", state.getCaption());
                    }

                    var acts = StreamSupport.stream(state.getEntryActionList().spliterator(), false)
                        .map(Object::toString)
                        .collect(Collectors.toList());

                    if (!acts.isEmpty()) {
                        stateMap.put("entryActions", acts);
                    }

                    if (state instanceof ActionState) {
                        acts = StreamSupport.stream(ActionState.class.cast(state).getActionList().spliterator(), false)
                            .map(Object::toString)
                            .collect(Collectors.toList());
                        if (!acts.isEmpty()) {
                            stateMap.put("actionList", acts);
                        }
                    }

                    if (state instanceof EndState) {
                        stateMap.put("isEndState", Boolean.TRUE);
                    }
                    if (state.isViewState()) {
                        stateMap.put("isViewState", state.isViewState());
                        stateMap.put("isRedirect", ((ViewState) state).getRedirect());

                        acts = StreamSupport.stream(state.getEntryActionList().spliterator(), false)
                            .map(Object::toString)
                            .collect(Collectors.toList());

                        if (!acts.isEmpty()) {
                            stateMap.put("renderActions", ((ViewState) state).getRenderActionList());
                        }

                        acts = Arrays.stream(((ViewState) state).getVariables())
                            .map(value -> value.getName() + " -> " + value.getValueFactory().toString())
                            .collect(Collectors.toList());

                        if (!acts.isEmpty()) {
                            stateMap.put("viewVariables", acts);
                        }

                        val field = ReflectionUtils.findField(((ViewState) state).getViewFactory().getClass(), "viewId");
                        if (field != null) {
                            ReflectionUtils.makeAccessible(field);
                            val exp = (Expression) ReflectionUtils.getField(field, ((ViewState) state).getViewFactory());
                            stateMap.put("viewId", StringUtils.defaultIfBlank(exp.getExpressionString(), exp.getValue(null).toString()));
                        } else {
                            LOGGER.warn("Field viewId cannot be located on view state [{}]", state);
                        }
                    }

                    if (state instanceof TransitionableState) {
                        val stDef = TransitionableState.class.cast(state);

                        acts = StreamSupport.stream(stDef.getExitActionList().spliterator(), false)
                            .map(Object::toString)
                            .collect(Collectors.toList());

                        if (!acts.isEmpty()) {
                            stateMap.put("exitActions", acts);
                        }

                        acts = Arrays.stream(stDef.getTransitions())
                            .map(tr -> tr.getId() + " -> " + tr.getTargetStateId())
                            .collect(Collectors.toList());

                        if (!acts.isEmpty()) {
                            stateMap.put("transitions", acts);
                        }
                    }
                    states.put(st, stateMap);
                });
                flowDetails.put("states", states);
                flowDetails.put("possibleOutcomes", def.getPossibleOutcomes());
                flowDetails.put("stateCount", def.getStateCount());

                var acts = StreamSupport.stream(def.getEndActionList().spliterator(), false)
                    .map(Object::toString)
                    .collect(Collectors.toList());
                if (!acts.isEmpty()) {
                    flowDetails.put("endActions", acts);
                }

                acts = StreamSupport.stream(def.getGlobalTransitionSet().spliterator(), false)
                    .map(tr -> tr.getId() + " -> " + tr.getTargetStateId() + " @ " + tr.getExecutionCriteria().toString())
                    .collect(Collectors.toList());
                if (!acts.isEmpty()) {
                    flowDetails.put("globalTransitions", acts);
                }

                acts = Arrays.stream(def.getExceptionHandlerSet().toArray())
                    .map(Object::toString)
                    .collect(Collectors.toList());
                if (!acts.isEmpty()) {
                    flowDetails.put("exceptionHandlers", acts);
                }

                val vars = Arrays.stream(def.getVariables())
                    .map(FlowVariable::getName)
                    .collect(Collectors.joining(","));

                if (StringUtils.isNotBlank(vars)) {
                    flowDetails.put("variables", vars);
                }

                jsonMap.put(id, flowDetails);
            }));

        return jsonMap;
    }
1232353
public static appflowparam get(nitro_service service) throws Exception{
		appflowparam obj = new appflowparam();
		appflowparam[] response = (appflowparam[])obj.get_resources(service);
		return response[0];
	}
1120782
public java.util.List<FlowLog> getFlowLogs() {
        if (flowLogs == null) {
            flowLogs = new com.amazonaws.internal.SdkInternalList<FlowLog>();
        }
        return flowLogs;
    }
862968
public static PageFlowController getPageFlow(ServletRequest request, ServletResponse response) {
        assert request instanceof HttpServletRequest;

        PageFlowController jpf = PageFlowUtils.getCurrentPageFlow((HttpServletRequest)request);
        if(jpf != null)
            return jpf;
        else {
            String message = "There is no current Page Flow!";
            LOGGER.error(message);
            throw new RuntimeException(message);
        }
    }
1300965
public GetStatSrcFlowResponse getStatSrcFlow(GetStatSrcFlowRequest request) {
        InternalRequest internalRequest = this.createRequest(request, HttpMethodName.GET, STAT, "srcflow");
        
        if (request.getStartTime() != null) {
            internalRequest.addParameter("startTime", DateUtils.formatAlternateIso8601Date(request.getStartTime()));
        }
        
        if (request.getEndTime() != null) {
            internalRequest.addParameter("endTime", DateUtils.formatAlternateIso8601Date(request.getEndTime()));
        }
        
        if (request.getDomain() != null) {
            internalRequest.addParameter("domain", request.getDomain());
        }
        
        if (request.getPeriod() != null) {
            internalRequest.addParameter("period", String.valueOf(request.getPeriod()));
        }
        
        return this.invokeHttpClient(internalRequest, GetStatSrcFlowResponse.class);
    }
1184862
public List<FlowEvent> getFlowEventsSince(FlowEventKey lastSeen)
      throws IOException {
    // rows must match the FlowKey portion + SEP
    byte[] keyPrefix =
        Bytes.add(flowKeyConverter.toBytes(lastSeen), Constants.SEP_BYTES);
    // start at the next following sequence number
    FlowEventKey nextEvent = new FlowEventKey(lastSeen.getCluster(),
        lastSeen.getUserName(), lastSeen.getAppId(), lastSeen.getRunId(),
        lastSeen.getSequence() + 1);
    byte[] startKey = keyConverter.toBytes(nextEvent);
    Scan scan = new Scan(startKey);
    scan.setFilter(new WhileMatchFilter(new PrefixFilter(keyPrefix)));

    List<FlowEvent> results = new ArrayList<FlowEvent>();
    ResultScanner scanner = null;
    Table eventTable = null;
    try {
      eventTable = hbaseConnection
          .getTable(TableName.valueOf(Constants.FLOW_EVENT_TABLE));
      scanner = eventTable.getScanner(scan);
      for (Result r : scanner) {
        FlowEvent event = createEventFromResult(r);
        if (event != null) {
          results.add(event);
        }
      }
    } finally {
      try {
        if (scanner != null) {
          scanner.close();
        }
      } finally {
        if (eventTable != null) {
          eventTable.close();
        }
      }
    }
    return results;
  }
130067
public List<FacesConfigFlowDefinitionType<FacesConfigType<T>>> getAllFlowDefinition()
   {
      List<FacesConfigFlowDefinitionType<FacesConfigType<T>>> list = new ArrayList<FacesConfigFlowDefinitionType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("flow-definition");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionType<FacesConfigType<T>>  type = new FacesConfigFlowDefinitionTypeImpl<FacesConfigType<T>>(this, "flow-definition", childNode, node);
         list.add(type);
      }
      return list;
   }
202410
public List<FacesConfigFlowDefinitionType<WebFacesConfigDescriptor>> getAllFlowDefinition()
   {
      List<FacesConfigFlowDefinitionType<WebFacesConfigDescriptor>> list = new ArrayList<FacesConfigFlowDefinitionType<WebFacesConfigDescriptor>>();
      List<Node> nodeList = model.get("flow-definition");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionType<WebFacesConfigDescriptor>  type = new FacesConfigFlowDefinitionTypeImpl<WebFacesConfigDescriptor>(this, "flow-definition", model, node);
         list.add(type);
      }
      return list;
   }
388833
@SuppressWarnings({ "rawtypes", "unchecked" })
	private IntegrationFlowBuilder getFlowBuilder() {

		IntegrationFlowBuilder flowBuilder;
		URLName urlName = this.properties.getUrl();

		if (this.properties.isIdleImap()) {
			flowBuilder = getIdleImapFlow(urlName);
		}
		else {

			MailInboundChannelAdapterSpec adapterSpec;
			switch (urlName.getProtocol().toUpperCase()) {
				case "IMAP":
				case "IMAPS":
					adapterSpec = getImapFlowBuilder(urlName);
					break;
				case "POP3":
				case "POP3S":
					adapterSpec = getPop3FlowBuilder(urlName);
					break;
				default:
					throw new IllegalArgumentException(
							"Unsupported mail protocol: " + urlName.getProtocol());
			}
			flowBuilder = IntegrationFlows.from(
					adapterSpec.javaMailProperties(getJavaMailProperties(urlName))
							.selectorExpression(this.properties.getExpression())
							.shouldDeleteMessages(this.properties.isDelete()),
					new Consumer<SourcePollingChannelAdapterSpec>() {

						@Override
						public void accept(
								SourcePollingChannelAdapterSpec sourcePollingChannelAdapterSpec) {
							sourcePollingChannelAdapterSpec.poller(MailSourceConfiguration.this.defaultPoller);
						}

					});

		}
		return flowBuilder;
	}
226872
def ListFlows(self):
    """"""

    args = flow_pb2.ApiListFlowsArgs(client_id=self.client_id)

    items = self._context.SendIteratorRequest("ListFlows", args)
    return utils.MapItemsIterator(
        lambda data: flow.Flow(data=data, context=self._context), items)
851659
@Override
    public Set<Resource<ResourceType>> getInputs()
    {
        assert resourceConsumption.getInputs()!=null : "Check doesConsume() before calling getInputs()";
        return resourceConsumption.getInputs();
    }
273797
public String getRunningFlowIds() {
    final List<Integer> allIds = new ArrayList<>();
    getRunningFlowsIdsHelper(allIds, this.queuedFlows.getAllEntries());
    getRunningFlowsIdsHelper(allIds, this.runningExecutions.get().values());
    Collections.sort(allIds);
    return allIds.toString();
  }