This method does forward pass and returns output provided by OutputAdapter

@param adapter
@param input
@param inputMasks
@param <T>
@return
777671
public <T> T output(@NonNull ModelAdapter<T> adapter,INDArray[] input, INDArray[] inputMasks) {
        throw new ND4JIllegalStateException("Adapted mode requires Inplace inference mode");
    }
1224364
public INDArray[] output(long graphId, Pair<String, INDArray>... inputs) {
        val operands = new Operands();
        for (val in:inputs)
            operands.addArgument(in.getFirst(), in.getSecond());

        return output(graphId, operands).asArray();
    }
957242
public <S, T> Converter<S, T> findConverter(Class<S> input, Class<T> output) {
		return findConverter(new ConverterKey<S,T>(input, output, DefaultBinding.class));
	}
221490
public INDArray[] output(INDArray[] input, INDArray[] inputMasks){
        Nd4j.getExecutioner().commit(); //Commit before passing input to other thread

        // basically, depending on model type we either throw stuff to specific model, or wait for batch
        BasicInferenceObserver observer = new BasicInferenceObserver();
        InferenceObservable observable;

        if (inferenceMode == InferenceMode.SEQUENTIAL) {
            observable = new BasicInferenceObservable(input, inputMasks);
            observable.addObserver(observer);
            try {
                observables.put(observable);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
        } else {
            observable = provider.setInput(observer, input, inputMasks);
        }

        try {
            // submit query to processing
            // and block until Observable returns
            //observer.wait();

            observer.waitTillDone();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return observable.getOutput();
    }
128623
public synchronized void addAdapter(int pid, InternalClientResponseAdapter adapter)
    {
        final ImmutableMap.Builder<Integer, InternalClientResponseAdapter> builder = ImmutableMap.builder();
        builder.putAll(m_adapters);
        builder.put(pid, adapter);
        m_adapters = builder.build();
    }
398855
public final void setAdapter(@Nullable final ExpandableListAdapter adapter) {
        expandedGroups.clear();

        if (adapter != null) {
            this.adapter = new AdapterWrapper(adapter);
            super.setAdapter(this.adapter);
        } else {
            this.adapter = null;
            super.setAdapter(null);
        }
    }
171630
private Map<FieldPath, Object> applyFieldMask(
      Map<String, Object> fields, List<FieldPath> fieldMask) {
    List<FieldPath> remainingFields = new ArrayList<>(fieldMask);
    Map<FieldPath, Object> filteredData =
        applyFieldMask(fields, remainingFields, FieldPath.empty());

    if (!remainingFields.isEmpty()) {
      throw new IllegalArgumentException(
          String.format(
              "Field masks contains invalid path. No data exist at field '%s'.",
              remainingFields.get(0)));
    }

    return filteredData;
  }
492302
protected void onLookupAfter(StreamMessage input, K lookupKey, V lookupValue)
    {
        // デフォルトでは取得した結果がnull以外の場合、下流にデータを流す。
        if (lookupValue != null)
        {
            StreamMessage message = new StreamMessage();
            message.addField(FieldName.MESSAGE_KEY, lookupKey);
            message.addField(FieldName.MESSAGE_VALUE, lookupValue);

            emitWithGrouping(message, lookupKey, lookupKey.toString());
        }
    }
258603
public boolean canAdapt(Object input, Class<?> outputType) {
		Class<?> inputType = input.getClass();
		Adapter a = findAdapter(input, inputType, outputType);
		return a != null;
	}
531356
public static <A, B, C> Converter<Example<A, C>, Example<B, C>> inputConverter(Converter<A, B> converter) {
    return new ExampleConverter<A, C, B, C>(converter, Converters.<C> identity());
  }
629233
public static List<IItem> getAllItems(final IItemAdapter adapter, boolean countHeaders) {
        return getAllItems(adapter.getAdapterItems(), countHeaders, false, null);
    }
47892
@CheckResult
    @NonNull
    public final PowerAdapter prepend(@NonNull PowerAdapter... adapters) {
        checkNotNull(adapters, "adapters");
        if (adapters.length == 0) {
            return this;
        }
        return new ConcatAdapterBuilder().addAll(adapters).add(this).build();
    }
987620
function Adapter(clientSvc, serverSvc, hash, isRemote) {
  this._clientSvc = clientSvc;
  this._serverSvc = serverSvc;
  this._hash = hash; // Convenience to access it when creating handshakes.
  this._isRemote = !!isRemote;
  this._readers = createReaders(clientSvc, serverSvc);
}
509356
public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null) {
            mAdapter.unregisterDataSetObserver(mDataObserver);
        }

        mAdapter = adapter;

        if (mAdapter != null) {
            mAdapter.registerDataSetObserver(mDataObserver);
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
        }

        setupChildren();

    }
640616
static Gson create(Iterable<TypeAdapter<?>> adapters) {
    GsonBuilder builder = new GsonBuilder().setPrettyPrinting();
    builder.registerTypeAdapter(new TypeToken<Map<String, Object>>() {}.getType(),
        new DoubleToIntMapTypeAdapter());
    for (TypeAdapter<?> adapter : adapters) {
      Type type = resolveLastTypeParameter(adapter.getClass(), TypeAdapter.class);
      builder.registerTypeAdapter(type, adapter);
    }
    return builder.create();
  }
1189809
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    public static InputManager getInputManager(Context context) {
        return (InputManager) context.getSystemService(Context.INPUT_SERVICE);
    }
1102945
private function getAdapter(string $adapter = null, array $params, SymfonyStyle $inputOutput): Adapter
    {
        $adapterName = $adapter ?? $inputOutput->askQuestion(new AdapterChoice());
        $adapterName = strtolower($adapterName);

        if (empty($params)) {
            $questionGenerator = new AdapterQuestionProvider();
            foreach ($questionGenerator->getQuestionsFor($adapterName) as $question) {
                $params[] = $inputOutput->askQuestion($question);
            }
        }

        return $this->adapterFactory->build($adapterName, $params);
    }