public void GetObjectFromObjectValueLinkTest()
{
ILinks <TLinkAddress> links = CreateLinks();
var defaultXmlStorage = CreateXmlStorage(links);
TLinkAddress document = defaultXmlStorage.CreateDocument("documentName");
TLinkAddress documentObjectValueLink = defaultXmlStorage.AttachObject(document);
TLinkAddress objectValueLink = links.GetTarget(documentObjectValueLink);
TLinkAddress objectFromGetObject = defaultXmlStorage.GetObject(objectValueLink);
Assert.Equal(links.GetTarget(objectValueLink), objectFromGetObject);
}
public static TLink GetByKeys <TLink>(this ILinks <TLink> links, TLink root, params int[] path)
{
links.EnsureLinkExists(root, "root");
var currentLink = root;
for (var i = 0; i < path.Length; i++)
{
currentLink = links.GetLink(currentLink)[path[i]];
}
return(currentLink);
}
public static TLink Create <TLink>(this ILinks <TLink> sequences, IList <TLink[]> groupedSequence)
{
var finalSequence = new TLink[groupedSequence.Count];
for (var i = 0; i < finalSequence.Length; i++)
{
var part = groupedSequence[i];
finalSequence[i] = part.Length == 1 ? part[0] : sequences.Create(part.ShiftRight());
}
return(sequences.Create(finalSequence.ShiftRight()));
}
public ObjectsAndTagsStorage(string path, long minimumStorageSizeInBytes)
{
var constants = new LinksConstants <uint>(enableExternalReferencesSupport: true);
_memory = new FileMappedResizableDirectMemory(path);
_memoryManager = new ResizableDirectMemoryLinks <uint>(_memory, minimumStorageSizeInBytes, constants, useAvlBasedIndex: false);
_links = _memoryManager.DecorateWithAutomaticUniquenessAndUsagesResolution();
_links = new LinksItselfConstantToSelfReferenceResolver <uint>(_links);
_addressToRawNumberConverter = new AddressToRawNumberConverter <uint>();
}
private static void TestCharAndUnicodeSymbolConverters(ILinks <ulong> links, ulong meaningRoot, IConverter <ulong> addressToNumberConverter, IConverter <ulong> numberToAddressConverter)
{
var unicodeSymbolMarker = links.CreateAndUpdate(meaningRoot, links.Constants.Itself);
var charToUnicodeSymbolConverter = new CharToUnicodeSymbolConverter <ulong>(links, addressToNumberConverter, unicodeSymbolMarker);
var originalCharacter = 'H';
var characterLink = charToUnicodeSymbolConverter.Convert(originalCharacter);
var unicodeSymbolCriterionMatcher = new TargetMatcher <ulong>(links, unicodeSymbolMarker);
var unicodeSymbolToCharConverter = new UnicodeSymbolToCharConverter <ulong>(links, numberToAddressConverter, unicodeSymbolCriterionMatcher);
var resultingCharacter = unicodeSymbolToCharConverter.Convert(characterLink);
Assert.Equal(originalCharacter, resultingCharacter);
}
public static void EnsureLinkIsAnyOrExists <TLink>(this ILinks <TLink> links, IList <TLink> restrictions)
{
var equalityComparer = EqualityComparer <TLink> .Default;
var any = links.Constants.Any;
for (var i = 0; i < restrictions.Count; i++)
{
if (!equalityComparer.Equals(restrictions[i], any) && !links.Exists(restrictions[i]))
{
throw new ArgumentLinkDoesNotExistsException <TLink>(restrictions[i], $"sequence[{i}]");
}
}
}
public CompressingConverter(ILinks <TLink> links, IConverter <IList <TLink>, TLink> baseConverter, LinkFrequenciesCache <TLink> doubletFrequenciesCache, TLink minFrequencyToCompress, bool doInitialFrequenciesIncrement)
: base(links)
{
_baseConverter = baseConverter;
_doubletFrequenciesCache = doubletFrequenciesCache;
if (_comparer.Compare(minFrequencyToCompress, _one) < 0)
{
minFrequencyToCompress = _one;
}
_minFrequencyToCompress = minFrequencyToCompress;
_doInitialFrequenciesIncrement = doInitialFrequenciesIncrement;
ResetMaxDoublet();
}
public static void Setup()
{
var dataMemory = new HeapResizableDirectMemory();
var indexMemory = new HeapResizableDirectMemory();
_splitMemory = new SplitMemoryLinks <uint>(dataMemory, indexMemory);
_splitMemoryLinks = _splitMemory.DecorateWithAutomaticUniquenessAndUsagesResolution();
var memory = new HeapResizableDirectMemory();
_unitedMemory = new UnitedMemoryLinks <uint>(memory);
_unitedMemoryLinks = _unitedMemory.DecorateWithAutomaticUniquenessAndUsagesResolution();
}
public static void RunRandomSearches <TLink>(this ILinks <TLink> links, ulong amountOfSearches)
{
var random = RandomHelpers.Default;
var addressToUInt64Converter = UncheckedConverter <TLink, ulong> .Default;
var uInt64ToAddressConverter = UncheckedConverter <ulong, TLink> .Default;
for (var i = 0UL; i < amountOfSearches; i++)
{
var linksAddressRange = new Range <ulong>(0, addressToUInt64Converter.Convert(links.Count()));
var source = uInt64ToAddressConverter.Convert(random.NextUInt64(linksAddressRange));
var target = uInt64ToAddressConverter.Convert(random.NextUInt64(linksAddressRange));
links.SearchOrDefault(source, target);
}
}
public static void DeleteAll <TLink>(this ILinks <TLink> links)
{
var equalityComparer = EqualityComparer <TLink> .Default;
var comparer = Comparer <TLink> .Default;
for (var i = links.Count(); comparer.Compare(i, default) > 0; i = Arithmetic.Decrement(i))
{
links.Delete(i);
if (!equalityComparer.Equals(links.Count(), Arithmetic.Decrement(i)))
{
i = links.Count();
}
}
}
public static IList <TLinkAddress> GetLink <TLinkAddress, TConstants>(this ILinks <TLinkAddress, TConstants> links, TLinkAddress link)
where TConstants : LinksConstants <TLinkAddress>
{
var constants = links.Constants;
if (constants.IsExternalReference(link))
{
return(new Point <TLinkAddress>(link, constants.TargetPart + 1));
}
var linkPartsSetter = new Setter <IList <TLinkAddress>, TLinkAddress>(constants.Continue, constants.Break);
links.Each(linkPartsSetter.SetAndReturnTrue, link);
return(linkPartsSetter.Result);
}
public void AttachNullValueToKey()
{
ILinks <TLinkAddress> links = CreateLinks();
var defaultXmlStorage = CreateXmlStorage(links);
TLinkAddress document = defaultXmlStorage.CreateDocument("documentName");
TLinkAddress documentObjectValue = defaultXmlStorage.AttachObject(document);
TLinkAddress @object = defaultXmlStorage.GetObject(documentObjectValue);
TLinkAddress memberLink = defaultXmlStorage.AttachMemberToObject(@object, "keyName");
TLinkAddress memberNullValueLink = defaultXmlStorage.AttachNull(memberLink);
TLinkAddress nullValueLink = links.GetTarget(memberNullValueLink);
List <TLinkAddress> objectMembersLinks = defaultXmlStorage.GetMembersLinks(@object);
Assert.Equal(nullValueLink, defaultXmlStorage.GetValueLink(objectMembersLinks[0]));
}
public static TLink UpdateOrCreateOrGet <TLink>(this ILinks <TLink> links, TLink source, TLink target, TLink newSource, TLink newTarget)
{
var equalityComparer = EqualityComparer <TLink> .Default;
var link = links.SearchOrDefault(source, target);
if (equalityComparer.Equals(link, default))
{
return(links.CreateAndUpdate(newSource, newTarget));
}
if (equalityComparer.Equals(newSource, source) && equalityComparer.Equals(newTarget, target))
{
return(link);
}
return(links.Update(link, newSource, newTarget));
}
public static TLink Update <TLink>(this ILinks <TLink> links, params TLink[] restrictions)
{
if (restrictions.Length == 2)
{
return(links.MergeAndDelete(restrictions[0], restrictions[1]));
}
if (restrictions.Length == 4)
{
return(links.UpdateOrCreateOrGet(restrictions[0], restrictions[1], restrictions[2], restrictions[3]));
}
else
{
return(links.Update(new LinkAddress <TLink>(restrictions[0]), restrictions));
}
}
public static string FromSequenceLinkToString(ulong link, ILinks<ulong> links)
{
var sb = new StringBuilder();
if (links.Exists(link))
{
StopableSequenceWalker.WalkRight(link, links.GetSource, links.GetTarget,
x => x <= MapSize || links.GetSource(x) == x || links.GetTarget(x) == x, element =>
{
sb.Append(FromLinkToChar(element));
return true;
});
}
return sb.ToString();
}
public static IList <TLink> AllIndices <TLink>(this ILinks <TLink> links, params TLink[] restrictions)
{
var arraySize = CheckedConverter <TLink, ulong> .Default.Convert(links.Count(restrictions));
if (arraySize > 0)
{
var array = new TLink[arraySize];
var filler = new ArrayFiller <TLink, TLink>(array, links.Constants.Continue);
links.Each(filler.AddFirstAndReturnConstant, restrictions);
return(array);
}
else
{
return(Array.Empty <TLink>());
}
}
private static void TestNonexistentReferences(this ILinks <ulong> memoryAdapter)
{
var link = memoryAdapter.Create();
memoryAdapter.Update(link, ulong.MaxValue, ulong.MaxValue);
var resultLink = _constants.Null;
memoryAdapter.Each(foundLink =>
{
resultLink = foundLink[_constants.IndexPart];
return(_constants.Break);
}, _constants.Any, ulong.MaxValue, ulong.MaxValue);
Assert.True(resultLink == link);
Assert.True(memoryAdapter.Count(ulong.MaxValue) == 0);
memoryAdapter.Delete(link);
}
// TODO: Реализовать компактификацию при чтении
//public bool EnforceSingleSequenceVersionOnRead;
//public bool UseRequestMarker;
//public bool StoreRequestResults;
public void InitOptions(ILinks<ulong> links)
{
if (UseSequenceMarker)
{
if (SequenceMarkerLink == Constants.Null)
SequenceMarkerLink = links.CreatePoint();
else
{
if (!links.Exists(SequenceMarkerLink))
{
var link = links.CreatePoint();
if(link != SequenceMarkerLink)
throw new Exception("Cannot recreate sequence marker link.");
}
}
}
}
private static List <SpanRef> BuildReferences(ILinks links)
{
var refs = new List <SpanRef>();
foreach (var link in links.Links)
{
var traceIdParts = SplitTraceId(link.Context.TraceId);
refs.Add(new SpanRef(
SpanRefType.FOLLOWS_FROM, // Is this right?
traceIdParts.lower,
traceIdParts.higher,
BitConverter.ToInt64(link.Context.SpanId.Bytes, 0)));
}
return(refs);
}
public static bool AnyLinkIsAny(this ILinks <ulong> links, params ulong[] sequence)
{
if (sequence == null)
{
return(false);
}
var constants = links.Constants;
for (var i = 0; i < sequence.Length; i++)
{
if (sequence[i] == constants.Any)
{
return(true);
}
}
return(false);
}
public void TestLoadAndRunDynamicClassicImpl()
{
var cities = new Cities();
cities.ReadCities(CitiesTestFile);
ILinks links = LinksFactory.Create(cities, "Fhnw.Ecnf.RoutePlanner.RoutePlannerLib.Links");
links.ReadLinks(LinksTestFile);
Assert.AreEqual(28, cities.Count);
// test available cities
List <Link> resultLinks = links.FindShortestRouteBetween("Zürich", "Basel", TransportMode.Rail);
var expectedLinks = new List <Link>();
expectedLinks.Add(new Link(new City("Zürich", "Switzerland", 7000, 1, 2),
new City("Aarau", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Aarau", "Switzerland", 7000, 1, 2),
new City("Liestal", "Switzerland", 7000, 1, 2), 0));
expectedLinks.Add(new Link(new City("Liestal", "Switzerland", 7000, 1, 2),
new City("Basel", "Switzerland", 7000, 1, 2), 0));
Assert.IsNotNull(resultLinks);
Assert.AreEqual(expectedLinks.Count, resultLinks.Count);
for (int i = 0; i < resultLinks.Count; i++)
{
Assert.IsTrue(
(expectedLinks[i].FromCity.Name == resultLinks[i].FromCity.Name &&
expectedLinks[i].ToCity.Name == resultLinks[i].ToCity.Name) ||
(expectedLinks[i].FromCity.Name == resultLinks[i].ToCity.Name &&
expectedLinks[i].ToCity.Name == resultLinks[i].FromCity.Name));
}
try
{
resultLinks = links.FindShortestRouteBetween("doesNotExist", "either", TransportMode.Rail);
Assert.Fail("Should throw a KeyNotFoundException");
}
catch (KeyNotFoundException)
{
}
}
public void AttachArrayValueToKey()
{
ILinks <TLinkAddress> links = CreateLinks();
var defaultXmlStorage = CreateXmlStorage(links);
TLinkAddress document = defaultXmlStorage.CreateDocument("documentName");
TLinkAddress documentObjectValue = defaultXmlStorage.AttachObject(document);
TLinkAddress @object = defaultXmlStorage.GetObject(documentObjectValue);
TLinkAddress memberLink = defaultXmlStorage.AttachMemberToObject(@object, "keyName");
TLinkAddress arrayElement = defaultXmlStorage.CreateString("arrayElement");
TLinkAddress[] array = { arrayElement, arrayElement, arrayElement };
TLinkAddress memberArrayValueLink = defaultXmlStorage.AttachArray(memberLink, array);
TLinkAddress arrayValueLink = links.GetTarget(memberArrayValueLink);
List <TLinkAddress> objectMembersLinks = defaultXmlStorage.GetMembersLinks(@object);
Assert.Equal(memberLink, objectMembersLinks[0]);
Assert.Equal(arrayValueLink, defaultXmlStorage.GetValueLink(objectMembersLinks[0]));
}
private void CalculateCore(ILinks<ulong> links, ulong current, int stepsLeft, Counter counter)
{
links.Each(link =>
{
if (links.IsFullPoint(link[links.Constants.IndexPart]))
return links.Constants.Continue;
if (stepsLeft == 0)
counter.Count++;
else
{
var target = link[links.Constants.TargetPart];
CalculateCore(links, target, stepsLeft - 1, counter);
}
return links.Constants.Continue;
}, links.Constants.Any, current, links.Constants.Any);
}
public static IList <TLink> ResolveConstantAsSelfReference <TLink>(this ILinks <TLink> links, TLink constant, IList <TLink> restrictions, IList <TLink> substitution)
{
var equalityComparer = EqualityComparer <TLink> .Default;
var constants = links.Constants;
var restrictionsIndex = restrictions[constants.IndexPart];
var substitutionIndex = substitution[constants.IndexPart];
if (equalityComparer.Equals(substitutionIndex, default))
{
substitutionIndex = restrictionsIndex;
}
var source = substitution[constants.SourcePart];
var target = substitution[constants.TargetPart];
source = equalityComparer.Equals(source, constant) ? substitutionIndex : source;
target = equalityComparer.Equals(target, constant) ? substitutionIndex : target;
return(new Link <TLink>(substitutionIndex, source, target));
}
public static ISpanData Create(
ISpanContext context,
ISpanId parentSpanId,
bool?hasRemoteParent,
string name,
Timestamp startTimestamp,
IAttributes attributes,
ITimedEvents <IAnnotation> annotations,
ITimedEvents <IMessageEvent> messageOrNetworkEvents,
ILinks links,
int?childSpanCount,
Status status,
SpanKind kind,
Timestamp endTimestamp)
{
if (messageOrNetworkEvents == null)
{
messageOrNetworkEvents = TimedEvents <IMessageEvent> .Create(new List <ITimedEvent <IMessageEvent> >(), 0);
}
var messageEventsList = new List <ITimedEvent <IMessageEvent> >();
foreach (ITimedEvent <IMessageEvent> timedEvent in messageOrNetworkEvents.Events)
{
messageEventsList.Add(timedEvent);
}
ITimedEvents <IMessageEvent> messageEvents = TimedEvents <IMessageEvent> .Create(messageEventsList, messageOrNetworkEvents.DroppedEventsCount);
return(new SpanData(
context,
parentSpanId,
hasRemoteParent,
name,
startTimestamp,
attributes,
annotations,
messageEvents,
links,
childSpanCount,
status,
kind,
endTimestamp));
}
public static void TestMultipleRandomCreationsAndDeletions<TLink>(this ILinks<TLink> links, int maximumOperationsPerCycle)
{
var comparer = Comparer<TLink>.Default;
var addressToUInt64Converter = CheckedConverter<TLink, ulong>.Default;
var uInt64ToAddressConverter = CheckedConverter<ulong, TLink>.Default;
for (var N = 1; N < maximumOperationsPerCycle; N++)
{
var random = new System.Random(N);
var created = 0UL;
var deleted = 0UL;
for (var i = 0; i < N; i++)
{
var linksCount = addressToUInt64Converter.Convert(links.Count());
var createPoint = random.NextBoolean();
if (linksCount >= 2 && createPoint)
{
var linksAddressRange = new Range<ulong>(1, linksCount);
TLink source = uInt64ToAddressConverter.Convert(random.NextUInt64(linksAddressRange));
TLink target = uInt64ToAddressConverter.Convert(random.NextUInt64(linksAddressRange)); //-V3086
var resultLink = links.GetOrCreate(source, target);
if (comparer.Compare(resultLink, uInt64ToAddressConverter.Convert(linksCount)) > 0)
{
created++;
}
}
else
{
links.Create();
created++;
}
}
Assert.True(created == addressToUInt64Converter.Convert(links.Count()));
for (var i = 0; i < N; i++)
{
TLink link = uInt64ToAddressConverter.Convert((ulong)i + 1UL);
if (links.Exists(link))
{
links.Delete(link);
deleted++;
}
}
Assert.True(addressToUInt64Converter.Convert(links.Count()) == 0L);
}
}
public DoubletsDbContext(string dataDBFilename, string indexDBFilename)
{
var dataMemory = new FileMappedResizableDirectMemory(dataDBFilename);
var indexMemory = new FileMappedResizableDirectMemory(indexDBFilename);
var linksConstants = new LinksConstants <TLinkAddress>(enableExternalReferencesSupport: true);
// Init the links storage
_disposableLinks = new UInt32SplitMemoryLinks(dataMemory, indexMemory, UInt32SplitMemoryLinks.DefaultLinksSizeStep, linksConstants); // Low-level logic
_links = new UInt32Links(_disposableLinks); // Main logic in the combined decorator
// Set up constant links (markers, aka mapped links)
TLinkAddress currentMappingLinkIndex = 1;
_meaningRoot = GetOrCreateMeaningRoot(currentMappingLinkIndex++);
_unicodeSymbolMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
_unicodeSequenceMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
_titlePropertyMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
_contentPropertyMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
_publicationDateTimePropertyMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
_blogPostMarker = GetOrCreateNextMapping(currentMappingLinkIndex++);
// Create properties operator that is able to control reading and writing properties for any link (object)
_defaultLinkPropertyOperator = new PropertiesOperator <TLinkAddress>(_links);
// Create converters that are able to convert link's address (UInt64 value) to a raw number represented with another UInt64 value and back
_numberToAddressConverter = new RawNumberToAddressConverter <TLinkAddress>();
_addressToNumberConverter = new AddressToRawNumberConverter <TLinkAddress>();
// Create converters for dates
_longRawNumberToDateTimeConverter = new LongRawNumberSequenceToDateTimeConverter <TLinkAddress>(new LongRawNumberSequenceToNumberConverter <TLinkAddress, long>(_links, _numberToAddressConverter));
_dateTimeToLongRawNumberConverter = new DateTimeToLongRawNumberSequenceConverter <TLinkAddress>(new NumberToLongRawNumberSequenceConverter <long, TLinkAddress>(_links, _addressToNumberConverter));
// Create converters that are able to convert string to unicode sequence stored as link and back
var balancedVariantConverter = new BalancedVariantConverter <TLinkAddress>(_links);
var unicodeSymbolCriterionMatcher = new TargetMatcher <TLinkAddress>(_links, _unicodeSymbolMarker);
var unicodeSequenceCriterionMatcher = new TargetMatcher <TLinkAddress>(_links, _unicodeSequenceMarker);
var charToUnicodeSymbolConverter = new CharToUnicodeSymbolConverter <TLinkAddress>(_links, _addressToNumberConverter, _unicodeSymbolMarker);
var unicodeSymbolToCharConverter = new UnicodeSymbolToCharConverter <TLinkAddress>(_links, _numberToAddressConverter, unicodeSymbolCriterionMatcher);
var sequenceWalker = new RightSequenceWalker <TLinkAddress>(_links, new DefaultStack <TLinkAddress>(), unicodeSymbolCriterionMatcher.IsMatched);
_stringToUnicodeSequenceConverter = new CachingConverterDecorator <string, TLinkAddress>(new StringToUnicodeSequenceConverter <TLinkAddress>(_links, charToUnicodeSymbolConverter, balancedVariantConverter, _unicodeSequenceMarker));
_unicodeSequenceToStringConverter = new CachingConverterDecorator <TLinkAddress, string>(new UnicodeSequenceToStringConverter <TLinkAddress>(_links, unicodeSequenceCriterionMatcher, sequenceWalker, unicodeSymbolToCharConverter));
}
public Patterns(string sourceImagePath)
{
_sourceImagePath = Path.GetFullPath(sourceImagePath);
_image = new MagickImage(sourceImagePath);
_pixels = _image.GetPixels();
_linksPath = Path.ChangeExtension(_sourceImagePath, ".links");
var memory = new HeapResizableDirectMemory(); //new FileMappedResizableDirectMemory(_linksPath);
var constants = new LinksConstants <ulong>(enableExternalReferencesSupport: true);
_links = new UInt64Links(new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep, constants, Platform.Data.Doublets.Memory.IndexTreeType.SizedAndThreadedAVLBalancedTree));
_addressToRawNumberConverter = new AddressToRawNumberConverter <ulong>();
_rawNumberToAddressConverter = new RawNumberToAddressConverter <ulong>();
_totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(_links);
_linkFrequenciesCache = new LinkFrequenciesCache <ulong>(_links, _totalSequenceSymbolFrequencyCounter);
_index = new CachedFrequencyIncrementingSequenceIndex <ulong>(_linkFrequenciesCache);
_linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(_linkFrequenciesCache);
_sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(_links, _linkToItsFrequencyNumberConverter);
_optimalVariantConverter = new OptimalVariantConverter <ulong>(_links, _sequenceToItsLocalElementLevelsConverter);
}
public static TLink CountUsages <TLink>(this ILinks <TLink> links, TLink link)
{
var constants = links.Constants;
var values = links.GetLink(link);
TLink usagesAsSource = links.Count(new Link <TLink>(constants.Any, link, constants.Any));
var equalityComparer = EqualityComparer <TLink> .Default;
if (equalityComparer.Equals(values[constants.SourcePart], link))
{
usagesAsSource = Arithmetic <TLink> .Decrement(usagesAsSource);
}
TLink usagesAsTarget = links.Count(new Link <TLink>(constants.Any, constants.Any, link));
if (equalityComparer.Equals(values[constants.TargetPart], link))
{
usagesAsTarget = Arithmetic <TLink> .Decrement(usagesAsTarget);
}
return(Arithmetic <TLink> .Add(usagesAsSource, usagesAsTarget));
}
public static void RunRandomDeletions <TLink>(this ILinks <TLink> links, ulong amountOfDeletions)
{
var random = RandomHelpers.Default;
var addressToUInt64Converter = UncheckedConverter <TLink, ulong> .Default;
var uInt64ToAddressConverter = UncheckedConverter <ulong, TLink> .Default;
var linksCount = addressToUInt64Converter.Convert(links.Count());
var min = amountOfDeletions > linksCount ? 0UL : linksCount - amountOfDeletions;
for (var i = 0UL; i < amountOfDeletions; i++)
{
linksCount = addressToUInt64Converter.Convert(links.Count());
if (linksCount <= min)
{
break;
}
var linksAddressRange = new Range <ulong>(min, linksCount);
var link = uInt64ToAddressConverter.Convert(random.NextUInt64(linksAddressRange));
links.Delete(link);
}
}
public static TLink First <TLink>(this ILinks <TLink> links)
{
TLink firstLink = default;
var equalityComparer = EqualityComparer <TLink> .Default;
if (equalityComparer.Equals(links.Count(), default))
{
throw new InvalidOperationException("В хранилище нет связей.");
}
links.Each(links.Constants.Any, links.Constants.Any, link =>
{
firstLink = link[links.Constants.IndexPart];
return(links.Constants.Break);
});
if (equalityComparer.Equals(firstLink, default))
{
throw new InvalidOperationException("В процессе поиска по хранилищу не было найдено связей.");
}
return(firstLink);
}
public static TLink GetSquareMatrixSequenceElementByIndex <TLink>(this ILinks <TLink> links, TLink root, ulong size, ulong index)
{
var constants = links.Constants;
var source = constants.SourcePart;
var target = constants.TargetPart;
if (!Platform.Numbers.Math.IsPowerOfTwo(size))
{
throw new ArgumentOutOfRangeException(nameof(size), "Sequences with sizes other than powers of two are not supported.");
}
var path = new BitArray(BitConverter.GetBytes(index));
var length = Bit.GetLowestPosition(size);
links.EnsureLinkExists(root, "root");
var currentLink = root;
for (var i = length - 1; i >= 0; i--)
{
currentLink = links.GetLink(currentLink)[path[i] ? target : source];
}
return(currentLink);
}
private static void AppendPattern(ILinks <ulong> links, LinksConstants <ulong> constants, ulong start, ulong patternMarker, Dictionary <ulong, char> chars, ulong any, ulong @continue, StringBuilder sb, ulong initialPosition, RawNumberToAddressConverter <ulong> rawNumberToAddressConverter)
{
sb.Append('(');
var alternatives = 0;
links.Each(linkParts =>
{
var link = new UInt64Link(linkParts);
if (patternMarker == link.Target)
{
if (alternatives > 0)
{
sb.Append('|');
}
alternatives++;
}
else if (!constants.IsExternalReference(link.Target))
{
var charPosition = new UInt64Link(links.GetLink(link.Target));
if (constants.IsExternalReference(charPosition.Source) && chars.TryGetValue(charPosition.Target, out char targetSymbol))
{
var position = rawNumberToAddressConverter.Convert(charPosition.Source) - 10;
if (position == initialPosition)
{
if (alternatives > 0)
{
sb.Append('|');
}
sb.Append(targetSymbol);
AppendPattern(links, constants, link.Target, patternMarker, chars, any, @continue, sb, initialPosition + 1, rawNumberToAddressConverter);
alternatives++;
}
}
}
return(@continue);
}, new UInt64Link(any, start, any));
sb.Append(')');
}
private static void SetSteps(ILinks<ulong> links, ulong[] digits)
{
// 0
links.CreateAndUpdate(digits[0], digits[4]);
links.CreateAndUpdate(digits[0], digits[6]);
// 1
links.CreateAndUpdate(digits[1], digits[6]);
links.CreateAndUpdate(digits[1], digits[8]);
// 2
links.CreateAndUpdate(digits[2], digits[7]);
links.CreateAndUpdate(digits[2], digits[9]);
// 3
links.CreateAndUpdate(digits[3], digits[4]);
links.CreateAndUpdate(digits[3], digits[8]);
// 4
links.CreateAndUpdate(digits[4], digits[0]);
links.CreateAndUpdate(digits[4], digits[3]);
links.CreateAndUpdate(digits[4], digits[9]);
// 5
// 6
links.CreateAndUpdate(digits[6], digits[0]);
links.CreateAndUpdate(digits[6], digits[1]);
links.CreateAndUpdate(digits[6], digits[7]);
// 7
links.CreateAndUpdate(digits[7], digits[2]);
links.CreateAndUpdate(digits[7], digits[6]);
// 8
links.CreateAndUpdate(digits[8], digits[1]);
links.CreateAndUpdate(digits[8], digits[3]);
// 9
links.CreateAndUpdate(digits[9], digits[2]);
links.CreateAndUpdate(digits[9], digits[4]);
}
public MasterServer(ILinks<ulong> links, Sequences sequences, UdpSender sender)
{
_links = links;
_sequences = sequences;
_sender = sender;
}
public UnicodeMap(ILinks<ulong> links)
{
_links = links;
}
public static UnicodeMap InitNew(ILinks<ulong> links)
{
var map = new UnicodeMap(links);
map.Init();
return map;
}
private static void SetPoints(ILinks<ulong> links, ulong[] digits)
{
// Создадим точки в графе для каждой цифры
for (int i = 0; i < digits.Length; i++)
digits[i] = links.CreatePoint();
}
