public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage,
Codepage suggestedCodepage, INativeTextLocationMessageReporter messageReporter,
ISettingsGroup settingsGroup)
{
var info = new SniffInfo();
try
{
_packageModel = _packageService.GetPackageModel();
var sourceLanguageExtension = string.Empty;
if (_packageModel != null)
{
sourceLanguageExtension = _packageModel.LanguagePairs[0].SourceLanguage.ThreeLetterWindowsLanguageName;
}
if (File.Exists(nativeFilePath))
{
// call method to check if file is supported
info.IsSupported = IsFileSupported(nativeFilePath, sourceLanguageExtension);
// call method to determine the file language pair
GetFileLanguages(ref info, nativeFilePath);
}
else
{
info.IsSupported = true;
}
}
catch (Exception ex)
{
Log.Logger.Error($"Sniff method: {ex.Message}\n {ex.StackTrace}");
}
return(info);
}
public SniffInfo Sniff(string nativeFilePath, Language language,
Codepage suggestedCodepage, INativeTextLocationMessageReporter messageReporter, ISettingsGroup settingsGroup)
{
var sniffer = new Sdl.Sdk.FileTypeSupport.Samples.SimpleText.SimpleTextSniffer();
return(sniffer.Sniff(nativeFilePath, language, suggestedCodepage, messageReporter, settingsGroup));
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage,
Codepage suggestedCodepage, INativeTextLocationMessageReporter messageReporter,
ISettingsGroup settingsGroup)
{
var info = new SniffInfo();
_fileService = new FileService();
var packageModel = _packageService.GetPackageModel();
var sourceLanguageExtension = string.Empty;
if (packageModel != null)
{
sourceLanguageExtension = packageModel.LanguagePairs[0].SourceLanguage.ThreeLetterWindowsLanguageName;
}
if (File.Exists(nativeFilePath))
{
// call method to check if file is supported
info.IsSupported = IsFileSupported(nativeFilePath, sourceLanguageExtension);
// call method to determine the file language pair
SetFileLanguages(ref info);
}
else
{
info.IsSupported = false;
}
return(info);
}
/// <summary>
/// Constructor of class from stream
/// </summary>
/// <param name="stream">Stream that send data whom</param>
/// <param name="stream">Codepage for save string</param>
public XlsExportBIFF2(Stream stream, Codepage codepage)
{
if (stream == null)
throw new ArgumentNullException("'stream' is null!");
this.stream = new BinaryWriter(stream);
this.codepage = codepage;
}
public void SetUp()
{
_testLanguage = new Language();
_testCodepage = new Codepage();
_messageReporterMock = A.Fake <INativeTextLocationMessageReporter>();
_settingsGroupMock = A.Fake <ISettingsGroup>();
_lineValidationSessionMock = A.Fake <ILineValidationSession>();
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage,
Codepage suggestedCodepage, INativeTextLocationMessageReporter messageReporter,
ISettingsGroup settingsGroup)
{
SniffInfo info = new SniffInfo();
if (System.IO.File.Exists(nativeFilePath))
{
// call method to check if file is supported
info.IsSupported = IsFileSupported(nativeFilePath);
// call method to determine the file language pair
GetFileLanguages(ref info, nativeFilePath);
}
else
{
info.IsSupported = false;
}
return(info);
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage,
Codepage suggestedCodepage, INativeTextLocationMessageReporter messageReporter,
ISettingsGroup settingsGroup)
{
var info = new SniffInfo();
if (System.IO.File.Exists(nativeFilePath))
{
// call method to check if file is supported
info.IsSupported = IsFileSupported(nativeFilePath);
// call method to determine the file language pair
GetFileLanguages(ref info, nativeFilePath);
}
else
{
info.IsSupported = false;
}
return info;
}
public static void Save()
{
XmlElement config = XmlHelper.CreateDocument(RootTag);
XmlElement dirs = config.EnsureChildElement("Directories");
{
dirs.SetString("Game", GameDirectory);
dirs.SetString("Working", WorkingDirectory);
dirs.SetString("CVS", CVSDirectory);
}
XmlElement reserves = config.EnsureChildElement("Reserves");
{
reserves.SetUInt32("Absolute", AbsoluteReserve);
reserves.SetUInt32("Relative", RelativeReserve);
}
UserTags.Save(config.EnsureChildElement("UserTags"));
Codepage.Serial(config);
config.GetOwnerDocument().Save(ConfigFile);
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage, Codepage suggestedCodepage,
INativeTextLocationMessageReporter messageReporter, ISettingsGroup settingsGroup)
{
try
{
var input = File.ReadAllText(nativeFilePath);
JToken.Parse(input);
}
catch (JsonException e)
{
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, JsonFileTypeResources.Invalid_Json_Format, e.Message);
return(new SniffInfo {
IsSupported = false
});
}
catch (Exception)
{
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, JsonFileTypeResources.Json_Could_Not_Be_Validated, string.Empty);
return(new SniffInfo {
IsSupported = false
});
}
return(new SniffInfo {
IsSupported = true
});
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage, Codepage suggestedCodepage,
INativeTextLocationMessageReporter messageReporter, ISettingsGroup settingsGroup)
{
SniffInfo fileInfo = new SniffInfo();
using (StreamReader _reader = new StreamReader(nativeFilePath))
{
if (_reader.ReadLine().StartsWith("[Version="))
{
fileInfo.IsSupported = true;
}
else
{
fileInfo.IsSupported = false;
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, StringResources.Sniffer_Message,
StringResources.Sniffer_Location);
}
}
return(fileInfo);
}
/// <summary>
/// Auswertung der Optionen
/// </summary>
/// <param name="args"></param>
public void Evaluate(string[] args)
{
if (args == null)
{
return;
}
List <string> InputArray_Tmp = new List <string>();
try {
cmd.Parse(args);
foreach (MyOptions opt in Enum.GetValues(typeof(MyOptions))) // jede denkbare Option testen
{
int optcount = cmd.OptionAssignment((int)opt); // Wie oft wurde diese Option verwendet?
string arg;
if (optcount > 0)
{
switch (opt)
{
case MyOptions.Input:
for (int i = 0; i < optcount; i++)
{
InputArray_Tmp.Add(cmd.StringValue((int)opt, i).Trim());
}
break;
case MyOptions.InputWithSubdirs:
if (cmd.ArgIsUsed((int)opt))
{
InputWithSubdirs = cmd.BooleanValue((int)opt);
}
else
{
InputWithSubdirs = true;
}
break;
case MyOptions.InputListfile:
InputArray_Tmp.AddRange(System.IO.File.ReadAllLines(cmd.StringValue((int)opt)));
for (int i = InputArray_Tmp.Count - 1; i >= 0; i--)
{
InputArray_Tmp[i] = InputArray_Tmp[i].Trim();
if (InputArray_Tmp[i].Length == 0)
{
InputArray_Tmp.RemoveAt(i);
}
}
break;
case MyOptions.Output:
Output = cmd.StringValue((int)opt).Trim();
break;
case MyOptions.OutputOverwrite:
if (cmd.ArgIsUsed((int)opt))
{
OutputOverwrite = cmd.BooleanValue((int)opt);
}
else
{
OutputOverwrite = true;
}
break;
case MyOptions.Info:
if (cmd.ArgIsUsed((int)opt))
{
switch (cmd.UnsignedIntegerValue((int)opt))
{
case 0: ToDo = ToDoType.Info; break;
case 1: ToDo = ToDoType.LongInfo; break;
case 2: ToDo = ToDoType.ExtLongInfo; break;
default: ToDo = ToDoType.VeryLongInfo; break;
}
}
else
{
ToDo = ToDoType.Info;
}
break;
case MyOptions.Split:
if (cmd.ArgIsUsed((int)opt))
{
arg = cmd.StringValue((int)opt);
if (arg == "r")
{
ToDo = ToDoType.SplitRecursive;
}
else if (arg == "j")
{
ToDo = ToDoType.SplitJoin;
}
else if (arg == "rj" || arg == "jr")
{
ToDo = ToDoType.SplitRecursiveJoin;
}
}
else
{
ToDo = ToDoType.Split;
}
break;
case MyOptions.CreateFiles4Mapsource:
for (int i = 0; i < optcount; i++)
{
if (cmd.ArgIsUsed((int)opt, i))
{
arg = cmd.StringValue((int)opt, i);
if (!string.IsNullOrEmpty(arg))
{
if (arg.StartsWith("pid:"))
{
PID.Set(InterpretUInt(arg));
}
else if (arg.StartsWith("fid:"))
{
FID.Set(InterpretUInt(arg));
}
else if (arg.StartsWith("cp:"))
{
Codepage.Set(InterpretUInt(arg));
//} else if (arg.StartsWith("ovno:")) {
// MapsourceOverviewNo.Set(InterpretUInt(arg));
}
else if (arg.StartsWith("ov:"))
{
MapsourceOverviewfile.Set(arg.Substring(3));
}
else if (arg.StartsWith("typ:"))
{
MapsourceTYPfile.Set(arg.Substring(4));
}
else if (arg.StartsWith("tdb:"))
{
MapsourceTDBfile.Set(arg.Substring(4));
}
else if (arg.StartsWith("mdx:"))
{
MapsourceMDXfile.Set(arg.Substring(4));
}
else if (arg.StartsWith("mdr:"))
{
MapsourceMDRfile.Set(arg.Substring(4));
}
else if (arg.StartsWith("tdb:"))
{
MapsourceTDBfile.Set(arg.Substring(4));
}
else if (arg.StartsWith("mindim:"))
{
MapsourceMinDimension.Set(InterpretUInt(arg));
}
else if (arg.StartsWith("points:"))
{
InterpretTypes(arg, MapsourceOVPointtypes);
}
else if (arg.StartsWith("lines:"))
{
InterpretTypes(arg, MapsourceOVLinetypes);
}
else if (arg.StartsWith("areas:"))
{
InterpretTypes(arg, MapsourceOVAreatypes);
}
else if (arg == "noov")
{
MapsourceNoOverviewfile.Set(true);
}
else if (arg == "notyp")
{
MapsourceNoTYPfile.Set(true);
}
else if (arg == "nomdx")
{
MapsourceNoMDXfile.Set(true);
}
else if (arg == "nomdr")
{
MapsourceNoMDRfile.Set(true);
}
else if (arg == "notdb")
{
MapsourceNoTDBfile.Set(true);
}
else if (arg == "noinst")
{
MapsourceNoInstfiles.Set(true);
}
else
{
throw new Exception("unbekanntes Argument: " + arg);
}
}
}
}
ToDo = ToDoType.CreateFiles4Mapsource;
break;
case MyOptions.Join:
if (cmd.ArgIsUsed((int)opt))
{
arg = cmd.StringValue((int)opt);
if (arg == "device")
{
ToDo = ToDoType.JoinDevice;
}
else if (arg == "tile")
{
ToDo = ToDoType.JoinTile;
}
}
else
{
ToDo = ToDoType.Join;
}
break;
case MyOptions.AnalyzingTypes:
switch (cmd.UnsignedIntegerValue((int)opt))
{
case 1: ToDo = ToDoType.AnalyzingTypesLong; break;
default: ToDo = ToDoType.AnalyzingTypes; break;
}
break;
case MyOptions.SetPID:
PID.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetFID:
FID.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetCodepage:
Codepage.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetTDBCopyright:
for (int j = 0; j < optcount; j++)
{
arg = cmd.StringValue((int)opt, j);
if (arg.Length < 3)
{
throw new Exception("Falscher Aufbau der Copyright-Option '" + arg + "'");
}
else
{
switch (arg[0])
{
case 'S':
TDBCopyrightCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.CopyrightCodes.SourceInformation, true));
break;
case 'C':
TDBCopyrightCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.CopyrightCodes.CopyrightInformation, true));
break;
case '*':
TDBCopyrightCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.CopyrightCodes.Unknown, true));
break;
default:
throw new Exception("Falsche Angabe in der Copyright-Option: '" + arg[0] + "'");
}
switch (arg[1])
{
case 'I':
TDBCopyrightWhereCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.WhereCodes.ProductInformation, true));
break;
case 'P':
TDBCopyrightWhereCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.WhereCodes.Printing, true));
break;
case 'E':
TDBCopyrightWhereCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.WhereCodes.ProductInformationAndPrinting, true));
break;
case '*':
TDBCopyrightWhereCodes.Add(new Property((int)GarminCore.Files.File_TDB.SegmentedCopyright.Segment.WhereCodes.Unknown, true));
break;
default:
throw new Exception("Falsche Angabe in der Copyright-Option: '" + arg[1] + "'");
}
switch (arg[2])
{
case 'N':
string sText = arg.Substring(3).Trim();
if (sText.Length >= 2)
{
if (sText[0] == '"' && sText[sText.Length - 1] == '"')
{
sText = sText.Substring(1, sText.Length - 2);
}
}
TDBCopyrightText.Add(new Property(sText, true));
break;
case 'D':
TDBCopyrightText.Add(new Property(null, false));
break;
case '*':
TDBCopyrightText.Add(new Property(null, true));
break;
default:
throw new Exception("Falsche Angabe in der Copyright-Option: '" + arg[1] + "'");
}
}
}
break;
case MyOptions.SetDescription:
Description.Set(cmd.StringValue((int)opt));
break;
case MyOptions.SetTransparent:
Transparent.Set(cmd.BooleanValue((int)opt) ? 1 : 0);
break;
case MyOptions.SetPriority:
Priority.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetMapFamilyName:
MapFamilyName.Set(cmd.StringValue((int)opt));
break;
case MyOptions.SetMapSeriesName:
MapSeriesName.Set(cmd.StringValue((int)opt));
break;
case MyOptions.SetVersion:
Version.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetRoutable:
Routable.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetHighestRoutable:
HighestRoutable.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetHasDEM:
HasDEM.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetHasProfile:
HasProfile.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.SetMaxCoordBits4Overview:
MaxCoordBits4Overview.Set((int)cmd.UnsignedIntegerValue((int)opt));
break;
case MyOptions.RefreshTDB:
ToDo = ToDoType.RefreshTDB;
break;
case MyOptions.NewTypfile:
NewTypfile.Set(cmd.StringValue((int)opt));
ToDo = ToDoType.SetNewTypfile;
break;
case MyOptions.Help:
ShowHelp();
break;
}
}
}
//TestParameter = new string[cmd.Parameters.Count];
//cmd.Parameters.CopyTo(TestParameter);
if (cmd.Parameters.Count > 0)
{
throw new Exception("Es sind keine Argumente sondern nur Optionen erlaubt.");
}
Input = new string[InputArray_Tmp.Count];
InputArray_Tmp.CopyTo(Input);
} catch (Exception ex) {
Console.Error.WriteLine(ex.Message);
ShowHelp();
throw new Exception("Fehler beim Ermitteln oder Anwenden der Programmoptionen.");
}
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage, Codepage suggestedCodepage,
INativeTextLocationMessageReporter messageReporter, ISettingsGroup settingsGroup)
{
try
{
using (var reader = _yamlFactory.CreateYamlTextReader(nativeFilePath))
{
while (reader.Read())
{
}
}
}
catch (YamlException e)
{
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, YamlFileTypeResources.Invalid_Yaml_Format + "(" + e.Message + ")", e.Message);
return(new SniffInfo {
IsSupported = false
});
}
catch (Exception e)
{
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, YamlFileTypeResources.Yaml_Could_Not_Be_Validated, e.Message);
return(new SniffInfo {
IsSupported = false
});
}
return(new SniffInfo {
IsSupported = true
});
}
public SniffInfo Sniff(string nativeFilePath, Language suggestedSourceLanguage, Codepage suggestedCodepage,
INativeTextLocationMessageReporter messageReporter, ISettingsGroup settingsGroup)
{
var lineValidationSession = _lineParser.StartLineValidationSession();
using (var extendedStreamReader = _fileHelper.GetExtendedStreamReader(nativeFilePath))
{
string currentLine;
while ((currentLine = extendedStreamReader.ReadLineWithEofLine()) != null)
{
var isValidLine = lineValidationSession.IsValid(currentLine);
if (isValidLine)
{
continue;
}
var message = string.Format(
PoFileTypeResources.Sniffer_Unexpected_Line,
extendedStreamReader.CurrentLineNumber + ": " + currentLine,
lineValidationSession.NextExpectedLineDescription);
messageReporter.ReportMessage(this, nativeFilePath,
ErrorLevel.Error, message,
extendedStreamReader.CurrentLineNumber + ": " + currentLine);
return(new SniffInfo {
IsSupported = false
});
}
}
return(new SniffInfo {
IsSupported = true
});
}
