internal static void addCaseLineToCurrentCopyCommVar(Variable orjVariable, Variable copyCommVar, KpCore.Rule rule, Module module, Module targetModule, int strategyIndex)
{
//for each variable generate a case line
CaseLine caseLine = new CaseLine();
OperExp result = new OperExp();
int resultValue = 0;
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
foreach (var target in rcr.TargetRhs.Values)
{
TargetedMultiset targetMultiSet = (TargetedMultiset)target;
InstanceIdentifier targetType = (InstanceIdentifier)targetMultiSet.Target;
if (targetModule.Type == targetType.Value)
{
Multiset ms = targetMultiSet.Multiset;
foreach (var obj in ms.Objects)
{
if (obj.Equals(orjVariable.Name))
{
resultValue += ms[obj];
}
}
}
}
result.Exp = copyCommVar.Name;
if (resultValue != 0)
{
result.Oper.Value = MathOper.ADD;
result.Result = new Expression(resultValue.ToString());
}
caseLine.Result = result;
caseLine.Rule = BRulesStandardVar.extractStandardRuleFromKPRule(rule, module, strategyIndex);
ICondition sequenceCondition = BRulesStandardVar.getSequenceCondition(module, strategyIndex, rule.Id);
ICondition targetBounds = getBoundCondition(copyCommVar, caseLine.Result);
CompoundBoolExpression sequenceAndBound = new CompoundBoolExpression(sequenceCondition, BinaryOperator.AND, targetBounds);
ICondition statusCondition = BRulesStandardVar.getTurnCondition(module, strategyIndex);
CompoundBoolExpression statusAndSequence = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceAndBound);
// _conn = to_c2
if (module.connectionToModuleExist(targetModule))
{
BoolExp connEqInstance = new BoolExp(module.getConnectionToModule(targetModule).Name, NuSMV.RelationalOperator.EQUAL, SMVPreFix.getConnectedTo(targetModule.Instance));
caseLine.Rule.AddBoolExpression(connEqInstance, BinaryOperator.AND);
}
caseLine.Rule.AddBoolExpression(statusAndSequence, BinaryOperator.AND);
caseLine.Rule.ID = rule.Id;
if (copyCommVar.Next != null)
{
//if the case line has not added yet
if (!ruleExist(copyCommVar.Next, caseLine))
{
copyCommVar.Next.addCaseLine(caseLine);
}
}
}
public void ObjectEquals_DifferentValue_FalseReturned()
{
object id1 = new InstanceIdentifier();
object id2 = new InstanceIdentifier();
id1.Equals(id2).Should().BeFalse();
}
public void ObjectEquals_SameInstance_TrueReturned()
{
object id1 = new InstanceIdentifier();
object id2 = id1;
id1.Equals(id2).Should().BeTrue();
}
public void ImplicitConversionToString_ValueReturned()
{
var id = new InstanceIdentifier();
var idString = (string)id;
idString.Should().BeSameAs(id.Value);
}
public void Equals_SameInstance_TrueReturned()
{
var id1 = new InstanceIdentifier();
var id2 = id1;
id1.Equals(id2).Should().BeTrue();
}
public async Task GivenMultipleFrames_WhenRetrieveFrame_ThenServerShouldReturnExpectedContent()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile1 = Samples.CreateRandomDicomFileWithPixelData(studyInstanceUid, frames: 3);
DicomPixelData pixelData = DicomPixelData.Create(dicomFile1.Dataset);
InstanceIdentifier dicomInstance = dicomFile1.Dataset.ToInstanceIdentifier();
await InternalStoreAsync(new[] { dicomFile1 });
using DicomWebAsyncEnumerableResponse <Stream> response = await _client.RetrieveFramesAsync(
dicomInstance.StudyInstanceUid,
dicomInstance.SeriesInstanceUid,
dicomInstance.SopInstanceUid,
frames : new[] { 1, 2 },
dicomTransferSyntax : "*");
Stream[] frames = await response.ToArrayAsync();
Assert.NotNull(frames);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(2, frames.Length);
Assert.Equal(KnownContentTypes.MultipartRelated, response.ContentHeaders.ContentType.MediaType);
Assert.Equal(pixelData.GetFrame(0).Data, frames[0].ToByteArray());
Assert.Equal(pixelData.GetFrame(1).Data, frames[1].ToByteArray());
}
public void InequalityOperator_DifferentValue_TrueReturned()
{
var id1 = new InstanceIdentifier();
var id2 = new InstanceIdentifier();
(id1 != id2).Should().BeTrue();
}
public void EqualityOperator_DifferentValue_FalseReturned()
{
var id1 = new InstanceIdentifier();
var id2 = new InstanceIdentifier();
(id1 == id2).Should().BeFalse();
}
private InstanceIdentifier readInstanceIdentifier(XPathNavigator nav)
{
InstanceIdentifier id = null;
string name = nav.GetAttribute("name", String.Empty);
if (String.IsNullOrEmpty(name))
{
string mtype = nav.GetAttribute("mtype", String.Empty);
if (String.IsNullOrEmpty(mtype))
{
string label = nav.GetAttribute("label", String.Empty);
if (!String.IsNullOrEmpty(label))
{
id = new InstanceIdentifier(InstanceIndicator.LABEL, label);
}
}
else
{
id = new InstanceIdentifier(InstanceIndicator.TYPE, mtype);
//register the newly found type with the kP system
if (kp != null)
{
kp.EnsureType(mtype);
}
}
}
else
{
id = new InstanceIdentifier(InstanceIndicator.NAME, name);
}
return(id);
}
public void EqualityOperator_SameValue_TrueReturned()
{
var value = Guid.NewGuid();
var id1 = new InstanceIdentifier(value);
var id2 = new InstanceIdentifier(value);
(id1 == id2).Should().BeTrue();
}
public void ObjectEquals_SameValue_TrueReturned()
{
var value = Guid.NewGuid();
object id1 = new InstanceIdentifier(value);
object id2 = new InstanceIdentifier(value);
id1.Equals(id2).Should().BeTrue();
}
public void InequalityOperator_SameValue_FalseReturned()
{
var value = Guid.NewGuid();
var id1 = new InstanceIdentifier(value);
var id2 = new InstanceIdentifier(value);
(id1 != id2).Should().BeFalse();
}
public static void SetCurrent(IAmbientScope scope, InstanceIdentifier key)
{
CurrentIdentifier.Value = key;
if (!Scopes.TryGetValue(key, out _))
{
Scopes.Add(key, scope);
}
}
private void Instance_OnTerminated(InstanceIdentifier id, TaskbarApplicationInstanceButton instanceButton)
{
Dispatcher.InvokeAsync(() =>
{
instances.Remove(instances.FirstOrDefault(i => i.Id == id));
InstanceStackPanel.Children.Remove(instanceButton);
});
}
public Uri ResolveRetrieveInstanceUri(InstanceIdentifier instanceIdentifier)
{
EnsureArg.IsNotNull(instanceIdentifier, nameof(instanceIdentifier));
return(new Uri(
$"/{instanceIdentifier.StudyInstanceUid}/{instanceIdentifier.SeriesInstanceUid}/{instanceIdentifier.SopInstanceUid}",
UriKind.Relative));
}
private async Task <InstanceIdentifier> CreateDicomFileAndGetInstanceIdentifierAsync()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
InstanceIdentifier dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
await _client.StoreAsync(new[] { dicomFile }, studyInstanceUid);
return(dicomInstance);
}
private InstanceIdentifier RandomizeInstanceIdentifier(DicomDataset dataset)
{
InstanceIdentifier newId = new InstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate());
dataset.AddOrUpdate(DicomTag.StudyInstanceUID, newId.StudyInstanceUid);
dataset.AddOrUpdate(DicomTag.SeriesInstanceUID, newId.SeriesInstanceUid);
dataset.AddOrUpdate(DicomTag.SOPInstanceUID, newId.SopInstanceUid);
return(newId);
}
public static Header Read(StandardBusinessDocumentHeader sbdh) // throws SbdhException
{
Header header = Header.NewInstance();
// Sender
PartnerIdentification senderIdentifier = sbdh.Sender[0].Identifier;
header = header.SetSender(
ParticipantIdentifier.Of(senderIdentifier.Value, Scheme.Of(senderIdentifier.Authority)));
// Receiver
PartnerIdentification receiverIdentifier = sbdh.Receiver[0].Identifier;
header = header.SetReceiver(
ParticipantIdentifier.Of(receiverIdentifier.Value, Scheme.Of(receiverIdentifier.Authority)));
// Identifier
header = header.SetIdentifier(InstanceIdentifier.Of(sbdh.DocumentIdentification.InstanceIdentifier));
// InstanceType
header = header.SetInstanceType(
InstanceType.Of(
sbdh.DocumentIdentification.Standard,
sbdh.DocumentIdentification.Type,
sbdh.DocumentIdentification.TypeVersion));
// CreationTimestamp
if (sbdh.DocumentIdentification.CreationDateAndTime == null)
{
throw new SbdhException("Element 'CreationDateAndTime' is not set or contains invalid value.");
}
header = header.SetCreationTimestamp(sbdh.DocumentIdentification.CreationDateAndTime);
// Scope
foreach (Scope scope in sbdh.BusinessScope)
{
if (scope.Type.Equals("DOCUMENTID"))
{
Scheme scheme = scope.Identifier != null
? Scheme.Of(scope.Identifier)
: DocumentTypeIdentifier.DefaultScheme;
header = header.SetDocumentType(DocumentTypeIdentifier.Of(scope.InstanceIdentifier, scheme));
}
else if (scope.Type.Equals("PROCESSID"))
{
Scheme scheme = scope.Identifier != null
? Scheme.Of(scope.Identifier)
: ProcessIdentifier.DefaultScheme;
header = header.SetProcess(ProcessIdentifier.Of(scope.InstanceIdentifier, scheme));
}
}
return(header);
}
public void Constructor_UniqueValueInitialized()
{
var id1 = new InstanceIdentifier();
var id2 = new InstanceIdentifier();
id1.Value.Should().NotBeNullOrEmpty();
id2.Value.Should().NotBeNullOrEmpty();
id2.Value.Should().NotBeEquivalentTo(id1.Value);
}
public EnvironmentScope()
{
_items = new List <object>();
_clear = new HashSet <Type>();
_keyValues = new Dictionary <string, object>();
_instanceIdentifier = new InstanceIdentifier();
_parentScope = GetAmbientScope();
SetAmbientScope(this);
}
public async Task GivenChangeFeedRequest_WhenAnInstanceExists_ThenAuditLogEntriesShouldBeCreated()
{
InstanceIdentifier dicomInstance = await CreateDicomFileAndGetInstanceIdentifierAsync();
await ExecuteAndValidate(
() => _client.GetChangeFeed(),
AuditEventSubType.ChangeFeed,
"changefeed",
HttpStatusCode.OK);
}
public async Task GivenRetrieveRequestForInstance_WhenResourceIsFound_ThenAuditLogEntriesShouldBeCreated()
{
InstanceIdentifier dicomInstance = await CreateDicomFileAndGetInstanceIdentifierAsync();
await ExecuteAndValidate(
() => _client.RetrieveInstanceAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid, dicomInstance.SopInstanceUid),
AuditEventSubType.Retrieve,
$"studies/{dicomInstance.StudyInstanceUid}/series/{dicomInstance.SeriesInstanceUid}/instances/{dicomInstance.SopInstanceUid}",
HttpStatusCode.OK);
}
public async Task GivenRetrieveMetadataRequestForStudy_WhenResourceIsFound_ThenAuditEntriesShouldBeCreated()
{
InstanceIdentifier dicomInstance = await CreateDicomFileAndGetInstanceIdentifierAsync();
await ExecuteAndValidate(
() => _client.RetrieveStudyMetadataAsync(dicomInstance.StudyInstanceUid),
AuditEventSubType.RetrieveMetadata,
$"studies/{dicomInstance.StudyInstanceUid}/metadata",
HttpStatusCode.OK);
}
public async Task GivenDeleteRequestForSeries_WhenResourceExists_ThenAuditLogEntriesShouldBeCreated()
{
InstanceIdentifier dicomInstance = await CreateDicomFileAndGetInstanceIdentifierAsync();
await ExecuteAndValidate(
() => _client.DeleteSeriesAsync(dicomInstance.StudyInstanceUid, dicomInstance.SeriesInstanceUid),
AuditEventSubType.Delete,
$"studies/{dicomInstance.StudyInstanceUid}/series/{dicomInstance.SeriesInstanceUid}",
HttpStatusCode.NoContent);
}
private void ApplicationControl_Clicked(InstanceIdentifier id = null)
{
if (id == null)
{
CreateNewInstance();
}
else
{
instances.FirstOrDefault(i => i.Id == id)?.Window?.BringToForeground();
}
}
private void SendHealthReport(InstanceIdentifier instanceIdentifier, HealthState state)
{
var healthInformation = new HealthInformation("Watchdog", "Healthcheck", state)
{
TimeToLive = TimeSpan.FromSeconds(30)
};
var healthReport = new StatelessServiceInstanceHealthReport(instanceIdentifier.PartitionId,
instanceIdentifier.InstanceId, healthInformation);
_fabricClient.HealthManager.ReportHealth(healthReport);
}
public async Task GivenStoreRequest_WhenStoringUsingStudyInstanceUid_ThenAuditLogEntriesShouldBeCreated()
{
string studyInstanceUid = TestUidGenerator.Generate();
DicomFile dicomFile = Samples.CreateRandomDicomFile(studyInstanceUid);
InstanceIdentifier dicomInstance = dicomFile.Dataset.ToInstanceIdentifier();
await ExecuteAndValidate(
() => _client.StoreAsync(new[] { dicomFile }, studyInstanceUid),
AuditEventSubType.Store,
$"studies/{dicomInstance.StudyInstanceUid}",
HttpStatusCode.OK);
}
/// <inheritdoc />
public Uri ResolveRetrieveInstanceUri(InstanceIdentifier instanceIdentifier)
{
EnsureArg.IsNotNull(instanceIdentifier, nameof(instanceIdentifier));
return(RouteUri(
KnownRouteNames.RetrieveInstance,
new RouteValueDictionary()
{
{ KnownActionParameterNames.StudyInstanceUid, instanceIdentifier.StudyInstanceUid },
{ KnownActionParameterNames.SeriesInstanceUid, instanceIdentifier.SeriesInstanceUid },
{ KnownActionParameterNames.SopInstanceUid, instanceIdentifier.SopInstanceUid },
}));
}
private void Instance_OnTerminated(InstanceIdentifier id, ActionCenterApplicationButton button)
{
Dispatcher.InvokeAsync(() =>
{
InstancePanel.Children.Remove(button);
if (InstancePanel.Children.Count == 0)
{
ApplicationName.Visibility = Visibility.Collapsed;
ApplicationButton.Visibility = Visibility.Visible;
}
});
}
private List <int> Rule(Rule rule)
{
List <int> list = new List <int>();
list.AddRange(Multiset(((ConsumerRule)rule).Lhs));
if (rule is DivisionRule)
{
list.Add(2);
list.Add(((DivisionRule)rule).Rhs.Count);
foreach (InstanceBlueprint rhs in ((DivisionRule)rule).Rhs)
{
list.AddRange(Multiset(rhs.Multiset));
}
}
else
if (rule is RewriteCommunicationRule)
{
list.Add(1);
list.Add(((RewriteCommunicationRule)rule).Rhs.Count + ((RewriteCommunicationRule)rule).TargetRhs.Count);
bool b = false;
if (((RewriteCommunicationRule)rule).Rhs.Count > 0)
{
list.AddRange((Multiset(((RewriteCommunicationRule)rule).Rhs)));
list.Add(-1);
}
foreach (KeyValuePair <IInstanceIdentifier, TargetedMultiset> kv in ((RewriteCommunicationRule)rule).TargetRhs)
{
list.AddRange((Multiset(kv.Value.Multiset)));
InstanceIdentifier i = kv.Key as InstanceIdentifier;
list.Add(membraneId[i.Value]);
}
}
else
if (rule is RewritingRule)
{
list.Add(0);
list.AddRange(Multiset(((RewritingRule)rule).Rhs));
}
else
if (rule is DissolutionRule)
{
list.Add(3);
}
else
if (rule is ConsumerRule)
{
list.Add(0);
}
return(list);
}
private static void SetIdInternal(InstanceIdentifier id, string key) => CallContext.LogicalSetData(key, id);
private static void SetIdInternal(InstanceIdentifier id, string key) => Id.Value = id;
