Gets sopl subscriber.

@param <I>               the type parameter
@param transformFunction the transform function
@return the sopl subscriber
321799
public static <I> JMSubscriber<I> getSOPLSubscriber(
            Function<I, ?> transformFunction) {
        return build(o -> System.out.println(transformFunction.apply(o)));
    }
873204
@Override
	@PublicEvolving
	public <R> SingleOutputStreamOperator<R> transform(String operatorName,
			TypeInformation<R> outTypeInfo, OneInputStreamOperator<T, R> operator) {

		SingleOutputStreamOperator<R> returnStream = super.transform(operatorName, outTypeInfo, operator);

		// inject the key selector and key type
		OneInputTransformation<T, R> transform = (OneInputTransformation<T, R>) returnStream.getTransformation();
		transform.setStateKeySelector(keySelector);
		transform.setStateKeyType(keyType);

		return returnStream;
	}
396583
private Subscriber realSubs(RLPredicate<Record> filter, ChangeReceiver receiver) {
        Subscriber subs = new Subscriber(filter,receiver);
        this.realSubscribe(subs);
        return subs;
    }
1216546
@Nonnull
	public static <T, R> LFunctionBuilder<T, R> function(Consumer<LFunction<T, R>> consumer) {
		return new LFunctionBuilder(consumer);
	}
438846
@Nonnull
    public <T> Word<T> transform(Function<? super I, ? extends T> transformer) {
        int len = length();
        Object[] array = new Object[len];
        int i = 0;
        for (I symbol : this) {
            array[i++] = transformer.apply(symbol);
        }
        return new SharedWord<>(array);
    }
1279056
public Set<Method> subscriptionsOn(Object subscriber) {
        SubscriptionMethodFilter filter = new SubscriptionMethodFilter();
        Class<?> subscriberClass = subscriber.getClass();
        List<Method> methods = Arrays.asList(subscriberClass.getMethods());
        Set<Method> subscriptions = new HashSet<Method>();
        for (Method method : methods) {
            if (filter.accepts(method)) {
                subscriptions.add(method);
            }
        }
        return subscriptions;
    }
803833
function (obj) {
    return function (subscriber) {
        var obs = obj[_symbol_observable__WEBPACK_IMPORTED_MODULE_0__["observable"]]();
        if (typeof obs.subscribe !== 'function') {
            throw new TypeError('Provided object does not correctly implement Symbol.observable');
        }
        else {
            return obs.subscribe(subscriber);
        }
    };
}
1193638
private Object getLengthOfObject(Object object, String functionName) throws TransformationOperationException {
        try {
            Method method = object.getClass().getMethod(functionName);
            return method.invoke(object);
        } catch (NoSuchMethodException e) {
            StringBuilder builder = new StringBuilder();
            builder.append("The type of the given field for the length step doesn't support ");
            builder.append(functionName).append(" method. So 0 will be used as standard value.");
            throw new TransformationOperationException(builder.toString(), e);
        } catch (IllegalArgumentException e) {
            throw new TransformationOperationException("Can't get length of the source field", e);
        } catch (IllegalAccessException e) {
            throw new TransformationOperationException("Can't get length of the source field", e);
        } catch (InvocationTargetException e) {
            throw new TransformationOperationException("Can't get length of the source field", e);
        }
    }
1368581
public static <I, O> JMProcessor<I, O> build(
            Function<I, O> transformerFunction) {
        return new JMProcessor<>(transformerFunction);
    }
624293
public SubscriberEndpoint getNewOrExistingSubscriber(String senderPublicId) {
		SubscriberEndpoint subscriberEndpoint = new SubscriberEndpoint(webParticipant, this, senderPublicId,
				this.getPipeline(), this.openviduConfig);

		SubscriberEndpoint existingSendingEndpoint = this.subscribers.putIfAbsent(senderPublicId, subscriberEndpoint);
		if (existingSendingEndpoint != null) {
			subscriberEndpoint = existingSendingEndpoint;
			log.trace("PARTICIPANT {}: Already exists a subscriber endpoint to user {}", this.getParticipantPublicId(),
					senderPublicId);
		} else {
			log.debug("PARTICIPANT {}: New subscriber endpoint to user {}", this.getParticipantPublicId(),
					senderPublicId);
		}

		return subscriberEndpoint;
	}
1063877
public PSBrokerBuilder typeToSubscriberMapping(
			ConcurrentMap<Class<?>, List<SubscriberParent>> mapping) {
		broker.mapping = mapping;
		return this;
	}
1246250
@Override
    public String getSubscribeId(String fname) {
        final Document userLayout = this.getUserLayoutDOM();
        return new PortletSubscribeIdResolver(fname).traverseDocument(userLayout);
    }
311457
public <R> Choice<R> transform(final Function<? super T, R> function) {
    checkNotNull(function);
    final Choice<T> thisChoice = this;
    return new Choice<R>() {
      @Override
      protected Iterator<R> iterator() {
        return Iterators.transform(thisChoice.iterator(), function);
      }
    };
  }
261017
function transformType (type) {
  if (Array.isArray(type)) {
    return transformArray(type)
  }

  if (typeof type === 'object') {
    return transformObject(type)
  }

  if (
    typeof type === 'function' &&
    (!type.prototype || type.name === '')
  ) {
    return type
  }

  return findType(type)
}
350395
@Nonnull
	public static <T1, T2> LToDblBiFunctionBuilder<T1, T2> toDblBiFunction(Consumer<LToDblBiFunction<T1, T2>> consumer) {
		return new LToDblBiFunctionBuilder(consumer);
	}
1300698
@Override
    public java.util.concurrent.Future<GetSubscriptionAttributesResult> getSubscriptionAttributesAsync(String subscriptionArn,
            com.amazonaws.handlers.AsyncHandler<GetSubscriptionAttributesRequest, GetSubscriptionAttributesResult> asyncHandler) {

        return getSubscriptionAttributesAsync(new GetSubscriptionAttributesRequest().withSubscriptionArn(subscriptionArn), asyncHandler);
    }
692186
@Nonnull
	public static <T> LToFltFunctionBuilder<T> toFltFunction(Consumer<LToFltFunction<T>> consumer) {
		return new LToFltFunctionBuilder(consumer);
	}