/// <summary>
/// 新建词条
/// </summary>
public bool AddKeyword(string keyword, string channelName)
{
if (string.IsNullOrEmpty(channelName))
{
return(this.FaildMessage("频道为空"));
}
string keyId = keyword.GetKey();
Regex regex = new Regex(@"^~(?<Content>.+)~$");
if (regex.IsMatch(keyword))
{
keyword = regex.Match(keyword).Groups["Content"].Value;
}
using (DbExecutor db = NewExecutor())
{
db.ExecuteNonQuery(CommandType.StoredProcedure, "tran_AddKeyword", new
{
KeyID = keyId,
Content = keyword,
Channel = channelName
});
MemoryUtils.Remove(channelName);
}
return(true);
}
private static void CopyStreamToPointer(Transaction tx, Stream value, byte *pos)
{
TemporaryPage tmp;
using (tx.Environment.GetTemporaryPage(tx, out tmp))
{
var tempPageBuffer = tmp.TempPageBuffer;
var tempPagePointer = tmp.TempPagePointer;
while (true)
{
var read = value.Read(tempPageBuffer, 0, AbstractPager.PageSize);
if (read == 0)
{
break;
}
MemoryUtils.CopyInline(pos, tempPagePointer, read);
pos += read;
if (read != tempPageBuffer.Length)
{
break;
}
}
}
}
public void Save(Stream stream)
{
MemoryUtils.WriteStruct(stream, Header);
MemoryUtils.WriteAnsiString(MaterialName, stream);
bool tangents = (Header.Flags & AMeshFlags.HaveTangents) != AMeshFlags.None;
if (tangents)
{
for (ushort i = 0; i < Header.VerticesCount; ++i)
{
MemoryUtils.WriteStruct(stream, Position[i]);
MemoryUtils.WriteStruct(stream, UV0[i]);
MemoryUtils.WriteStruct(stream, Normal[i]);
MemoryUtils.WriteStruct(stream, Tangent[i]);
}
}
else
{
for (ushort i = 0; i < Header.VerticesCount; ++i)
{
MemoryUtils.WriteStruct(stream, Position[i]);
MemoryUtils.WriteStruct(stream, Normal[i]);
MemoryUtils.WriteStruct(stream, UV0[i]);
}
}
BinaryWriter writer = new BinaryWriter(stream);
foreach (var index in Indices)
{
writer.Write(index);
}
}
private Dictionary <string, ProjectAnalysisResult> AnalyzeProjects(
string solutionFileName,
List <string> projects,
List <AnalyzerResult> analyzerResult,
List <ProjectResult> analysisActions,
bool isIncremental = false,
string targetFramework = DEFAULT_TARGET)
{
_logger.LogInformation("Memory Consumption before AnalyzeProjects: ");
MemoryUtils.LogMemoryConsumption(_logger);
var results = projects
.Select((project) => new KeyValuePair <string, ProjectAnalysisResult>(
project,
AnalyzeProject(
project,
solutionFileName,
analyzerResult,
analysisActions,
isIncremental,
targetFramework)))
.Where(p => p.Value != null)
.ToDictionary(p => p.Key, p => p.Value);
_logger.LogInformation("Memory Consumption after AnalyzeProjects: ");
MemoryUtils.LogMemoryConsumption(_logger);
return(results);
}
public static void Connect(Peer Peer, string Host, int Port, int Ms, bool isSecure, bool isLocal, EventHandler <SocketAsyncEventArgs> Completed)
{
IPAddress IP = MemoryUtils.Host2IP(Host);
if (IP == null)
{
MemoryUtils.Error("Could not resolve host " + Host);
return;
}
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
e.RemoteEndPoint = new IPEndPoint(IP, Port);
e.Completed += Completed;
Socket Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Socket.NoDelay = true;
Socket.Blocking = false;
Socket.ExclusiveAddressUse = true;
Socket.LingerState = new LingerOption(true, 0);
e.UserToken = Create(Socket, Peer, isSecure, isLocal);
if (!Socket.ConnectAsync(e))
{
Completed(null, e);
}
}
protected override void _OUTTransaction(USBTransfer transfer, USBTransaction uTransaction, bool toggle, void *buffer, ushort length)
{
#if UHCI_TRACE
BasicConsole.WriteLine("UHCI: OUT Transaction");
BasicConsole.DelayOutput(5);
#endif
UHCITransaction uT = new UHCITransaction();
uTransaction.underlyingTz = uT;
uT.inBuffer = null;
uT.inLength = 0;
uT.qTD = CreateQTD_IO((UHCI_QueueHead_Struct *)transfer.underlyingTransferData, (uint *)1, UHCI_Consts.TD_OUT, toggle, length, transfer.device.address, transfer.endpoint, transfer.packetSize);
uT.qTDBuffer = uT.qTD->virtBuffer;
if (buffer != null && length != 0)
{
MemoryUtils.MemCpy_32((byte *)uT.qTDBuffer, (byte *)buffer, length);
}
if (transfer.transactions.Count > 0)
{
UHCITransaction uLastTransaction = (UHCITransaction)((USBTransaction)(transfer.transactions[transfer.transactions.Count - 1])).underlyingTz;
uLastTransaction.qTD->next = (((uint)VirtMemManager.GetPhysicalAddress(uT.qTD) & 0xFFFFFFF0) | UHCI_Consts.BIT_Vf); // build TD queue
uLastTransaction.qTD->q_next = uT.qTD;
}
}
public void LoadLevelData()
{
LevelData = new List <LevelData>();
// dump all single player save slots
var rawLevelData = MemoryUtils.DumpSaveSlots(Gecko, 0, SaveSlotsAddress, 768);
// read data from slots
var j = 0;
while (j < rawLevelData.Length)
{
var levelNumber = rawLevelData[j];
// check if an empty save slot
if (levelNumber == uint.MaxValue)
{
break;
}
var clearState = rawLevelData[j + 1];
var scroll = Convert.ToBoolean(rawLevelData[j + 2]);
// add to the list
LevelData.Add(new LevelData(levelNumber, clearState, scroll));
// move to next slot
j += 3;
}
}
public async Task <Dictionary <string, ProjectAnalysisResult> > AnalyzeSolutionIncremental(
string solutionFilename, List <string> projects, string targetFramework = DEFAULT_TARGET)
{
try
{
var analyzerResults = await RunCoderlyzerAnalysis(solutionFilename);
var analysisActions = AnalyzeActions(projects, targetFramework, analyzerResults, solutionFilename);
var solutionAnalysisResult = AnalyzeProjects(
solutionFilename, projects,
analyzerResults, analysisActions,
isIncremental: true, targetFramework);
var projectActions = projects
.Select((project) => new KeyValuePair <string, ProjectActions>
(project, analysisActions.FirstOrDefault(p => p.ProjectFile == project)?.ProjectActions ?? new ProjectActions()))
.Where(p => p.Value != null)
.ToDictionary(p => p.Key, p => p.Value);
return(solutionAnalysisResult);
}
catch (OutOfMemoryException e)
{
_logger.LogError("Analyze solution {0} with error {1}", solutionFilename, e);
MemoryUtils.LogMemoryConsumption(_logger);
throw e;
}
finally
{
CommonUtils.RunGarbageCollection(_logger, "PortingAssistantAnalysisHandler.AnalyzeSolutionIncremental");
}
}
static TranslateUtils()
{
APIURL = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build()["studio:language"];
if (string.IsNullOrEmpty(APIURL))
{
return;
}
Console.WriteLine("触发翻译器静态构造");
Timer timer = new Timer(60 * 1000)
{
Enabled = true
};
timer.Elapsed += (sender, e) =>
{
if (UPDATETIME != GetDataTime())
{
Console.WriteLine("语言包存在更新");
MemoryUtils.Set(KEY, GetAPIData(), TimeSpan.FromDays(7));
}
};
timer.Start();
}
public static object ReadHeader(Stream data)
{
var baseHeader = data.ReadStruct <BaseHeader>();
var baseSize = Marshal.SizeOf <BaseHeader>();
if (baseHeader.size < baseSize)
{
throw new Exception("Unexpected header size");
}
if (baseHeader.size == baseSize)
{
return(baseHeader);
}
if (baseHeader.platformId.Value == 0x44583131)
{
//dx11 platform
var dx11Size = Marshal.SizeOf <DX11Header>();
var extraBytesCount = dx11Size - baseSize;
var extraBytes = data.ReadBytes(extraBytesCount);
var baseBytes = MemoryUtils.StructToBytes(baseHeader);
List <byte> dx11Bytes = new List <byte>();
dx11Bytes.AddRange(baseBytes);
dx11Bytes.AddRange(extraBytes);
return(MemoryUtils.BytesToStruct <DX11Header>(dx11Bytes.ToArray()));
}
throw new Exception("Unknown platform");
}
public Dictionary <PackageVersionPair, Task <PackageDetails> > GetNugetPackages(List <PackageVersionPair> packageVersions, string pathToSolution,
bool isIncremental = false, bool incrementalRefresh = false)
{
_logger.LogInformation("Memory usage before GetNugetPackages: ");
MemoryUtils.LogMemoryConsumption(_logger);
var packageVersionsToQuery = new List <PackageVersionPair>();
var tasks = packageVersions.Select(packageVersion =>
{
var isNewCompatibilityTask = _compatibilityTaskCompletionSources.TryAdd(packageVersion, new TaskCompletionSource <PackageDetails>());
if (isNewCompatibilityTask)
{
packageVersionsToQuery.Add(packageVersion);
}
var packageVersionPairResult = _compatibilityTaskCompletionSources[packageVersion];
return(new Tuple <PackageVersionPair, Task <PackageDetails> >(packageVersion, packageVersionPairResult.Task));
}).ToDictionary(t => t.Item1, t => t.Item2);
_logger.LogInformation("Checking compatibility for {0} packages", packageVersionsToQuery.Count);
Process(packageVersionsToQuery, pathToSolution, isIncremental, incrementalRefresh);
_logger.LogInformation("Memory usage after GetNugetPackages: ");
MemoryUtils.LogMemoryConsumption(_logger);
return(tasks);
}
public async Task <string> RequestOAuth2Token(string appId)
{
GCHandle handle;
bool resultSuccess = false;
string data = null;
var semaphore = new SemaphoreSlim(0, 1);
unsafe
{
void ResolveTask(bool success, string token)
{
resultSuccess = success;
data = token;
semaphore.Release();
}
DiscordOAuth2TokenResultModuleDelegate resolveTask = ResolveTask;
handle = GCHandle.Alloc(resolveTask);
var appIdPtr = MemoryUtils.StringToHGlobalUtf8(appId);
core.Library.Client.Core_Discord_GetOAuth2Token(core.NativePointer, appIdPtr, resolveTask);
Marshal.FreeHGlobal(appIdPtr);
}
await semaphore.WaitAsync();
handle.Free();
semaphore.Dispose();
if (!resultSuccess)
{
throw new Exception("Failed to request OAuth2 token");
}
return(data);
}
private int CompareData(ValueReader other, int len)
{
if (_buffer != null)
{
fixed(byte *a = _buffer)
{
if (other._buffer != null)
{
fixed(byte *b = other._buffer)
{
return(MemoryUtils.Compare(a, b, len));
}
}
return(MemoryUtils.Compare(a, other._val, len));
}
}
if (other._buffer != null)
{
fixed(byte *b = other._buffer)
{
return(MemoryUtils.Compare(_val, b, len));
}
}
return(MemoryUtils.Compare(_val, other._val, len));
}
public void WriteGather(long position, IntPtr[] pages)
{
_locker.EnterWriteLock();
try
{
if (position != _lastPos)
{
throw new InvalidOperationException("Journal writes must be to the next location in the journal");
}
var size = pages.Length * AbstractPager.PageSize;
_lastPos += size;
var handle = Marshal.AllocHGlobal(size);
var buffer = new Buffer
{
Handle = handle,
Pointer = (byte *)handle.ToPointer(),
SizeInPages = pages.Length
};
_buffers = _buffers.Append(buffer);
for (int index = 0; index < pages.Length; index++)
{
MemoryUtils.Copy(buffer.Pointer + (index * AbstractPager.PageSize), (byte *)pages[index].ToPointer(), AbstractPager.PageSize);
}
}
finally
{
_locker.ExitWriteLock();
}
}
public void DeepCopyShouldCreateExactAndIndependentCopyOfAnObject()
{
var instance = new CustomSerializableType
{
DateTimeValueType =
DateTime.Now.AddDays(1).AddMilliseconds(123).AddTicks(123),
NumericValueType = 777,
StringValueType = Guid.NewGuid().ToString(),
ReferenceType =
new CustomSerializableType
{
DateTimeValueType = DateTime.Now,
StringValueType = Guid.NewGuid().ToString()
}
};
var deepCopy = MemoryUtils.DeepCopy(instance, true);
Assert.IsNotNull(deepCopy);
Assert.IsFalse(ReferenceEquals(instance, deepCopy));
Assert.That(instance.NumericValueType == deepCopy.NumericValueType);
Assert.That(instance.DateTimeValueType == deepCopy.DateTimeValueType);
Assert.That(instance.StringValueType == deepCopy.StringValueType);
Assert.IsFalse(ReferenceEquals(instance.ReferenceType, deepCopy.ReferenceType));
Assert.That(instance.ReferenceType.DateTimeValueType == deepCopy.ReferenceType.DateTimeValueType);
Assert.That(instance.ReferenceType.StringValueType == deepCopy.ReferenceType.StringValueType);
}
public void ReloadWeapons()
{
_weapons.Clear();
EquippedWeapon = Gecko.peek((uint)GearAddress.EquippedWeapon + Offset);
var weaponData = MemoryUtils.DumpSaveSlots(Gecko, Offset, (uint)GearAddress.Weapons, 5120);
// read data from slots
var j = 0;
while (j < weaponData.Length)
{
var id = weaponData[j];
// check if an empty save slot
if (id.Equals(uint.MaxValue))
{
break;
}
var number = weaponData[j + 1];
var sub = (SubWeapon)weaponData[j + 2];
var special = (SpecialWeapon)weaponData[j + 3];
var turfInked = weaponData[j + 4];
var timestamp = weaponData[j + 7];
var newFlag = weaponData[j + 8] == 0x0;
AddWeapon(new Weapon(id, number, sub, special, turfInked, timestamp, newFlag));
// move to next slot
j += 10;
}
}
public async Task <HttpResponse> Get(string url)
{
CheckIfEntityExists();
GCHandle handle;
HttpResponse?data = null;
var semaphore = new SemaphoreSlim(0, 1);
unsafe
{
void ResolveTask(int statusCode, string body, IntPtr headerKeys, IntPtr headerValues, int headerSize)
{
data = GetHttpResponse(statusCode, body, headerKeys, headerValues, headerSize);
semaphore.Release();
}
HttpResponseModuleDelegate resolveTask = ResolveTask;
handle = GCHandle.Alloc(resolveTask);
var urlPtr = MemoryUtils.StringToHGlobalUtf8(url);
Core.Library.Client.HttpClient_Get(NativePointer, urlPtr, resolveTask);
Marshal.FreeHGlobal(urlPtr);
}
await semaphore.WaitAsync();
handle.Free();
semaphore.Dispose();
return(data.Value);
}
internal int CompareDataInline(Slice other, ushort size)
{
if (Array != null)
{
fixed(byte *a = Array)
{
if (other.Array != null)
{
fixed(byte *b = other.Array)
{
return(MemoryUtils.CompareInline(a, b, size));
}
}
else
{
return(MemoryUtils.CompareInline(a, other.Pointer, size));
}
}
}
if (other.Array != null)
{
fixed(byte *b = other.Array)
{
return(MemoryUtils.CompareInline(Pointer, b, size));
}
}
else
{
return(MemoryUtils.CompareInline(Pointer, other.Pointer, size));
}
}
private void OnWriteExternalFlashStarted(byte[] flashMemoryImage, MemoryLayout flashMemoryLayout, Operation.CompletedOperationDelegate onOperationComplete, bool diffWrite, bool verify)
{
var KWP2000CommViewModel = App.CommInterfaceViewModel as KWP2000Interface_ViewModel;
var settings = new WriteExternalFlashOperation.WriteExternalFlashSettings();
settings.CheckIfWriteRequired = diffWrite;
settings.OnlyWriteNonMatchingSectors = diffWrite;
settings.VerifyWrittenData = verify;
settings.EraseEntireFlashAtOnce = false;
settings.SecuritySettings.RequestSeed = KWP2000CommViewModel.SeedRequest;
settings.SecuritySettings.SupportSpecialKey = KWP2000CommViewModel.ShouldSupportSpecialKey;
settings.SecuritySettings.UseExtendedSeedRequest = KWP2000CommViewModel.ShouldUseExtendedSeedRequest;
var sectorImages = MemoryUtils.SplitMemoryImageIntoSectors(flashMemoryImage, flashMemoryLayout);
App.CurrentOperation = new WriteExternalFlashOperation(KWP2000CommViewModel.KWP2000CommInterface, KWP2000CommViewModel.DesiredBaudRates, settings, sectorImages);
App.CurrentOperation.CompletedOperationEvent += onOperationComplete;
App.OperationInProgress = true;
App.PercentOperationComplete = 0.0f;
App.DisplayStatusMessage("Writing ECU flash memory.", StatusMessageType.USER);
App.CurrentOperation.Start();
}
/// <summary>
/// 显示验证码
/// </summary>
/// <param name="key"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
private Result ShowCode(string key, int width, int height)
{
string random = WebAgent.GetRandom(0, 9999).ToString().PadLeft(4, '0');
MemoryUtils.Set(key, random, TimeSpan.FromMinutes(5));
using (Bitmap bitmap = new Bitmap(width, height))
{
Bitmap bg = (Bitmap) new ResourceManager(typeof(Resources)).GetObject("validcode_bg");
Rectangle rectangle = new Rectangle(WebAgent.GetRandom(0, bg.Width - width),
WebAgent.GetRandom(0, bg.Height - height),
width, height);
using (Graphics g = Graphics.FromImage(bitmap))
{
g.Clear(Color.White);
g.DrawImage(bg, new Rectangle(0, 0, width, height),
rectangle, GraphicsUnit.Pixel);
for (int i = 0; i < random.Length; i++)
{
Bitmap code = (Bitmap) new ResourceManager(typeof(Resources)).GetObject($"validcode_{random[i]}");
Rectangle codeRectangle = new Rectangle(width / random.Length * i + WebAgent.GetRandom(-5, 5), WebAgent.GetRandom(-5, 5), width / 4, height);
g.DrawImage(code, codeRectangle,
new Rectangle(0, 0, code.Width, code.Height),
GraphicsUnit.Pixel);
}
}
using (MemoryStream ms = new MemoryStream())
{
bitmap.Save(ms, ImageFormat.Png);
return(new Result(ContentType.PNG, ms.ToArray()));
}
}
}
private void OnReadExternalFlashStarted(bool checkIfReadRequired, bool onlyReadRequiredSectors, bool shouldVerifyReadData, byte[] baseImage, MemoryLayout flashLayout, Operation.CompletedOperationDelegate operationCompletedDel)
{
var readImage = baseImage;
if ((readImage == null) || (readImage.Length != flashLayout.Size))
{
readImage = new byte[flashLayout.Size];
//fill the memory image with 0xFF because that is what blank data in the flash chip is
for (int x = 0; x < readImage.Length; x++)
{
readImage[x] = 0xFF;
}
}
var sectorImages = MemoryUtils.SplitMemoryImageIntoSectors(readImage, flashLayout);
var KWP2000CommViewModel = App.CommInterfaceViewModel as KWP2000Interface_ViewModel;
var settings = new ReadExternalFlashOperation.ReadExternalFlashSettings();
settings.CheckIfSectorReadRequired = checkIfReadRequired;
settings.OnlyReadNonMatchingSectors = onlyReadRequiredSectors;
settings.VerifyReadData = shouldVerifyReadData;
settings.SecuritySettings.RequestSeed = KWP2000CommViewModel.SeedRequest;
settings.SecuritySettings.SupportSpecialKey = KWP2000CommViewModel.ShouldSupportSpecialKey;
settings.SecuritySettings.UseExtendedSeedRequest = KWP2000CommViewModel.ShouldUseExtendedSeedRequest;
App.CurrentOperation = new ReadExternalFlashOperation(KWP2000CommViewModel.KWP2000CommInterface, KWP2000CommViewModel.DesiredBaudRates, settings, sectorImages);
App.CurrentOperation.CompletedOperationEvent += operationCompletedDel;
App.DisplayStatusMessage("Reading ECU flash memory.", StatusMessageType.USER);
App.CurrentOperation.Start();
}
public async Task <Dictionary <string, ProjectAnalysisResult> > AnalyzeSolution(
string solutionFilename, List <string> projects, string targetFramework = DEFAULT_TARGET)
{
try
{
var analyzerResults = await RunCoderlyzerAnalysis(solutionFilename);
var analysisActions = AnalyzeActions(projects, targetFramework, analyzerResults, solutionFilename);
var solutionAnalysisResult = AnalyzeProjects(
solutionFilename, projects,
analyzerResults, analysisActions,
isIncremental: false, targetFramework);
return(solutionAnalysisResult);
}
catch (OutOfMemoryException e)
{
_logger.LogError("Analyze solution {0} with error {1}", solutionFilename, e);
MemoryUtils.LogMemoryConsumption(_logger);
throw e;
}
finally
{
CommonUtils.RunGarbageCollection(_logger, "PortingAssistantAnalysisHandler.AnalyzeSolution");
}
}
/// <summary>
/// 清除缓存（本地缓存+Redis)
/// </summary>
/// <param name="adminId"></param>
public void RemoveCache(int adminId)
{
string key = $"SYSTEMADMIN:{adminId}";
MemoryUtils.Remove(key);
AdminCaching.Instance().RemoveCache(adminId);
}
protected override void NewConnection(object sender, SocketArgs args)
{
try
{
string request = string.Format(
"GET {0} HTTP/1.1" + Environment.NewLine +
"Upgrade: WebSocket" + Environment.NewLine +
"Connection: Upgrade" + Environment.NewLine +
"Host: {1}" + Environment.NewLine +
"Origin: {2}" + Environment.NewLine +
"Pragma: no-cache" + Environment.NewLine +
"Cache-Control: no-cache" + Environment.NewLine +
"Accept-Encoding: gzip, deflate" + Environment.NewLine +
"Sec-WebSocket-Version: 13" + Environment.NewLine +
"Sec-WebSocket-Key: " + Hybi.GenerateKey() + "" + Environment.NewLine +
"Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover; server_no_context_takeover" +
Environment.NewLine + Environment.NewLine, "/", args.Socket.Endpoint, "null");
if (!this.SendRaw(MemoryUtils.ToLatin(request)))
{
Console.WriteLine("Sendraw failed?");
throw new Exception("Sendraw failed?");
}
}
catch (ObjectDisposedException ex)
{
Console.WriteLine(ex.Message);
return;
}
}
internal Page ModifyPage(long num, Tree tree, Page page)
{
_env.AssertFlushingNotFailed();
page = page ?? GetReadOnlyPage(num);
if (page.Dirty)
{
return(page);
}
if (_dirtyPages.Contains(num))
{
page.Dirty = true;
return(page);
}
var newPage = AllocatePage(1, PageFlags.None, num); // allocate new page in a log file but with the same number
MemoryUtils.Copy(newPage.Base, page.Base, AbstractPager.PageSize);
newPage.LastSearchPosition = page.LastSearchPosition;
newPage.LastMatch = page.LastMatch;
tree.RecentlyFoundPages.Reset(num);
return(newPage);
}
public static unsafe Version getBTD6Version(string btd6Dir)
{
// GlobalGameManagers contains version string.
// Can move by a few bytes in updates, instead scan for it.
Version v;
byte[] file = File.ReadAllBytes(btd6Dir + "\\BloonsTD6_Data\\globalgamemanagers");
Int64 VersionStructOffset = 0;
fixed(byte *pFile = file)
{
// The signature is only a few bytes away, the next period should always be the peroid in the version (12.2)
VersionStructOffset = MemoryUtils.AOBScan(pFile, file.Length, BTD6VerisonInfoSignature);
if (VersionStructOffset == 0)
{
throw new Exception("Error, failed to find BTD6's version");
}
// Now we scan for the peroid (12.2) the .
for (Int64 i = VersionStructOffset + BTD6VerisonInfoSignature.Length; i < file.Length; i++)
{
if (pFile[i] == 0x2E)
{
byte[] versionBytes = MemoryUtils.BytesBetweenNull(pFile, file.Length, i);
int periodPos = 0;
for (int k = 0; k < versionBytes.Length; k++)
{
if (versionBytes[k] == 0x2e)
{
periodPos = k;
break;
}
}
byte[] majorVersionBytes = new byte[periodPos];
byte[] minorVersionBytes = new byte[versionBytes.Length - (periodPos + 1)];
Buffer.BlockCopy(versionBytes, 0, majorVersionBytes, 0, periodPos);
Buffer.BlockCopy(versionBytes, periodPos + 1, minorVersionBytes, 0, versionBytes.Length - (periodPos + 1));
string majorVersionString = Encoding.UTF8.GetString(majorVersionBytes);
string minorVersionString = Encoding.UTF8.GetString(minorVersionBytes);
v = new Version(int.Parse(majorVersionString), int.Parse(minorVersionString));
return(v);
}
}
}
throw new Exception("Error, unable to get BTD6 Version");
}
public static void Init(EventManagerConfiguration config)
{
Debug.Assert(config.MaxEvents > 0u);
Logger.Trace <EventManager>($"Initialize {nameof(EventManager)} with max events {config.MaxEvents}");
_maxEvents = (int)config.MaxEvents;
_events = MemoryUtils.AllocateBlock <Event>(config.MaxEvents * 2);
}
public void DeepCopyDoesNotThrowWhenCopyNonSerializableInstanceAndErrorsDisabled()
{
var nonSerializableInstance = new CustomNonSerializableType();
object result = null;
Assert.DoesNotThrow(() => result = MemoryUtils.DeepCopy(nonSerializableInstance, false));
Assert.IsNull(result);
}
public void GetMetaData(string key, out MValueConst value)
{
unsafe
{
var stringPtr = MemoryUtils.StringToHGlobalUtf8(key);
value = new MValueConst(Core, Core.Library.Shared.BaseObject_GetMetaData(BaseObjectNativePointer, stringPtr));
Marshal.FreeHGlobal(stringPtr);
}
}
public static void CopyTo(Transaction tx, NodeHeader *node, byte *dest)
{
if (node->Flags == (NodeFlags.PageRef))
{
var overFlowPage = tx.GetReadOnlyPage(node->PageNumber);
MemoryUtils.Copy(dest, overFlowPage.Base + Constants.PageHeaderSize, overFlowPage.OverflowSize);
}
MemoryUtils.Copy(dest, (byte *)node + node->KeySize + Constants.NodeHeaderSize, node->DataSize);
}
