public CompositionSongs(List <Composition> compositions) : this() { foreach (var composition in compositions) { Compositions.Add(new CompositionSong(composition)); } }
public bool LoadFromFile(string filename) { if (File.Exists(filename)) { Clear(); XElement xroot = XElement.Load(filename); XElement xmlApp = xroot.Element("AUTOSARTAPP"); BaseDataTypes.Clear(); LoadProperties(xroot); Enums.LoadFromXML(xroot); systemErrors.LoadFromXML(xroot); BaseDataTypes.LoadFromXML(xroot); SimpleDataTypes.LoadFromXML(xroot); ComplexDataTypes.LoadFromXML(xroot); SenderReceiverInterfaces.LoadFromXML(xroot); ClientServerInterfaces.LoadFromXML(xroot); ComponentDefenitionsList.LoadFromXML(xroot); Compositions.LoadFromXML(xroot); OsTasks.LoadFromXML(xroot); arrayDataTypes.LoadFromXML(xroot); BaseDataTypes.CheckBaseDataTypes(); SyncronizeRunnables(null, true); UpdateConnections(); FileName = filename; return(true); } else { return(false); } }
private void CheckItem() { _canRemove = Compositions.Any(x => x.IsChecked); _canSave = Compositions.Any(x => x.State != ItemState.Unchanged); UpdateCommands(); }
public override object Clone() { var newMixin = (ShaderMixinSource)MemberwiseClone(); newMixin.Compositions = Compositions == null ? null : ToSortedList(Compositions.Select(x => new KeyValuePair<string, ShaderSource>(x.Key, (ShaderSource)x.Value.Clone()))); newMixin.Mixins = Mixins == null ? null : Mixins.Select(x => (ShaderClassCode)x.Clone()).ToList(); newMixin.Macros = Macros == null ? null : new List<ShaderMacro>(Macros.ToArray()); return newMixin; }
public ActionResult DeleteConfirmed(Guid id) { Compositions compositions = db.Compositions.Find(id); db.Compositions.Remove(compositions); db.SaveChanges(); return(RedirectToAction("Index")); }
public async Task SaveAsync(INonTerminalDescriptor descriptor, ICollectionRetrievalContext <TData> retrievalContext, Action doAfterDataAdded) { Compositions.Save(descriptor, Describe(retrievalContext.Data)); await SaveAsync(retrievalContext, () => { Compositions.Save(descriptor, Describe(retrievalContext.Data)); doAfterDataAdded?.Invoke(); }); }
/// <summary> /// Adds a composition to this mixin. /// </summary> /// <param name="name">The name.</param> /// <param name="shaderSourceElement">The shader source element.</param> /// <returns>Returns the index of the composition in the array.</returns> public int AddCompositionToArray(string name, ShaderSource shaderSourceElement) { ShaderSource shaderSource; if (!Compositions.TryGetValue(name, out shaderSource)) Compositions.Add(name, shaderSource = new ShaderArraySource()); var shaderArraySource = (ShaderArraySource)shaderSource; shaderArraySource.Add(shaderSourceElement); return shaderArraySource.Values.Count - 1; }
/// <summary> /// Called at the end of the database Initialiser and used to repair and/or upgrade the database /// Note this method must contain re-runnable code as it executes at every app startup /// </summary> public void UpgradeContent() { foreach (var track in Tracks.Where(t => t.AlphamericTitle == null)) { log.Warning($"track {track.Title} [T-{track.Id}] has no alphameric text"); track.AlphamericTitle = track.Title.ToAlphaNumerics().ToLower(); } foreach (var work in Works.Where(w => w.AlphamericName == null)) { log.Warning($"work {work.Name} [W-{work.Id}] has no alphameric text"); work.AlphamericName = work.Name.ToAlphaNumerics().ToLower(); } foreach (var performance in Performances.Where(w => w.AlphamericPerformers == null)) { log.Warning($"performance {performance.Performers} [P-{performance.Id}] has no alphameric text"); performance.AlphamericPerformers = performance.Performers.ToAlphaNumerics().ToLower(); } foreach (var composition in Compositions.Where(w => w.AlphamericName == null)) { log.Warning($"composition {composition.Name} [C-{composition.Id}] has no alphameric text"); composition.AlphamericName = composition.Name.ToAlphaNumerics().ToLower(); } var toBeRemoved = TaskItems.Where(x => x.Type != TaskType.ResampleWork).ToList(); toBeRemoved.AddRange(TaskItems.Where(x => x.Status == Core.TaskStatus.Finished || x.Status == Core.TaskStatus.Failed)); TaskItems.RemoveRange(toBeRemoved); log.Information($"{toBeRemoved.Count()} task items removed"); TaskItems.ToList().ForEach(x => x.Status = Core.TaskStatus.Pending); SaveChanges(); //#if DEBUG // var allItems = TaskItems.ToArray(); // TaskItems.RemoveRange(allItems); // log.Warning($"{allItems.Count()} task items removed"); //#else // var staleTaskItemDate = DateTimeOffset.Now - TimeSpan.FromDays(5); // foreach (var item in TaskItems.Where(t => t.CreatedAt < staleTaskItemDate).ToArray()) // { // switch(item.Status) // { // case Core.TaskStatus.Finished: // break; // case Core.TaskStatus.Failed: // log.Warning($"Task {item.Type} created on {item.CreatedAt.ToDefaultWithTime()} for {item.TaskString} failed - removed"); // break; // default: // log.Warning($"Task {item.Type} created on {item.CreatedAt.ToDefaultWithTime()} for {item.TaskString}, status {item.Status} - removed"); // break; // } // TaskItems.Remove(item); // } //#endif // SaveChanges(); }
public ActionResult Edit([Bind(Include = "ID_Composotion,Name,Realise_Date,Original")] Compositions compositions) { if (ModelState.IsValid) { db.Entry(compositions).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.Original = new SelectList(db.Compositions, "ID_Composotion", "Name", compositions.Original); return(View(compositions)); }
S FoldNode <S>(S state, Func <S, A, S> f, Compositions <A> .Node node) { if (node.Children.IsNone) { return(f(state, node.Value)); } var(l, r) = node.Children.IfNone((default(Compositions <A> .Node), default(Compositions <A> .Node))); state = FoldNode(state, f, l); state = FoldNode(state, f, r); return(state); }
public ActionResult Create([Bind(Include = "ID_Composotion,Name,Realise_Date,Original")] Compositions compositions) { if (ModelState.IsValid) { compositions.ID_Composotion = Guid.NewGuid(); db.Compositions.Add(compositions); db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.Original = new SelectList(db.Compositions, "ID_Composotion", "Name", compositions.Original); return(View(compositions)); }
// GET: Compositions/Details/5 public ActionResult Details(Guid?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Compositions compositions = db.Compositions.Find(id); if (compositions == null) { return(HttpNotFound()); } return(View(compositions)); }
/// <summary> /// Writes the properties. /// </summary> /// <param name="properties">The properties.</param> /// <returns></returns> private static List <string> WriteProperties(List <Models.Property> properties) { List <string> _props = new List <string>(); properties.ForEach((n) => { if ((!Core.DataTypes.Contains(n.Type)) && (!Core.BaseTypes.Contains(Regex.Replace(n.Type.Name, Reflector.TypingSetter, "")))) { Compositions.Add(Regex.Replace(n.Type.Name, Reflector.TypingSetter, "")); } _props.Add('\t' + string.Format(Property_Notation, (n.ReadOnly ? "#" : "+"), n.Name, Regex.Replace(n.Type.Name, Reflector.TypingSetter, "[]"))); }); return(_props); }
public ActionResult Edit(Guid?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Compositions compositions = db.Compositions.Find(id); if (compositions == null) { return(HttpNotFound()); } ViewBag.Original = new SelectList(db.Compositions, "ID_Composotion", "Name", compositions.Original); return(View(compositions)); }
public void Clear() { SimpleDataTypes.Clear(); ComplexDataTypes.Clear(); ClientServerInterfaces.Clear(); SenderReceiverInterfaces.Clear(); Compositions.ClearCompositions(); ComponentDefenitionsList.Clear(); Enums.Clear(); systemErrors.Clear(); BaseDataTypes.Clear(); OsTasks.Clear(); arrayDataTypes.Clear(); FileName = ""; CleanProperties(); }
public override int GetHashCode() { unchecked { int hashCode = 0; for (int i = 0; i < Mixins.Count; i++) { hashCode = (hashCode * 397) ^ (Mixins[i]?.GetHashCode() ?? 0); } for (int i = 0; i < Macros.Count; i++) { hashCode = (hashCode * 397) ^ Macros[i].GetHashCode(); } hashCode = (hashCode * 397) ^ Compositions.GetHashCode(); return(hashCode); } }
private void RemoveCompositions() { foreach (var child in Compositions.Where(x => x.IsChecked).ToList()) { child.IsChecked = false; if (child.State == ItemState.Added) { Compositions.Remove(child); } else { child.State = ItemState.Removed; } } CompositionsView.Refresh(); CheckItem(); }
public Compositions <A> Append(Compositions <A> compx, Compositions <A> compy) { Seq <Compositions <A> .Node> go(Seq <Compositions <A> .Node> mx, Seq <Compositions <A> .Node> my) { if (mx.IsEmpty) { return(my); } if (my.IsEmpty) { return(go(mx.Tail, Seq1(mx.Head))); } var x = mx.Head; var sx = mx.Head.Size; var cx = mx.Head.Children; var vx = mx.Head.Value; var xs = mx.Tail; var y = my.Head; var sy = my.Head.Size; var vy = my.Head.Value; var ys = my.Tail; var ord = sx.CompareTo(sy); if (ord < 0) { return(go(xs, x.Cons(my))); } else if (ord > 0) { var(l, r) = cx.IfNone((default(Compositions <A> .Node), default(Compositions <A> .Node))); return(go(r.Cons(l.Cons(xs)), my)); } else { return(go(new Compositions <A> .Node(sx + sy, Some((x, y)), default(MonoidA).Append(vx, vy)).Cons(xs), ys)); } } return(new Compositions <A>(go(compx.Tree, compy.Tree))); }
/// <summary> /// Writes the class diagram. /// </summary> /// <param name="interface">The interface.</param> /// <param name="useIncludes">if set to <c>true</c> [use includes].</param> /// <returns></returns> internal static string WriteClassDiagram(Models.Interface @interface, bool useIncludes = false) { string markup = Templates.Descriptor; markup = markup.Replace(TypeElement, "interface ").Replace(NameElement, @interface.Name).Replace(ProtoTypeElement, "").Replace(StereoTypeElement, ""); markup = markup.Replace(BodyElement, WriteBody(@interface)); var aggregates = Aggregations.Distinct().ToList(); Aggregations.Clear(); var composites = Compositions.Distinct().ToList(); Compositions.Clear(); aggregates.ForEach((n) => markup += Aggregate(@interface.Name, n)); composites.ForEach((n) => markup += Composite(@interface.Name, n)); return(markup); }
public override void Initialize() { if (!_dataLoaded) { IsBusyLoading = true; var compositionsTask = Task.Factory.StartNew(() => _providerFactory.CompositionsProvider.GetCompositionsAsync().Result) .ContinueWith(t => t.Result.Select(x => x.ToCheckable()).CopyTo(Compositions), TaskScheduler.FromCurrentSynchronizationContext()); var templatesTask = Task.Factory.StartNew(() => _providerFactory.TemplateProvider.GetTemplatesAsync().Result) .ContinueWith(t => { t.Result.CopyTo(Templates); }, TaskScheduler.FromCurrentSynchronizationContext()); Task.WhenAll(compositionsTask, templatesTask) .ContinueWith(result => { IsBusyLoading = false; _dataLoaded = true; }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); } if (_updatedComposition == null || _updatedComposition.State == ItemState.Unchanged) { return; } if (!Compositions.Contains(_updatedComposition)) { Compositions.Add(_updatedComposition); } CheckItem(); _updatedComposition = null; }
public bool SaveToFile(string filename) { XDocument xdoc = new XDocument(); XElement root = new XElement("AUTOSARTAPP"); xdoc.Add(root); SaveProperties(root); BaseDataTypes.WriteToXML(root); SimpleDataTypes.WriteToXML(root); arrayDataTypes.WriteToXML(root); ComplexDataTypes.WriteToXML(root); SenderReceiverInterfaces.WriteToXML(root); ClientServerInterfaces.WriteToXML(root); ComponentDefenitionsList.WriteToXML(root); Enums.WriteToXML(root); systemErrors.WriteToXML(root); OsTasks.WriteToXML(root); Compositions.WriteToXML(root); xdoc.Save(filename); return(true); }
private void Save() { var removed = Compositions.Where(x => x.State == ItemState.Removed).ToList(); removed.ForEach(x => Compositions.Remove(x)); var added = Compositions.Where(x => x.State == ItemState.Added).ToList(); added.ForEach(x => x.State = ItemState.Unchanged); var updated = Compositions.Where(x => x.State == ItemState.Updated).ToList(); updated.ForEach(x => x.State = ItemState.Unchanged); _providerFactory.CompositionsProvider.RemoveCompositions(removed); _providerFactory.CompositionsProvider.AddCompositions(added); _providerFactory.CompositionsProvider.UpdateCompositions(updated); _providerFactory.CompositionsProvider.SaveChanges(); CheckItem(); }
/// <summary> /// Command which contains a multitude of command behaviors, to allow for easy disable and callback mechanisms /// </summary> public CompositionCommand(params IAsyncCompositeCommand[] behaviors) { Compositions.AddRange(behaviors); }
public bool Equals(Compositions <A> x, Compositions <A> y) => x == y;
public Task <int> GetHashCodeAsync(Compositions <A> x) => GetHashCode(x).AsTask();
public Task <bool> EqualsAsync(Compositions <A> x, Compositions <A> y) => Equals(x, y).AsTask();
public int GetHashCode(Compositions <A> x) => default(HashableCompositions <A>).GetHashCode(x);
public bool Contains(INonTerminalDescriptor descriptor) { return(Compositions.Contains(descriptor)); }
public virtual IEnumerable <TData> Retrieve(INonTerminalDescriptor descriptor) { return(Compositions.Retrieve(descriptor).Select(Retrieve).ToArray()); }
public int GetHashCode(Compositions <A> x) => x.GetHashCode();