public float GetCompactSize(out SizeRange sizeRange) { sizeRange = SizeRange.None; if (_sizeInKb <= 0) { return(0); } sizeRange = SizeRange.Kb; var tempSize = (double)_sizeInKb; if (tempSize < 1024) { return((float)tempSize); } sizeRange = SizeRange.Mb; tempSize = tempSize / 1024; if (tempSize < 1024) { return((float)tempSize); } sizeRange = SizeRange.Gb; tempSize = tempSize / 1024; if (tempSize < 1024) { return((float)tempSize); } sizeRange = SizeRange.Tb; tempSize = tempSize / 1024; return((float)tempSize); }
private static string GetRangeString(SizeRange range, bool longString) { if (range == SizeRange.None) { return(string.Empty); } string rangeName; switch (range) { case SizeRange.Tb: rangeName = longString ? Localisation.FileSize_TB_Long : Localisation.FileSize_TB_Short; break; case SizeRange.Gb: rangeName = longString ? Localisation.FileSize_GB_Long : Localisation.FileSize_GB_Short; break; case SizeRange.Mb: rangeName = longString ? Localisation.FileSize_MB_Long : Localisation.FileSize_MB_Short; break; case SizeRange.Kb: rangeName = longString ? Localisation.FileSize_KB_Long : Localisation.FileSize_KB_Short; break; default: throw new ArgumentOutOfRangeException(nameof(range), range, "Unknown range"); } return(rangeName); }
public static FsmValue FsmValueFromSizeRange(SizeRange value) { switch (value) { case SizeRange.Range0: return(FsmValue.Class0); case SizeRange.Range1: return(FsmValue.Class1); case SizeRange.Range2: return(FsmValue.Class2); case SizeRange.Range3: return(FsmValue.Class3); case SizeRange.Range4: return(FsmValue.Class4); case SizeRange.Range5: return(FsmValue.Class5); case SizeRange.Range6: return(FsmValue.Class6); case SizeRange.Range7: return(FsmValue.Class7); case SizeRange.Range8: return(FsmValue.Class8); case SizeRange.Range9: return(FsmValue.Class9); case SizeRange.Range10: return(FsmValue.Class10); case SizeRange.Range11: return(FsmValue.Class11); default: return(FsmValue.Full); } }
public static short[] ReadFixedSizeItemLengths(IPage page) { SizeRange range = PageHeaderBase.GetSizeRange(page); if (range == SizeRange.MultiPage || range == SizeRange.NotApplicable) { throw new PageFormatException("Page is not dedicated to fixed size items."); } short headerLength = PageHeaderBase.GetHeaderLength(page); short itemSizesLength = BitConverter.ToInt16(page.Content, headerLength); var result = new short[itemSizesLength]; int offset = headerLength + OnPagePointerSize; var content = page.Content; for (int i = 0; i < itemSizesLength; i++) { result[i] = BitConverter.ToInt16(content, offset); offset += OnPagePointerSize; } return(result); }
private bool ValidateSize(string value) { if (Size == null) { if (SizeRange == null) { return(true); } else { switch (DataType.BaseType) { case SmiEnums.DataTypeBase.INTEGER: return(SizeRange.ContainsValue(long.Parse(value))); case SmiEnums.DataTypeBase.OCTET_STRING: return(SizeRange.ContainsValue(value.Length)); } } } else { switch (DataType.BaseType) { case SmiEnums.DataTypeBase.INTEGER: return(long.Parse(value) < Size); case SmiEnums.DataTypeBase.OCTET_STRING: return(value.Length <= Size); } } return(false); }
public BPlusTreeNodeStorage(IPageManager pageManager, ISerializer <TKey> keySerializer, int maxKeySize) { if (maxKeySize <= 0) { throw new ArgumentException("ComparableComparableKeyOf size should be positive", nameof(maxKeySize)); } _pageManager = pageManager ?? throw new ArgumentNullException(nameof(pageManager)); _keySerializer = keySerializer ?? throw new ArgumentNullException(nameof(keySerializer)); _maxKeySize = maxKeySize; _nodeEntrySizeRange = DbItem.GetSizeRange(_maxKeySize + DbItemReference.BytesLength); if (NodeCapacity <= 2) { throw new ArgumentException("Too large key size", nameof(maxKeySize)); } _dbItems = new DbItem[NodeCapacity]; var bytes = new byte[_maxKeySize + DbItemReference.BytesLength]; for (int i = 0; i < NodeCapacity; i++) { _dbItems[i] = new DbItem(bytes); } _pageCacheEnabled = _pageManager is ICachingPageManager; }
private byte[] GenerateRandomSequence(SizeRange sizeRange) { return (GenerateRandomSequence(sizeRange == SizeRange.MultiPage ? _r.Next(327681) : DbItem.GetMaxSize(sizeRange))); }
private static string GetRangeString(SizeRange range) { if (range == SizeRange.None) { return("B"); } string rangeName; switch (range) { case SizeRange.Tb: rangeName = "TB"; break; case SizeRange.Gb: rangeName = "GB"; break; case SizeRange.Mb: rangeName = "MB"; break; case SizeRange.Kb: rangeName = "KB"; break; default: throw new ArgumentOutOfRangeException(nameof(range), range, "Unknown range"); } return(rangeName); }
public override void ExecutionComplete(DeploymentDetails details, List <Exception> exceptions) { try { base.ExecutionComplete(details, exceptions); } catch { } if (!_Ranges.ContainsKey(DeploymentControllerID)) { lock (_Ranges) if (!_Ranges.ContainsKey(DeploymentControllerID)) { _Ranges[DeploymentControllerID] = new List <SizeRange>(); } } lock (_Ranges[DeploymentControllerID]) { SizeRange range = _Ranges[DeploymentControllerID].FirstOrDefault(i => i.ActiveLoads.Exists(x => x.Loaded.Contains(details.InitiationSource))); if (range != null) { lock (range) { SizeRange.Load rem = range.ActiveLoads.FirstOrDefault(z => z.Loaded.Contains(details.InitiationSource)); if (rem != null) { rem.Loaded.Remove(details.InitiationSource); } } } } }
private static bool CheckSizeRange(ISearchItem file, SizeRange range) { if (range == null) { return(true); } return(range.IsInRange(file.Length)); }
public SizeRange Clone() { SizeRange r = new SizeRange(); r.MaxLoadPerBranch = MaxLoadPerBranch; r.MinMB = MinMB; r.MaxMB = MaxMB; return(r); }
public static short GetMaxSize(SizeRange sizeRange) { if (sizeRange == SizeRange.NotApplicable || sizeRange == SizeRange.MultiPage) { throw new ArgumentOutOfRangeException(nameof(sizeRange)); } return(_maxSizes[(int)sizeRange]); }
public DbItem(byte[] rawData) { if (rawData == null) { throw new ArgumentNullException(nameof(rawData)); } _rawData = rawData; _sizeRange = GetSizeRange(rawData.Length); }
public MainViewModel() { SearchIndexed = true; SearchPaths = new ObservableCollection <PathItem>(SettingsLoader.Paths); SearchResults = new ConcurrentList <ISearchItem>(); SearchResultsWPF = new ObservableCollection <ISearchItem>(); SearchConditions = new ObservableCollection <SearchConditionViewModel>(); DateFilterFrom = DateFilterTo = DateNow; SizeRange = new SizeRange(); ProgressBarVisibility = Visibility.Hidden; SearchPaths.CollectionChanged += (sender, args) => SettingsLoader.Save(SearchPaths); HandleCommandLineArgs(); }
public static short ReadFixedSizeItemMarkersLength(IPage page) { SizeRange sc = PageHeaderBase.GetSizeRange(page); if (sc == SizeRange.MultiPage || sc == SizeRange.NotApplicable) { throw new PageFormatException("Page is not dedicated to fixed size items."); } short headerLength = BitConverter.ToInt16(page.Content, OnPageOffsets.HeaderLength); return(BitConverter.ToInt16(page.Content, headerLength)); }
protected bool FastDetectWithAllWzImages(Wz_File wzFile, IList <Wz_Image> imgList) { var imageSizes = new SizeRange[imgList.Count]; while (wzFile.header.TryGetNextVersion()) { int count = 0; bool isSuccess = imgList.All(img => { uint offs = wzFile.CalcOffset(img.HashedOffsetPosition, img.HashedOffset); if (offs < wzFile.header.DirEndPosition || offs + img.Size > wzFile.fileStream.Length) //img offset out of file size { return(false); } imageSizes[count++] = new SizeRange() { Start = offs, End = offs + img.Size, }; return(true); }); if (isSuccess) { // check if there's any image overlaps with another image. Array.Sort(imageSizes, 0, count); for (int i = 1; i < count; i++) { if (imageSizes[i - 1].End > imageSizes[i].Start) { isSuccess = false; break; } } if (isSuccess) { wzFile.header.VersionChecked = true; break; } } } return(wzFile.header.VersionChecked); }
public static bool IsFixedSizeItemAllocated(IPage page, short itemIndex) { SizeRange sc = PageHeaderBase.GetSizeRange(page); if (sc == SizeRange.MultiPage || sc == SizeRange.NotApplicable) { throw new PageFormatException("Page is not dedicated to fixed size items."); } short headerLength = BitConverter.ToInt16(page.Content, OnPageOffsets.HeaderLength); short itemSizesLength = BitConverter.ToInt16(page.Content, headerLength); if (itemIndex >= itemSizesLength) { return(false); } int offset = headerLength + OnPagePointerSize + itemIndex * OnPagePointerSize; return(BitConverter.ToInt16(page.Content, offset) != -1); }
public static short ReadFixedSizeItemLength(IPage page, short itemIndex) { SizeRange range = PageHeaderBase.GetSizeRange(page); if (range == SizeRange.MultiPage || range == SizeRange.NotApplicable) { throw new PageFormatException("Page is not dedicated to fixed size items."); } short headerLength = BitConverter.ToInt16(page.Content, OnPageOffsets.HeaderLength); short itemSizesLength = BitConverter.ToInt16(page.Content, headerLength); if (itemIndex >= itemSizesLength) { throw new ArgumentOutOfRangeException(nameof(itemIndex)); } int offset = headerLength + OnPagePointerSize + itemIndex * OnPagePointerSize; return(BitConverter.ToInt16(page.Content, offset)); }
public void SizeZTest_ShouldBeNotNull(SizeRange sizeRange) { _figureSettings.SizeZ = sizeRange; Assert.IsNotNull(_figureSettings.SizeZ); }
public override DeploymentDetails GenerateDeploymentDetails(IReadOnlyList <string> listPreprocessResult, string initiationSource, string recommendedBranchIP, IReadOnlyList <string> limitedToBranches) { try { Dictionary <string, long> col; lock (_KnownSizes) { if (!_KnownSizes.ContainsKey(DeploymentControllerID)) { _KnownSizes[DeploymentControllerID] = new Dictionary <string, long>(); } col = _KnownSizes[DeploymentControllerID]; } long sz = 0; lock (col) sz = col[initiationSource]; if (!_Ranges.ContainsKey(DeploymentControllerID)) { lock (_Ranges) if (!_Ranges.ContainsKey(DeploymentControllerID)) { _Ranges[DeploymentControllerID] = new List <SizeRange>(); } } SizeRange range = null; lock (_Ranges[DeploymentControllerID]) range = _Ranges[DeploymentControllerID].FirstOrDefault(i => i.MinMB <= sz && i.MaxMB >= sz); if (range == null) { return(null); } lock (range) { SizeRange.Load load = range.ActiveLoads.Where(i => i.IP == recommendedBranchIP).FirstOrDefault(); if (load != null && load.Loaded.Count < range.MaxLoadPerBranch) { DeploymentDetails ret = base.GenerateDeploymentDetails(listPreprocessResult, initiationSource, load.IP, limitedToBranches); if (ret != null) { load.Loaded.Add(initiationSource); load.LastAssignment = DateTime.UtcNow; } return(ret); } } } catch (Exception ex) { STEM.Sys.EventLog.WriteEntry("FileSizeSubsetController.GenerateDeploymentDetails", new Exception(InstructionSetTemplate + ": " + initiationSource, ex).ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } return(null); }