Gets an input-only list.

@param message the message
@param operation the operation
@param runtime the runtime engine
@return the input-only list
169606
public static List<Object> getInputOnlyList(Message message, KnowledgeOperation operation, KnowledgeRuntimeEngine runtime) {
        return getInputList(message, operation.getInputOnlyExpressionMappings(), runtime);
    }
993067
public Iterator getFilterList(BaseMessageHeader messageHeader)
    {
        Iterator iterator = null;
        Object[][] mxString = messageHeader.getNameValueTree();
        NameValue node = this;
        int iIndex = -1;
        while (node != null)
        {
            Iterator nodeIterator = node.getFilterIterator();
            if (nodeIterator != null)
            {
                if (iterator == null)
                    iterator = nodeIterator;
                else
                {
                    if (!(iterator instanceof MultiIterator))
                        iterator = new MultiIterator(iterator);
                    ((MultiIterator)iterator).addIterator(nodeIterator);
                }
            }
            iIndex++;
            if ((mxString != null) && (iIndex < mxString.length))
                node = node.getNameValueNode((String)mxString[iIndex][MessageConstants.NAME], mxString[iIndex][MessageConstants.VALUE], false);
            else
                node = null;    // done
        }
        if (iterator == null)
            return gEmptyIterator;
        return iterator;
    }
247783
static SIMessageHandle[] getMessageHandles(final List messages) {

        final SIMessageHandle[] messageHandles = new SIMessageHandle[messages
                        .size()];
        for (int i = 0; i < messageHandles.length; i++) {
            final SIBusMessage message = (SIBusMessage) messages.get(i);
            messageHandles[i] = message.getMessageHandle();
        }
        return messageHandles;

    }
838995
private void doListGet(final Message<JsonObject> message) {
    final String name = message.body().getString("name");
    if (name == null) {
      message.reply(new JsonObject().putString("status", "error").putString("message", "No name specified."));
      return;
    }

    final Integer index = message.body().getInteger("index");
    if (index == null) {
      message.reply(new JsonObject().putString("status", "error").putString("message", "No index specified."));
      return;
    }

    context.execute(new Action<Object>() {
      @Override
      public Object perform() {
        return data.getList(formatKey(name)).get(index);
      }
    }, new Handler<AsyncResult<Object>>() {
      @Override
      public void handle(AsyncResult<Object> result) {
        if (result.failed()) {
          message.reply(new JsonObject().putString("status", "error").putString("message", result.cause().getMessage()));
        } else {
          message.reply(new JsonObject().putString("status", "ok").putValue("result", result.result()));
        }
      }
    });
  }
917744
public static <T extends Iterable<?>> T noNullElements(final T iterable, final String message) {
        return INSTANCE.noNullElements(iterable, message);
    }
719534
private void doListNode(final Message<JsonObject> message) {
    context.execute(new Action<Collection<String>>() {
      @Override
      public Collection<String> perform() {
        List<String> nodes = new ArrayList<>();
        for (String group : groups.keySet()) {
          nodes.addAll(groups.get(group));
        }
        return nodes;
      }
    }, new Handler<AsyncResult<Collection<String>>>() {
      @Override
      public void handle(AsyncResult<Collection<String>> result) {
        if (result.failed()) {
          message.reply(new JsonObject().putString("status", "error").putString("message", result.cause().getMessage()));
        } else {
          message.reply(new JsonObject().putString("status", "ok").putArray("result", new JsonArray(result.result().toArray(new String[result.result().size()]))));
        }
      }
    });
  }
194779
public static List<String> toList(String[] input) {
        List<String> ret = new ArrayList<>();
        for (int i = 0; i < input.length; i++)
            ret.add(input[i]);
        return ret;
    }
679279
private MBeanOperationInfo[] getOperationInfo() {
        final List<MBeanOperationInfo> infoList = new ArrayList<>();

        if (type != null) {
            ReflectionUtils.doWithMethods(type, new ReflectionUtils.MethodCallback() {
                @Override
                public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                    infoList.add(new MBeanOperationInfo(OPERATION_DESCRIPTION, method));
                }
            }, new ReflectionUtils.MethodFilter() {
                @Override
                public boolean matches(Method method) {
                    return method.getDeclaringClass().equals(type)
                            && !method.getName().startsWith("set")
                            && !method.getName().startsWith("get")
                            && !method.getName().startsWith("is")
                            && !method.getName().startsWith("$jacoco"); // Fix for code coverage
                }
            });
        } else {
            for (ManagedBeanInvocation.Operation operation : operations) {
                List<MBeanParameterInfo> parameterInfo = new ArrayList<>();

                int i = 1;
                for (OperationParam parameter : operation.getParameter().getParameter()) {
                    parameterInfo.add(new MBeanParameterInfo("p" + i++, parameter.getType(), "Parameter #" + i));
                }

                infoList.add(new MBeanOperationInfo(operation.getName(), OPERATION_DESCRIPTION, parameterInfo.toArray(new MBeanParameterInfo[operation.getParameter().getParameter().size()]), operation.getReturnType(), MBeanOperationInfo.UNKNOWN));
            }
        }

        return infoList.toArray(new MBeanOperationInfo[infoList.size()]);
    }
314767
public static Map<Method, OperationId> getMethodMap(Class<?> serviceInterface) {
    if (!serviceInterface.isInterface()) {
      Map<Method, OperationId> operations = new HashMap<>();
      for (Class<?> iface : serviceInterface.getInterfaces()) {
        operations.putAll(findMethods(iface));
      }
      return operations;
    }
    return findMethods(serviceInterface);
  }
77853
@Override
    public Set<URI> listInputs(URI operationUri) {

        if (operationUri == null || !operationUri.isAbsolute()) {
            log.warn("The Operation URI is either absent or relative. Provide an absolute URI");
            return ImmutableSet.of();
        }

        URI graphUri;
        try {
            graphUri = getGraphUriForElement(operationUri);
        } catch (URISyntaxException e) {
            log.warn("The namespace of the URI of the operation is incorrect.", e);
            return ImmutableSet.of();
        }

        if (graphUri == null) {
            log.warn("Could not obtain a graph URI for the element. The URI may not be managed by the server - " + operationUri);
            return ImmutableSet.of();
        }

        String queryStr = new StringBuilder()
                .append("SELECT DISTINCT ?input WHERE { \n")
                .append(" GRAPH <").append(graphUri.toASCIIString()).append("> { \n")
                .append("<").append(operationUri.toASCIIString()).append("> ").append("<").append(MSM.hasInput.getURI()).append(">").append(" ?input .")
                .append("?input ").append("<").append(RDF.type.getURI()).append(">").append(" ").append("<").append(MSM.MessageContent.getURI()).append("> .")
                .append(" } \n ")
                .append("} \n ")
                .toString();


        return this.graphStoreManager.listResourcesByQuery(queryStr, "input");
    }
39884
def _get_list(self, key, operation, create=False):
        
        return self._get_by_type(key, operation, create, b'list', [])
312105
public Collection<String> listOperationNames() {
        List<String> list = new ArrayList<String>();
        try {
            MBeanOperationInfo[] operations = beanInfo.getOperations();
            for (MBeanOperationInfo operation : operations) {
                list.add(operation.getName());
            }
        } catch (Exception e) {
            throwException("Could not list operation names. Reason: ", e);
        }
        return list;
    }
647770
public static List<Object> processParameters(OperationResourceInfo ori,
                                                 MultivaluedMap<String, String> values,
                                                 Message message) throws IOException, WebApplicationException {

        Class<?>[] parameterTypes = ori.getInParameterTypes();
        List<Parameter> paramsInfo = ori.getParameters();
        boolean preferModelParams = paramsInfo.size() > parameterTypes.length
                                    && !PropertyUtils.isTrue(message.getContextualProperty("org.apache.cxf.preferMethodParameters"));

        final int parameterTypesLength = preferModelParams ? paramsInfo.size() : parameterTypes.length;
        if (parameterTypesLength < 1) {
            return Collections.emptyList();
        }

        Type[] genericParameterTypes = ori.getInGenericParameterTypes();
        Annotation[][] anns = ori.getInParameterAnnotations();
        Object[] params = new Object[parameterTypesLength];

        // Ensure we process all request-body parameters first, then all @*Params, etc.
        ParamTuple[] tuple = new ParamTuple[parameterTypesLength];
        for (int i = 0; i < parameterTypesLength; i++) {
            tuple[i] = new ParamTuple();
            if (!preferModelParams) {
                tuple[i].param = parameterTypes[i];
                tuple[i].genericParam = InjectionUtils.processGenericTypeIfNeeded(
                    ori.getClassResourceInfo().getServiceClass(), tuple[i].param, genericParameterTypes[i]);
                tuple[i].param = InjectionUtils.updateParamClassToTypeIfNeeded(tuple[i].param, 
                                                                               tuple[i].genericParam);
                tuple[i].paramAnns = anns == null ? EMPTY_ANNOTATIONS : anns[i];
            } else {
                tuple[i].param = paramsInfo.get(i).getJavaType();
                tuple[i].genericParam = tuple[i].param;
                tuple[i].paramAnns = EMPTY_ANNOTATIONS;
            }
            if (paramsInfo.get(i).getType() == ParameterType.REQUEST_BODY) {
                params[i] = processRequestBodyParameter(tuple[i].param, 
                                                        tuple[i].genericParam, 
                                                        tuple[i].paramAnns,
                                                        message,
                                                        ori);
            }
        }
        for (int i = 0; i < parameterTypesLength; i++) {

            if (paramsInfo.get(i).getType() != ParameterType.REQUEST_BODY) {
                params[i] = processParameter(tuple[i].param,
                                             tuple[i].genericParam,
                                             tuple[i].paramAnns,
                                             paramsInfo.get(i),
                                             values,
                                             message,
                                             ori);
            }
        }

        return Arrays.asList(params);
    }
349686
public String getMessage(String message, Object[] args)
    {
        for (int i=0;i<args.length;i++)
        {
            if (args[i] instanceof List<?>)
            {
                @SuppressWarnings("unchecked")
				List<ProxyField> list = (List<ProxyField>)args[i];
                StringBuilder sb = new StringBuilder();
                for (ProxyField pf: list)
                {
                    sb.append(String.valueOf(pf.getValue()));
                    sb.append(",");
                }
                if (sb.length()>0)
                {
                    args[i] = sb.substring(0, sb.length()-1);
                }
                else
                {
                    args[i] = "";
                }
            }
        }
        return m_messageSourceAccessor.getMessage(message, args);
    }
103608
public List<IType> getMessageOrBuilderList() {
    if (externalMessageOrBuilderList == null) {
      externalMessageOrBuilderList = new MessageOrBuilderExternalList<MType, BType, IType>(this);
    }
    return externalMessageOrBuilderList;
  }
772716
public List<Field> getFields(Entity entity, String operationId, PMSecurityUser user) {
        final String[] fs = getFields().split("[ ]");
        final List<Field> result = new ArrayList<Field>();
        for (String string : fs) {
            final Field field = entity.getFieldById(string);
            if (field != null) {
                if (operationId == null || field.shouldDisplay(operationId, user)) {
                    result.add(field);
                }
            }
        }
        return result;
    }
1216552
public static Map<String, Object> getInputMap(Message message, KnowledgeOperation operation, KnowledgeRuntimeEngine runtime) {
        Map<String, Object> map = new HashMap<String, Object>();
        List<ExpressionMapping> inputs = operation.getInputExpressionMappings();
        if (inputs.size() > 0) {
            map.putAll(getMap(message, inputs, null));
        } else {
            Object content = filterRemoteDefaultInputContent(message.getContent(), runtime);
            if (content != null) {
                map.put(PARAMETER, content);
            }
        }
        return map;
    }