/// <summary> /// Combines this instance with another. /// <para> /// If both instances contain lists of the same type, the combining function will /// often be {@code Guavate::concatToList}. /// </para> /// <para> /// It is strongly advised to ensure that the function cannot throw an exception. /// /// </para> /// </summary> /// @param <U> the type of the value in the other instance </param> /// @param <R> the type of the value in the returned result </param> /// <param name="other"> the other instance </param> /// <param name="combiner"> the function that combines the two values </param> /// <returns> the combined instance of value and failures </returns> public ValueWithFailures <R> combinedWith <U, R>(ValueWithFailures <U> other, System.Func <T, U, R> combiner) { R combinedValue = Objects.requireNonNull(combiner(value, other.value)); ImmutableList <FailureItem> combinedFailures = concatToList(failures, other.failures); return(ValueWithFailures.of(combinedValue, combinedFailures)); }
/// <summary> /// Processes the value by applying a function that returns another result. /// <para> /// This operation allows post-processing of a result value. /// This is similar to <seealso cref="#map(Function)"/> but the function returns a {@code ValueWithFailures}. /// The result of this method consists of the transformed value, and the combined list of failures. /// </para> /// <para> /// It is strongly advised to ensure that the function cannot throw an exception. /// /// </para> /// </summary> /// @param <R> the type of the value in the returned result </param> /// <param name="function"> the function to transform the value with </param> /// <returns> the transformed instance of value and failures </returns> //JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint: //ORIGINAL LINE: public <R> ValueWithFailures<R> flatMap(java.util.function.Function<? super T, ValueWithFailures<R>> function) public ValueWithFailures <R> flatMap <R, T1>(System.Func <T1> function) { ValueWithFailures <R> transformedValue = Objects.requireNonNull(function(value)); ImmutableList <FailureItem> combinedFailures = ImmutableList.builder <FailureItem>().addAll(this.failures).addAll(transformedValue.failures).build(); return(ValueWithFailures.of(transformedValue.value, combinedFailures)); }
//------------------------------------------------------------------------- public virtual void test_of_array_noFailures() { ValueWithFailures <string> test = ValueWithFailures.of("success"); assertEquals(test.hasFailures(), false); assertEquals(test.Value, "success"); assertEquals(test.Failures, ImmutableList.of()); }
public virtual void test_of_list() { ValueWithFailures <string> test = ValueWithFailures.of("success", ImmutableList.of(FAILURE1, FAILURE2)); assertEquals(test.hasFailures(), true); assertEquals(test.Value, "success"); assertEquals(test.Failures, ImmutableList.of(FAILURE1, FAILURE2)); }
public virtual void test_of_supplier_success() { ValueWithFailures <string> test = ValueWithFailures.of("", () => "A"); assertEquals(test.hasFailures(), false); assertEquals(test.Value, "A"); assertEquals(test.Failures, ImmutableList.of()); }
public virtual void test_combinedWith_differentTypes() { ValueWithFailures <bool> @base = ValueWithFailures.of(true, ImmutableList.of(FAILURE1)); ValueWithFailures <int> other = ValueWithFailures.of(Convert.ToInt32(1), ImmutableList.of(FAILURE2)); ValueWithFailures <string> test = @base.combinedWith(other, (a, b) => a.ToString() + b.ToString()); assertEquals(test.Value, "true1"); assertEquals(test.Failures, ImmutableList.of(FAILURE1, FAILURE2)); }
// ------------------------------------------------------------------------- public virtual void test_combinedWith() { ValueWithFailures <IList <string> > @base = ValueWithFailures.of(ImmutableList.of("a"), ImmutableList.of(FAILURE1)); ValueWithFailures <IList <string> > other = ValueWithFailures.of(ImmutableList.of("b", "c"), ImmutableList.of(FAILURE2)); ValueWithFailures <IList <string> > test = @base.combinedWith(other, Guavate.concatToList); assertEquals(test.Value, ImmutableList.of("a", "b", "c")); assertEquals(test.Failures, ImmutableList.of(FAILURE1, FAILURE2)); }
//------------------------------------------------------------------------- public virtual void test_map() { ValueWithFailures <IList <string> > @base = ValueWithFailures.of(ImmutableList.of("1", "2"), ImmutableList.of(FAILURE1)); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: ValueWithFailures <IList <int> > test = @base.map(list => list.Select(s => Convert.ToInt32(s)).collect(toImmutableList())); assertEquals(test.Value, ImmutableList.of(Convert.ToInt32(1), Convert.ToInt32(2))); assertEquals(test.Failures, ImmutableList.of(FAILURE1)); }
//------------------------------------------------------------------------- public virtual void coverage() { ValueWithFailures <string> test = ValueWithFailures.of("success", FAILURE1, FAILURE2); coverImmutableBean(test); ValueWithFailures <string> test2 = ValueWithFailures.of("test"); coverBeanEquals(test, test2); }
public virtual void test_flatMap() { ValueWithFailures <IList <string> > @base = ValueWithFailures.of(ImmutableList.of("1", "a", "2"), ImmutableList.of(FAILURE1)); ValueWithFailures <IList <int> > test = @base.flatMap(this.flatMapFunction); assertEquals(test.Value, ImmutableList.of(Convert.ToInt32(1), Convert.ToInt32(2))); assertEquals(test.Failures.size(), 2); assertEquals(test.Failures.get(0), FAILURE1); assertEquals(test.Failures.get(1).Reason, FailureReason.INVALID); }
/// <summary> /// Creates an instance using a supplier. /// <para> /// If the supplier succeeds normally, the supplied value will be returned. /// If the supplier fails, the empty value will be returned along with a failure. /// /// </para> /// </summary> /// @param <T> the type of the value </param> /// <param name="emptyValue"> the empty value </param> /// <param name="supplier"> supplier of the result value </param> /// <returns> an instance containing the supplied value, or a failure if an exception is thrown </returns> public static ValueWithFailures <T> of <T>(T emptyValue, System.Func <T> supplier) { try { return(of(supplier())); } catch (Exception ex) { return(ValueWithFailures.of(emptyValue, FailureItem.of(FailureReason.ERROR, ex))); } }
public virtual void test_of_supplier_failure() { ValueWithFailures <string> test = ValueWithFailures.of("", () => { throw new System.ArgumentException(); }); assertEquals(test.hasFailures(), true); assertEquals(test.Value, ""); assertEquals(test.Failures.size(), 1); assertEquals(test.Failures.get(0).Reason, FailureReason.ERROR); }
//------------------------------------------------------------------------- public virtual void test_toValueWithFailures() { IList <double> testList = ImmutableList.of(5d, 6d, 7d); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: ValueWithFailures <double> result = testList.Select(value => mockCalc(value)).collect(ValueWithFailures.toValueWithFailures(1d, (val1, val2) => val1 * val2)); assertEquals(result.Value, 210d); //5 * 6 * 7 = 210 IList <FailureItem> failures = result.Failures; assertEquals(failures.Count, 3); //One failure item for each element in testList. assertEquals(failures[0].Message, Messages.format("Error calculating result for input value {}", 5d)); assertEquals(failures[1].Message, Messages.format("Error calculating result for input value {}", 6d)); assertEquals(failures[2].Message, Messages.format("Error calculating result for input value {}", 7d)); }
//----------------------------------------------------------------------- public override bool Equals(object obj) { if (obj == this) { return(true); } if (obj != null && obj.GetType() == this.GetType()) { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: ValueWithFailures<?> other = (ValueWithFailures<?>) obj; ValueWithFailures <object> other = (ValueWithFailures <object>)obj; return(JodaBeanUtils.equal(value, other.value) && JodaBeanUtils.equal(failures, other.failures)); } return(false); }
private ValueWithFailures <IList <int> > flatMapFunction(IList <string> input) { IList <int> integers = new List <int>(); IList <FailureItem> failures = new List <FailureItem>(); foreach (string str in input) { try { integers.Add(Convert.ToInt32(str)); } catch (System.FormatException ex) { failures.Add(FailureItem.of(FailureReason.INVALID, ex)); } } return(ValueWithFailures.of(integers, failures)); }
/// <summary> /// Processes the value by applying a function that alters the value. /// <para> /// This operation allows post-processing of a result value. /// The specified function represents a conversion to be performed on the value. /// </para> /// <para> /// It is strongly advised to ensure that the function cannot throw an exception. /// /// </para> /// </summary> /// @param <R> the type of the value in the returned result </param> /// <param name="function"> the function to transform the value with </param> /// <returns> the transformed instance of value and failures </returns> //JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint: //ORIGINAL LINE: public <R> ValueWithFailures<R> map(java.util.function.Function<? super T, ? extends R> function) public ValueWithFailures <R> map <R, T1>(System.Func <T1> function) where T1 : R { R transformedValue = Objects.requireNonNull(function(value)); return(ValueWithFailures.of(transformedValue, this.failures)); }
/// <summary> /// Returns a collector that can be used to create a ValueWithFailure instance from a stream of ValueWithFailure /// instances. /// <para> /// The <seealso cref="Collector"/> returned performs a reduction of its <seealso cref="ValueWithFailures"/> input elements under a /// specified <seealso cref="BinaryOperator"/> using the provided identity. /// /// </para> /// </summary> /// @param <T> the type of the success value in the <seealso cref="ValueWithFailures"/> </param> /// <param name="identityValue"> the identity value </param> /// <param name="operator"> the operator used for the reduction. </param> /// <returns> a <seealso cref="Collector"/> </returns> //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: public static <T> java.util.stream.Collector<ValueWithFailures<T>, ?, ValueWithFailures<T>> toValueWithFailures(T identityValue, java.util.function.BinaryOperator<T> operator) public static Collector <ValueWithFailures <T>, ?, ValueWithFailures <T> > toValueWithFailures <T>(T identityValue, System.Func <T, T, T> @operator) { System.Func <ValueWithFailures <T>, ValueWithFailures <T>, ValueWithFailures <T> > reduceFunction = (result1, result2) => result1.combinedWith(result2, @operator); return(Collectors.reducing(ValueWithFailures.of(identityValue), reduceFunction)); }
private static ValueWithFailures <double> mockCalc(double value) { FailureItem failure = FailureItem.of(FailureReason.CALCULATION_FAILED, "Error calculating result for input value {}", value); return(ValueWithFailures.of(value, ImmutableList.of(failure))); }
public virtual void test_serialization() { ValueWithFailures <string> test = ValueWithFailures.of("success", FAILURE1, FAILURE2); assertSerialization(test); }