private static void Count(string filePath, string fromDictionaryPath)
{
VerifyFileExists(filePath);
VerifyFileExists(fromDictionaryPath);
long tokenCount = 0;
using (new ConsoleWatch($"Reading [Count] {filePath} ({FileLength.MB(filePath)})...",
() => $"Done; {tokenCount:n0} tokens found in file"))
{
if (filePath.EndsWith(".bion", StringComparison.OrdinalIgnoreCase))
{
using (WordCompressor compressor = (fromDictionaryPath == null ? null : WordCompressor.OpenRead(fromDictionaryPath)))
using (BionReader reader = new BionReader(File.OpenRead(filePath), compressor: compressor))
{
while (reader.Read())
{
tokenCount++;
}
}
}
else
{
using (JsonTextReader reader = new JsonTextReader(new StreamReader(filePath)))
{
while (reader.Read())
{
tokenCount++;
}
}
}
}
}
private static void Skip(string filePath, string fromDictionaryPath)
{
VerifyFileExists(filePath);
VerifyFileExists(fromDictionaryPath);
using (new ConsoleWatch($"Reading [Skip All] {filePath} ({FileLength.MB(filePath)})..."))
{
if (filePath.EndsWith(".bion", StringComparison.OrdinalIgnoreCase))
{
using (WordCompressor compressor = (fromDictionaryPath == null ? null : WordCompressor.OpenRead(fromDictionaryPath)))
using (BionReader reader = new BionReader(File.OpenRead(filePath), compressor: compressor))
{
reader.Skip();
}
}
else
{
using (JsonTextReader reader = new JsonTextReader(new StreamReader(filePath)))
{
reader.Read();
reader.Skip();
}
}
}
}
private static void Compress(string fromPath, string toPath, string toDictionaryPath)
{
VerifyFileExists(fromPath);
using (new ConsoleWatch($"Compressing {fromPath}...",
() => $"Done. {FileLength.MB(fromPath)} to {FileLength.MB(toPath)} + {FileLength.MB(toDictionaryPath)} dictionary ({FileLength.Percentage(fromPath, toPath, toDictionaryPath)})"))
{
WordCompressor.Compress(fromPath, toPath, toDictionaryPath);
}
}
private static void ToBion(string jsonPath, string bionPath, string dictionaryPath)
{
VerifyFileExists(jsonPath);
using (new ConsoleWatch($"Converting {jsonPath} to {bionPath}...",
() => $"Done. {FileLength.MB(jsonPath)} JSON to {FileLength.MB(bionPath)} BION{(String.IsNullOrEmpty(dictionaryPath) ? "" : $" + {FileLength.MB(dictionaryPath)} dictionary")} ({FileLength.Percentage(jsonPath, bionPath, dictionaryPath)})"))
{
JsonBionConverter.JsonToBion(jsonPath, bionPath, dictionaryPath);
}
}
private static void Expand(string fromPath, string toPath, string fromDictionaryPath)
{
VerifyFileExists(fromPath);
VerifyFileExists(fromDictionaryPath);
using (new ConsoleWatch($"Expanding {fromPath}...",
() => $"Done. {FileLength.MB(fromPath)} + {FileLength.MB(fromDictionaryPath)} dictionary to {FileLength.MB(toPath)}"))
{
WordCompressor.Expand(fromPath, toPath, fromDictionaryPath);
}
}
private static void ToJson(string fromPath, string toPath, string dictionaryPath)
{
VerifyFileExists(fromPath);
VerifyFileExists(dictionaryPath);
using (new ConsoleWatch($"Converting {fromPath} to {toPath}...",
() => $"Done. {FileLength.MB(fromPath)} BION to {FileLength.MB(toPath)} JSON"))
{
JsonBionConverter.BionToJson(fromPath, toPath, dictionaryPath);
}
}
public static bool SizeRatioUnder(string originalFile, string actualFile, float maximumSizePercentage)
{
long originalSize = new FileInfo(originalFile).Length;
long actualSize = new FileInfo(actualFile).Length;
Trace.WriteLine($"{originalFile} => {FileLength.MB(originalSize)}");
Trace.WriteLine($"{actualFile} => {FileLength.MB(actualSize)}");
bool isSmallEnough = actualSize <= originalSize * maximumSizePercentage;
Assert.IsTrue(isSmallEnough, $"{actualFile} was {FileLength.MB(actualSize)}, which was over {maximumSizePercentage:p0} of {originalFile} size {FileLength.MB(originalSize)}.");
return(isSmallEnough);
}
private static void AddWhitespace(string fromJsonPath, string toJsonPath)
{
VerifyFileExists(fromJsonPath);
using (new ConsoleWatch($"Writing {fromJsonPath} with formatting to {toJsonPath}...",
() => $"Done; {FileLength.MB(fromJsonPath)} => {FileLength.MB(toJsonPath)} ({FileLength.Percentage(fromJsonPath, toJsonPath)})"))
{
using (JsonTextReader reader = new JsonTextReader(new StreamReader(fromJsonPath)))
using (JsonTextWriter writer = new JsonTextWriter(new StreamWriter(toJsonPath)))
{
writer.Formatting = Formatting.Indented;
writer.WriteToken(reader);
}
}
}
private static void Read(string filePath, string fromDictionaryPath)
{
VerifyFileExists(filePath);
VerifyFileExists(fromDictionaryPath);
long tokenCount = 0;
using (new ConsoleWatch($"Reading [Full] {filePath} ({FileLength.MB(filePath)})...",
() => $"Done; {tokenCount:n0} tokens found in file"))
{
if (filePath.EndsWith(".bion", StringComparison.OrdinalIgnoreCase))
{
using (WordCompressor compressor = (fromDictionaryPath == null ? null : WordCompressor.OpenRead(fromDictionaryPath)))
using (BionReader reader = new BionReader(File.OpenRead(filePath), compressor: compressor))
{
while (reader.Read())
{
tokenCount++;
switch (reader.TokenType)
{
case BionToken.PropertyName:
case BionToken.String:
String8 value8 = reader.CurrentString8();
//string valueS = reader.CurrentString();
break;
case BionToken.Integer:
long valueI = reader.CurrentInteger();
break;
case BionToken.Float:
double valueF = reader.CurrentFloat();
break;
}
}
}
}
else
{
using (JsonTextReader reader = new JsonTextReader(new StreamReader(filePath)))
{
while (reader.Read())
{
tokenCount++;
switch (reader.TokenType)
{
case JsonToken.PropertyName:
case JsonToken.String:
string valueS = (string)reader.Value;
break;
case JsonToken.Integer:
long valueI = (long)reader.Value;
break;
case JsonToken.Float:
double valueF = (double)reader.Value;
break;
}
}
}
}
}
}
