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();
