/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings.
/// </summary>
/// <param name="store">Store to parse into.</param>
/// <param name="tokeniser">Tokeniser to use.</param>
/// <param name="traceParsing">Whether to trace parsing.</param>
/// <param name="traceTokeniser">Whether to trace tokenisation.</param>
public TokenisingStoreParserContext(ITripleStore store, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(store, tokeniser)
{
_traceParsing = traceParsing;
_traceTokeniser = traceTokeniser;
_queue.Tracing = _traceTokeniser;
}
/// <summary>
/// Executes the RUN command.
/// </summary>
/// <param name="tokeniser">Tokeniser used by the load command.</param>
public void Execute(ITokeniser tokeniser)
{
var nextToken = _runEnvironment.CurrentLine.NextToken();
if (nextToken.TokenClass == TokenClass.String)
{
// Since we have a tokeniser, we can just fake being the executor/interpreter
// and create our own LOAD command and call it.
var oldLine = _runEnvironment.CurrentLine;
_runEnvironment.CurrentLine = tokeniser.Tokenise($"LOAD {nextToken}");
var loadToken = _runEnvironment.CurrentLine.NextToken() as ITokeniserCommand;
loadToken.Execute(tokeniser);
_runEnvironment.CurrentLine = oldLine;
}
else
{
_runEnvironment.CurrentLine.PushToken(nextToken);
}
_variableRepository.Clear();
_runEnvironment.Clear();
_dataStatementReader.RestoreToLineNumber(null);
int?startingLineNumber = _runEnvironment.CurrentLine.GetLineNumber();
_runEnvironment.CurrentLine = startingLineNumber.HasValue ?
_programRepository.GetLine(startingLineNumber.Value) :
_programRepository.GetFirstLine();
}
public Deployer(ITemplateManager templateManager, IProvisionManager provisioningManager, IHandlerFactory handlerFactory, ITokeniser tokeniser)
{
this.templateManger = templateManager;
this.provisioningManager = provisioningManager;
this.handlerFactory = handlerFactory;
this.tokeniser = tokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingParserContext(IGraph g, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(g, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Executes the LOAD comand.
/// </summary>
/// <param name="tokeniser">Tokeniser to use.</param>
public void Execute(ITokeniser tokeniser)
{
var fileName = _expressionEvaluator.GetExpression().ValueAsString();
int lastProgramLine = 0;
try
{
var program = _fileSystem.File.ReadAllLines(fileName, System.Text.Encoding.UTF8);
_programRepository.Clear();
foreach (var line in program)
{
var programLine = tokeniser.Tokenise(line);
if (!programLine.LineNumber.HasValue)
{
throw new Exception("MISSING LINE NUMBER");
}
lastProgramLine = programLine.LineNumber.Value;
_programRepository.SetProgramLine(programLine);
}
}
catch (Exception ex)
{
throw new Exceptions.BasicException($"BAD LOAD {ex.Message}, LAST GOOD LINE WAS {lastProgramLine}", 100);
}
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="handler">RDF Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingParserContext(IRdfHandler handler, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(handler, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="results">Result Set to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(results, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(ISparqlResultsHandler handler, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(handler, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings.
/// </summary>
/// <param name="handler">Store to parse into.</param>
/// <param name="tokeniser">Tokeniser to use.</param>
/// <param name="traceParsing">Whether to trace parsing.</param>
/// <param name="traceTokeniser">Whether to trace tokenisation.</param>
public TokenisingStoreParserContext(IRdfHandler handler, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(handler, tokeniser)
{
_traceParsing = traceParsing;
_traceTokeniser = traceTokeniser;
_queue.Tracing = _traceTokeniser;
}
public TokenisationRunner(IFileSystem fileSystem, ITokeniser tokeniser)
{
Args.NotNull(fileSystem, "fileSystem");
Args.NotNull(tokeniser, "tokeniser");
this.fileSystem = fileSystem;
this.tokeniser = tokeniser;
}
public static void SetupSut(TestContext context)
{
var builder = new ContainerBuilder();
RegisterTypes.Register(builder);
builder.RegisterInstance(new MockTeletype()).As <ITeletype>();
var container = builder.Build();
_tokeniser = container.Resolve <ITokeniser>();
}
public HttpTokenReader(ITokeniser tokeniser = null, Encoding encoding = null, TextMimeType mimeType = TextMimeType.Default, Func<Uri, bool> linkFilter = null, Func<XNode, bool> nodeFilter = null, Func<XElement, IEnumerable<string>> linkExtractor = null)
{
_client = new HttpClient();
_visited = new HashSet<Uri>();
_tokeniser = tokeniser ?? new Tokeniser();
_encoding = encoding ?? Encoding.UTF8;
_mimeType = mimeType;
_nodeFilter = nodeFilter ?? HtmlTextNodeFilter.Filter;
_linkFilter = linkFilter ?? (_ => true);
_linkExtractor = linkExtractor ?? (e => e.Descendants().Where(x => x.Name.LocalName == "a").Select(a => a.Attribute("href")).Where(a => a != null).Select(a => a.Value));
}
/// <summary>
/// Initializes a new instance of the <see cref="Executor"/> class.
/// </summary>
/// <param name="teletype">Teletype to use for input output.</param>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program repository.</param>
/// <param name="tokensProvider">Provider of tokens.</param>
/// <param name="tokeniser">Tokeniser to pass to ITokeniserCommands.</param>
public Executor(
ITeletype teletype,
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
ITokensProvider tokensProvider,
ITokeniser tokeniser)
{
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_tokeniser = tokeniser;
_letToken = tokensProvider.Tokens.Find(t => t.Statement == TokenType.Let);
teletype.CancelEventHandler += InterruptExecution;
}
/// <summary>
/// Initializes a new instance of the <see cref="Interpreter"/> class.
/// </summary>
/// <param name="teletypeWithPosition">Teletype to use for input output.</param>
/// <param name="tokeniser">Tokeniser.</param>
/// <param name="runEnvironment">Run time environment.</param>
/// <param name="programRepository">Program repository.</param>
/// <param name="executor">Executor class to run program lines.</param>
public Interpreter(
ITeletypeWithPosition teletypeWithPosition,
ITokeniser tokeniser,
IRunEnvironment runEnvironment,
IProgramRepository programRepository,
IExecutor executor)
{
_teletypeWithPosition = teletypeWithPosition;
_tokeniser = tokeniser;
_runEnvironment = runEnvironment;
_programRepository = programRepository;
_executor = executor;
}
public static void SetupTokeniser(TestContext context)
{
_mockTeletype = new MockTeletype();
var builder = new ContainerBuilder();
RegisterTypes.Register(builder);
builder.RegisterInstance(_mockTeletype).As <ITeletype>();
var container = builder.Build();
_tokeniser = container.Resolve <ITokeniser>();
_runEnvironment = container.Resolve <IRunEnvironment>();
_variableRepository = container.Resolve <IVariableRepository>();
}
public void Parse(ITokeniser tokeniser)
{
tokens = new List <Token>();
var queue = new Queue <Token>();
Token token = tokeniser.GetNextToken();
while (token != null)
{
tokens.Add(token);
queue.Enqueue(token);
token = tokeniser.GetNextToken();
}
grammarian.LoadTokens(queue);
Tree = grammarian.ParseClass();
}
public ConsoleBASICInterpreter()
{
BASICRunEnvironment = new RunEnvironment();
BASICProgramRepository = new ProgramRepository();
BASICVariableRepository = new VariableRepository();
BASICDataStatement = new DataStatementReader(BASICRunEnvironment, BASICProgramRepository);
BASICExpresionEval = new ExpressionEvaluator(BASICVariableRepository, BASICRunEnvironment);
BASICTokensProvider = new TokensProvider(new IToken[] {
new ClassicBasic.Interpreter.Commands.Clear(BASICRunEnvironment, BASICVariableRepository, BASICDataStatement),
new ClassicBasic.Interpreter.Commands.Cont(BASICRunEnvironment, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.Data(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.Def(BASICRunEnvironment, BASICExpresionEval),
new ClassicBasic.Interpreter.Commands.Del(BASICRunEnvironment, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.Dim(BASICRunEnvironment, BASICExpresionEval, BASICVariableRepository),
new ClassicBasic.Interpreter.Commands.Dim(BASICRunEnvironment, BASICExpresionEval, BASICVariableRepository),
new ClassicBasic.Interpreter.Commands.Edit(BASICRunEnvironment, BASICProgramRepository, this),
new ClassicBasic.Interpreter.Commands.Else(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.End(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.For(BASICRunEnvironment, BASICExpresionEval, BASICVariableRepository),
//new ClassicBasic.Interpreter.Commands.Get(BASICRunEnvironment,BASICExpresionEval,this),
new ClassicBasic.Interpreter.Commands.Gosub(BASICRunEnvironment, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.Goto(BASICRunEnvironment, BASICExpresionEval, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.If(BASICRunEnvironment, BASICExpresionEval, BASICProgramRepository),
//new ClassicBasic.Interpreter.Commands.Input(BASICRunEnvironment,BASICExpresionEval,BASICVariableRepository, this),
new ClassicBasic.Interpreter.Commands.Let(BASICRunEnvironment, BASICExpresionEval),
new ClassicBasic.Interpreter.Commands.List(BASICProgramRepository, this, BASICRunEnvironment),
//new ClassicBasic.Interpreter.Commands.Load(BASICRunEnvironment,BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.New(BASICRunEnvironment, BASICProgramRepository, BASICVariableRepository, BASICDataStatement),
new ClassicBasic.Interpreter.Commands.Next(BASICRunEnvironment, BASICVariableRepository),
new ClassicBasic.Interpreter.Commands.On(BASICRunEnvironment, BASICExpresionEval, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.OnErr(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.Pop(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.Print(BASICRunEnvironment, BASICExpresionEval, this),
new ClassicBasic.Interpreter.Commands.Read(BASICRunEnvironment, BASICExpresionEval, BASICDataStatement),
new ClassicBasic.Interpreter.Commands.Remark(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.Restore(BASICRunEnvironment, BASICDataStatement),
new ClassicBasic.Interpreter.Commands.Resume(BASICRunEnvironment, BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.Return(BASICRunEnvironment),
new ClassicBasic.Interpreter.Commands.Run(BASICRunEnvironment, BASICProgramRepository, BASICVariableRepository, BASICDataStatement),
//new ClassicBasic.Interpreter.Commands.Save(BASICRunEnvironment,BASICProgramRepository),
new ClassicBasic.Interpreter.Commands.Stop(BASICRunEnvironment),
});
BASICTokeniser = new Tokeniser(BASICTokensProvider);
BASICExecutor = new ExecutorFrameBased(this, BASICRunEnvironment, BASICProgramRepository, BASICTokensProvider, BASICTokeniser);
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public TokenisingParserContext(IGraph g, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(g)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings.
/// </summary>
/// <param name="store">Store to parse into.</param>
/// <param name="tokeniser">Tokeniser to use.</param>
/// <param name="queueMode">Tokeniser Queue Mode.</param>
public TokenisingStoreParserContext(ITripleStore store, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(store)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
_queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
_queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
_queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings.
/// </summary>
/// <param name="results">Result Set to parse into.</param>
/// <param name="tokeniser">Tokeniser to use.</param>
/// <param name="queueMode">Tokeniser Queue Mode.</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(results)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
_queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
_queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
_queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public TokenisingResultParserContext(ISparqlResultsHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(handler)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings.
/// </summary>
/// <param name="handler">Store to parse into.</param>
/// <param name="tokeniser">Tokeniser to use.</param>
/// <param name="queueMode">Tokeniser Queue Mode.</param>
/// <param name="traceParsing">Whether to trace parsing.</param>
/// <param name="traceTokeniser">Whether to trace tokenisation.</param>
public TokenisingStoreParserContext(IRdfHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(handler, traceParsing)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
_queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
_queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
_queue = new TokenQueue(tokeniser);
break;
}
_traceTokeniser = traceTokeniser;
_queue.Tracing = _traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="results">Result Set to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(results, traceParsing)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Buffered Queue for the given Tokeniser
/// </summary>
/// <param name="tokeniser">Tokeniser to Buffer</param>
public BufferedTokenQueue(ITokeniser tokeniser)
{
this._tokeniser = tokeniser;
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings
/// </summary>
/// <param name="handler">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public TokenisingStoreParserContext(IRdfHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(handler)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Parser Context with default settings
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
public TokenisingResultParserContext(ISparqlResultsHandler handler, ITokeniser tokeniser)
: base(handler)
{
this._queue = new TokenQueue(tokeniser);
}
/// <summary>
/// the tokeniser to use should a different tokeniser be required
/// </summary>
/// <param name="tokeniserToUse"></param>
public MatchingCoefficient(ITokeniser tokeniserToUse) {
tokeniser = tokeniserToUse;
tokenUtilities = new TokeniserUtilities<string>();
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with default settings
/// </summary>
/// <param name="store">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public TokenisingStoreParserContext(ITripleStore store, ITokeniser tokeniser)
: base(store)
{
this._queue = new TokenQueue(tokeniser);
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(g, tokeniser, queueMode, traceParsing, traceTokeniser) { }
/// <summary>
/// constructor
/// </summary>
/// <param name="tokeniserToUse">the tokeniser to use should a different tokeniser be required</param>
public CosineSimilarity(ITokeniser tokeniserToUse) {
tokeniser = tokeniserToUse;
tokenUtilities = new TokeniserUtilities<string>();
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings
/// </summary>
/// <param name="store">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingStoreParserContext(ITripleStore store, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(store, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="results">Result Set to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(results)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingParserContext(IGraph g, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(g, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings
/// </summary>
/// <param name="store">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingStoreParserContext(ITripleStore store, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(store, traceParsing)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new SPARQL Query Parser Context with custom settings
/// </summary>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public SparqlQueryParserContext(ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: base(new NullHandler(), tokeniser, traceParsing, traceTokeniser) { }
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(ISparqlResultsHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(handler, traceParsing)
{
switch (queueMode)
{
case TokenQueueMode.AsynchronousBufferDuringParsing:
this._queue = new AsynchronousBufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.SynchronousBufferDuringParsing:
this._queue = new BufferedTokenQueue(tokeniser);
break;
case TokenQueueMode.QueueAllBeforeParsing:
default:
this._queue = new TokenQueue(tokeniser);
break;
}
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(ISparqlResultsHandler handler, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(handler, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Asynchronous Buffered Queue with the given Tokeniser
/// </summary>
/// <param name="tokeniser">Tokeniser to Buffer</param>
public AsynchronousBufferedTokenQueue(ITokeniser tokeniser)
: base(tokeniser)
{
}
/// <summary>
/// Creates a new Token Queue with the given Tokeniser
/// </summary>
/// <param name="tokeniser">Tokeniser</param>
public TokenQueue(ITokeniser tokeniser)
{
this._tokeniser = tokeniser;
}
/// <summary>
/// Creates a new Tokenising Parser Context with default settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public TokenisingParserContext(IGraph g, ITokeniser tokeniser)
: base(g)
{
this._queue = new TokenQueue(tokeniser);
}
/// <summary>
/// Creates a new Tokenising Parser Context with default settings
/// </summary>
/// <param name="results">Result Set to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser)
: base(results)
{
this._queue = new TokenQueue(tokeniser);
}
/// <summary>
/// Creates a new Notation 3 Parser Context with default settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser)
: base(g, tokeniser) { }
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: base(g, tokeniser, traceParsing, traceTokeniser) { }
/// <summary>
/// Creates a new Notation 3 Parser Context with default settings
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="tokeniser">Tokeniser to use</param>
public Notation3ParserContext(IRdfHandler handler, ITokeniser tokeniser)
: base(handler, tokeniser)
{
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with custom settings
/// </summary>
/// <param name="handler">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingStoreParserContext(IRdfHandler handler, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(handler, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public Notation3ParserContext(IRdfHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(handler, tokeniser, queueMode, traceParsing, traceTokeniser)
{
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(g, tokeniser, queueMode) { }
/// <summary>
/// Creates a new Tokenising Parser Context with custom settings
/// </summary>
/// <param name="results">Result Set to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public TokenisingResultParserContext(SparqlResultSet results, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: this(results, tokeniser)
{
this._traceParsing = traceParsing;
this._traceTokeniser = traceTokeniser;
this._queue.Tracing = this._traceTokeniser;
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(g, tokeniser, queueMode)
{
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(g, tokeniser, queueMode, traceParsing, traceTokeniser)
{
}
/// <summary>
/// constructor
/// </summary>
/// <param name="tokeniserToUse">the tokeniser to use should a different tokeniser be required</param>
public EuclideanDistance(ITokeniser tokeniserToUse)
{
tokeniser = tokeniserToUse;
tokenUtilities = new TokeniserUtilities <string>();
}
/// <summary>
/// the tokeniser to use; should a different tokeniser be required
/// </summary>
/// <param name="tokeniserToUse"></param>
public QGramsDistance(ITokeniser tokeniserToUse) {
tokeniser = tokeniserToUse;
tokenUtilities = new TokeniserUtilities<string>();
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public Notation3ParserContext(IRdfHandler handler, ITokeniser tokeniser, TokenQueueMode queueMode)
: base(handler, tokeniser, queueMode)
{
}
/// <summary>
/// Creates a new SPARQL Update Parser Context with custom settings
/// </summary>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public SparqlUpdateParserContext(ITokeniser tokeniser, TokenQueueMode queueMode, bool traceParsing, bool traceTokeniser)
: base(new NullHandler(), tokeniser, queueMode, traceParsing, traceTokeniser) { }
/// <summary>
/// Creates a new Notation 3 Parser Context with default settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser)
: base(g, tokeniser)
{
}
/// <summary>
/// Creates a new Tokenising Store Parser Context with default settings
/// </summary>
/// <param name="handler">Store to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
public TokenisingStoreParserContext(IRdfHandler handler, ITokeniser tokeniser)
: base(handler)
{
this._queue = new TokenQueue(tokeniser);
}
/// <summary>
/// Creates a new Notation 3 Parser Context with custom settings
/// </summary>
/// <param name="g">Graph to parse into</param>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="traceParsing">Whether to trace parsing</param>
/// <param name="traceTokeniser">Whether to trace tokenisation</param>
public Notation3ParserContext(IGraph g, ITokeniser tokeniser, bool traceParsing, bool traceTokeniser)
: base(g, tokeniser, traceParsing, traceTokeniser)
{
}
/// <summary>
/// Creates a new SPARQL Update Parser Context
/// </summary>
/// <param name="tokeniser">Tokeniser</param>
public SparqlUpdateParserContext(ITokeniser tokeniser)
: base(new NullHandler(), tokeniser) { }
public OverlapCoefficient(ITokeniser tokeniserToUse)
{
this.estimatedTimingConstant = 0.00014000000373926014;
this.tokeniser = tokeniserToUse;
this.tokenUtilities = new TokeniserUtilities <string>();
}
/// <summary>
/// Creates a new SPARQL Update Parser Context with custom settings
/// </summary>
/// <param name="tokeniser">Tokeniser to use</param>
/// <param name="queueMode">Tokeniser Queue Mode</param>
public SparqlUpdateParserContext(ITokeniser tokeniser, TokenQueueMode queueMode)
: base(new NullHandler(), tokeniser, queueMode) { }
