public SelectManyModelCollection(IModelCollection <TSource> source, Func <TSource, IModelCollection <TCollection> > collectionSelector, Func <TSource, TCollection, TResult> resultSelector) { this.source = source; this.collectionSelector = collectionSelector; this.resultSelector = resultSelector; collectionChangedEvent = new ModelCollectionChangedEvent <TResult>(); }
protected List <RemovedAndAddedPair <T> > ListenForChanges <T>(IModelCollection <T> collection) { var list = new List <RemovedAndAddedPair <T> >(); collection.CollectionChanged += (oldItems, newItems) => list.Add(new RemovedAndAddedPair <T>(oldItems, newItems)); return(list); }
public static IModelCollection <TItem> AddItemsLinks <TItem>(this IModelCollection <TItem> page, Func <TItem, IEnumerable <Maybe <Link> > > linkGenerator) where TItem : BaseModel { foreach (var item in page.items) { item.AddLinks(linkGenerator(item)); } return(page); }
public TypeDefinitionTreeNode(ITypeDefinitionModel definition) { if (definition == null) { throw new ArgumentNullException("definition"); } this.definition = definition; this.combinedModelChildren = definition.NestedTypes.Concat <object>(definition.Members); }
public ModelCollectionEventCheck(IModelCollection <T> modelCollection) { if (modelCollection == null) { throw new ArgumentNullException("modelCollection"); } this.modelCollection = modelCollection; this.list = new List <T>(modelCollection); modelCollection.CollectionChanged += OnCollectionChanged; }
public TypeDefinitionTreeNode(ITypeDefinitionModel definition) { if (definition == null) { throw new ArgumentNullException("definition"); } this.definition = definition; this.definition.Updated += (sender, e) => { UpdateBaseTypesNode(); UpdateDerivedTypesNode(); }; this.combinedModelChildren = definition.NestedTypes.Concat <object>(definition.Members); }
public InputCollection(SelectManyModelCollection <TSource, TCollection, TResult> parent, TSource source) { this.parent = parent; this.source = source; this.collection = parent.collectionSelector(source); }
public static IModelCollection <TResult> SelectMany <TSource, TCollection, TResult>(this IModelCollection <TSource> source, Func <TSource, IModelCollection <TCollection> > collectionSelector, Func <TSource, TCollection, TResult> resultSelector) { if (source == null) { throw new ArgumentNullException("source"); } if (collectionSelector == null) { throw new ArgumentNullException("collectionSelector"); } if (resultSelector == null) { throw new ArgumentNullException("resultSelector"); } return(new SelectManyModelCollection <TSource, TCollection, TResult>(source, collectionSelector, resultSelector)); }
public static IModelCollection <TResult> SelectMany <TSource, TResult>(this IModelCollection <TSource> input, Func <TSource, IModelCollection <TResult> > selector) { return(SelectMany(input, selector, (a, b) => b)); }
public static IModelCollection <TResult> Select <TSource, TResult>(this IModelCollection <TSource> source, Func <TSource, TResult> selector) { return(SelectMany(source, item => new ImmutableModelCollection <TResult>(new[] { selector(item) }))); }
public static IModelCollection <TSource> Where <TSource>(this IModelCollection <TSource> source, Func <TSource, bool> predicate) { return(SelectMany(source, item => predicate(item) ? new ImmutableModelCollection <TSource>(new[] { item }) : ImmutableModelCollection <TSource> .Empty)); }
public static IModelCollection <T> Concat <T>(this IModelCollection <T> input1, IModelCollection <T> input2) { return(new ImmutableModelCollection <IModelCollection <T> >(new [] { input1, input2 }).SelectMany(c => c)); }
public static IModelCollection <TResult> Cast <TResult>(this IModelCollection <object> source) { return(SelectMany(source, item => new ImmutableModelCollection <TResult>(new[] { (TResult)item }))); }
public static void FillCollection <TIn, TOut>(this IApiMapper <TIn, TOut> mapper, IEnumerable <TIn> input, IModelCollection <TOut> output) where TOut : class, new() { output.items.AddRange(mapper.Map(input)); }
public WorkspaceTreeNode() { combinedModelChildren = SD.ClassBrowser.CurrentWorkspace.AssemblyLists .Concat <object>(SD.ClassBrowser.MainAssemblyList.Assemblies) .Concat <object>(SD.ClassBrowser.UnpinnedAssemblies.Assemblies); }
public static IModelCollection <TItem> AddItemsLinks <TItem>(this IModelCollection <TItem> page, Func <TItem, Maybe <Link> > linkGenerator) where TItem : BaseModel { return(page.AddItemsLinks(item => new Maybe <Link>[] { linkGenerator(item) })); }
// Note, This method is a dirty patch to avoid issues because it does not work: // public static TPage AddItemsLinks<TPage, TItem>(this TPage page, Func<TItem, IEnumerable<Link>> linkGenerator) // where TPage : BaseCollectionPage<TItem> // where TItem : BaseModel // Code: // new ListsCollectionPage().AddItemsLinks(item => new[] { .... // Error: // The type arguments for method 'AddLinksHelpers.AddItemsLinks<TPage, TItem>(TPage, Func<TItem, IEnumerable<Link>>)' cannot be inferred from the usage.Try specifying the type arguments explicitly. public static T Cast <T>(this IModelCollection collection) where T : IModelCollection { return((T)collection); }
// A general 'AsObservableCollection()' would be nice; but I don't see any good way // to implement that without leaking memory. // The problem is that IModelCollection is unordered; but ObservableCollection requires us to maintain a stable order. #region OfType / Cast public static IModelCollection <TResult> OfType <TResult>(this IModelCollection <object> source) { return(SelectMany(source, item => item is TResult ? new ImmutableModelCollection <TResult>(new[] { (TResult)item }) : ImmutableModelCollection <TResult> .Empty)); }
public WorkspaceTreeNode() { combinedModelChildren = SD.ClassBrowser.MainAssemblyList.Assemblies.Concat(SD.ClassBrowser.UnpinnedAssemblies.Assemblies); SD.ClassBrowser.CurrentWorkspace.AssemblyLists.CollectionChanged += AssemblyListsCollectionChanged; }