コード例 #1
0
ファイル: ValidStep.cs プロジェクト: carlubian/DotNet.Safe
        public OneOf <object, Exception> Invoke(OneOf <object, Exception> param)
        {
            // If previous step failed, propagate failure
            if (param.IsT1)
            {
                return(param.AsT1);
            }

            // Otherwise, execute current step
            try
            {
                if (typeof(TPrevious) == typeof(Unit))
                {
                    return(_func(default));
コード例 #2
0
        protected OneOf <string, RenderFragment> GetShowValue(SelectOption option)
        {
            if (option.IsSearch || option.IsTag)
            {
                return(option.Value);
            }

            return(OptionLabelProp switch
            {
                "children" => option?.ChildContent,
                "value" => option?.Value ?? option.Label,
                "label" => option?.Label ?? option.Value,
                _ => SelectMode == SelectMode.Default ? OneOf <string, RenderFragment> .FromT1((option?.ChildContent)) : option?.Label ?? option.Value,
            });
コード例 #3
0
        /// <inheritdoc/>
        public override void Write(Utf8JsonWriter writer, OneOf <T1, T2> value, JsonSerializerOptions options)
        {
            var json = null as string;

            if (value.T1Value != null)
            {
                json = JsonSerializer.Serialize(value.T1Value);
            }
            else
            {
                json = JsonSerializer.Serialize(value.T2Value);
            }
            writer.WriteStringValue(json);
        }
コード例 #4
0
        public void Can_use_classic_switch()
        {
            var actual = new OneOf <string, int>("foo");

            switch (actual.Value)
            {
            case string str:
                Assert.Equal("foo", str);
                break;

            default:
                Assert.True(false);
                break;
            }
        }
コード例 #5
0
 /// <inheritdoc/>
 public override void WriteJson(JsonWriter writer, OneOf <T1, T2>?value, JsonSerializer serializer)
 {
     if (value == null)
     {
         return;
     }
     if (value.T1Value != null)
     {
         serializer.Serialize(writer, value.T1Value);
     }
     else if (value.T2Value != null)
     {
         serializer.Serialize(writer, value.T2Value);
     }
 }
コード例 #6
0
        public void Validation_or_value_is_serializable_validation()
        {
            var expected = new OneOf <string, ValidationState>(
                new Validator()
                .Error("SomeField", "Required field")
                .State
                );

            var serialized   = JsonConvert.SerializeObject(expected);
            var deserialized = JsonConvert.DeserializeObject <OneOf <string, ValidationState> >(serialized);

            Assert.True(deserialized.Is2);
            Assert.Equal(expected.As2.Count, deserialized.As2.Count);
            Assert.Equal(expected.As2.GetErrorText("SomeField"), deserialized.As2.GetErrorText("SomeField"));
        }
コード例 #7
0
 private void HandleSearchResult(OneOf <CustomerResult, CustomerSearchError> result)
 {
     result.Switch(sr =>
     {
         var formattedTextResult = JsonSerializer.Serialize(sr, new JsonSerializerOptions
         {
             WriteIndented = true
         });
         _consoleWriter.WriteLine(formattedTextResult);
     }, error =>
     {
         var formattedErrors = string.Join(", ", error.ErrorMessages);
         _consoleWriter.WriteLine(formattedErrors);
     });
 }
コード例 #8
0
        public async Task SetLabelText(string labelText)
        {
            OneOf <string, MarkerLabel> markerLabel = await GetLabel();

            if (markerLabel.IsT1)
            {
                MarkerLabel label = markerLabel.AsT1;
                label.Text = labelText;
                await SetLabel(label);
            }
            else
            {
                await SetLabel(labelText);
            }
        }
コード例 #9
0
        public void MatcherMatchesOnlyOnceWhenParentClassAndSubClassesAreInOneofAndCreationReferenceIsOfTypeParentButInstanceIsReallyChild()
        {
            OneOf <Fake, Fake.One, Fake.Two> hiddenOne = (Fake) new Fake.One();

            Func <OneOf <Fake, Fake.One, Fake.Two>, int> testerFunc = o =>
            {
                var result = o.Match((Fake f) => 3).
                             Match((Fake.One f) => 1).
                             Match((Fake.Two f) => 2);

                return(result);
            };

            Assert.AreEqual(1, testerFunc(hiddenOne));
        }
コード例 #10
0
 public static OneOf <IEnumerable <TResult>, TError> SelectMany <TSource, TSuccess, TError, TResult>(
     this IEnumerable <TSource> source,
     Func <TSource, OneOf <TSuccess, TError> > selector,
     Func <TSource, TSuccess, TResult> resultSelector)
 {
     return(source.Aggregate(
                OneOf <ImmutableArray <TResult>, TError> .FromT0(ImmutableArray <TResult> .Empty),
                (previousAggregate, currentItem) =>
                previousAggregate.Match(
                    previousSuccesses => selector(currentItem).Match <OneOf <ImmutableArray <TResult>, TError> >(
                        itemSuccess => previousSuccesses.Add(resultSelector(currentItem, itemSuccess)),
                        itemError => itemError),
                    previousError => previousError),
                aggregate => aggregate.Match <OneOf <IEnumerable <TResult>, TError> >(allSuccesses => allSuccesses, error => error)));
 }
コード例 #11
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (matchPatternCase_ == MatchPatternOneofCase.OneOf)
            {
                hash ^= OneOf.GetHashCode();
            }
            hash ^= (int)matchPatternCase_;
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
コード例 #12
0
        /// <summary>
        /// Add the provided JSON schema as an option for the oneOf property of this JSON schema.
        /// </summary>
        /// <param name="oneOfOption"></param>
        /// <returns></returns>
        public JsonSchema AddOneOf(JsonSchema oneOfOption)
        {
            if (oneOfOption == null)
            {
                throw new ArgumentNullException(nameof(oneOfOption));
            }

            if (OneOf == null)
            {
                OneOf = new List <JsonSchema>();
            }

            OneOf.Add(oneOfOption);

            return(this);
        }
コード例 #13
0
 Should
 <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
  T10, T11, T12, T13, T14, T15, T16, T17, T18, T19,
  T20, T21, T22, T23, T24, T25, T26, T27, T28, T29>
     (this OneOf
     <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
      T10, T11, T12, T13, T14, T15, T16, T17, T18, T19,
      T20, T21, T22, T23, T24, T25, T26, T27, T28, T29>
     item)
 {
     return(new OneOfAssertions
            <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
             T10, T11, T12, T13, T14, T15, T16, T17, T18, T19,
             T20, T21, T22, T23, T24, T25, T26, T27, T28, T29>
                (item));
 }
コード例 #14
0
ファイル: OneOf.cs プロジェクト: Marwan0/tlplib
 public bool Equals(OneOf <A, B, C> other)
 {
     if (whichOne != other.whichOne)
     {
         return(false);
     }
     if (isA)
     {
         return(EqComparer <A> .Default.Equals(_aValue, other._aValue));
     }
     if (isB)
     {
         return(EqComparer <B> .Default.Equals(_bValue, other._bValue));
     }
     return(EqualityComparer <C> .Default.Equals(_cValue, other._cValue));
 }
コード例 #15
0
        internal static async Task TraceBlockAsync(Uri uri, OneOf <uint, UInt256> blockId, IConsole console)
        {
            var settings = await GetProtocolSettingsAsync(uri).ConfigureAwait(false);

            using var rpcClient = new RpcClient(uri, protocolSettings: settings);
            var block = await GetBlockAsync(rpcClient, blockId).ConfigureAwait(false);

            if (block.Transactions.Length == 0)
            {
                throw new Exception($"Block {block.Index} ({block.Hash}) had no transactions");
            }

            await console.Out.WriteLineAsync($"Tracing all the transactions in block {block.Index} ({block.Hash})");

            TraceBlock(uri, block, settings, console);
        }
コード例 #16
0
ファイル: OneOfTests.cs プロジェクト: chriswxyz/funccy
 private static Task <string> Process(OneOf <string, int> input)
 {
     return(input
            .Map(
                x => Task.FromResult(x + "!"),
                x => Task.FromResult(x + 1)
                )
            .Map(
                x => x + "$$",
                x => x * 4
                )
            .Extract(
                a => a,
                b => b.ToString()
                ));
 }
コード例 #17
0
        public void AssertOption_OneOf_CaseNotPresent()
        {
            var itemToCheck =
                OneOf <Some <int>, None>
                .FromT0(
                    new Some <int>
            {
                Value = 3
            });


            Action failureAction = () => itemToCheck.Should().BeCase <int>();

            failureAction.Should().Throw <AssertionException>().WithMessage(
                "Unable to find any Discriminated Union method on type \"OneOf<Some<Int32>,None>\" for expected type \"Int32\"");
        }
コード例 #18
0
 /// <summary>
 /// Serves as a hash function for a particular type.
 /// </summary>
 /// <returns>
 /// A hash code for the current <see cref="T:System.Object"/>.
 /// </returns>
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = Type.GetHashCode();
         hashCode = (hashCode * 397) ^ (Id?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Schema?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Comment?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Title?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Description?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Default?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ MultipleOf.GetHashCode();
         hashCode = (hashCode * 397) ^ Maximum.GetHashCode();
         hashCode = (hashCode * 397) ^ ExclusiveMaximum.GetHashCode();
         hashCode = (hashCode * 397) ^ Minimum.GetHashCode();
         hashCode = (hashCode * 397) ^ ExclusiveMinimum.GetHashCode();
         hashCode = (hashCode * 397) ^ (MaxLength?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (MinLength?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Pattern?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (AdditionalItems?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Items?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (MaxItems?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (MinItems?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (UniqueItems?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Contains?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (AdditionalProperties?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Definitions?.GetCollectionHashCode().GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Properties?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (PatternProperties?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Dependencies?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Const?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Enum?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Format?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (ContentMediaType?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (ContentEncoding?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (If?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Then?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Else?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (AllOf?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (AnyOf?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (OneOf?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Not?.GetHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Required?.GetCollectionHashCode() ?? 0);
         hashCode = (hashCode * 397) ^ (Examples?.GetCollectionHashCode() ?? 0);
         return(hashCode);
     }
 }
コード例 #19
0
        public bool Equals(OneOf <A, B, C> other)
        {
            if (whichOne != other.whichOne)
            {
                return(false);
            }
            switch (whichOne)
            {
            case OneOf.Choice.A: return(EqComparer <A> .Default.Equals(_aValue, other._aValue));

            case OneOf.Choice.B: return(EqComparer <B> .Default.Equals(_bValue, other._bValue));

            case OneOf.Choice.C: return(EqComparer <C> .Default.Equals(_cValue, other._cValue));

            default: throw new IllegalStateException("Unreachable code");
            }
        }
コード例 #20
0
        /// <summary>
        /// show a confirm dialog like MessageBox of Windows
        /// </summary>
        /// <param name="content">the content of dialog</param>
        /// <param name="title">the title of dialog</param>
        /// <param name="confirmButtons">the buttons of dialog</param>
        /// <param name="confirmIcon">the icon of dialog</param>
        /// <param name="options">the configuration options for dialog</param>
        /// <returns></returns>
        public async Task <ConfirmResult> Show(
            OneOf <string, RenderFragment> content,
            OneOf <string, RenderFragment> title,
            ConfirmButtons confirmButtons,
            ConfirmIcon confirmIcon,
            ConfirmButtonOptions options)
        {
            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }
            ConfirmOptions confirmOptions = new ConfirmOptions()
            {
                Title          = title,
                Content        = content,
                ConfirmButtons = confirmButtons,
                ConfirmIcon    = confirmIcon,
            };

            #region config button default properties

            if (options.Button1Props != null)
            {
                confirmOptions.Button1Props = options.Button1Props;
            }
            if (options.Button2Props != null)
            {
                confirmOptions.Button2Props = options.Button2Props;
            }
            if (options.Button3Props != null)
            {
                confirmOptions.Button3Props = options.Button3Props;
            }

            #endregion

            var modalRef = new ConfirmRef(confirmOptions)
            {
                TaskCompletionSource = new TaskCompletionSource <ConfirmResult>()
            };
            if (OnOpenEvent != null)
            {
                await OnOpenEvent.Invoke(modalRef);
            }
            return(await modalRef.TaskCompletionSource.Task);
        }
コード例 #21
0
        private IDictionary <string, JsonSchemaProperty> GetActualProperties(bool includeInherited)
#endif
        {
            var ignoredSchema = includeInherited ? null : InheritedSchema;
            var properties    = Properties
                                .Union(AllOf.Where(s => s.ActualSchema != ignoredSchema).SelectMany(s => s.ActualSchema.GetActualProperties(false)))
                                .Union(AnyOf.Where(s => s.ActualSchema != ignoredSchema).SelectMany(s => s.ActualSchema.GetActualProperties(true)))
                                .Union(OneOf.Where(s => s.ActualSchema != ignoredSchema).SelectMany(s => s.ActualSchema.GetActualProperties(true)))
                                .ToList();

            // Collapse all duplicated properties, checking that the duplicated ones are compatible
            var duplicatedProperties = properties
                                       .GroupBy(p => p.Key)
                                       .Where(g => g.Count() > 1)
                                       .Select(g => g.ToList())
                                       .ToList();
            var invalidDuplicates = new List <string>();

            foreach (var duped in duplicatedProperties)
            {
                // Make sure all the properties are the same type as each other so they are compatible primitive types
                var toKeep = duped[0].Value;
                if (duped.Any(dupe => dupe.Value.Type != toKeep.Type))
                {
                    invalidDuplicates.Add(duped[0].Key);
                    continue;
                }

                // All good, so remove the duplicates here
                foreach (var c in duped.Skip(1))
                {
                    properties.Remove(c);
                }
            }

            if (invalidDuplicates.Count > 0)
            {
                throw new InvalidOperationException("The properties " + string.Join(", ", invalidDuplicates.Select(key => "'" + key + "'")) + " are defined multiple times and are not the same type.");
            }

#if !LEGACY
            return(new ReadOnlyDictionary <string, JsonSchemaProperty>(properties.ToDictionary(p => p.Key, p => p.Value)));
#else
            return(new Dictionary <string, JsonSchemaProperty>(properties.ToDictionary(p => p.Key, p => p.Value)));
#endif
        }
コード例 #22
0
        /// <inheritdoc/>
        public override OneOf <T1, T2>?ReadJson(JsonReader reader, Type objectType, OneOf <T1, T2>?existingValue, bool hasExistingValue, JsonSerializer serializer)
        {
            var token = JToken.ReadFrom(reader);

            if (token == null)
            {
                return(null);
            }
            try
            {
                return(new(token.ToObject <T1>() !));
            }
            catch
            {
                return(new(token.ToObject <T2>() !));
            }
        }
コード例 #23
0
 private Block(OneOf <
                   Plain,
                   Para,
                   LineBlock,
                   CodeBlock,
                   RawBlock,
                   BlockQuote,
                   OrderedList,
                   BulletList,
                   DefinitionList,
                   Header,
                   HorizontalRule,
                   Table,
                   Div,
                   Null
                   > value) : base(value)
 {
 }
コード例 #24
0
 /// <summary>
 /// 从当前Bundle组集合中删除一组Bundle的配置
 /// </summary>
 public static void Delete()
 {
     if ((EGameBundle)focusGame != EGameBundle.EGB_ALL)
     {
         foreach (var OneOf in Setting.ListOfBundles)
         {
             if (OneOf.GetHashCode() == SelBundle)
             {
                 Setting.ListOfBundles.Remove(OneOf);
                 break;
             }
         }
     }
     else
     {
         EditorUtility.DisplayDialog("Warning", "Can not delete a bundle in preview model(ALL)", "Cancel");
     }
 }
コード例 #25
0
        public void OneOf2Test()
        {
            string str;
            var    item1 = OneOf <Case1, Case2> .Create(new Case1());

            Assert.AreEqual("Case1", item1.GetValue(v => v.Name, v => v.Name));

            str = "";
            item1.Do(v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case1", str);

            var item2 = OneOf <Case1, Case2> .Create(new Case2());

            Assert.AreEqual("Case2", item2.GetValue(v => v.Name, v => v.Name));

            str = "";
            item2.Do(v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case2", str);
        }
コード例 #26
0
        public void OneOf5Test()
        {
            string str;
            var    item1 = OneOf <Case1, Case2, Case3, Case4, Case5> .Create(new Case1());

            Assert.AreEqual("Case1", item1.GetValue(v => v.Name, v => v.Name, v => v.Name, v => v.Name, v => v.Name));

            str = "";
            item1.Do(v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case1", str);

            var item2 = OneOf <Case1, Case2, Case3, Case4, Case5> .Create(new Case2());

            Assert.AreEqual("Case2", item2.GetValue(v => v.Name, v => v.Name, v => v.Name, v => v.Name, v => v.Name));

            str = "";
            item2.Do(v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case2", str);

            var item3 = OneOf <Case1, Case2, Case3, Case4, Case5> .Create(new Case3());

            Assert.AreEqual("Case3", item3.GetValue(v => v.Name, v => v.Name, v => v.Name, v => v.Name, v => v.Name));

            str = "";
            item3.Do(v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case3", str);

            var item4 = OneOf <Case1, Case2, Case3, Case4, Case5> .Create(new Case4());

            Assert.AreEqual("Case4", item4.GetValue(v => v.Name, v => v.Name, v => v.Name, v => v.Name, v => v.Name));

            str = "";
            item4.Do(v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case4", str);

            var item5 = OneOf <Case1, Case2, Case3, Case4, Case5> .Create(new Case5());

            Assert.AreEqual("Case5", item5.GetValue(v => v.Name, v => v.Name, v => v.Name, v => v.Name, v => v.Name));

            str = "";
            item5.Do(v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name, v => str = v.Name);
            Assert.AreEqual("Case5", str);
        }
コード例 #27
0
        public void MergeFrom(ListMatcher other)
        {
            if (other == null)
            {
                return;
            }
            switch (other.MatchPatternCase)
            {
            case MatchPatternOneofCase.OneOf:
                if (OneOf == null)
                {
                    OneOf = new global::Envoy.Type.Matcher.ValueMatcher();
                }
                OneOf.MergeFrom(other.OneOf);
                break;
            }

            _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }
コード例 #28
0
ファイル: Day19.cs プロジェクト: Red-F/AdventOfCode2020
        private static OneOf <AndNode, OrNode, Leaf> ReduceNode(OneOf <AndNode, OrNode, Leaf> node,
                                                                Dictionary <int, OneOf <AndNode, OrNode, Leaf> > rules)
        {
            if (IsLeaf(node) && !IsTrueLeaf(node))
            {
                var subrule = rules[int.Parse(node.AsT2.Value)];
                if (IsTrueLeaf(subrule))
                {
                    return(subrule);
                }
            }
            else if (IsAnd(node))
            {
                var andRule = node.AsT0;
                if (andRule.Sequence.All(IsTrueLeaf))
                {
                    return(new Leaf(andRule.Sequence.Aggregate(string.Empty,
                                                               (current, x) => current + x.AsT2.Value)));
                }

                for (var j = 0; j < andRule.Sequence.Length; j++)
                {
                    andRule.Sequence[j] = ReduceNode(andRule.Sequence[j], rules);
                }
                return(andRule);
            }
            else if (IsOr(node))
            {
                var orRule = node.AsT1;
                if (orRule.Sequence.All(IsTrueLeaf))
                {
                    var left  = orRule.Sequence[0].AsT2.Value;
                    var right = orRule.Sequence[1].AsT2.Value;
                    return(new Leaf('(' + left + '|' + right + ')'));
                }
                for (var j = 0; j < orRule.Sequence.Length; j++)
                {
                    orRule.Sequence[j] = ReduceNode(orRule.Sequence[j], rules);
                }
                return(orRule);
            }
            return(node);
        }
コード例 #29
0
        private async Task <Option <OneOf <PostReadModel, NotApprovedResult <PostReadModel> > > > FindApprovedPost(Expression <Func <PostEntity, bool> > predicate)
        {
            var postEntity = await CreateBasePostQuery().FirstOrDefaultAsync(predicate);

            if (postEntity == null)
            {
                return(Option.None <OneOf <PostReadModel, NotApprovedResult <PostReadModel> > >());
            }
            else
            {
                var claims = await GetCreatorClaims(postEntity.CreatedBy.Id);

                var post   = postEntity.ToReadModel(claims);
                var result = post.IsApproved ?
                             OneOf <PostReadModel, NotApprovedResult <PostReadModel> > .FromT0(post) :
                             OneOf <PostReadModel, NotApprovedResult <PostReadModel> > .FromT1(new NotApprovedResult <PostReadModel>(post));

                return(Option.Some(result));
            }
        }
コード例 #30
0
            public async ValueTask <bool> MoveNextAsync()
            {
                if (!_pageInfo.HasNextPage)
                {
                    return(false);
                }

                Current = await NyaaSiService.SearchAsync(_request);

                if (Current.Match((IAniListError error) => true)
                    .Match(data => data.PageInfo?.HasNextPage != true))
                {
                    return(false);
                }

                _request.PageNumber += 1;
                Current.Switch(result => _pageInfo.HasNextPage = result.PageInfo.HasNextPage = result.Data.Count >= 75);

                return(true);
            }