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);
}
