public StartupTemplate(IOutputTarget outputTarget, object model = null) : base(TemplateId, outputTarget, model)
{
outputTarget.Application.EventDispatcher.Subscribe <ContainerRegistrationRequest>(HandleServiceRegistration);
//eventDispatcher.Subscribe(ContainerRegistrationForDbContextEvent.EventId, HandleDbContextRegistration);
//eventDispatcher.Subscribe(ServiceConfigurationRequiredEvent.EventId, HandleServiceConfiguration);
//eventDispatcher.Subscribe(InitializationRequiredEvent.EventId, HandleInitialization);
}
public bool Equals(IOutputTarget other)
{
var ot = other as ListBoxOutputTarget;
if (ot == null)
return false;
return ot._listBox == _listBox;
}
/// <summary>
/// Returns a namespace string based on the full path from the <paramref name="target"/>. This will include folders and C# projects.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static string GetNamespace(this IOutputTarget target)
{
return(string.Join(".", target.GetTargetPath()
.Where(x => !x.Metadata.ContainsKey("Namespace Provider") ||
x.Metadata["Namespace Provider"] as bool? == true)
.Select(x => x.Name.ToCSharpNamespace())));
}
private IEnumerable <INugetPackageInfo> GetTemplateNugetDependencies(IOutputTarget project)
{
return(project.TemplateInstances
.SelectMany(ti => ti.GetAllNugetDependencies())
.Distinct()
.ToList());
}
public bool Update(IMotionSource motionSource, IOutputTarget outputTarget)
{
if (_isLoading)
{
for (var i = 0; i < 9; i++)
{
ETarget[i] = Mathf.Lerp(ETarget[i], 0f, 0.05f);
}
for (var i = 0; i < 3; i++)
{
XTarget[i] = Mathf.Lerp(XTarget[i], 0.5f, 0.05f);
RTarget[i] = Mathf.Lerp(RTarget[i], 0f, 0.05f);
}
}
else if (motionSource != null)
{
UpdateMotion(motionSource);
DebugDraw.DrawCircle(motionSource.TargetPosition + motionSource.TargetUp * RangeMinL0Slider.val * motionSource.ReferenceLength, motionSource.TargetUp, motionSource.TargetRight, Color.white, 0.05f);
DebugDraw.DrawCircle(motionSource.TargetPosition + motionSource.TargetUp * RangeMaxL0Slider.val * motionSource.ReferenceLength, motionSource.TargetUp, motionSource.TargetRight, Color.white, 0.05f);
}
UpdateValues(outputTarget);
return(true);
}
public void Install(XDocument doc, IOutputTarget p)
{
_namespaces = new XmlNamespaceManager(new NameTable());
var defaultNamespace = doc.Root.GetDefaultNamespace();
_namespaces.AddNamespace("ns", defaultNamespace.NamespaceName);
_namespaces.AddNamespace("urns", "urn:schemas-microsoft-com:asm.v1");
var configurationElement = doc.XPathSelectElement("/ns:configuration", _namespaces);
if (configurationElement == null)
{
doc.Add(configurationElement = new XElement("configuration"));
}
var runtimeElement = doc.XPathSelectElement("/ns:configuration/ns:runtime", _namespaces);
if (runtimeElement == null)
{
configurationElement.Add(runtimeElement = new XElement("runtime"));
}
var assemblyBindingElement = doc.XPathSelectElement("/ns:configuration/ns:runtime/urns:assemblyBinding", _namespaces);
if (assemblyBindingElement == null)
{
runtimeElement.AddFirst(assemblyBindingElement = new XElement((XNamespace)_namespaces.LookupNamespace("urns") + "assemblyBinding"));
}
var nugetPackages = p.Application.OutputTargets.Where(x => x.IsVSProject()).SelectMany(x => x.NugetPackages()).Distinct(); // NOTE: This is not very robust as we are "distincting" on name. Logic should be implemented to choose which version.
AddAssemblyBindingRedirects(assemblyBindingElement, nugetPackages.SelectMany(x => x.AssemblyRedirects).ToList());
}
public IdentityServerConfigurationTemplate(IOutputTarget outputTarget, object model = null) : base(TemplateId, outputTarget, model)
{
AddNugetDependency(NugetPackages.IdentityServer4);
base.Project.Application.EventDispatcher.Subscribe <CertificateSpecifiedEvent>(evt =>
{
_hasCertificateSpecified = true;
});
}
public DbContextInterfaceTemplate(IOutputTarget outputTarget, IList <ClassModel> model) : base(Identifier, outputTarget, model)
{
AddNugetDependency(NugetPackages.EntityFrameworkCore(Project));
ExecutionContext.EventDispatcher.Subscribe <EntityTypeConfigurationCreatedEvent>(evt =>
{
_entityTypeConfigurations.Add(evt);
});
}
public override ITemplate CreateTemplateInstance(IOutputTarget project, ElementSettingsModel model)
{
var associationSettings = _metadataManager.ModuleBuilder(project.Application).GetAssociationSettingsModels()
.Where(x => x.TargetEnd.TargetsType(model.Id) || x.SourceEnd.TargetsType(model.Id))
.ToList();
return(new ApiElementModelTemplate(project, model, associationSettings));
}
public HtmlFileTemplatePartialTemplate(IOutputTarget outputTarget, HtmlFileTemplateModel model) : base(TemplateId, outputTarget, model)
{
AddNugetDependency(IntentNugetPackages.IntentCommonHtml);
//if (!string.IsNullOrWhiteSpace(Model.GetModule().NuGetPackageId))
//{
// AddNugetDependency(new NugetPackageInfo(Model.GetModule().NuGetPackageId, Model.GetModule().NuGetPackageVersion));
//}
}
/// <summary>
/// Returns the package name of the <paramref name="target"/>'s using the <paramref name="rootFolder"/> folder as the root.
/// </summary>
/// <param name="target"></param>
/// <param name="rootFolder"></param>
/// <returns></returns>
public static string GetPackageName(this IOutputTarget target, string rootFolder)
{
return(string.Join(".", target.GetTargetPath().Select(x => x.Name)
.Reverse()
.TakeWhile(x => !string.Equals(x, rootFolder, StringComparison.InvariantCultureIgnoreCase))
.Reverse())
.ToKotlinPackage());
}
public void CreateUI()
{
pluginLabelJSON.val = PluginName;
_builder = new UIBuilder();
_group = new UIGroup(_builder);
_group.BlacklistStorable("Device Report");
PluginTitle = _group.CreateDisabledButton("Plugin", new Color(0.3f, 0.3f, 0.3f), Color.white);
PresetButtonGroup = _group.CreateHorizontalGroup(510, 50, new Vector2(10, 0), 3, idx => _group.CreateButtonEx());
var saveButton = PresetButtonGroup.items[0].GetComponent <UIDynamicButton>();
saveButton.buttonText.fontSize = 25;
saveButton.label = "Save Config";
saveButton.buttonColor = new Color(0.309f, 1f, 0.039f) * 0.8f;
saveButton.textColor = Color.white;
saveButton.button.onClick.AddListener(SaveConfigCallback);
var loadButton = PresetButtonGroup.items[1].GetComponent <UIDynamicButton>();
loadButton.buttonText.fontSize = 25;
loadButton.label = "Load Config";
loadButton.buttonColor = new Color(1f, 0.168f, 0.039f) * 0.8f;
loadButton.textColor = Color.white;
loadButton.button.onClick.AddListener(LoadConfigCallback);
var defaultButton = PresetButtonGroup.items[2].GetComponent <UIDynamicButton>();
defaultButton.buttonText.fontSize = 25;
defaultButton.label = "As Default";
defaultButton.buttonColor = new Color(1f, 0.870f, 0.039f) * 0.8f;
defaultButton.textColor = Color.white;
defaultButton.button.onClick.AddListener(SaveDefaultConfigCallback);
OutputTargetSettings = new OutputTargetSettings(t => _outputTarget = t);
OutputTargetSettings.CreateUI(_group);
var debugGroup = new UIGroup(_group);
var visible = false;
DebugTitle = _group.CreateButton("Debug", () => debugGroup.SetVisible(visible = !visible), new Color(0.3f, 0.3f, 0.3f), Color.white);
DebugDrawEnableToggle = debugGroup.CreateToggle("Plugin:DebugDrawEnable", "Enable Debug", false);
DeviceReportText = debugGroup.CreateTextField("Device Report", "", 320);
DeviceReportText.text.font = Font.CreateDynamicFontFromOSFont("Consolas", 24);
DeviceReportText.text.fontSize = 24;
debugGroup.SetVisible(false);
MotionSourceTitle = _group.CreateDisabledButton("Motion Source", new Color(0.3f, 0.3f, 0.3f), Color.white);
MotionSourceChooser = _group.CreatePopup("Plugin:MotionSourceChooser", "Select motion source", new List <string> {
"Male + Female", "Asset + Female", "D***o + Female", "Animation Pattern", "Range Test"
}, "Male + Female", MotionSourceChooserCallback);
DeviceChooserCallback("T-code");
MotionSourceChooserCallback("Male + Female");
}
public AngularModuleTemplate(IOutputTarget outputTarget, Intent.Modelers.WebClient.Angular.Api.ModuleModel model) : base(TemplateId, outputTarget, model)
{
if (Model.IsRootModule())
{
_angularImports.Add(this.UseType("BrowserModule", "@angular/platform-browser"));
_angularImports.Add(this.UseType("BrowserAnimationsModule", "@angular/platform-browser/animations"));
_components.Add(this.UseType("AppComponent", "./app.component"));
}
else
{
_angularImports.Add(this.UseType("CommonModule", "@angular/common"));
}
ExecutionContext.EventDispatcher.Subscribe <AngularComponentCreatedEvent>(@event =>
{
if (@event.ModuleId == ClassName)
{
_components.Add(GetTypeName(@event.ModelId));
}
else if (@event.ModuleId == Model.Id)
{
_components.Add(GetTypeName(AngularComponentTsTemplate.TemplateId, @event.ModelId));
}
});
ExecutionContext.EventDispatcher.Subscribe <AngularServiceProxyCreatedEvent>(@event =>
{
if (@event.ModuleId != Model.Id)
{
return;
}
var templateClassName = GetTypeName(@event.TemplateId, @event.ModelId);
_providers.Add(templateClassName);
});
ExecutionContext.EventDispatcher.Subscribe <AngularImportDependencyRequiredEvent>(@event =>
{
if (@event.ModuleId != Model.Id && @event.ModuleId != ClassName)
{
return;
}
_angularImports.Add(@event.Dependency);
_imports.Add(@event.Import);
});
ExecutionContext.EventDispatcher.Subscribe <AngularCustomProviderRequiredEvent>(@event =>
{
if (@event.ModuleId != Model.Id && @event.ModuleId != ClassName)
{
return;
}
_providers.Add($"{{ provide: {@event.Provide}, useClass: {@event.UseClass}, multi: {@event.Multi.ToString().ToLower()} }}");
_imports.Add(@event.Import);
});
}
public static void AddReference(this IOutputTarget outputTarget, IAssemblyReference assemblyDependency)
{
var collection = outputTarget.References();
if (!collection.Contains(assemblyDependency))
{
collection.Add(assemblyDependency);
}
}
public DataTransferModelTemplate(IOutputTarget outputTarget, Intent.Modelers.Services.Api.DTOModel model) : base(TemplateId, outputTarget, model)
{
AddDependency(new JavaDependency("org.projectlombok", "lombok", "1.18.12"));
if (model.Fields.Any(x => x.TypeReference.IsCollection))
{
SetDefaultTypeCollectionFormat($"{ImportType("java.util.List")}<{{0}}>");
}
AddTypeSource(TemplateId, type => $"{ImportType("java.util.List")}<{type}>");
}
public override ITemplate CreateTemplateInstance(IOutputTarget project, FileTemplateModel model)
{
return(new TemplatePreProcessedFileTemplate(
templateId: TemplateId,
project: project,
model: model,
t4TemplateId: FileTemplateTemplate.TemplateId,
partialTemplateId: FileTemplatePartialTemplate.TemplateId));
}
public FormGroupTemplate(IOutputTarget outputTarget, Intent.Modelers.WebClient.Angular.Api.FormGroupDefinitionModel model) : base(TemplateId, outputTarget, model)
{
AddTypeSource(FormGroupTemplate.TemplateId);
// GCB - an interesting dependency predicament. Perhaps there should be a mechanism where a template can declare itself
// the representative of a model type, and this would not be necessary. Using the hierarchy of the OutputTargets could
// make the discovery of the type predictable. Food for thought.
//AddTypeSource(AngularDTOTemplate.TemplateId);
AddTypeSource("Intent.Angular.ServiceProxies.Proxies.AngularDTOTemplate");
}
public CustomTemplateRegistrationTemplate(IOutputTarget project, TemplateRegistrationModel model) : base(TemplateId, project, model)
{
AddNugetDependency(IntentNugetPackages.IntentModulesCommon);
if (!string.IsNullOrWhiteSpace(Model.GetModelType()?.ParentModule.NuGetPackageId))
{
AddNugetDependency(new NugetPackageInfo(Model.GetModelType()?.ParentModule.NuGetPackageId, Model.GetModelType()?.ParentModule.NuGetPackageVersion));
}
}
public ApiElementExtensionModelTemplate(IOutputTarget outputTarget, ElementExtensionModel model) : base(TemplateId, outputTarget, model)
{
AddNugetDependency(IntentNugetPackages.IntentModulesCommon);
if (Model.TypeReference.Element.Id == FolderModel.SpecializationTypeId)
{
AddNugetDependency(IntentNugetPackages.IntentModulesCommonTypes);
}
}
public WebApiServiceCSProjectFileTemplate(IOutputTarget project, IVisualStudioProject model)
: base(Identifier, project, model)
{
//_port = project.ProjectType.Properties.FirstOrDefault(x => x.Name == "Port")?.Value;
//bool.TryParse(project.ProjectType.Properties.FirstOrDefault(x => x.Name == "UseSsl")?.Value, out var useSsl);
//if (useSsl)
//{
// _sslPort = project.ProjectType.Properties.First(x => x.Name == "SslPort").Value;
//}
}
public AngularComponentTsTemplate(IOutputTarget outputTarget, Intent.Modelers.WebClient.Angular.Api.ComponentModel model) : base(TemplateId, outputTarget, model)
{
AddTypeSource(ModelTemplate.TemplateId);
AddTypeSource(FormGroupTemplate.TemplateId);
AddTypeSource("Intent.Angular.ServiceProxies.Proxies.AngularDTOTemplate");
AddTypeSource("Intent.Angular.ServiceProxies.Proxies.AngularServiceProxyTemplate");
_injectedServices = Model.GetAngularComponentSettings().InjectServices()?.Where(x => x.SpecializationTypeId == AngularServiceModel.SpecializationTypeId)
.Select(x => (x.Name.ToCamelCase(), this.UseType(x.Name, new AngularServiceModel(x).GetAngularServiceSettings().Location())))
.ToList() ?? new List <(string, string)>();
}
public TemplatePreProcessedFileTemplate(
string templateId,
IOutputTarget project,
TemplateRegistrationModel model,
string t4TemplateId,
string partialTemplateId)
: base(templateId, project, model)
{
_t4TemplateId = t4TemplateId;
_partialTemplateId = partialTemplateId;
}
public DbContextTemplate(IOutputTarget outputTarget, IList <ClassModel> model) : base(TemplateId, outputTarget, model)
{
ExecutionContext.EventDispatcher.Subscribe <OverrideDbContextOptionsEvent>(evt =>
{
_useDbContextAsOptionsParameter |= evt.UseDbContextAsOptionsParameter;
});
ExecutionContext.EventDispatcher.Subscribe <EntityTypeConfigurationCreatedEvent>(evt =>
{
_entityTypeConfigurations.Add(evt);
AddTemplateDependency(TemplateDependency.OnTemplate(evt.Template));
});
}
public static bool IsVSProject(this IOutputTarget outputTarget)
{
return(new[] {
VisualStudioProjectTypeIds.CSharpLibrary,
VisualStudioProjectTypeIds.WebApiApplication,
VisualStudioProjectTypeIds.WcfApplication,
VisualStudioProjectTypeIds.ConsoleAppNetFramework,
VisualStudioProjectTypeIds.NodeJsConsoleApplication,
VisualStudioProjectTypeIds.CoreWebApp,
VisualStudioProjectTypeIds.CoreCSharpLibrary,
VisualStudioProjectTypeIds.SQLServerDatabaseProject
}.Contains(outputTarget.Type));
}
public static void AddDependency(this IOutputTarget outputTarget, IOutputTarget dependency)
{
if (outputTarget.Equals(dependency))
{
throw new Exception($"OutputTarget [{outputTarget}] cannot add a dependency to itself");
}
var collection = outputTarget.Dependencies();
if (!collection.Contains(dependency))
{
collection.Add(dependency);
}
}
public ApiElementModelTemplate(IOutputTarget outputTarget, ElementSettingsModel model, List <AssociationSettingsModel> associationSettings) : base(TemplateId, outputTarget, model)
{
AddNugetDependency(IntentNugetPackages.IntentModulesCommon);
AssociationSettings = associationSettings;
AddTypeSource(CSharpTypeSource.Create(ExecutionContext, TemplateId, collectionFormat: "IEnumerable<{0}>"));
ExecutionContext.EventDispatcher.Subscribe <NotifyModelHasParentFolderEvent>(@event =>
{
if (@event.ModelId == model.Id)
{
HasParentFolder = true;
}
});
}
public ApiElementModelExtensionsTemplate(IOutputTarget outputTarget, ExtensionModel model = null) : base(TemplateId, outputTarget, model)
{
AddNugetDependency(IntentNugetPackages.IntentModulesCommon);
foreach (var module in Model.StereotypeDefinitions
.SelectMany(x => x.TargetElements)
.Distinct()
.Select(x => new IntentModuleModel(x.Package))
.Distinct()
.Where(x => !string.IsNullOrWhiteSpace(x.NuGetPackageId) && !string.IsNullOrWhiteSpace(x.NuGetPackageVersion)))
{
AddNugetDependency(module.NuGetPackageId, module.NuGetPackageVersion);
}
}
public FrameworkProjectSyncProcessor(
string projectPath,
ISoftwareFactoryEventDispatcher sfEventDispatcher,
IXmlFileCache xmlFileCache,
IChanges changeManager,
IOutputTarget project)
{
_projectPath = projectPath;
_sfEventDispatcher = sfEventDispatcher;
_xmlFileCache = xmlFileCache;
_changeManager = changeManager;
_project = project;
_syncProjectFile = UpdateFileOnHdd;
}
public void UpdateValues(IOutputTarget outputTarget)
{
if (_lastNoCollisionSmoothingEnabled)
{
_lastCollisionSmoothingT = Mathf.Pow(2, 10 * ((Time.time - _lastNoCollisionSmoothingStartTime) / _lastNoCollisionSmoothingDuration - 1));
if (_lastCollisionSmoothingT > 1.0f)
{
_lastNoCollisionSmoothingEnabled = false;
_lastCollisionSmoothingT = 0;
}
}
UpdateL0(); UpdateL1(); UpdateL2();
UpdateR0(); UpdateR1(); UpdateR2();
UpdateV0();
UpdateA0(); UpdateA1(); UpdateA2();
_stringBuilder.Length = 0;
var l0 = AppendIfChanged(_stringBuilder, "L0", XCmd[0], ref LastXCmd[0]);
var l1 = AppendIfChanged(_stringBuilder, "L1", XCmd[1], ref LastXCmd[1]);
var l2 = AppendIfChanged(_stringBuilder, "L2", XCmd[2], ref LastXCmd[2]);
var r0 = AppendIfChanged(_stringBuilder, "R0", RCmd[0], ref LastRCmd[0]);
var r1 = AppendIfChanged(_stringBuilder, "R1", RCmd[1], ref LastRCmd[1]);
var r2 = AppendIfChanged(_stringBuilder, "R2", RCmd[2], ref LastRCmd[2]);
var v0 = AppendIfChanged(_stringBuilder, "V0", ECmd[0], ref LastECmd[0]);
var a0 = AppendIfChanged(_stringBuilder, "A0", ECmd[1], ref LastECmd[1]);
var a1 = AppendIfChanged(_stringBuilder, "A1", ECmd[2], ref LastECmd[2]);
var a2 = AppendIfChanged(_stringBuilder, "A2", ECmd[3], ref LastECmd[3]);
var data = $"{_stringBuilder}\n";
if (!string.IsNullOrEmpty(data.Trim()))
{
outputTarget?.Write(data);
}
_stringBuilder.Length = 0;
_stringBuilder.Append(" Target Cmd Output\n");
_stringBuilder.Append("L0\t").AppendFormat("{0,5:0.00}", XTarget[0]).Append(",\t").AppendFormat("{0,5:0.00}", XCmd[0]).Append(",\t").AppendLine(l0);
_stringBuilder.Append("L1\t").AppendFormat("{0,5:0.00}", XTarget[1]).Append(",\t").AppendFormat("{0,5:0.00}", XCmd[1]).Append(",\t").AppendLine(l1);
_stringBuilder.Append("L2\t").AppendFormat("{0,5:0.00}", XTarget[2]).Append(",\t").AppendFormat("{0,5:0.00}", XCmd[2]).Append(",\t").AppendLine(l2);
_stringBuilder.Append("R0\t").AppendFormat("{0,5:0.00}", RTarget[0]).Append(",\t").AppendFormat("{0,5:0.00}", RCmd[0]).Append(",\t").AppendLine(r0);
_stringBuilder.Append("R1\t").AppendFormat("{0,5:0.00}", RTarget[1]).Append(",\t").AppendFormat("{0,5:0.00}", RCmd[1]).Append(",\t").AppendLine(r1);
_stringBuilder.Append("R2\t").AppendFormat("{0,5:0.00}", RTarget[2]).Append(",\t").AppendFormat("{0,5:0.00}", RCmd[2]).Append(",\t").AppendLine(r2);
_stringBuilder.Append("V0\t").AppendFormat("{0,5:0.00}", ETarget[0]).Append(",\t").AppendFormat("{0,5:0.00}", ECmd[0]).Append(",\t").AppendLine(v0);
_stringBuilder.Append("A0\t").AppendFormat("{0,5:0.00}", ETarget[1]).Append(",\t").AppendFormat("{0,5:0.00}", ECmd[1]).Append(",\t").AppendLine(a0);
_stringBuilder.Append("A1\t").AppendFormat("{0,5:0.00}", ETarget[2]).Append(",\t").AppendFormat("{0,5:0.00}", ECmd[2]).Append(",\t").AppendLine(a1);
_stringBuilder.Append("A2\t").AppendFormat("{0,5:0.00}", ETarget[3]).Append(",\t").AppendFormat("{0,5:0.00}", ECmd[3]).Append(",\t").Append(a2);
DeviceReport = _stringBuilder.ToString();
}
public CSharpProject(IOutputTarget outputTarget)
{
_outputTarget = outputTarget;
if (_outputTarget.Metadata.TryGetValue("Language Version", out var languageVersion))
{
LanguageVersion = languageVersion as string;
}
if (_outputTarget.Metadata.TryGetValue("Nullable Enabled", out var nullableEnabled))
{
NullableEnabled = nullableEnabled as bool? ?? false;
}
if (_outputTarget.Metadata.TryGetValue("Target Frameworks", out var targetFrameworks))
{
TargetFrameworks = targetFrameworks as IEnumerable <string>;
}
}
public static void SyncFrameworkReferences(this IOutputTarget project, XDocument doc)
{
var frameworkDependencies = project.FrameworkDependencies().ToArray();
if (frameworkDependencies.Length == 0)
{
return;
}
var itemGroupElement = doc.XPathSelectElement("Project/ItemGroup[FrameworkReference]");
if (itemGroupElement == null)
{
itemGroupElement = new XElement("ItemGroup");
itemGroupElement.Add(Environment.NewLine);
itemGroupElement.Add(" ");
var projectElement = doc.XPathSelectElement("Project");
projectElement.Add(" ");
projectElement.Add(itemGroupElement);
projectElement.Add(Environment.NewLine);
projectElement.Add(" ");
}
foreach (var dependency in frameworkDependencies)
{
var existingItem = doc.XPathSelectElement($"/Project/ItemGroup/FrameworkReference[@Include='{dependency}']");
if (existingItem != null)
{
continue;
}
/*
* <FrameworkReference Include="Microsoft.AspNetCore.App" />
*/
var item = new XElement(XName.Get("FrameworkReference"));
item.Add(new XAttribute("Include", dependency));
itemGroupElement.Add(" ");
itemGroupElement.Add(item);
itemGroupElement.Add(Environment.NewLine);
itemGroupElement.Add(" ");
}
}
public ComposedLogger(IOutputTarget outputTarget)
{
_outputTarget = outputTarget;
}
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <returns>
/// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(IOutputTarget other)
{
return (other != null) && (other is ConsoleOutputTarget);
}
/// <summary>
/// Tries to add the target to the manager,
/// so it gets notifications.
/// </summary>
public bool RegisterTarget(IOutputTarget target)
{
return _targets.Add(target);
}
/// <summary>
/// Tries to remove the target from the manager,
/// so it will no longer receive notifications.
/// </summary>
public bool UnregisterTarget(IOutputTarget target)
{
return _targets.Remove(target);
}
