public void Can_load_srv_file(TestMessage file)
{
var parser = new ServiceParser(file.Content.Value);
var actual = parser.Parse();
Assert.NotNull(actual);
}
public FileService(IBuildingRepository buildingRepo,
IFileRepository fileRepo,
IRoomRepository roomRepo,
IUnitRepository unitRepo,
IGenericRepository <BuildingCategory> buildingTypeRepo,
IGenericRepository <Guest> guestRepo,
IGenericRepository <Stay> stayRepo,
IGenericRepository <Rank> rankRepo,
IGenericRepository <Service> serviceRepo,
BuildingService buildingsService,
RankParser rankConverter,
ServiceParser serviceParser,
IMapper mapper)
{
_buildingRepo = buildingRepo;
_buildingTypeRepo = buildingTypeRepo;
_fileRepo = fileRepo;
_roomRepo = roomRepo;
_unitRepo = unitRepo;
_guestRepo = guestRepo;
_stayRepo = stayRepo;
_rankRepo = rankRepo;
_serviceRepo = serviceRepo;
_buildingsService = buildingsService;
_rankConverter = rankConverter;
_serviceParser = serviceParser;
_mapper = mapper;
}
private void ParseMessagesInternal()
{
var packageDependencyCollector = new PackageDependencyCollector(new [] { Package.Name });
var typeDependencyCollector = new TypeDependencyCollector(new [] { Package.Name });
var collectors = new RosMessageVisitorListenerCollection(new IRosMessageVisitorListener[]
{ packageDependencyCollector, typeDependencyCollector });
var messages = new List <KeyValuePair <RosTypeInfo, MessageDescriptor> >();
var actions = new List <KeyValuePair <RosTypeInfo, ActionDescriptor> >();
var services = new List <KeyValuePair <RosTypeInfo, ServiceDescriptor> >();
foreach (var messageFile in Package.Messages)
{
using (var fileStream = File.OpenRead(messageFile.FullName))
{
var rosType = RosTypeInfo.CreateRosType(Package.Name, messageFile.NameWithoutExtension());
switch (messageFile.GetRosMessageType())
{
case RosMessageType.Message:
var messageParser = new RobSharper.Ros.MessageParser.MessageParser(fileStream);
var messageDescriptor = messageParser.Parse(collectors);
messages.Add(
new KeyValuePair <RosTypeInfo, MessageDescriptor>(rosType, messageDescriptor));
break;
case RosMessageType.Service:
var serviceParser = new ServiceParser(fileStream);
var serviceDescriptor = serviceParser.Parse(collectors);
services.Add(
new KeyValuePair <RosTypeInfo, ServiceDescriptor>(rosType, serviceDescriptor));
break;
case RosMessageType.Action:
var actionParser = new ActionParser(fileStream);
var actionDescriptor = actionParser.Parse(collectors);
actions.Add(
new KeyValuePair <RosTypeInfo, ActionDescriptor>(rosType, actionDescriptor));
break;
}
}
}
// Add actionlib dependency
if (actions.Any() && !packageDependencyCollector.Dependencies.Contains("actionlib_msgs"))
{
packageDependencyCollector.Dependencies.Add("actionlib_msgs");
}
_packageDependencies = packageDependencyCollector.Dependencies;
_externalTypeDependencies = typeDependencyCollector.Dependencies;
_messages = messages;
_actions = actions;
_services = services;
}
public void ParseFileStream(string filePath)
{
ServiceDescriptor descriptor;
using (var file = File.OpenRead(filePath))
{
var parser = new ServiceParser(file);
descriptor = parser.Parse();
}
}
/// <summary>
/// Ändert die aktuelle Tonspur.
/// </summary>
/// <param name="audio">Name der aktuellen Tonspur gemäß der Senderliste
/// oder <i>null</i> für die bevorzugte Tonspur.</param>
/// <returns>Name des aktuellen Senders und der aktuellen Tonspur.</returns>
public override string SetAudio(string audio)
{
// Not possible
if (null == CurrentSourceConfiguration)
{
return((null == CurrentService) ? StationName : CurrentService.Name);
}
// Ask favorites for default
if (string.IsNullOrEmpty(audio))
{
audio = Favorites.GetPreferredAudio();
}
// Always remember
m_LastAudio = audio;
// Remember if not a service
if (null == CurrentPortal)
{
LocalInfo.LocalAudio = audio;
}
// Audio to use
AudioInformation info = null;
// Try default
if (!string.IsNullOrEmpty(audio))
{
info = CurrentSourceConfiguration.AudioTracks.Find(a => 0 == string.Compare(audio, a.ToString(), true));
}
// Start up
Activate(info);
// Enable service parser if we are allowed to to so
if (!Profile.DisableProgramGuide)
{
if (!Profile.GetFilter(CurrentSourceConfiguration.Source).DisableProgramGuide)
{
// Stop current
if (null != ServiceParser)
{
ServiceParser.Disable();
}
// Create new
ServiceParser = new ServiceParser(Profile, (null == CurrentPortal) ? CurrentSourceConfiguration.Source : CurrentPortal.Source);
}
}
// Report full name
return(string.Format("{0} ({1})", (null == CurrentService) ? StationName : CurrentService.Name, (null == info) ? "-" : info.ToString()));
}
public void Can_parse_empty_service()
{
var message = "---";
var parser = new ServiceParser(message);
var actual = parser.Parse();
Assert.NotNull(actual);
Assert.NotNull(actual.Request);
Assert.NotNull(actual.Response);
Assert.True(actual.Request.IsEmpty);
Assert.True(actual.Response.IsEmpty);
}
/// <summary>
/// Beendet die Datenübertragung in den DirectShow Graphen und zusätzlich
/// eine eventuell laufende Aufzeichnung.
/// </summary>
/// <param name="pictureOnly">Gesetzt, wenn die Aufzeichnung selbst weiter laufen soll.</param>
private void StopReceivers(bool pictureOnly)
{
// Stop all consumers we registered
Device.RemoveProgramGuideConsumer(ReceiveEPG);
Device.SetConsumerState(VideoId, null);
Device.SetConsumerState(AudioId, null);
Device.SetConsumerState(TextId, null);
// Restart videotext caching from scratch
VideoText.Deactivate(true);
// Partial mode
if (pictureOnly)
{
return;
}
// Stop reader
using (var reader = m_InfoReader)
{
// Forget
m_InfoReader = null;
// Enforce proper shutdown
if (reader != null)
{
reader.Cancel();
}
}
// Reset flag
m_HasPendingGroupInformation = false;
// Stop portal parser
if (null != ServiceParser)
{
// Stop it
ServiceParser.Disable();
// Forget it
ServiceParser = null;
}
// Stop recording, too
using (SourceStreamsManager recording = RecordingStream)
RecordingStream = null;
}
/// <summary>
/// Beendet die Auswertung der programmzeitschrift für die NVOD Dienste.
/// </summary>
private void DisableServiceParser()
{
// Stop service parser
if (m_ServiceParser != null)
{
try
{
// Shut down
m_ServiceParser.Disable();
}
catch
{
// Ignore any error
}
finally
{
// Forget
m_ServiceParser = null;
}
}
}
/// <summary>
/// Führt die eintreffenden Aufträge aus.
/// </summary>
private void WorkerThread(object reset)
{
// Always use the configured language
UserProfile.ApplyLanguage();
// Use hardware manager
using (HardwareManager.Open())
{
// Device to use
Hardware device;
// Try to attach profile
try
{
// Open it
device = HardwareManager.OpenHardware(Profile);
// Should reset
if ((bool)reset)
{
device.ResetWakeupDevice();
}
// Report success
ActionDone(null, null);
}
catch (Exception e)
{
// Report error
ActionDone(e, null);
// Did it
return;
}
// Loop
for (var lastIdle = DateTime.UtcNow; m_Running;)
{
// Wait for new item to process
m_Trigger.WaitOne();
// Load operation
var operation = m_Operation;
// Clear
m_Operation = null;
// Process
if (m_Running)
{
if (operation != null)
{
try
{
// Process
var result = operation(device);
// See if there is at least one active source with a program guide running
var withGuide = Streams.Values.FirstOrDefault(stream => stream.IsProgamGuideActive.GetValueOrDefault(false));
// Check for service parser operation
if (m_ServiceParser == null)
{
// Can be activated it at least one source with active program guide
if (withGuide != null)
{
try
{
// Create
m_ServiceParser = new ServiceParser(Profile, withGuide.Manager.Source);
}
catch
{
// Ignore any error
m_ServiceParser = null;
}
}
}
else
{
// Only allowed if there is at least one source with active program guide
if (withGuide == null)
{
DisableServiceParser();
}
}
// Done
if (!ReferenceEquals(result, DelayedOperationTag))
{
ActionDone(null, result);
}
}
catch (Exception e)
{
// Report
ActionDone(e, null);
}
}
}
// See if idle processing should be started
if (m_Running)
{
if ((DateTime.UtcNow - lastIdle).TotalSeconds >= 5)
{
// Run
OnIdle(device);
// Reset
lastIdle = DateTime.UtcNow;
}
}
}
// Reset EPG flag
EPGProgress = null;
// Clear EPG list to preserve memory
m_EPGItems.Clear();
// Reset PSI scan flag
using (var scanner = m_Scanner)
{
// Forget all
m_ScanProgress = -1;
m_Scanner = null;
}
// Just be safe
try
{
// Final cleanup
RemoveAll();
}
catch
{
// Ignore any error
}
}
}
/// <summary>
/// Ändert die aktuelle Tonspur.
/// </summary>
/// <param name="audio">Name der aktuellen Tonspur gemäß der Senderliste
/// oder <i>null</i> für die bevorzugte Tonspur.</param>
/// <returns>Name des aktuellen Senders und der aktuellen Tonspur.</returns>
public override string SetAudio( string audio )
{
// Not possible
if (null == CurrentSourceConfiguration)
return (null == CurrentService) ? StationName : CurrentService.Name;
// Ask favorites for default
if (string.IsNullOrEmpty( audio ))
audio = Favorites.GetPreferredAudio();
// Always remember
m_LastAudio = audio;
// Remember if not a service
if (null == CurrentPortal)
LocalInfo.LocalAudio = audio;
// Audio to use
AudioInformation info = null;
// Try default
if (!string.IsNullOrEmpty( audio ))
info = CurrentSourceConfiguration.AudioTracks.Find( a => 0 == string.Compare( audio, a.ToString(), true ) );
// Start up
Activate( info );
// Enable service parser if we are allowed to to so
if (!Profile.DisableProgramGuide)
if (!Profile.GetFilter( CurrentSourceConfiguration.Source ).DisableProgramGuide)
{
// Stop current
if (null != ServiceParser)
ServiceParser.Disable();
// Create new
ServiceParser = new ServiceParser( Profile, (null == CurrentPortal) ? CurrentSourceConfiguration.Source : CurrentPortal.Source );
}
// Report full name
return string.Format( "{0} ({1})", (null == CurrentService) ? StationName : CurrentService.Name, (null == info) ? "-" : info.ToString() );
}
/// <summary>
/// Beendet die Datenübertragung in den DirectShow Graphen und zusätzlich
/// eine eventuell laufende Aufzeichnung.
/// </summary>
/// <param name="pictureOnly">Gesetzt, wenn die Aufzeichnung selbst weiter laufen soll.</param>
private void StopReceivers( bool pictureOnly )
{
// Stop all consumers we registered
Device.RemoveProgramGuideConsumer( ReceiveEPG );
Device.SetConsumerState( VideoId, null );
Device.SetConsumerState( AudioId, null );
Device.SetConsumerState( TextId, null );
// Restart videotext caching from scratch
VideoText.Deactivate( true );
// Partial mode
if (pictureOnly)
return;
// Stop reader
using (var reader = m_InfoReader)
{
// Forget
m_InfoReader = null;
// Enforce proper shutdown
if (reader != null)
reader.Cancel();
}
// Reset flag
m_HasPendingGroupInformation = false;
// Stop portal parser
if (null != ServiceParser)
{
// Stop it
ServiceParser.Disable();
// Forget it
ServiceParser = null;
}
// Stop recording, too
using (SourceStreamsManager recording = RecordingStream)
RecordingStream = null;
}
/// <summary>
/// Parses input files and generates output files.
/// </summary>
/// <param name="parser">The service parser.</param>
/// <param name="generator">The code generator.</param>
/// <param name="settings">The settings.</param>
/// <returns>The number of updated files.</returns>
public static int GenerateFiles(ServiceParser parser, CodeGenerator generator, FileGeneratorSettings settings)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (settings.InputPath == null)
{
throw new ArgumentException("InputPath required.", nameof(settings));
}
if (settings.OutputPath == null)
{
throw new ArgumentException("OutputPath required.", nameof(settings));
}
if (settings.IndentText != null)
{
if (!generator.RespectsIndentText)
{
throw new ArgumentException("Generator does not support IndentText setting.");
}
generator.IndentText = settings.IndentText;
}
if (settings.NewLine != null)
{
if (!generator.RespectsNewLine)
{
throw new ArgumentException("Generator does not support NewLine setting.");
}
generator.NewLine = settings.NewLine;
}
generator.ApplySettings(settings);
var shouldClean = settings.ShouldClean;
if (shouldClean && !generator.HasPatternsToClean)
{
throw new ArgumentException("Generator does not support ShouldClean setting.");
}
ServiceDefinitionText input;
if (settings.InputPath == "-")
{
input = new ServiceDefinitionText("", Console.In.ReadToEnd());
}
else
{
if (!File.Exists(settings.InputPath))
{
throw new ApplicationException("Input file does not exist: " + settings.InputPath);
}
input = new ServiceDefinitionText(Path.GetFileName(settings.InputPath), File.ReadAllText(settings.InputPath));
}
var service = parser.ParseDefinition(input);
if (settings.ExcludeTags != null)
{
foreach (var excludeTag in settings.ExcludeTags)
{
service = service.ExcludeTag(excludeTag);
}
}
var output = generator.GenerateOutput(service);
var filesToWrite = new List <CodeGenFile>();
var namesToDelete = new List <string>();
var outputIsFile = false;
var writeToConsole = false;
if (generator.SupportsSingleOutput &&
!settings.OutputPath.EndsWith("/", StringComparison.Ordinal) &&
!settings.OutputPath.EndsWith("\\", StringComparison.Ordinal) &&
!Directory.Exists(settings.OutputPath) &&
output.Files.Count == 1)
{
outputIsFile = true;
writeToConsole = settings.OutputPath == "-";
}
var notQuiet = !settings.IsQuiet && !outputIsFile;
foreach (var file in output.Files)
{
var existingFilePath = outputIsFile ? settings.OutputPath : Path.Combine(settings.OutputPath, file.Name);
if (File.Exists(existingFilePath))
{
// ignore CR when comparing files
string Normalize(string text) => settings.IgnoreNewLines ? text.Replace("\r", "") : text;
if (Normalize(file.Text) != Normalize(File.ReadAllText(existingFilePath)))
{
filesToWrite.Add(file);
if (notQuiet)
{
Console.WriteLine("changed " + file.Name);
}
}
}
else
{
filesToWrite.Add(file);
if (notQuiet)
{
Console.WriteLine("added " + file.Name);
}
}
}
if (shouldClean && output.PatternsToClean.Count != 0)
{
var directoryInfo = new DirectoryInfo(settings.OutputPath);
if (directoryInfo.Exists)
{
foreach (var nameMatchingPattern in FindNamesMatchingPatterns(directoryInfo, output.PatternsToClean))
{
if (output.Files.All(x => x.Name != nameMatchingPattern))
{
namesToDelete.Add(nameMatchingPattern);
if (notQuiet)
{
Console.WriteLine("removed " + nameMatchingPattern);
}
}
}
}
}
if (!settings.IsDryRun)
{
if (!outputIsFile && !Directory.Exists(settings.OutputPath))
{
Directory.CreateDirectory(settings.OutputPath);
}
foreach (var fileToWrite in filesToWrite)
{
var outputFilePath = outputIsFile ? settings.OutputPath : Path.Combine(settings.OutputPath, fileToWrite.Name);
var outputFileDirectoryPath = Path.GetDirectoryName(outputFilePath);
if (outputFileDirectoryPath != null && outputFileDirectoryPath != settings.OutputPath && !Directory.Exists(outputFileDirectoryPath))
{
Directory.CreateDirectory(outputFileDirectoryPath);
}
if (writeToConsole)
{
Console.Write(fileToWrite.Text);
}
else
{
File.WriteAllText(outputFilePath, fileToWrite.Text);
}
}
foreach (var nameToDelete in namesToDelete)
{
File.Delete(Path.Combine(settings.OutputPath, nameToDelete));
}
}
return(filesToWrite.Count + namesToDelete.Count);
}
public void ParseFileFContent(string filePath)
{
var parser = new ServiceParser(File.ReadAllText(filePath));
var descriptor = parser.Parse();
}
