public void Capture(TimeSpan measuredTime, IClassification measurementClassification = null)
{
lock (classSyncRoot)
{
PerformCapture(measuredTime, measurementClassification);
}
}
public async Task <ClassificationResponse> Classify(IClassification classificationToRun,
DateTime?asOfDate = null)
{
if (null != _classificationProcessor)
{
ClassificationResponse ret = await _classificationProcessor.Classify(classificationToRun,
asOfDate);
if (null != _notificationDispatcher)
{
await _notificationDispatcher.ClassificationCompleted(this,
ClassificationNameAttribute.GetClassificationName(classificationToRun.GetType()),
_classificationProcessor.Parameters,
ret.AsOfSequence,
asOfDate,
ret);
}
return(ret);
}
else
{
return(await Task.FromException <ClassificationResponse>(
new Exception("Classification processor not initialised")));
}
}
// ReSharper disable once TooManyDependencies
public ArrayReader(IInnerContentServices services, IClassification classification, TypeInfo elementType,
IReader item)
: this(classification,
elementType,
services.CreateContents <ArrayList>(new CollectionInnerContentHandler(item, services)))
{
}
public Activation(ISpecification <TypeInfo> specification, IClassification classification,
IActivators activators)
{
_specification = specification;
_classification = classification;
_activators = activators;
}
protected override void Context()
{
base.Context();
_parentClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "parent"
};
_childEmptyClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "childEmpty", Parent = _parentClassification
};
_childClassification = new Classification {
ClassificationType = ClassificationType.Simulation, Name = "child", Parent = _parentClassification
};
_simulation = new ClassifiableSimulation {
Subject = new IndividualSimulation()
};
sut.AddClassificationsToTree(new[] { _childEmptyClassification, _parentClassification, _childClassification });
//do that after so that real node and node fakes are created when adding the classificaiton to the tree
_project.AddClassification(_childEmptyClassification);
_project.AddClassification(_parentClassification);
_project.AddClassification(_childClassification);
_childEmptyClassificationNode = _classificationNodesCache[_childEmptyClassification];
_childClassificationNode = _classificationNodesCache[_childClassification];
_parentClassificationNode = _childClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
_simulationNode = new SimulationNode(_simulation);
_childClassificationNode.AddChild(_simulationNode);
_parentClassificationNode = _childClassificationNode.ParentNode.DowncastTo <ITreeNode <IClassification> >();
A.CallTo(() => _explorerPresenter.NodeFor(_childEmptyClassification)).Returns(_childEmptyClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_childClassification)).Returns(_childClassificationNode);
A.CallTo(() => _explorerPresenter.NodeFor(_parentClassification)).Returns(_parentClassificationNode);
}
/// <summary>
/// Lists all nodes that currently have the same classification path as the parameter.
/// </summary>
/// <param name="classification">The comparison classification</param>
/// <returns>A Enumeration of all the current nodes with the same path as the classification argument</returns>
private IEnumerable <ITreeNode <IClassification> > equivalentNodes(IClassification classification)
{
var project = _projectRetriever.CurrentProject;
var equivalentClassifications = project.AllClassifications
.Where(c => c.HasEquivalentClassification(classification));
return(equivalentClassifications.Select(classificationNodeFor).Where(n => n != null));
}
public Contents(IFormatReaders <System.Xml.XmlReader> factory, IClassification classification,
ITypedTable <IEnumerable <Action <XElement> > > migrations, IContents contents)
{
_factory = factory;
_classification = classification;
_migrations = migrations;
_contents = contents;
}
public RuntimeActivator(IActivators activators, IClassification classification, IReader activator,
ISpecification <TypeInfo> specification)
{
_activators = activators;
_classification = classification;
_activator = activator;
_specification = specification;
}
private IClassification createClassificationUnder(IClassification parentClassification, string name)
{
var project = _projectRetriever.CurrentProject;
var classification = project.GetOrCreateByPath(parentClassification, name, parentClassification.ClassificationType);
SetParentClassificationIfRequired(parentClassification, classification);
return(classification);
}
// ReSharper disable once TooManyDependencies
public ReferenceReader(IReader reader, IReferenceMaps maps, IEntities entities, TypeInfo definition,
IClassification classification) : base(reader)
{
_maps = maps;
_entities = entities;
_definition = definition;
_classification = classification;
}
public Migrator(IFormatReaders <System.Xml.XmlReader> factory, IClassification classification,
IProperty <uint> property,
ImmutableArray <Action <XElement> > migrations)
{
_factory = factory;
_classification = classification;
_migrations = migrations;
_property = property;
}
public void RemoveClassification(IClassification classification)
{
if (classification == null)
{
return;
}
_allClassifications.Remove(classification);
HasChanged = true;
}
public Migrator(IFormatReaders factory, TypeInfo type, IClassification classification,
IProperty <uint> property, ImmutableArray <Action <XElement> > migrations, uint version)
{
_factory = factory;
_type = type;
_classification = classification;
_migrations = migrations;
_version = version;
_property = property;
}
/// <summary>
/// Creates new .
/// </summary>
/// <param name="performanceMonitor">The performance monitor.</param>
/// <param name="measurementClassification">The measurement classification.</param>
/// <returns>PerformanceTimer.</returns>
public static PerformanceTimer StartNew(
IPerformanceMonitor performanceMonitor,
IClassification measurementClassification
)
{
var timer = new PerformanceTimer(performanceMonitor, measurementClassification);
timer._timer.Start();
return(timer);
}
public void AddClassification(IClassification classification)
{
if (classification == null)
{
return;
}
_allClassifications.Add(classification);
HasChanged = true;
}
public InquiryController(DatabaseContext context, IInquiry inquiry, ISystem system, IContactMethod contactMethod, IGuestType guestType, IUser user, IClassification classification, ICallRegister callRegister)
{
this._context = context;
this._inquiryModel = inquiry;
this._system = system;
this._contactMethod = contactMethod;
this._guestType = guestType;
this._user = user;
this._classification = classification;
this._callRegister = callRegister;
}
protected override void Context()
{
base.Context();
_classificationNode = A.Fake <ITreeNode <IClassification> >();
_classification = A.Fake <IClassification>().WithName("OLD_NAME");
_presenter = A.Fake <IRenameClassificationPresenter>();
A.CallTo(() => _classificationNode.Tag).Returns(_classification);
A.CallTo(() => _applicationController.Start <IRenameClassificationPresenter>()).Returns(_presenter);
A.CallTo(() => _presenter.Rename(_classification)).Returns(true);
A.CallTo(() => _presenter.Name).Returns("NEW_NAME");
}
/// <summary>
/// A classification has been requested in processing a query.
/// This function will run it and attach the result back to the query
/// event stream when complete.
/// </summary>
public static async Task RunClassificationForQuery(
ClassifierRequestedEventGridEventData classifierRequestData)
{
if (classifierRequestData != null)
{
// handle the classifier request
ClassificationResponse response = null;
Classification classifier = new Classification(
new ClassificationAttribute(
classifierRequestData.ClassifierRequest.DomainName,
classifierRequestData.ClassifierRequest.EntityTypeName,
classifierRequestData.ClassifierRequest.InstanceKey,
classifierRequestData.ClassifierRequest.ClassifierTypeName
));
if (classifier != null)
{
if (_classificationMap == null)
{
_classificationMap = ClassificationMaps.CreateDefaultClassificationMaps();
}
// get the classifier class - must implement TClassification : IClassification, new()
IClassification classificationToRun = _classificationMap.CreateClassificationClass(classifier.ClassifierTypeName);
if (classificationToRun != null)
{
response = await classifier.Classify(classificationToRun, null);
}
}
if (response != null)
{
// and post the result back to the query that asked for it
Query qrySource = new Query(classifierRequestData.DomainName,
classifierRequestData.EntityTypeName,
classifierRequestData.InstanceKey);
if (qrySource != null)
{
await qrySource.PostClassifierResponse(classifierRequestData.ClassifierRequest.DomainName,
classifierRequestData.ClassifierRequest.EntityTypeName,
classifierRequestData.ClassifierRequest.InstanceKey,
classifierRequestData.ClassifierRequest.ClassifierTypeName,
response.AsOfDate,
classifierRequestData.ClassifierRequest.CorrelationIdentifier,
response.AsOfSequence,
response.Result
);
}
}
}
}
public static async Task OnQueryClassificationHandler([EventGridTrigger] EventGridEvent eventGridEvent)
{
if (eventGridEvent != null)
{
// Get the data from the event that describes what classification is requested
ClassifierRequestedEventGridEventData classifierRequestData = eventGridEvent.Data as ClassifierRequestedEventGridEventData;
if (classifierRequestData != null)
{
// handle the classifier request
ClassificationResponse response = null;
Classification classifier = new Classification(
new ClassificationAttribute(
classifierRequestData.ClassifierRequest.DomainName,
classifierRequestData.ClassifierRequest.EntityTypeName,
classifierRequestData.ClassifierRequest.InstanceKey,
classifierRequestData.ClassifierRequest.ClassifierTypeName
));
if (classifier != null)
{
// get the classifier class - must implement TClassification : IClassification, new()
IClassification classificationToRun = Classification.GetClassifierByName(classifier.ClassifierTypeName);
if (classificationToRun != null)
{
response = await classifier.Classify(classificationToRun, null);
}
}
if (response != null)
{
// and post the result back to the query that asked for it
Query qrySource = new Query(classifierRequestData.DomainName,
classifierRequestData.EntityTypeName,
classifierRequestData.InstanceKey);
if (qrySource != null)
{
await qrySource.PostClassifierResponse(classifierRequestData.ClassifierRequest.DomainName,
classifierRequestData.ClassifierRequest.EntityTypeName,
classifierRequestData.ClassifierRequest.InstanceKey,
classifierRequestData.ClassifierRequest.ClassifierTypeName,
response.AsOfDate,
classifierRequestData.ClassifierRequest.CorrelationIdentifier,
response.AsOfSequence,
response.Result
);
}
}
}
}
}
private ITreeNode addClassificationToTree(IClassification classification, bool alsoAddRoot = true)
{
var classificationNode = createClassificationNodeFor(classification);
if (alsoAddRoot)
{
_explorerPresenter.AddNode(classificationNode.RootNode);
}
_explorerPresenter.AddNode(classificationNode);
return(classificationNode);
}
public ReferenceContents(ISpecification <TypeInfo> specification, ISpecification <TypeInfo> convertible,
IReferenceEncounters identifiers, IReferenceMaps maps, IEntities entities,
IContents option, IClassification classification)
{
_identifiers = identifiers;
_maps = maps;
_entities = entities;
_option = option;
_classification = classification;
_specification = specification;
_convertible = convertible;
}
/// <summary>
/// Recurisively creates a node up to the top most ancestor of for the given <paramref name="classification" />.
/// </summary>
/// <remarks>The created nodes will not be added to the view! This is the responsability of the caller</remarks>
private ITreeNode <IClassification> createClassificationNodeFor(IClassification classification)
{
if (classification == null)
{
return(null);
}
var parentNode = createClassificationNodeFor(classification.Parent);
parentNode = parentNode ?? rootNodeFor(classification);
return(createFor(classification)
.Under(parentNode));
}
/// <summary>
/// Creates a classification node for the given <paramref name="classification" />
/// </summary>
/// <returns>A <see cref="ClassificationNode" /> that can be added to the tree</returns>
private ITreeNode <IClassification> createFor(IClassification classification)
{
var classificationNode = existingEquivalent(classification);
if (classificationNode != null)
{
return(classificationNode);
}
return(new ClassificationNode(classification)
{
Icon = ApplicationIcons.Folder
});
}
public static TypeInfo GetClassification(this IClassification @this, IFormatReader parameter,
TypeInfo defaultValue = null)
{
var result = @this.Get(parameter) ?? defaultValue;
if (result == null)
{
var name = IdentityFormatter.Default.Get(parameter);
throw new InvalidOperationException(
$"An attempt was made to load a type with the fully qualified name of '{name}', but no type could be located with that name.");
}
return(result);
}
public void Capture(TimeSpan measuredTime, IClassification classification = null)
{
StringBuilder sb = new StringBuilder("*** T = " + measuredTime.TotalMilliseconds + " [msec]");
if (classification == null || classification.ClassifiersCount == 0)
{
Trace.WriteLine(sb);
}
foreach (var classifier in classification.Classifiers)
{
sb.Append(", " + classifier.ClassifierType.Name + " : " + classifier.ClassifierObject);
}
Trace.WriteLine(sb);
}
protected override void Context()
{
base.Context();
_presenter = A.Fake <INameClassificationPresenter>();
A.CallTo(() => _applicationController.Start <INameClassificationPresenter>()).Returns(_presenter);
//required to use this unspecific CallTo because of an issue with enum type
A.CallTo(_presenter).WithReturnType <bool>().Returns(true);
A.CallTo(() => _presenter.Name).Returns("CLASS");
_parentClassification = new Classification {
ClassificationType = ClassificationType.Simulation
};
_project.AddClassification(_parentClassification);
_parentClassificationNode = new ClassificationNode(_parentClassification);
A.CallTo(() => _explorerPresenter.NodeFor(A <IClassification> ._)).Returns(null);
}
protected override void Context()
{
base.Context();
_parent = new Classification {
ClassificationType = ClassificationType.ObservedData
}
.WithId("parent").WithName("parent");
_classification = new Classification {
ClassificationType = ClassificationType.ObservedData
}
.WithId("child").WithName("child");
_classification.Parent = _parent;
}
private void PerformCapture(TimeSpan measuredTime, IClassification measurementClassification = null)
{
StringBuilder sb = new StringBuilder(measuredTime.TotalMilliseconds.ToString());// + " [msec],");
foreach (var classifier in measurementClassification.Classifiers)
{
sb.Append("," + classifier.ClassifierObject);
}
//sb.AppendLine();
using (StreamWriter file = new StreamWriter(RollbarPerformanceMonitor.performanceLogFileName, true))
{
file.WriteLine(sb.ToString());
}
}
public ClassificationCPVOptional(IClassification classification)
{
Id = classification?.Id;
Description = classification?.Description;
if (classification != null)
{
if (classification.Uri != null)
{
Trace.TraceWarning("CPV classification uri is not empty: {0}.", classification.Uri);
}
if (!"CPV".Equals(classification.Scheme, StringComparison.OrdinalIgnoreCase))
{
Trace.TraceWarning("CPV classification scheme {0} is wrong.", classification.Scheme);
}
}
}
static IList <Span> AnalyzeExtendedAndItemize(
TextItemizer textItemizer,
IntPtr text,
uint length,
CultureInfo numberCulture,
IClassification classification
)
{
Debug.Assert(length >= 0);
CharAttribute[] pCharAttribute = new CharAttribute[length];
// Analyze the extended character ranges.
AnalyzeExtendedCharactersAndDigits(text, length, textItemizer, pCharAttribute, numberCulture, classification);
return(textItemizer.Itemize(numberCulture, pCharAttribute));
}
public Color ColorFor(IClassification classification)
{
return _classificationColors[classification];
}
private ClassificationSpan ClassificationSpan(int position, int length, IClassification classification)
{
return new ClassificationSpan(classification, Buffer.CurrentSnapshot.GetTextSpan(position, length));
}
public Color ColorFor(IClassification classification)
{
return _classificationStyler.ColorFor(classification);
}
public ClassificationSpan(IClassification classification, TextSpan span)
{
Classification = classification;
Span = span;
}
