internal void Initialize()
{
CheckDisposed();
Requires = Requires.Clear();
Provides = Provides.Clear();
var provided = HashSet <Type>();
foreach (var dependency in _queue)
{
Requires = Requires.Union(dependency.Requires);
if (Node == dependency.Instance)
{
Provides = Provides.Union(dependency.Provides);
}
provided = provided.Union(dependency.Provides);
}
Requires = Requires.Except(provided);
this.LogDebug("Calculating dependencies.");
Provides.Iter(type => this.LogDebug("- Provides: {}", type));
Requires.Iter(type => this.LogDebug("- Requires: {}", type));
Parent.BiIter(p => ((AutowireContext)p).Register(this), _ => Build());
}
public void Close()
{
Cycle c;
foreach (var n in InternalNodes)
{
foreach (var ep in n.Requests)
{
if (Owner.cycleMap.TryFindValue((Node)ep.Target, out c) && c == this)
{
InternalEnds.Add(ep);
}
else
{
Requests.Add(ep);
}
}
foreach (var ep in n.Provides)
{
if (!Owner.cycleMap.TryFindValue((Node)ep.Target, out c) || c != this)
{
Provides.Add(ep);
}
}
}
}
public async Task <IActionResult> PutProvides(int id, Provides provides)
{
if (id != provides.ReservationSystemId)
{
return(BadRequest());
}
_context.Entry(provides).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProvidesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Decompiles the WixDependencyRef table.
/// </summary>
/// <param name="table">The table to decompile.</param>
private void DecompileWixDependencyRefTable(Table table)
{
foreach (Row row in table.Rows)
{
RequiresRef requiresRef = new RequiresRef();
requiresRef.Id = (string)row[1];
Provides provides = (Provides)this.Core.GetIndexedElement("WixDependencyProvider", (string)row[0]);
if (null != provides)
{
provides.AddChild(requiresRef);
}
else
{
this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerCore.PrimaryKeyDelimiter), "WixDependencyProvider_", (string)row[0], "WixDependencyProvider"));
}
// Get the cached keys for the provider and dependency IDs and generate registry rows.
string providesKey = null;
string requiresKey = null;
if (null != provides && this.keyCache.ContainsKey(provides.Id))
{
providesKey = this.keyCache[provides.Id];
}
else
{
this.Core.OnMessage(DependencyWarnings.ProvidesKeyNotFound(row.SourceLineNumbers, provides.Id));
}
if (this.keyCache.ContainsKey(requiresRef.Id))
{
requiresKey = this.keyCache[requiresRef.Id];
}
else
{
this.Core.OnMessage(DependencyWarnings.RequiresKeyNotFound(row.SourceLineNumbers, requiresRef.Id));
}
if (!this.Core.EncounteredError)
{
// Add the dependency-specific registry keys to be removed during finalization.
// Only remove specific keys that the compiler writes.
string keyRequires = String.Format(@"{0}{1}\{2}\{3}", DependencyCommon.RegistryRoot, requiresKey, DependencyCommon.RegistryDependents, providesKey);
this.registryValues.Add(keyRequires, "*");
this.registryValues.Add(keyRequires, "MinVersion");
this.registryValues.Add(keyRequires, "MaxVersion");
this.registryValues.Add(keyRequires, "Attributes");
}
}
}
public void AddProvides(Node requester, T role)
{
var ep = new EndPoint(requester, role);
if (!Provides.Contains(ep))
{
if (requester == this)
{
HasLoop = true;
}
Provides.Add(ep);
Owner.Invalidate();
}
}
public void Populate(ManifestMetadata manifestMetadata)
{
IPackageMetadata metadata = manifestMetadata;
Id = metadata.Id;
Version = metadata.Version;
Title = metadata.Title;
Authors.AddRange(metadata.Authors);
Owners.AddRange(metadata.Owners);
IconUrl = metadata.IconUrl;
LicenseUrl = metadata.LicenseUrl;
ProjectUrl = metadata.ProjectUrl;
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance;
DevelopmentDependency = metadata.DevelopmentDependency;
Description = metadata.Description;
Summary = metadata.Summary;
ReleaseNotes = metadata.ReleaseNotes;
Language = metadata.Language;
Copyright = metadata.Copyright;
MinClientVersion = metadata.MinClientVersion;
ContentFiles = new Collection <ManifestContentFiles>(manifestMetadata.ContentFiles);
ProjectSourceUrl = metadata.ProjectSourceUrl;
PackageSourceUrl = metadata.PackageSourceUrl;
DocsUrl = metadata.DocsUrl;
WikiUrl = metadata.WikiUrl;
MailingListUrl = metadata.MailingListUrl;
BugTrackerUrl = metadata.BugTrackerUrl;
Replaces.AddRange(metadata.Replaces);
Provides.AddRange(metadata.Provides);
Conflicts.AddRange(metadata.Conflicts);
SoftwareDisplayName = metadata.SoftwareDisplayName;
SoftwareDisplayVersion = metadata.SoftwareDisplayVersion;
if (metadata.Tags != null)
{
Tags.AddRange(ParseTags(metadata.Tags));
}
DependencySets.AddRange(metadata.DependencySets);
FrameworkReferences.AddRange(metadata.FrameworkAssemblies);
if (manifestMetadata.ReferenceSets != null)
{
PackageAssemblyReferences.AddRange(manifestMetadata.ReferenceSets.Select(r => new PackageReferenceSet(r)));
}
}
/// <summary>
/// Decompiles the WixDependencyProvider table.
/// </summary>
/// <param name="table">The table to decompile.</param>
private void DecompileWixDependencyProviderTable(Table table)
{
foreach (Row row in table.Rows)
{
Provides provides = new Provides();
provides.Id = (string)row[0];
provides.Key = (string)row[2];
if (null != row[3])
{
provides.Version = (string)row[3];
}
if (null != row[4])
{
provides.DisplayName = (string)row[4];
}
// Nothing to parse for attributes currently.
Wix.Component component = (Wix.Component) this.Core.GetIndexedElement("Component", (string)row[1]);
if (null != component)
{
component.AddChild(provides);
}
else
{
this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerCore.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component"));
}
// Index the provider to parent the RequiresRef elements.
this.Core.IndexElement(row, provides);
// Add the provider-specific registry keys to be removed during finalization.
// Only remove specific keys that the compiler writes.
string keyProvides = String.Concat(DependencyCommon.RegistryRoot, provides.Key);
this.registryValues.Add(keyProvides, null);
this.registryValues.Add(keyProvides, "Version");
this.registryValues.Add(keyProvides, "DisplayName");
this.registryValues.Add(keyProvides, "Attributes");
// Cache the provider key.
this.keyCache[provides.Id] = provides.Key;
}
}
public async Task <ActionResult <Provides> > PostProvides(Provides provides)
{
_context.Provides.Add(provides);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ProvidesExists(provides.ReservationSystemId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetProvides", new { id = provides.ReservationSystemId }, provides));
}
