/// <summary>
/// Creates an observable from the specified observable's <see cref="IReactiveQbservable{T}.Subscribe"/> implementation method.
/// </summary>
/// <typeparam name="T">Type of the data produced by the observable.</typeparam>
/// <param name="provider">Provider to use for creation of the observable.</param>
/// <param name="subscribe">The observable's <see cref="IReactiveQbservable{T}.Subscribe"/> method implementation.</param>
/// <returns>Newly created observable. To define the observable on a service, use <c>IReactiveDefinition.DefineObservable</c>.</returns>
public static IReactiveQbservable <T> CreateQbservable <T>(this IReactiveQueryProvider provider, Expression <Func <IReactiveQbserver <T>, Uri, object, CancellationToken, Task <IReactiveQubscription> > > subscribe)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (subscribe == null)
{
throw new ArgumentNullException(nameof(subscribe));
}
return(provider.CreateQbservable <T>(
Expression.Call(
((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(T)),
Expression.Constant(provider, typeof(IReactiveQueryProvider)),
subscribe
)
));
}
public MyReactiveQubscription(IReactiveQueryProvider provider, Expression expression)
: base(provider)
{
_expression = expression;
}
public MyReactiveQubscription(IReactiveQueryProvider provider)
: base(provider)
{
_expression = Expression.Constant(this);
}
/// <summary>
/// Creates a parameterized subject factory from the specified factory's <see cref="IReactiveQubjectFactory{TInput, TOutput, TArgs}.Create"/> implementation method.
/// </summary>
/// <typeparam name="TArgs">Type of the parameter passed to the subject factory.</typeparam>
/// <typeparam name="TInput">Type of the data received by the subjects created by the stream factory.</typeparam>
/// <typeparam name="TOutput">Type of the data produced by the subjects created by the stream factory.</typeparam>
/// <param name="provider">Provider to use for creation of the factory.</param>
/// <param name="create">The factory's <see cref="IReactiveQubjectFactory{TInput, TOutput, TArgs}.Create"/> method implementation.</param>
/// <returns>Newly created parameterized stream factory. To define the factory on a service, use <c>IReactiveDefinition.DefineStreamFactory</c>.</returns>
public static IReactiveQubjectFactory <TInput, TOutput, TArgs> CreateQubjectFactory <TArgs, TInput, TOutput>(this IReactiveQueryProvider provider, Expression <Func <Uri, TArgs, object, CancellationToken, Task <IReactiveQubject <TInput, TOutput> > > > create)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (create == null)
{
throw new ArgumentNullException(nameof(create));
}
return(provider.CreateQubjectFactory <TArgs, TInput, TOutput>(
Expression.Call(
((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TArgs), typeof(TInput), typeof(TOutput)),
Expression.Constant(provider, typeof(IReactiveQueryProvider)),
create
)
));
}
public Qbservable(Expression expression, IReactiveQueryProvider provider)
: base(provider)
{
Expression = expression;
}
public QubscriptionFactory(Expression expression, IReactiveQueryProvider provider)
: base(provider)
{
Expression = expression;
}
public MyReactiveQbservable(IReactiveQueryProvider provider, Expression expression)
: base(provider)
{
_expression = expression;
}
/// <summary> /// Creates a new subscription represented by an expression tree, using the specified associated query provider. /// </summary> /// <param name="provider">Query provider associated with the observable.</param> protected ReactiveQubscriptionBase(IReactiveQueryProvider provider) => Provider = provider;
/// <summary>
/// Makes a parameterized subject factory with the specified expression representation.
/// </summary>
/// <typeparam name="TInput">Type of the elements received by the subjects returned by the factory.</typeparam>
/// <typeparam name="TOutput">Type of the elements produced by the subjects returned by the factory.</typeparam>
/// <typeparam name="TArg">Type of the argument passed to the stream factory.</typeparam>
/// <param name="provider">Query provider to use for creation of the subject factory expression representation.</param>
/// <param name="expression">Expression representation of the subject factory.</param>
/// <returns>Instance of a parameterized subject factory with the specified expression tree as its representation.</returns>
public static IReactiveQubjectFactory <TInput, TOutput, TArg> MakeQubjectFactory <TArg, TInput, TOutput>(this IReactiveQueryProvider provider, Expression <Func <IReactiveQubjectFactory <TInput, TOutput, TArg> > > expression)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
return(provider.CreateQubjectFactory <TArg, TInput, TOutput>(expression.Body));
}
public MyReactiveQbservable(IReactiveQueryProvider provider)
: base(provider)
{
_expression = Expression.Constant(this);
}
public Qubject(Expression expression, IReactiveQueryProvider provider)
: base(provider)
{
Expression = expression;
_observer = new Lazy <IReactiveObserver <TInput> >(Resolve);
}
/// <summary> /// Creates a new observer represented by an expression tree, using the specified associated query provider. /// </summary> /// <param name="provider">Query provider associated with the observer.</param> protected ReactiveQbserverBase(IReactiveQueryProvider provider) => Provider = provider;
public KnownQbservable(Expression expression, Uri observableUri, IReactiveQueryProvider provider)
: base(expression, provider)
{
Uri = observableUri;
}
/// <summary>
/// Creates a new observable represented by an expression tree, using the specified associated query provider.
/// </summary>
/// <param name="provider">Query provider associated with the observable.</param>
protected ReactiveQbservableBase(IReactiveQueryProvider provider)
{
Provider = provider;
}
public KnownQubscriptionFactory(Expression expression, Uri subscriptionFactoryUri, IReactiveQueryProvider provider)
: base(expression, provider)
{
Uri = subscriptionFactoryUri;
}
public KnownQubjectFactory(Expression expression, Uri streamFactoryUri, IReactiveQueryProvider provider)
: base(expression, provider)
{
Uri = streamFactoryUri;
}
/// <summary> /// Creates a new subject factory represented by an expression tree, using the specified associated query provider. /// </summary> /// <param name="provider">Query provider associated with the subject factory.</param> protected ReactiveQubjectFactoryBase(IReactiveQueryProvider provider) => Provider = provider;
