/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="input"></param>
/// <param name="mode"></param>
/// <returns></returns>
static public int ImportToSingleLanguageDBFromFile(SingleLanguageDB db, ILocalizationFile input,
LocalizationDB.ImportMode mode = LocalizationDB.ImportMode.kReplace)
{
// for now, all input file will be marked as english...
if (!input.VerifyHeader("english"))
{
return(0);
}
int importCount = 0;
int count = input.CountLines();
if (count > 0)
{
for (int i = 0; i < count; ++i)
{
if (input.IsLineLocalizationData(i))
{
string tag = "";
int ver = 0;
string data = "";
string rest = "";
input.GetData(i, ref tag, ref ver, ref data, ref rest);
if (db.Import(tag, ver, data, mode))
{
++importCount;
}
}
}
}
return(importCount);
}
public void Execute(ILocalizationFile localization)
{
using (Stream stream = DetermineFileStream())
{
Write(localization, stream);
}
}
public static void Write(ILocalizationFile localization, Stream stream)
{
//File format is
// VERSION
// HEADER
// PAYLOAD
//
// VERSION consists of
// version identifier (unsigned 4 bytes)
//
// HEADER consists of
// Number of items (N) (unsigned 4 bytes)
//
// PAYLOAD consists of
// N occurences of ITEM
//
// ITEM consists of
// GUID (16 bytes)
// STRING
//
// STRING is string represented however BinaryWriter/BinaryReader represent it
//When allocating initial memory we'll guess that each string is on average 100 bytes including the header
const uint BYTES_PER_STRING_GUESS = 100;
var data = localization.ExistingLocalizations.ToDictionary(x => x, x => localization.Localize(x));
stream.SetLength(data.Count * BYTES_PER_STRING_GUESS); //Header size is negligible
uint VERSION = 0;
using (var binaryWriter = new BinaryWriter(stream, Encoding.UTF8, true))
{
binaryWriter.Write(VERSION);
binaryWriter.Write((uint)data.Count);
foreach (var kvp in data)
{
var guidBytes = kvp.Key.Guid.ToByteArray();
binaryWriter.Write(guidBytes, 0, guidBytes.Length);
binaryWriter.Write(kvp.Value);
}
}
stream.SetLength(stream.Position);
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="path"></param>
/// <param name="fileFormat"></param>
/// <param name="overridePattern"></param>
/// <param name="mode"></param>
/// <returns></returns>
static public int BatchImportToSingleLanguageDB(SingleLanguageDB db, string path, LocalizationFileFormat fileFormat,
string overridePattern = null, LocalizationDB.ImportMode mode = LocalizationDB.ImportMode.kReplace)
{
if (!Directory.Exists(path))
{
return(0);
}
string pattern = overridePattern != null ? overridePattern : fileFormat.GetLocalizationFileInstance().DefaultNamePattern();
int totalCount = 0;
foreach (var filename in Directory.EnumerateFiles(path, pattern))
{
ILocalizationFile file = fileFormat.GetLocalizationFileInstance();
file.Read(filename);
totalCount += ImportToSingleLanguageDBFromFile(db, file, mode);
}
return(totalCount);
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="reference"></param>
/// <param name="output"></param>
/// <returns></returns>
static public bool ExportLocalization(SingleLanguageDB db, ILocalizationFile reference, ILocalizationFile output)
{
// for now, all input file will be marked as english...
if (!reference.VerifyHeader("english"))
{
return(false);
}
output.GenHeader("english");
int count = reference.CountLines();
if (count > 0)
{
for (int i = reference.HeaderLines(); i < count; ++i)
{
if (reference.IsLineLocalizationData(i))
{
string tag = "";
int ver = 0;
string data = "";
string rest = "";
reference.GetData(i, ref tag, ref ver, ref data, ref rest);
if (db != null)
{
string localizeddata = db.LookupText(tag, ver);
if (localizeddata != null)
{
output.AppendLine(tag, ver, localizeddata, rest);
continue;
}
}
output.AppendLine(tag, ver, data, rest);
}
else
{
string data = "";
reference.GetNonLocalizationData(i, ref data);
output.AppendLine(null, 0, data, null);
}
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="refPath"></param>
/// <param name="refFileFormat"></param>
/// <param name="overrideRefPattern"></param>
/// <param name="outPath"></param>
/// <param name="outFileFormat"></param>
/// <param name="splitLine"></param>
/// <returns></returns>
static public bool BatchExportLocalization(SingleLanguageDB db,
string refPath, LocalizationFileFormat refFileFormat, string overrideRefPattern,
string outPath, LocalizationFileFormat outFileFormat, int splitLine = 0)
{
if (!Directory.Exists(refPath))
{
return(false);
}
string refpattern = overrideRefPattern != null ? overrideRefPattern : refFileFormat.GetLocalizationFileInstance().DefaultNamePattern();
foreach (var filename in Directory.EnumerateFiles(refPath, refpattern))
{
ILocalizationFile reffile = refFileFormat.GetLocalizationFileInstance();
reffile.Read(filename);
ILocalizationFile outfile = outFileFormat.GetLocalizationFileInstance();
if (!outfile.CanWrite())
{
continue;
}
if (!ExportLocalization(db, reffile, outfile))
{
continue;
}
string newName = Path.GetFileNameWithoutExtension(filename);
Directory.CreateDirectory(outPath);
if (splitLine <= 0)
{
outfile.Write(outPath + "\\" + newName + "." + outfile.DefaultExtension());
}
else
{
int count = outfile.CountLines();
if (count > 0)
{
ILocalizationFile splitFile = outFileFormat.GetLocalizationFileInstance();
splitFile.GenHeader("english");
int contentCount = 0;
int fileCount = 1;
for (int i = outfile.HeaderLines(); i < count; ++i)
{
if (contentCount >= splitLine)
{
splitFile.Write(outPath + "\\" + newName + "-" + fileCount.ToString() + "." + splitFile.DefaultExtension());
fileCount++;
contentCount = 0;
if (i != count - 1)
{
splitFile = outFileFormat.GetLocalizationFileInstance();
splitFile.GenHeader("english");
}
}
if (outfile.IsLineLocalizationData(i))
{
string tag = "";
int ver = 0;
string data = "";
string rest = "";
outfile.GetData(i, ref tag, ref ver, ref data, ref rest);
splitFile.AppendLine(tag, ver, data, rest);
contentCount++;
}
else
{
string data = "";
outfile.GetNonLocalizationData(i, ref data);
splitFile.AppendLine(null, 0, data, null);
}
}
splitFile.Write(outPath + "\\" + newName + "-" + fileCount.ToString() + "." + splitFile.DefaultExtension());
}
}
}
return(true);
}
