public void Personnel_Returns_ValidViewModel()
{
var models = MongoPersonnel.Personnel;
var viewModel = models.Select(Personnel.ToViewModel).First();
var expectedViewModel = new PersonnelViewModel
{
Id = "5a8417f68317338c8e080a62",
Name = "999 Call Handler",
ImageUrl = "....",
Context = new List <ContentView>()
{
new ContentView
{
Title = "Title Text",
Content = new List <string> {
"Content Text"
},
CssClass = "CssClass Text",
Order = 1
}
},
UsesNrls = true,
ActorOrganisationId = "5a82f9ffcb969daa58d33377",
CModule = "CModule-Type",
SystemIds = new List <string> {
"5a8417338317338c8e0809e5"
},
Benefits = new List <string> {
"benefitid"
}
};
Assert.Equal(expectedViewModel, viewModel, Comparers.ModelComparer <PersonnelViewModel>());
}
public void TestRemove()
{
var pq = new PriorityQueue <int> {
1, 2, 3, 4, 5, 6
};
pq.Remove(3).ShouldEqual(true);
pq.Count.ShouldEqual(5);
pq.Remove(3).ShouldEqual(false);
pq.Count.ShouldEqual(5);
pq.Remove(0).ShouldEqual(false);
pq.Dequeue().ShouldEqual(1);
pq.Remove(2).ShouldEqual(true);
pq.Dequeue().ShouldEqual(4);
pq.Remove(6).ShouldEqual(true);
pq.Dequeue().ShouldEqual(5);
pq.Count.ShouldEqual(0);
var absoluteQueue = new PriorityQueue <int>(Comparers.Create <int, int>(Math.Abs));
absoluteQueue.Remove(2).ShouldEqual(false);
absoluteQueue.Enqueue(2);
absoluteQueue.Remove(-2).ShouldEqual(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}"/> class.
/// </summary>
/// <param name="comparers">The comparers.</param>
private ImmutableDictionary(Comparers?comparers = null)
{
_comparers = comparers ?? Comparers.Get(EqualityComparer <TKey> .Default, EqualityComparer <TValue> .Default);
_root = SortedInt32KeyNode <HashBucket> .EmptyNode;
}
internal override NodeBase Update(object owner, int shift, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result)
{
if (comparers.KeyComparer.Equals(this.Key, key))
{
switch (behavior)
{
case KeyCollisionBehavior.SetValue:
result = OperationResult.AppliedWithoutSizeChange;
return(SetValue(owner, key, value));
case KeyCollisionBehavior.SetIfValueDifferent:
if (comparers.ValueComparer.Equals(this.Value, value))
{
result = OperationResult.NoChangeRequired;
return(this);
}
else
{
result = OperationResult.AppliedWithoutSizeChange;
return(SetValue(owner, key, value));
}
case KeyCollisionBehavior.Skip:
result = OperationResult.NoChangeRequired;
return(this);
case KeyCollisionBehavior.ThrowIfValueDifferent:
if (!comparers.ValueComparer.Equals(this.Value, value))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Strings.DuplicateKey, key));
}
result = OperationResult.NoChangeRequired;
return(this);
case KeyCollisionBehavior.ThrowAlways:
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Strings.DuplicateKey, key));
default:
throw new InvalidOperationException(); // unreachable
}
}
result = OperationResult.SizeChanged;
return(MergeIntoNode(owner, shift, this, comparers.KeyComparer.GetHashCode(this.Key), hash, key, value));
}
internal override NodeBase Remove(object owner, int shift, int hash, TKey key, Comparers comparers, out OperationResult result)
{
int idx = IndexOf(key, comparers);
if (idx == -1)
{
// no found, no-op
result = OperationResult.NoChangeRequired;
return(this);
}
result = OperationResult.SizeChanged;
if (_count == 1)
{
return(null);
} // one count left, return null
if (_count == 2)
{
return(_values[0]);
} // return the value node.
if (IsEditable(owner))
{
_values[idx] = _values[_count - 1];
_values[_count - 1] = null;
_count--;
return(this);
}
else
{
ValueNode[] newValues = new ValueNode[_count - 1];
Array.Copy(_values, newValues, newValues.Length);
if (idx < newValues.Length)
{
newValues[idx] = _values[_count - 1];
}
return(SetNode(owner, _count - 1, newValues));
}
}
private HashArrayMapNode ExpandToArrayMap(object owner, int shift, int count, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result)
{
NodeBase[] nodes = new NodeBase[WIDTH];
int index = Mask(hash, shift);
nodes[index] = Empty.Update(owner, shift + BITS, hash, key, value, comparers, behavior, out result);
int j = 0;
for (int i = 0; i < nodes.Length; i++)
{
if (((_bitmap >> i) & 1) != 0)
{
nodes[i] = _nodes[j++];
}
}
return(new HashArrayMapNode(owner, count + 1, nodes));
}
internal abstract NodeBase Remove(object owner, int shift, int hash, TKey key, Comparers comparers, out OperationResult result);
internal override NodeBase Remove(object owner, int shift, int hash, TKey key, Comparers comparers, out OperationResult result)
{
int bit = 1 << Mask(hash, shift);
if ((_bitmap & bit) == 0)
{
// Not found noop
result = OperationResult.NoChangeRequired;
return(this);
}
int idx = GetIndex(bit);
NodeBase n = _nodes[idx].Remove(owner, shift + BITS, hash, key, comparers, out result);
if (n == _nodes[idx])
{
return(this);
}
if (n != null)
{
var newNode = EnsureEditable(owner);
newNode._nodes[idx] = n;
return(newNode);
}
if (_bitmap == bit)
{
return(null);
}
// removed, so resize
BitmapIndexedNode editable = EnsureEditable(owner);
editable._bitmap ^= bit;
Array.Copy(editable._nodes, idx + 1, editable._nodes, idx, editable._nodes.Length - (idx + 1));
editable._nodes[editable._nodes.Length - 1] = null;
return(editable);
}
internal override NodeBase Remove(object owner, int shift, int hash, TKey key, Comparers comparers, out OperationResult result)
{
int idx = Mask(hash, shift);
NodeBase node = _array[idx];
if (node == null)
{
result = OperationResult.NoChangeRequired;
return(this);
}
NodeBase newSubNode = node.Remove(owner, shift + BITS, hash, key, comparers, out result);
if (newSubNode == null) // the sub-node is removed.
{
return((_count <= MIN_HASH_ARRAY_MAP_SIZE)
// Compress it to BitmapIndexedNode
? PackNodes(owner, idx)
// just set null if the current count is not small enough to pack
: SetNode(owner, _count - 1, idx, null));
}
return(newSubNode == node ? this : SetNode(owner, _count, idx, newSubNode));
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableTrieDictionary{TKey, TValue}"/> class/
/// </summary>
/// <param name="count">The number of elements stored.</param>
/// <param name="root">The root node.</param>
/// <param name="compares">The comparers.</param>
internal ImmutableTrieDictionary(int count, NodeBase root, Comparers compares = null)
{
_count = count;
_root = root;
_comparers = compares ?? Comparers.Default;
}
public void FhirResponse_ValidDocumentReferenceResources()
{
var documentReferenceModels = MongoDocumentReferences.DocumentReferences.ToList();
var documentReferenceBundle = FhirBundle.GetBundle <DocumentReference>(documentReferenceModels);
var actual = new FhirResponse();
actual.Resource = documentReferenceBundle;
Assert.Equal(documentReferenceModels, actual.GetResources <DocumentReference>(), Comparers.ModelComparer <DocumentReference>());
}
public async void PointerService_Returns_ValidPointerList()
{
var patientModels = MongoPatients.Patients.ToList();
var organizationModels = MongoOrganizations.Organizations.ToList();
var documentReferenceModels = MongoDocumentReferences.DocumentReferences_3656987882;
var testNhsNumber = "3656987882";
var testAsid = "200000000116";
var testOrgCode = "AMS01";
var _docRefService = new Mock <IDocumentReferenceServices>();
_docRefService.Setup(m => m.GetPointersBundle(It.IsAny <NrlsPointerRequest>())).Returns(SystemTasks.Task.Run(() => FhirBundle.GetBundle <DocumentReference>(documentReferenceModels) as Resource)).Verifiable();
var _patientService = new Mock <IPatientServices>();
_patientService.Setup(m => m.GetPatients()).Returns(SystemTasks.Task.Run(() => patientModels)).Verifiable();
var _organisationServices = new Mock <IOrganisationServices>();
_organisationServices.Setup(m => m.GetOrganisations()).Returns(SystemTasks.Task.Run(() => organizationModels)).Verifiable();
var pointerCache = new PatientPointers
{
Pointers = MongoPointerViewModels.PointerViewModels_3656987882
};
var cacheMock = MemoryCacheStub.MockMemoryCacheService.GetMemoryCache(pointerCache);
var pdfBinaryId = "TestBinaryPdf1";
var _documentServices = new Mock <IDocumentsServices>();
_documentServices.Setup(m => m.GetPointerDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(SystemTasks.Task.Run(() => MongoBinaries.Binaries.FirstOrDefault(x => x.Id == pdfBinaryId) as Resource)).Verifiable();
var opts = new ApiSetting
{
BaseUrl = "://localhost",
DefaultPort = "55448",
Secure = false,
SecureOnly = false,
SecurePort = "55443",
SupportedContentTypes = new List <string> {
"application/fhir+json"
}
};
var _apiSettings = new Mock <IOptions <ApiSetting> >();
_apiSettings.Setup(op => op.Value).Returns(opts);
var pointerService = new PointerService(_apiSettings.Object, _docRefService.Object, _patientService.Object, _organisationServices.Object, cacheMock, _documentServices.Object);
var request = RequestViewModel.Create(testNhsNumber);
request.Asid = testAsid;
request.OrgCode = testOrgCode;
var actual = await pointerService.GetPointers(request);
var pointers = MongoPointerViewModels.PointerViewModels_3656987882;
var patient = MongoPatientViewModels.PatientViewModel_3656987882;
var org = MongoOrganizationViewModels.OrganizationViewModel_00003X;
var expected = new List <PointerViewModel>();
foreach (var exp in pointers)
{
exp.SubjectViewModel = patient;
exp.AuthorViewModel = org;
exp.CustodianViewModel = org;
expected.Add(exp);
}
_docRefService.Verify();
_patientService.Verify();
_organisationServices.Verify();
Assert.Equal(expected, actual, Comparers.ModelComparer <PointerViewModel>());
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableDictionary<TKey, TValue>.MutationInput"/> struct.
/// </summary>
/// <param name="map">The map.</param>
internal MutationInput(ImmutableDictionary <TKey, TValue> map)
{
this.root = map.root;
this.comparers = map.comparers;
this.count = map.count;
}
public void NrlsConformance_Valid()
{
var expected = new CapabilityStatement
{
Url = "https://fhir.nhs.uk/STU3/CapabilityStatement/NRL-CapabilityStatement-1",
Version = ModelInfo.Version,
Name = "NRL-CapabilityStatement-1",
Status = PublicationStatus.Draft,
Date = "2017-10-11T10:20:38+00:00",
Publisher = "NHS Digital",
Contact = new List <ContactDetail>
{
new ContactDetail
{
Name = "Interoperability Team",
Telecom = new List <ContactPoint>
{
new ContactPoint
{
System = ContactPoint.ContactPointSystem.Email,
Use = ContactPoint.ContactPointUse.Work,
Value = "*****@*****.**"
}
}
}
},
Description = new Markdown("This profile defines the expected capabilities of the NRL STU3 FHIR server when conforming to the NRL API IG. The Capability Statement resource includes a complete list of actual profiles, RESTful operations, and search parameters that are expected to be supported by NRL STU3 FHIR Server."),
Copyright = new Markdown("Copyright © 2017 NHS Digital"),
Kind = CapabilityStatement.CapabilityStatementKind.Requirements,
FhirVersion = "3.0.1",
AcceptUnknown = CapabilityStatement.UnknownContentCode.No,
Format = new List <string>
{
"application/fhir+xml",
"application/fhir+json"
},
Rest = new List <CapabilityStatement.RestComponent>
{
new CapabilityStatement.RestComponent
{
Mode = CapabilityStatement.RestfulCapabilityMode.Server,
Security = new CapabilityStatement.SecurityComponent
{
Cors = true
},
Resource = new List <CapabilityStatement.ResourceComponent>
{
new CapabilityStatement.ResourceComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "http://hl7.org/fhir/StructureDefinition/conformance-search-parameter-combination",
Extension = new List <Extension>
{
new Extension
{
Url = "required",
Value = new FhirString("_id")
}
}
},
new Extension
{
Url = "http://hl7.org/fhir/StructureDefinition/conformance-search-parameter-combination",
Extension = new List <Extension>
{
new Extension
{
Url = "required",
Value = new FhirString("subject")
},
new Extension
{
Url = "optional",
Value = new FhirString("custodian")
},
new Extension
{
Url = "optional",
Value = new FhirString("type")
}
}
},
new Extension
{
Url = "http://hl7.org/fhir/StructureDefinition/conformance-search-parameter-combination",
Extension = new List <Extension>
{
new Extension
{
Url = "required",
Value = new FhirString("subject")
},
new Extension
{
Url = "required",
Value = new FhirString("_summary")
}
}
},
new Extension
{
Url = "http://hl7.org/fhir/StructureDefinition/conformance-search-parameter-combination",
Extension = new List <Extension>
{
new Extension
{
Url = "required",
Value = new FhirString("subject")
},
new Extension
{
Url = "required",
Value = new FhirString("identifier")
}
},
FhirComments = new List <string>
{
"This combination can only be used for Supersede, Patch, and Delete interactions."
}
}
},
Type = ResourceType.DocumentReference,
Profile = new ResourceReference
{
Reference = "https://fhir.hl7.org.uk/StructureDefinition/NRL-DocumentReference-1"
},
Interaction = new List <CapabilityStatement.ResourceInteractionComponent>
{
new CapabilityStatement.ResourceInteractionComponent
{
Code = CapabilityStatement.TypeRestfulInteraction.SearchType,
Documentation = "Allows discovery of existing NRL document reference resources using different search criteria"
},
new CapabilityStatement.ResourceInteractionComponent
{
Code = CapabilityStatement.TypeRestfulInteraction.Read,
Documentation = "Allows retrieval of specific NRL document references by id"
},
new CapabilityStatement.ResourceInteractionComponent
{
Code = CapabilityStatement.TypeRestfulInteraction.Patch,
Documentation = "Allows update of specific NRL document references by id"
},
new CapabilityStatement.ResourceInteractionComponent
{
Code = CapabilityStatement.TypeRestfulInteraction.Delete,
Documentation = "Allows deletion of specific NRL document references by id"
},
new CapabilityStatement.ResourceInteractionComponent
{
Code = CapabilityStatement.TypeRestfulInteraction.Create,
Documentation = "Allows creation of NRL document references"
}
},
SearchParam = new List <CapabilityStatement.SearchParamComponent>
{
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("SHOULD")
}
},
Name = "subject",
Definition = "http://hl7.org/fhir/SearchParameter/DocumentReference.subject",
Type = SearchParamType.Reference,
Documentation = "The Patient the DocumentReference relates to. This is MUST when searching by patient."
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("MAY")
}
},
Name = "custodian",
Definition = "http://hl7.org/fhir/SearchParameter/DocumentReference.custodian",
Type = SearchParamType.Reference,
Documentation = "The owner of the DocumentReference"
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("SHOULD")
}
},
Name = "_id",
Definition = "http://hl7.org/fhir/search",
Type = SearchParamType.String,
Documentation = "Logical id of the DocumentReference. This is MUST when searching by _id"
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("MAY")
}
},
Name = "type",
Definition = "http://hl7.org/fhir/search",
Type = SearchParamType.Token,
Documentation = "Clinical type the DocumentReference refers too"
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("MAY")
}
},
Name = "_summary",
Definition = "http://hl7.org/fhir/search",
Type = SearchParamType.String,
Documentation = "Type of summary to return"
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("MAY")
}
},
Name = "identifier",
Definition = "http://hl7.org/fhir/search",
Type = SearchParamType.Token,
Documentation = "The MasterIdentifer associated to the DocumentReference. Used in Supersede, Patch, and Delete interactions."
},
new CapabilityStatement.SearchParamComponent
{
Extension = new List <Extension>
{
new Extension
{
Url = "https://fhir.nhs.uk/STU3/StructureDefinition/Extension-CapabilityStatementExpectation-1",
Value = new FhirString("MAY")
}
},
Name = "_format",
Definition = "http://hl7.org/fhir/search",
Type = SearchParamType.String,
Documentation = "Content Type of returned result"
}
}
}
}
}
}
};
var actual = new NrlsConformance().GetConformance();
Assert.Equal(expected, actual, Comparers.ModelComparer <CapabilityStatement>());
}
public LabelCache(Comparers.Comparer<string> comparer)
{
_comparer = comparer;
}
internal override NodeBase Update(object owner, int shift, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result)
{
int idx = Mask(hash, shift);
NodeBase node = _array[idx];
if (node == null)
{
NodeBase newSubNode = BitmapIndexedNode.Empty.Update(owner, shift + BITS, hash, key, value, comparers, behavior, out result);
return(SetNode(owner, _count + 1, idx, newSubNode));
}
else
{
NodeBase newSubNode = node.Update(owner, shift + BITS, hash, key, value, comparers, behavior, out result);
if (newSubNode == node)
{
return(this);
} // No Change
return(SetNode(owner, _count, idx, newSubNode));
}
}
static void Main(string[] args)
{
Trace.Write("START");
Debuggers.LogError("error occured");
Debuggers.LogError(new Exception("ex occured"));
Dictionary <string, int> dict = new Dictionary <string, int>()
{
{ "Marketing", 1 }, { "Sales", 2 }, { "IT", 3 }
};
var dictExists = dict.Contains(new KeyValuePair <string, int>("IT", 2));
Formaters.DateAndTime(DateTime.Now, 10.23456D);
Debuggers.Start();
var customers = Linqers.CustomersWithOrdersByYear(2017);
Linqers.GetProductsLongestNameByCategory();
string asyncResult;
Task.Run(async() =>
{
asyncResult = await Threads.StartAsync();
}).GetAwaiter().GetResult();
Threads.RunTimer();
var publicTypes = new Reflections().GetPublicTypes();
var assemblyName = new Reflections().GetAssemblyName();
var isPositiveDecimal = Regexes.PositiveWithTwoDecimalPlaces(5.666M);
Console.WriteLine("Available memory: " + new PerformanceCounter("Memory", "Available MBytes").NextValue());
var assemblies = new Reflections().GetTypesFromCurrentDomain();
Product productForSerialization = new Product()
{
CategoryId = 1, Id = 2, IsValid = true
};
Serializators.SerializeWithBinaryFormatter(productForSerialization, "bin.dat");
Serializators.SerializeWithDataContractToFile(productForSerialization, "datacontract.dat");
string userSerialized = Serializators.SerializeWithBinaryWriter(new Product {
Id = 10
});
DateTime?nullableDateTime = null;
bool isDateNotNull = nullableDateTime.HasValue;
RateCollection rateCollection = new RateCollection(new Rate[] { new Rate {
Value = 1
} });
foreach (var item in rateCollection)
{
Console.WriteLine(item);
}
var currentAssembly = Assembly.GetExecutingAssembly();
var sb = new StringBuilder();
sb.Append("First");
sb.AppendLine();
sb.Append("Second");
Console.WriteLine(sb);
SortedList <string, string> sortedList = new SortedList <string, string>()
{
{ "asd", "dsa" }
};
Debug.Assert(false, "stop");
float amount = 1.6F;
object amountObj = amount;
int amountInt = (int)(float)amountObj;
new Product().Add("book1");
User newUser = new User()
{
UserGroup = Group.Supervisors | Group.Users
};
bool isTrue = newUser.UserGroup < Group.Administrator;
var userGroup = newUser.UserGroup;
Console.WriteLine(userGroup);
string stringNull = null;
string stringNotNull = "asd";
Comparers.AreEqual(stringNull, stringNotNull);
Rate rate1 = new Rate()
{
Value = 1, Category = "cat"
};
string xml = Serializators.SerializeWithDataContract(rate1);
string json = Serializators.SerializeWithDataContractJson(rate1);
Console.WriteLine("xml:\r\n" + xml);
Console.WriteLine("json:\r\n" + json);
Subscriber sub = new Subscriber();
sub.Subscribe();
sub.Execute();
Console.Read();
return;
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Rate));
Console.WriteLine(string.Format("{0} asdasd {1:000#} asd", 4, 159));
Console.WriteLine(123.ToString("000#"));
Rate ratenull = null;
int wynik;
int.TryParse(ratenull.Category, out wynik);
Console.Read();
BaseLogger logger = new Logger();
logger.Log("Log started");
logger.Log("Base: Log contiuniug");
((Logger)logger).LogCompleted();
Console.Read();
return;
Reflections.SetPropertiesOnObject(new Rate()
{
MyInt = 10
}, "MyInt", "MyIntSpecified");
float mojfloat = 1.6F;
double dable = (double)mojfloat;
var hashed = Hashers.HashByAlgName(@"C:\windows-version.txt", "SHA");
Threads.ConcurrentDict();
var x = from i in new List <int> {
1, 2
}
group i by i into grouped
where grouped.Key > 1
select grouped.Key;
string xmlInput = "<xml><RateSheet><rate category=\"boutou\" date=\"2012-12-12\"><value>0.03</value></rate><rate category=\"druga\" date=\"2011-11-11\"><value>0.04</value></rate></RateSheet></xml>";
var result = Serializators.ReadFromXml(xmlInput);
SHA1Managed SHhash = new SHA1Managed();
//new Class2().Method1();
Class1 class1 = new Class1();
INewInterface interf = class1;
interf.Method1();
IEnumerable <Person> people = new List <Person>()
{
new Person {
PhoneNumbers = new List <PhoneNumber> {
new PhoneNumber {
Number = "1"
}, new PhoneNumber {
Number = "2"
}
}
},
new Person {
PhoneNumbers = new List <PhoneNumber> {
new PhoneNumber {
Number = "2"
}, new PhoneNumber {
Number = "3"
}
}
},
};
IEnumerable <IEnumerable <PhoneNumber> > phoneLists = people.Select(p => p.PhoneNumbers);
IEnumerable <PhoneNumber> phoneNumbers = people.SelectMany(p => p.PhoneNumbers);
}
internal override NodeBase Update(object owner, int shift, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result)
{
int bit = 1 << Mask(hash, shift);
int idx = GetIndex(bit);
if ((_bitmap & bit) != 0)
{ // exist
NodeBase node = _nodes[idx];
var newSubNode = node.Update(owner, shift + BITS, hash, key, value, comparers, behavior, out result);
if (newSubNode == node)
{
return(this);
}
var newNode = EnsureEditable(owner);
newNode._nodes[idx] = newSubNode;
return(newNode);
}
else
{ // not exist
int count = PopCount(_bitmap);
if (count == 0)
{
result = OperationResult.SizeChanged;
return(new ValueNode(owner, key, value));
}
if (count < _nodes.Length && IsEditable(owner))
{
// still has room in the array and editable
result = OperationResult.SizeChanged;
Array.Copy(_nodes, idx, _nodes, idx + 1, count - idx);
_nodes[idx] = new ValueNode(owner, key, value);
_bitmap |= bit;
return(this);
}
return((count >= MAX_BITMAP_INDEXED_SIZE)
? (NodeBase)ExpandToArrayMap(owner, shift, count, hash, key, value, comparers, behavior, out result)
: AddToNode(owner, idx, bit, count, key, value, out result));
}
}
public MultiStepComparer(IComparer <T> primaryComparer, IEnumerable <IComparer <T> > secondaryComparers)
{
Comparers.Add(primaryComparer);
Comparers.AddRange(secondaryComparers);
}
internal abstract NodeBase Update(object owner, int shift, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result);
public MultiStepComparer(IComparer <T> primaryComparer, params IComparer <T>[] secondaryComparers)
{
Comparers.Add(primaryComparer);
Comparers.AddRange(secondaryComparers);
}
internal abstract bool TryGet(int shift, int hash, Comparers comparers, TKey key, out TKey actualKey, out TValue value);
/// <summary>
/// Wraps the specified data structure with an immutable collection wrapper.
/// </summary>
/// <param name="root">The root of the data structure.</param>
/// <param name="comparers">The comparers.</param>
/// <param name="count">The number of elements in the data structure.</param>
/// <returns>
/// The immutable collection.
/// </returns>
private static ImmutableDictionary <TKey, TValue> Wrap(ImmutableSortedDictionary <int, HashBucket> .Node root, Comparers comparers, int count)
{
Requires.NotNull(root, "root");
Requires.NotNull(comparers, "comparers");
Requires.Range(count >= 0, "count");
return(new ImmutableDictionary <TKey, TValue>(root, comparers, count));
}
internal override NodeBase Update(object owner, int shift, int hash, TKey key, TValue value, Comparers comparers, KeyCollisionBehavior behavior, out OperationResult result)
{
if (hash == _hash)
{
int idx = IndexOf(key, comparers);
if (idx != -1)
{
// Found the same key, just update
var editable = EnsureEditable(owner);
editable._values[idx] = (ValueNode)editable._values[idx]
.Update(owner, shift, hash, key, value, comparers, behavior, out result);
return(editable);
}
if (_count < _values.Length && IsEditable(owner)) // There are still some spots left
{
_values[_count] = new ValueNode(owner, key, value);
_count++;
result = OperationResult.SizeChanged;
return(this);
}
// Key cannot be found in the existing buckets, nor the list has extra room
// let's copy the array again
ValueNode[] newValues = new ValueNode[_count + 1];
Array.Copy(_values, newValues, _count);
newValues[_count] = new ValueNode(owner, key, value);
result = OperationResult.SizeChanged;
return(SetNode(owner, _count + 1, newValues));
}
else
{
// different hash, nest in a bit mapnode
result = OperationResult.SizeChanged;
return(NestToBitmapNode(owner, shift, this, _hash, hash, key, value));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableDictionary<TKey, TValue>"/> class.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="comparers">The comparers.</param>
/// <param name="count">The number of elements in the map.</param>
private ImmutableDictionary(ImmutableSortedDictionary <int, HashBucket> .Node root, Comparers comparers, int count)
: this(Requires.NotNull(comparers, "comparers"))
{
Requires.NotNull(root, "root");
root.Freeze(FreezeBucketAction);
this.root = root;
this.count = count;
}
internal override NodeBase Remove(object owner, int shift, int hash, TKey key, Comparers comparers, out OperationResult result)
{
if (!comparers.KeyComparer.Equals(this.Key, key))
{
result = OperationResult.NoChangeRequired;
return(this);
}
else
{
result = OperationResult.SizeChanged;
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableDictionary<TKey, TValue>"/> class.
/// </summary>
/// <param name="comparers">The comparers.</param>
private ImmutableDictionary(Comparers comparers = null)
{
this.comparers = comparers ?? Comparers.Get(EqualityComparer <TKey> .Default, EqualityComparer <TValue> .Default);
this.root = ImmutableSortedDictionary <int, HashBucket> .Node.EmptyNode;
}
/// <summary>
/// Wraps the specified data structure with an immutable collection wrapper.
/// </summary>
/// <param name="root">The root of the data structure.</param>
/// <param name="comparers">The comparers.</param>
/// <param name="count">The number of elements in the data structure.</param>
/// <returns>
/// The immutable collection.
/// </returns>
private static ImmutableDictionary <TKey, TValue> Wrap(SortedInt32KeyNode <HashBucket> root, Comparers comparers, int count)
{
Requires.NotNull(root, nameof(root));
Requires.NotNull(comparers, nameof(comparers));
Requires.Range(count >= 0, nameof(count));
return(new ImmutableDictionary <TKey, TValue>(root, comparers, count));
}
/// <summary>
/// Initializes a new instance of the <see cref="ImmutableDictionary{TKey, TValue}.MutationInput"/> struct.
/// </summary>
/// <param name="map">The map.</param>
internal MutationInput(ImmutableDictionary <TKey, TValue> map)
{
_root = map._root;
_comparers = map._comparers;
_count = map._count;
}
public void UnorderableType2()
{
IComparer <Unorderable> ordering = Comparers.DefaultComparer <Unorderable>();
}
private static void ProcessSubFolders(this Vault vault, SyncDownResponse rs)
{
var comparers = new Comparers();
var folderList = new SortedSet <IFolderNode>(vault.userFolders.Values, comparers);
var recordList = new SortedSet <IRecordNode>(vault.userFolderRecords ?? Enumerable.Empty <IRecordNode>(), comparers);
if (rs.userFoldersRemoved != null)
{
foreach (var ufr in rs.userFoldersRemoved)
{
folderList.RemoveWhere(x => x.FolderUid == ufr.folderUid);
recordList.RemoveWhere(x => x.FolderUid == ufr.folderUid);
}
}
if (rs.sharedFolderFolderRemoved != null)
{
foreach (var sffr in rs.sharedFolderFolderRemoved)
{
folderList.RemoveWhere(x => x.FolderUid == sffr.folderUid);
recordList.RemoveWhere(x => x.FolderUid == sffr.folderUid);
}
}
if (rs.userFolderSharedFoldersRemoved != null)
{
foreach (var ufsfr in rs.userFolderSharedFoldersRemoved)
{
folderList.RemoveWhere(x => x.FolderUid == ufsfr.folderUid);
recordList.RemoveWhere(x => x.FolderUid == ufsfr.folderUid);
}
}
if (rs.userFoldersRemovedRecords != null)
{
foreach (var uffr in rs.userFoldersRemovedRecords)
{
recordList.Remove(uffr);
}
}
if (rs.sharedFolderFolderRecordsRemoved != null)
{
foreach (var sffrr in rs.sharedFolderFolderRecordsRemoved)
{
recordList.Remove(sffrr);
}
}
if (rs.userFolders != null)
{
foreach (var uf in rs.userFolders)
{
var encryptedKey = uf.userFolderKey.Base64UrlDecode();
uf.unencryptedFolderKey = uf.keyType == 2
? CryptoUtils.DecryptRsa(encryptedKey, vault.Auth.PrivateKey)
: CryptoUtils.DecryptAesV1(encryptedKey, vault.Auth.DataKey);
folderList.Remove(uf);
folderList.Add(uf);
}
}
if (rs.sharedFolderFolders != null)
{
foreach (var sff in rs.sharedFolderFolders)
{
if (vault.sharedFolders.TryGetValue(sff.sharedFolderUid, out SyncDownSharedFolder sf))
{
var encryptedKey = sff.sharedFolderFolderKey.Base64UrlDecode();
sff.unencryptedFolderKey = CryptoUtils.DecryptAesV1(encryptedKey, sf.unencryptedSharedFolderKey);
folderList.Remove(sff);
folderList.Add(sff);
}
else
{
Trace.TraceError("Sync_Down: shared_folder_folders: Shared Folder UID {0} not found", sff.sharedFolderUid);
}
}
}
if (rs.userFolderSharedFolders != null)
{
foreach (var ufsf in rs.userFolderSharedFolders)
{
folderList.Remove(ufsf);
folderList.Add(ufsf);
}
}
if (rs.userFolderRecords != null)
{
foreach (var ufr in rs.userFolderRecords)
{
recordList.Add(ufr);
}
}
if (rs.sharedFolderFolderRecords != null)
{
foreach (var sffr in rs.sharedFolderFolderRecords)
{
recordList.Add(sffr);
}
}
var toDelete = new HashSet <string>();
foreach (var folder in vault.keeperFolders.Values)
{
toDelete.Add(folder.FolderUid);
folder.Children.Clear();
folder.Records.Clear();
}
foreach (var folder in folderList)
{
if (vault.keeperFolders.TryGetValue(folder.FolderUid, out FolderNode node))
{
toDelete.Remove(folder.FolderUid);
node.Children.Clear();
node.Records.Clear();
node.Name = null;
}
else
{
node = new FolderNode
{
FolderType = folder.Type,
FolderUid = folder.FolderUid
};
vault.keeperFolders.Add(folder.FolderUid, node);
}
node.ParentUid = folder.ParentUid;
byte[] unencrypted_data = null;
switch (folder.Type)
{
case FolderType.UserFolder:
if (folder is SyncDownUserFolder uf)
{
unencrypted_data = CryptoUtils.DecryptAesV1(uf.data.Base64UrlDecode(), uf.unencryptedFolderKey);
}
else
{
Trace.TraceError("Folder UID {0} expected to be User-Folder", folder.FolderUid);
}
break;
case FolderType.SharedFolderForder:
if (folder is SyncDownSharedFolderFolder sff)
{
unencrypted_data = CryptoUtils.DecryptAesV1(sff.data.Base64UrlDecode(), sff.unencryptedFolderKey);
}
else
{
Trace.TraceError("Folder UID {0} expected to be Shared-Folder-Folder", folder.FolderUid);
}
break;
case FolderType.SharedFolder:
if (vault.sharedFolders.TryGetValue(folder.FolderUid, out SyncDownSharedFolder sf))
{
node.Name = Encoding.UTF8.GetString(CryptoUtils.DecryptAesV1(sf.name.Base64UrlDecode(), sf.unencryptedSharedFolderKey));
}
else
{
Trace.TraceError("Folder UID {0} expected to be Shared-Folder", folder.FolderUid);
}
break;
}
if (unencrypted_data != null)
{
var serializer = new DataContractJsonSerializer(typeof(FolderData));
using (var stream = new MemoryStream(unencrypted_data))
{
var folderData = serializer.ReadObject(stream) as FolderData;
node.Name = folderData.name;
}
}
if (string.IsNullOrEmpty(node.Name))
{
node.Name = node.FolderUid;
}
}
foreach (var uid in toDelete)
{
vault.keeperFolders.Remove(uid);
}
vault.Root.Children.Clear();
vault.Root.Records.Clear();
foreach (var node in vault.keeperFolders.Values)
{
if (string.IsNullOrEmpty(node.ParentUid))
{
vault.Root.Children.Add(node.FolderUid);
}
else
{
if (vault.keeperFolders.TryGetValue(node.ParentUid, out FolderNode parent))
{
parent.Children.Add(node.FolderUid);
}
else
{
Trace.TraceError("Folder UID {0} was lost", node.FolderUid);
}
}
}
foreach (var record in recordList)
{
if (string.IsNullOrEmpty(record.FolderUid))
{
vault.Root.Records.Add(record.RecordUid);
}
else
{
if (vault.keeperFolders.TryGetValue(record.FolderUid, out FolderNode node))
{
node.Records.Add(record.RecordUid);
}
else
{
Trace.TraceError("Folder UID {0} was lost", node.FolderUid);
vault.Root.Records.Add(record.RecordUid);
}
}
}
vault.userFolders.Clear();
foreach (var folder in folderList)
{
vault.userFolders.Add(folder.FolderUid, folder);
}
vault.userFolderRecords = recordList.ToList();
}
