public static ProductionBase <T2> Second <T1, T2>(this ProductionBase <Tuple <T1, T2> > tupleProduction)
{
CodeContract.RequiresArgumentNotNull(tupleProduction, "tupleProduction");
return(tupleProduction.Select(t => t.Item2));
}
public static Parser <IEnumerable <Lexeme> > Many(this Token token)
{
CodeContract.RequiresArgumentNotNull(token, "token");
return(token.AsParser().Many());
}
public static Parser <IEnumerable <Lexeme> > Many <TSeparator>(this Token token, Parser <TSeparator> separator)
{
CodeContract.RequiresArgumentNotNull(token, "parser");
return(token.AsParser().Many(separator));
}
/// <summary>
/// Internal constructor for unit testing.
/// </summary>
internal TelemetryNotificationService(ITelemetryNotificationProvider provider)
{
CodeContract.RequiresArgumentNotNull <ITelemetryNotificationProvider>(provider, "provider");
this.provider = provider;
}
public static Parser <T2> Second <T1, T2>(this Parser <Tuple <T1, T2> > tupleParser)
{
CodeContract.RequiresArgumentNotNull(tupleParser, "tupleParser");
return(tupleParser.Select(t => t.Item2));
}
/// <summary>
/// Creates an instance of the IdentitiyInformatinoProvider
/// </summary>
protected IdentityInformationProvider(Func <IPersistentPropertyBag> createStore)
{
CodeContract.RequiresArgumentNotNull <Func <IPersistentPropertyBag> >(createStore, "createStore");
lazyMachineStore = new Lazy <IPersistentPropertyBag>(createStore);
lazyMachineIdentifiers = new Lazy <Dictionary <string, MachineIdentitifier> >(() => ConfigureIdentities());
}
public DefaultContextPropertyManager(IEnumerable <IPropertyProvider> propertyProviders)
{
CodeContract.RequiresArgumentNotNull <IEnumerable <IPropertyProvider> >(propertyProviders, "propertyProviders");
cancellationTokenSource = new CancellationTokenSource();
this.propertyProviders = propertyProviders.ToList();
}
/// <summary>
/// Check, whether does event match conditions
/// </summary>
/// <param name="telemetryEvent"></param>
/// <returns></returns>
public bool IsEventMatch(TelemetryEvent telemetryEvent)
{
CodeContract.RequiresArgumentNotNull <TelemetryEvent>(telemetryEvent, "telemetryEvent");
return(!Not.IsEventMatch(telemetryEvent));
}
/// <summary>
/// Add session channel
/// </summary>
/// <param name="channel"></param>
public void AddChannel(ISessionChannel channel)
{
CodeContract.RequiresArgumentNotNull <ISessionChannel>(channel, "channel");
channelList.Add(channel);
OnUpdateChannelList();
}
public static ProductionBase <T> Optional <T>(this ProductionBase <T> production)
{
CodeContract.RequiresArgumentNotNull(production, "production");
return(production.Union(Empty(default(T))));
}
public static ProductionBase <Lexeme> Optional(this Token token)
{
CodeContract.RequiresArgumentNotNull(token, "token");
return(token.AsTerminal().Optional());
}
public static ProductionBase <IEnumerable <Lexeme> > Many1(this Token token, Token separator)
{
CodeContract.RequiresArgumentNotNull(token, "token");
return(token.AsTerminal().Many1(separator.AsTerminal()));
}
public static ProductionBase <IEnumerable <T> > Many1 <T>(this ProductionBase <T> production, Token seperator)
{
CodeContract.RequiresArgumentNotNull(production, "production");
return(production.Many1(seperator.AsTerminal()));
}
public static ProductionBase <IEnumerable <T> > Many <T, TSeparator>(this ProductionBase <T> production, ProductionBase <TSeparator> separator)
{
CodeContract.RequiresArgumentNotNull(production, "production");
return(Empty(new RepeatParserListNode <T>() as IEnumerable <T>).Union(production.Many1(separator)));
}
public T Parse(string source)
{
CodeContract.RequiresArgumentNotNull(source, "source");
return(Parse(new StringReader(source)));
}
public EventProcessorRouter(IPersistentPropertyBag persistentPropertyBag)
{
CodeContract.RequiresArgumentNotNull <IPersistentPropertyBag>(persistentPropertyBag, "persistentPropertyBag");
this.persistentPropertyBag = persistentPropertyBag;
}
internal void AddEdge(DFAEdge edge)
{
CodeContract.RequiresArgumentNotNull(edge, "edge");
m_outEdges.Add(edge);
}
/// <summary>
/// Post telemetry event information
/// </summary>
/// <param name="telemetryEvent"></param>
public void PostEvent(TelemetryEvent telemetryEvent)
{
CodeContract.RequiresArgumentNotNull <TelemetryEvent>(telemetryEvent, "telemetryEvent");
eventBuffer.Enqueue(telemetryEvent);
}
public OSInformationProvider(IRegistryTools registryTools)
{
CodeContract.RequiresArgumentNotNull <IRegistryTools>(registryTools, "registryTools");
this.registryTools = registryTools;
}
public void Assign <U>(Parser <U> assignedParser) where U : class, T
{
CodeContract.RequiresArgumentNotNull(assignedParser, "assignedParser");
Rule = assignedParser.Rule;
}
/// <summary>
/// Adds additional property providers. Used for unit tests.
/// </summary>
/// <param name="propertyProvider"></param>
public void AddPropertyProvider(IPropertyProvider propertyProvider)
{
CodeContract.RequiresArgumentNotNull <IPropertyProvider>(propertyProvider, "propertyProvider");
propertyProviders.Add(propertyProvider);
}
public void Assign(Parser <T> assignedParser)
{
CodeContract.RequiresArgumentNotNull(assignedParser, "assignedParser");
Rule = assignedParser.Rule;
}
public static Parser <Lexeme> AsParser(this Token token)
{
CodeContract.RequiresArgumentNotNull(token, "token");
return(new TokenParser(token, null));
}
public KleeneStarExpression(RegularExpression innerExp)
: base(RegularExpressionType.KleeneStar)
{
CodeContract.RequiresArgumentNotNull(innerExp, "innerExp");
InnerExpression = innerExp;
}
public static Parser <IEnumerable <T> > Many <T, TSeparator>(this Parser <T> parser, Parser <TSeparator> separator)
{
CodeContract.RequiresArgumentNotNull(parser, "parser");
return(parser.Many1(separator).Union(Succeed(new RepeatParserListNode <T>() as IEnumerable <T>)));
}
public T Parse(SourceReader source)
{
CodeContract.RequiresArgumentNotNull(source, "source");
if (!m_isInitialized)
{
OnInitialize();
}
Scanner scanner = m_scanner;
scanner.SetSource(source);
ParserEngine engine = new ParserEngine(m_transitionTable, m_errorDefinition);
Lexeme r = scanner.Read();
while (true)
{
try
{
engine.Input(r);
}
catch (PanicRecoverException prex)
{
var follow = prex.PossibleFollow;
HashSet <int> validTokens = new HashSet <int>(follow.Select(p =>
{
Terminal t = p as Terminal;
if (t != null)
{
return(t.Token.Index);
}
else
{
return(m_scannerInfo.EndOfStreamTokenIndex);
}
}));
while (!validTokens.Contains(r.TokenIndex) && !r.IsEndOfStream)
{
r = scanner.Read();
}
continue;
}
if (r.IsEndOfStream)
{
break;
}
r = scanner.Read();
}
if (engine.AcceptedCount == 0)
{
throw new ParsingFailureException("There's no parsing result");
}
if (engine.AcceptedCount > 1 && engine.GetResultInfo(0).ErrorCount == 0)
{
throw new ParsingFailureException("Multiple parsing results are found. There's ambiguity in your grammar");
}
object result = engine.GetResult(0, m_errorManager);
return((T)result);
}
public static Parser <Lexeme> AsParser(this Token token, int lexerStateIndex)
{
CodeContract.RequiresArgumentNotNull(token, "token");
return(new TokenParser(token, lexerStateIndex));
}
public T Parse(TextReader source)
{
CodeContract.RequiresArgumentNotNull(source, "source");
return(Parse(new SourceReader(source)));
}
public static Parser <IEnumerable <T> > Many <T>(this Parser <T> parser, Token separator)
{
CodeContract.RequiresArgumentNotNull(parser, "parser");
return(parser.Many(separator.AsParser()));
}
public TelemetryVsOptinStatusReader(IRegistryTools2 registryTools)
{
CodeContract.RequiresArgumentNotNull <IRegistryTools2>(registryTools, "registryTools");
this.registryTools = registryTools;
}
