public override void Run(IDataAdapter adapter, Logger logger)
{
DataFrame frame = null;
DataFrameFilterExpression filters = Config.CreateFilters();
if (!String.IsNullOrWhiteSpace(Config.TagOnStart))
{
LogPacket[] packets = Config.Packets.GetPacketsByTag(Config.TagOnStart);
for (int i = 0; i < Config.RepeatOnStart; ++i)
{
SendPacketLog(adapter, packets, logger);
}
}
do
{
frame = adapter.Read();
if (frame != null)
{
if (filters.IsMatch(frame, Meta, GlobalMeta, null, Guid.Empty, null))
{
if (!String.IsNullOrWhiteSpace(Config.TagOnMatch))
{
LogPacket[] packets = Config.Packets.GetPacketsByTag(Config.TagOnMatch);
for (int i = 0; i < Config.RepeatOnMatch; ++i)
{
SendPacketLog(adapter, packets, logger);
}
}
if (Config.CloseAfterMatch)
{
break;
}
}
else
{
if (!String.IsNullOrWhiteSpace(Config.TagOnNonMatch))
{
LogPacket[] packets = Config.Packets.GetPacketsByTag(Config.TagOnNonMatch);
for (int i = 0; i < Config.RepeatOnNonMatch; ++i)
{
SendPacketLog(adapter, packets, logger);
}
}
if (Config.CloseAfterNonMatch)
{
break;
}
}
}
}while (frame != null);
}
/// <summary>
/// Create the filter list
/// </summary>
/// <returns></returns>
internal DataFrameFilterExpression CreateFilters()
{
DataFrameFilterExpression filters = new DataFrameFilterExpression(MatchAllFilters);
if (Filters != null)
{
foreach (DataFrameFilterFactory factory in Filters)
{
filters.Add(factory.CreateFilter());
}
}
return(filters);
}
/// <summary>
/// Create a new pipeline node based on this factory
/// </summary>
/// <param name="graph">The netgraph associated with this node</param>
/// <param name="logger">The logger associated with the graph</param>
/// <param name="stateDictionary">A dictionary which can be used to store construction state</param>
/// <returns>The new node</returns>
public BasePipelineNode Create(Logger logger, NetGraph graph, Dictionary <string, object> stateDictionary)
{
BasePipelineNode node = null;
try
{
node = OnCreate(logger, graph, stateDictionary);
if (node != null)
{
foreach (var pair in Properties)
{
node.Properties[pair.Key] = pair.Value;
}
DataFrameFilterExpression filters = new DataFrameFilterExpression(MatchAllFilters);
foreach (DataFrameFilterFactory factory in Filters)
{
if (factory.Enabled)
{
filters.Add(factory.CreateFilter());
}
}
node.Filters = filters;
node.Enabled = Enabled;
node.SelectionPath = SelectionPath;
node.Hidden = Hidden;
node.LogInput = LogInput;
node.LogOutput = LogOutput;
}
}
catch (Exception e)
{
throw new NodeFactoryException(String.Format(CANAPE.Properties.Resources.BaseNodeFactory_Create, this.Label, e.Message), e);
}
return(node);
}
public override void Run(DataAdapters.IDataAdapter adapter, Logger logger)
{
LogPacket[] packets = Config.GetPackets();
DataFrameFilterExpression filters = Config.CreateFilters();
int pos = 0;
int repeat = 0;
bool finished = false;
bool sendatstart = Config.SendAtStart;
do
{
bool matchedFrame = false;
if (sendatstart)
{
matchedFrame = true;
sendatstart = false;
}
else
{
DataFrame frame = adapter.Read();
if ((frame == null) || (finished && Config.CloseAfterSend))
{
break;
}
matchedFrame = filters.IsMatch(frame);
}
if (matchedFrame)
{
if (!finished)
{
// Send if any packets left
if (pos < packets.Length)
{
DataFrame current = packets[pos++].Frame.CloneFrame();
if (Config.ConvertToBasic)
{
current.ConvertToBasic();
}
adapter.Write(current);
}
if (pos == packets.Length)
{
repeat++;
pos = 0;
}
if (repeat >= Config.RepeatCount)
{
finished = true;
if (!Config.WaitForResponseOnClose && Config.CloseAfterSend)
{
break;
}
}
}
}
}while (true);
}
