public void RunTest02()
{
StringCompression test = new StringCompression("aabcccccfghjkyreaaa");
var result = test.Run();
Assert.AreEqual(Test02Result, result);
}
private bool GetInfoFromJson()
{
Log.Logger.Information("Reading media info from sidecar : {FileName}", SidecarFileInfo.Name);
// Decompress the tool data
FfProbeInfoJson = StringCompression.Decompress(SidecarJson.FfProbeInfoData);
MkvMergeInfoJson = StringCompression.Decompress(SidecarJson.MkvMergeInfoData);
MediaInfoXml = StringCompression.Decompress(SidecarJson.MediaInfoData);
// Deserialize the tool data
if (!MediaInfoTool.GetMediaInfoFromXml(MediaInfoXml, out MediaInfo mediaInfoInfo) ||
!MkvMergeTool.GetMkvInfoFromJson(MkvMergeInfoJson, out MediaInfo mkvMergeInfo) ||
!FfProbeTool.GetFfProbeInfoFromJson(FfProbeInfoJson, out MediaInfo ffProbeInfo))
{
Log.Logger.Error("Failed to de-serialize tool data : {FileName}", SidecarFileInfo.Name);
return(false);
}
// Assign mediainfo data
FfProbeInfo = ffProbeInfo;
MkvMergeInfo = mkvMergeInfo;
MediaInfoInfo = mediaInfoInfo;
// Assign state
State = SidecarJson.State;
return(true);
}
public static string Serialize(string identifier, Type storageType, object instance, bool encryptSaveFile)
{
var serializer = new fsSerializer();
fsData data;
GetJsonConverters(ref serializer);
//serialize data
serializer.TrySerialize(storageType, instance, out data).AssertSuccessWithoutWarnings(); // 5.1 Serialize data
string serializedData = (encryptSaveFile) ? fsJsonPrinter.CompressedJson(data) : fsJsonPrinter.PrettyJson(data); // 5.2 Create Json string
if (encryptSaveFile)
{
serializedData = StringCompression.Compress(serializedData); // 5.3 Compress Json string
}
if (encryptSaveFile)
{
serializedData = StringCipher.Encrypt(serializedData, encryptionPassword); // 5.4 Encrpyt Json string
}
//write identifier
string identifierStart = "<" + identifier + ">\n";
string identifierEnd = "\n</" + identifier + ">\n";
serializedData = serializedData.Insert(0, identifierStart);
serializedData += identifierEnd;
return(serializedData);
}
public virtual void Deserialize(GenericReader reader)
{
var version = reader.GetVersion();
ProviderID = reader.ReadInt();
switch (version)
{
case 2:
{
Value = reader.ReadString();
_ValueHash = reader.ReadInt();
}
break;
case 1:
{
var seed = reader.ReadBool()
? StringCompression.Unpack(reader.ReadBytes())
: Encoding.UTF32.GetString(reader.ReadBytes());
Value = CryptoGenerator.GenString(ProviderID, seed ?? String.Empty);
}
break;
case 0:
{
var seed = reader.ReadString();
Value = CryptoGenerator.GenString(ProviderID, seed ?? String.Empty);
}
break;
}
}
//--------------------------------------------------------------------------------------Queue----------------------------------------------------------------------------------
public void AstroQueueUpdate(String jSon)
{
jSon = StringCompression.DecompressString(jSon);
JObject obj = JObject.Parse(jSon);
STATIONNAME stationName = TTCSHelper.StationStrConveter(obj["StationName"].ToString());
String Id = obj["Id"].ToString();
String Event = obj["Event"].ToString();
DateTime TimeStamp = DateTime.Parse(obj["TimeStamp"].ToString());
Console.WriteLine("[AstroQueueUpdate] " + obj["StationName"] + " : " + obj["Event"] + " --> " + Id);
AstroQueueImpl astroQueue = DBQueueEngine.FindById(stationName, Id);
if (Event == "RECEIVED")
{
QueueStatus queueStatus = new QueueStatus(QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED, TimeStamp);
astroQueue.QueueStatus.Add(queueStatus);
astroQueue.Save();
}
Task task = Task.Run(async() =>
{
await Task.Delay(100);
StationHandler StationCommunication = AstroData.GetStationObject(stationName);
StationCommunication.AckTarget(astroQueue, QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED);
});
}
public void AstroQueueUpdateExposure(String jSon)
{
jSon = StringCompression.DecompressString(jSon);
JObject obj = JObject.Parse(jSon);
STATIONNAME stationName = TTCSHelper.StationStrConveter(obj["StationName"].ToString());
String Id = obj["Id"].ToString();
String AstroQueueId = obj["AstroQueueId"].ToString();
ExposedHistory exposedHistoryRecv = (ExposedHistory)JsonConvert.DeserializeObject(obj["ExposedHistory"].ToString(), typeof(ExposedHistory));
Console.WriteLine("[AstroQueueUpdateExposure] " + obj["StationName"] + " : " + exposedHistoryRecv.filterName + " --> " + Id);
AstroQueueImpl astroQueue = DBQueueEngine.FindById(stationName, AstroQueueId);
ExposedHistory exposedHistory = astroQueue.Target.exposedHistory.Find(Item => Item.filterName == exposedHistoryRecv.filterName && Item.executedStatus == EXECUTESTATUS.WAIT);
if (exposedHistory != null)
{
exposedHistory.executedStatus = exposedHistoryRecv.executedStatus;
exposedHistory.executedDate = exposedHistoryRecv.executedDate;
astroQueue.Save();
Task task = Task.Run(async() =>
{
await Task.Delay(100);
StationHandler StationCommunication = AstroData.GetStationObject(stationName);
StationCommunication.AckExposure(Id, SENDING_STATUS.COMPLETED);
});
}
}
private bool SetJsonInfo()
{
// Create the sidecar json object
SidecarJson ??= new SidecarFileJsonSchema();
// Schema version
SidecarJson.SchemaVersion = SidecarFileJsonSchema.CurrentSchemaVersion;
// Media file info
MediaFileInfo.Refresh();
SidecarJson.MediaLastWriteTimeUtc = MediaFileInfo.LastWriteTimeUtc;
SidecarJson.MediaLength = MediaFileInfo.Length;
SidecarJson.MediaHash = ComputeHash();
// Tool version info
SidecarJson.FfProbeToolVersion = Tools.FfProbe.Info.Version;
SidecarJson.MkvMergeToolVersion = Tools.MkvMerge.Info.Version;
SidecarJson.MediaInfoToolVersion = Tools.MediaInfo.Info.Version;
// Compressed tool info
SidecarJson.FfProbeInfoData = StringCompression.Compress(FfProbeInfoJson);
SidecarJson.MkvMergeInfoData = StringCompression.Compress(MkvMergeInfoJson);
SidecarJson.MediaInfoData = StringCompression.Compress(MediaInfoXml);
// State
// TODO: Only update tool and file info if changed, else just update state
SidecarJson.State = State;
return(true);
}
public void ThirdTry_Given_String_abc_returns_abc()
{
string input = "abc";
string result = new StringCompression().ThirdTry(input);
Assert.Equal("abc", result);
}
public Boolean ScheduleEvented(String ScriptsJSON)
{
String jSonC = StringCompression.DecompressString(ScriptsJSON);
ScriptStructureNew Script = (ScriptStructureNew)Newtonsoft.Json.JsonConvert.DeserializeObject(jSonC, typeof(ScriptStructureNew));
DBScheduleEngine.UpdateSchedule(Script);
return(true);
}
public void FirstTry_Given_String_aabcccccaaa_returns_a2b1c5a3()
{
string input = "aabcccccaaa";
string result = new StringCompression().FirstTry(input);
Assert.Equal("a2b1c5a3", result);
}
public void GetCompressedString_Success()
{
var data = StringCompression.GetCompressedString("aabcccccaaa");
Assert.AreEqual(data, "a2b1c5a3", "Strings are not compressed properly.");
data = StringCompression.GetCompressedString("aaaabcdddeeeeee");
Assert.AreEqual(data, "a4b1c1d3e6", "Strings are not compressed properly.");
}
static void Main(string[] args)
{
//IsUniqueString.Run();
//IsAStringPermutationOfOtherString.Run();
//URLify.Run();
//PalindromePermutation.Run();
//OneAway.Run();
StringCompression.Run();
}
protected override void Context()
{
_stringToCompress = "toto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tontontoto tata titi tutu tonton";
var compression = A.Fake <ICompression>();
A.CallTo(() => compression.Compress(A <byte[]> ._)).ReturnsLazily(x => x.GetArgument <byte[]>(0));
A.CallTo(() => compression.Decompress(A <byte[]> ._)).ReturnsLazily(x => x.GetArgument <byte[]>(0));
sut = new StringCompression(compression);
}
public void StringCompression_ShouldNotReturnACompressedString_WhenTheCompressedStringIsNotSmallerThanTheOriginalString_Testcase_3()
{
// Arrange
string input = "abcdefghijklmnopqrstuvwqyz";
// Act
string output = StringCompression.Compress(input);
// Assert
Assert.AreEqual("abcdefghijklmnopqrstuvwqyz", output);
}
public void StringCompression_ShouldNotReturnACompressedString_WhenTheCompressedStringIsNotSmallerThanTheOriginalString_Testcase_2()
{
// Arrange
string input = "aabbccddeeffgghhiijjkk";
// Act
string output = StringCompression.Compress(input);
// Assert
Assert.AreEqual("aabbccddeeffgghhiijjkk", output);
}
public void StringCompressionShouldCompressStringSuccessfully_Testcase_3()
{
// Arrange
string input = "hhhhbboooooaaa";
// Act
string output = StringCompression.Compress(input);
// Assert
Assert.AreEqual("h4b2o5a3", output);
}
public void StringCompressionShouldCompressStringSuccessfully_Testcase_2()
{
// Arrange
string input = "aabbccc";
// Act
string output = StringCompression.Compress(input);
// Assert
Assert.AreEqual("a2b2c3", output);
}
public void TestStringCompression()
{
// solution #1 ineffective string comparison
Assert.Equal("a2b1c5a3", StringCompression.CompressBad("aabcccccaaa"));
// solution #2 with string builder
Assert.Equal("a2b1c5a3", StringCompression.CompressStringBuilder("aabcccccaaa"));
// solution #3 with added check if compressed string is longer than initial one
Assert.Equal("a2b1c5a3", StringCompression.Compress("aabcccccaaa"));
}
public void StringCompress()
{
//aaaabbbcdd => compressed: a4b3c1d2 return compressed
//aabbcd => compressed: a2b2c1d1 return original (because compressed is longer)
var compressed1 = StringCompression.CompressString("aaaabbbcdd");
Assert.AreEqual(compressed1, "a4b3c1d2");
var compressed2 = StringCompression.CompressString("aabbcd");
Assert.AreEqual(compressed2, "aabbcd");
}
static void Main(string[] args)
{
var option = 9;
switch (option)
{
case 1:
UniqueChecker.Run();
break;
case 2:
Permutation.Run();
break;
case 3:
StringCompression.Run();
break;
case 4:
StringChecker.Run();
break;
case 5:
MatrixModifier.Run();
break;
case 6:
ImageRotation.Run();
break;
case 7:
LinkedListDeduplicator.Run();
break;
case 8:
BitManipulationHelper.Run();
break;
case 9:
FibonacciHelper.Run();
break;
default:
Console.WriteLine("No option selected.");
break;
}
Console.WriteLine("Press any key to close this app.");
Console.ReadKey();
}
public Boolean DelayScheduleEvented(String ScriptsJSON)
{
String jSonC = StringCompression.DecompressString(ScriptsJSON);
ScriptStructureNew[] Scripts = (ScriptStructureNew[])Newtonsoft.Json.JsonConvert.DeserializeObject(jSonC, typeof(ScriptStructureNew[]));
foreach (ScriptStructureNew Script in Scripts)
{
DBScheduleEngine.UpdateSchedule(Script);
}
Console.WriteLine("RECEIVED DelayScheduleEvented() = " + Scripts.Count());
return(true);
}
public void Test_RunLength()
{
StringCompression compress = new StringCompression();
string str = "wwwggopp";
Console.WriteLine("Run Length:");
Console.WriteLine("Input: {0}", str);
Console.WriteLine("Output: {0}", compress.RunLength(str));
Console.WriteLine();
str = "wwwbbbw";
Console.WriteLine("Input: {0}", str);
Console.WriteLine("Output: {0}", compress.RunLength(str));
Console.WriteLine();
}
static void Main(string[] args)
{
Console.WriteLine(String.Format("Has all unique characters for {0}? The answer is: {1}", "mondaym", HasAllUniqueCharacters.HasAllUniqueCharatersWithDS("mondaym")));
ReverseString.reverse("thisiscorrect");
Console.WriteLine(String.Format("{0} is permutation of {1}: {2}", "danliu", "uinlda", StringPermutation.IsPermutation("danliu", "uinlda")));
Console.WriteLine(String.Format("{0} is permutation of {1}: {2}", "danliu", "sophia", StringPermutation.IsPermutation("danliu", "sophia")));
ReplacWhiteSpaceWith20Percent.ReplaceWhiteSpaceWith20("Mr. John Smith");
StringCompression.CompressString("aabcccccaaa");
StringCompression.CompressString("abcdefgg");
int[,] imageOrignal = new int[2, 2] {
{ 1, 2 }, { 3, 4 }
};
RotateImage.Rotate(imageOrignal);
int[,] m1 = new int[3, 3] {
{ 1, 2, 5 }, { 3, 1, 0 }, { 0, 4, 7 }
};
SetZeroToMatrix.SetZeroToRowAndColumn(m1);
Console.WriteLine(WordRotation.IsWordRotation("erbottlewat", "Waterbottle"));
Console.WriteLine(WordRotation.IsWordRotation("Waterbottle", "erbettoewti"));
}
public static void Deserialize <T>(string identifier, string fileContent, bool saveFileIsEncrypted, ref T instance)
{
var serializer = new fsSerializer();
GetJsonConverters(ref serializer);
string serializedData = fileContent.Substring("<" + identifier + ">", "</" + identifier + ">");
if (saveFileIsEncrypted)
{
serializedData = StringCipher.Decrypt(serializedData, encryptionPassword); // 0.2 Decrypt json string
}
if (saveFileIsEncrypted)
{
serializedData = StringCompression.Decompress(serializedData); // 0.3 Decompress json string
}
fsData parsedData = fsJsonParser.Parse(serializedData); // 0.4 Create data from json string
serializer.TryDeserialize(parsedData, ref instance); // 0.5 Deserialize json
}
private void OnLoadButtonPressed()
{
if (this.HasSaveData == false)
{
// Initialize new EncounterState, EncounterScene
var scene = _encounterPrefab.Instance() as EncounterScene;
var newState = EncounterState.Create(this.SaveLocation);
newState.SetStateForNewGame();
scene.SetEncounterState(newState);
// Save to slot
newState.WriteToFile();
var sceneManager = (SceneManager)GetNode("/root/SceneManager");
sceneManager.ShowEncounterScene(scene);
}
else
{
var scene = _encounterPrefab.Instance() as EncounterScene;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Godot.File file = new Godot.File();
file.Open(this.SaveLocation, File.ModeFlags.Read);
var saveData = file.GetAsText();
saveData = StringCompression.DecompressString(saveData);
file.Close();
var oldState = EncounterState.FromSaveData(saveData);
stopwatch.Stop();
GD.Print("SaveSlotScene load completed, elapsed ms: ", stopwatch.ElapsedMilliseconds);
scene.SetEncounterState(oldState);
var sceneManager = (SceneManager)GetNode("/root/SceneManager");
sceneManager.ShowEncounterScene(scene);
}
}
static void Main(string[] args)
{
var condition = true;
//just keeping the current solving problem in if condition; nothing else
if (condition)
{
KStacks.MainMethod();
}
else
{
#region LinkedLists
LinkIntersection.MainMethod();
SumList.MainMethod();
RemoveDups <int> .MainMethod();
ReturnKthToLast.MainMethod(1);
DeleteMiddleNode.MainMethod();
LoopDetection.MainMethod();
#endregion
#region Array and Strings
StringRotation.IsStringRotation("waterbottle", "erbottlewat");
ZeroMatrixImplementation();
RotateMatrixImplementation(4);
StringCompression.CompressedString("aabcccccaaa");
OneAway.IsStringOneAway("pale", "paled");
PalindromePermutation.IsPalindromePermutation("Mr. owl ate my Metal worm");
URLify.URLifyString("Spaces in this string will be replaced by percent20");
IsStringPermutation.VerifyStringPermutation("abdcdefgh", "aefgb2cdh");
UniqueString.VerifyUniqueStringAsciiSet("!@#$%$^&*()EFgh");
HashTableImplentation();
SwapWithoutTemp.SwapWithoutTempVar(12, 24);
#endregion
}
}
public void AddDeviceData(STATIONNAME StationName, String ScriptsJSON, Boolean IsInsertDB = true, Boolean IsSentWebSocket = true)
{
//Console.WriteLine(StationName);
Task DeviceTask = Task.Run(() =>
{
if (ScriptsJSON == null)
{
return;
}
if (ScriptsJSON[0] != '[' && ScriptsJSON['1'] != '{')
{
ScriptsJSON = StringCompression.DecompressString(ScriptsJSON);
}
if (ScriptsJSON == null)
{
return;
}
//Console.WriteLine("AddDeviceData - " + StationName.ToString() + " (" + Datas[0].DataId + ") - Packet: " + Datas.Count() + " Rows");
DataPacket[] Datas = (DataPacket[])Newtonsoft.Json.JsonConvert.DeserializeObject(ScriptsJSON, typeof(DataPacket[]));
StationHandler StationCommunication = AstroData.GetStationObject(StationName);
foreach (DataPacket Data in Datas)
{
//if (Data.FieldName == "IMAGING_FILTER_FILTERPOSITION")
//{
// Console.WriteLine(Data.Value);
//}
if (Data.DeviceCategory == DEVICECATEGORY.CCTV)
{
//Console.WriteLine(Data.Value);
if (Data.FieldName.ToString() == CCTV.CCTV_DEVICE1_IMAGE.ToString() || Data.FieldName.ToString() == CCTV.CCTV_DEVICE2_IMAGE.ToString())
{
Data.Value = Convert.ToBase64String(((JArray)Data.Value).ToObject <byte[]>());
}
}
else if (Data.DeviceCategory == DEVICECATEGORY.ALLSKY)
{
if (Data.FieldName.ToString() == ALLSKY.ALLSKY_IMAGE.ToString())
{
//Console.WriteLine("RECEIVED ALLSKY: " + IsSentWebSocket);
if (typeof(JArray).Equals(Data.Value.GetType()))
{
Data.Value = Convert.ToBase64String(((JArray)Data.Value).ToObject <byte[]>());
}
}
}
else if (Data.DeviceCategory == DEVICECATEGORY.IMAGING)
{
//Console.WriteLine(Data.FieldName);
if (Data.FieldName.ToString() == IMAGING.IMAGING_CCD_DOWNLOAD_STATUS.ToString())
{
String[] TempValue = Data.Value.ToString().Split(';');
if (TempValue.Count() > 1)
{
if (TempValue[0] == "Completed")
{
// BlockID#/files/AIRFORCE/FITS/maIeayp9iEO57G9LXZVPA_TakenFromClient.FITS
String[] PreFileName = TempValue[1].Split('#');
if (PreFileName.Count() > 1)
{
String BlockID = PreFileName[0];
String[] TmpFileName = PreFileName[1].Split('/');
String FileName = TmpFileName[(TmpFileName.Count() - 1)] + ".FITS";
String[] TempTargetID = FileName.Split('_');
String TargetID = TempTargetID[0];
DBScheduleEngine.InsertFITSData(TargetID, BlockID, StationName, FileName, Data.DateTimeUTC, DateTime.UtcNow.Ticks);
}
Data.Value = "Completed";
}
}
}
else if (Data.FieldName.ToString() == IMAGING.IMAGING_PREVIEW_DOWNLOAD_STATUS.ToString())
{
AstroData.LoadPerviewImage(StationName, Data.DeviceName, StationCommunication);
}
//AstroData.NewIMAGINGInformationHandle(StationName, Data.DeviceName, Data.FieldName, Data.Value, new DateTime(Data.DateTimeUTC));
}
if (IsInsertDB)
{
DBScheduleEngine.InsertData(Data.DataId, StationName, Data.DeviceCategory, Data.DeviceName, Data.FieldName, Data.Value, Data.DateTimeUTC);
}
if (IsSentWebSocket)
{
WebSockets.ReturnWebSubscribe(StationName, Data.DeviceName, Data.FieldName.ToString(), Data.Value, new DateTime(Data.DateTimeUTC));
}
AstroData.UpdateInformation(StationName, Data.DeviceName, Data.FieldName, Data.Value, new DateTime(Data.DateTimeUTC));
}
});
}
public void Setup()
{
stringCompression = new StringCompression();
}
public void Compress(string input, string expected)
{
Assert.Equal(expected, StringCompression.Compress(input));
}
public Boolean AddDelayDeviceData(STATIONNAME StationName, String ScriptsJSON)
{
Task DelayTask = Task.Run(() =>
{
if (ScriptsJSON == null)
{
return;
}
if (ScriptsJSON[0] != '[' && ScriptsJSON['1'] != '{')
{
ScriptsJSON = StringCompression.DecompressString(ScriptsJSON);
}
DataPacket[] Datas = (DataPacket[])Newtonsoft.Json.JsonConvert.DeserializeObject(ScriptsJSON, typeof(DataPacket[]));
Console.WriteLine("AddDelayDeviceData - " + StationName.ToString() + " (" + Datas[0].DataId + ") - Packet: " + Datas.Count() + " Rows");
StationHandler StationCommunication = AstroData.GetStationObject(StationName);
//StationCommunication.ReceivedInformation(Datas, out Msg);
foreach (DataPacket Data in Datas)
{
if (Data.DeviceCategory == DEVICECATEGORY.CCTV)
{
if (Data.FieldName.ToString() != CCTV.CCTV_CONNECTED.ToString())
{
Data.Value = Convert.ToBase64String(((JArray)Data.Value).ToObject <byte[]>());
}
}
else if (Data.DeviceCategory == DEVICECATEGORY.ALLSKY)
{
//Console.WriteLine(Data.Value);
if (Data.FieldName.ToString() == ALLSKY.ALLSKY_IMAGE.ToString())
{
if (typeof(JArray).Equals(Data.Value.GetType()))
{
Data.Value = Convert.ToBase64String(((JArray)Data.Value).ToObject <byte[]>());
}
else if (Data.Value.ToString() == "System.Byte[]")
{
Data.Value = null;
}
else
{
Data.Value = Convert.ToBase64String((byte[])Data.Value);
}
}
}
else if (Data.DeviceCategory == DEVICECATEGORY.IMAGING)
{
//Console.WriteLine(Data.FieldName);
if (Data.FieldName.ToString() == IMAGING.IMAGING_CCD_DOWNLOAD_STATUS.ToString())
{
String[] TempValue = Data.Value.ToString().Split(';');
if (TempValue.Count() > 1)
{
if (TempValue[0] == "Completed")
{
// /files/AIRFORCE/FITS/maIeayp9iEO57G9LXZVPA_TakenFromClient.FITS
String[] TmpFileName = TempValue[1].Split('/');
String FileName = TmpFileName[(TmpFileName.Count() - 1)];
String[] TempBlockID = FileName.Split('_');
String TargetID = TempBlockID[0];
String BlockID = TempBlockID[1];
DBScheduleEngine.InsertFITSData(TargetID, BlockID, StationName, FileName, Data.DateTimeUTC, DateTime.UtcNow.Ticks);
}
}
}
}
DBScheduleEngine.InsertData(Data.DataId, StationName, Data.DeviceCategory, Data.DeviceName, Data.FieldName, Data.Value, Data.DateTimeUTC);
}
});
return(true);
}
