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;
}
