public Parser <TSchema, LayoutMatch <TLayout> > CreateQuery(LayoutParserOptions options, IQueryBuilder <TSchema> queryBuilder)
{
Parser <TSchema, TEntity> parser = queryBuilder.Select <TEntity>();
var listParser = _required ? parser.OneOrMore() : parser.ZeroOrMore();
return(new EntityListLayoutParser <TLayout, TSchema, TEntity>(listParser, this));
}
public Parser <TSchema, LayoutMatch <TLayout> > CreateQuery(LayoutParserOptions options, IQueryBuilder <TSchema> queryBuilder)
{
Parser <TSchema, T> parser = _layout.CreateParser(options, queryBuilder);
var listParser = _required ? parser.OneOrMore() : parser.ZeroOrMore();
return(new LayoutListLayoutParser <TLayout, TSchema, T>(listParser, this));
}
/// <summary>
/// Create a query using the document to infer the schema type, which is not specifically tied to the document, but easy to discover.
/// It's better to create a query using <see cref="Query{TSchema}.Create{T}"/> in advance, but really no difference.
/// </summary>
/// <param name="entityResult">A parsed text</param>
/// <param name="parserFactory"></param>
/// <param name="options"></param>
/// <typeparam name="T">The query result type</typeparam>
/// <typeparam name="TSchema">The schema type</typeparam>
/// <returns></returns>
public static Parser <TSchema, T> CreateQuery <TSchema, T>(this EntityResult <TSchema> entityResult, ILayoutParserFactory <T, TSchema> parserFactory,
LayoutParserOptions options = LayoutParserOptions.None)
where TSchema : Entity
where T : Layout
{
return(Query <TSchema> .Create(qb => parserFactory.CreateParser(options, qb)));
}
public IQueryParser <TSchema, T> Layout <T>(LayoutParserOptions options = LayoutParserOptions.None)
where T : Layout
{
if (_schema.TryGetLayout(out ILayoutParserFactory <T, TSchema> layout))
{
return(new EntityQueryParser <TSchema, T>(layout.CreateParser(options, this)));
}
throw new LayoutMissingException($"The layout was not found: {TypeCache<T>.ShortName}");
}
public IParser <TSchema, LayoutMatch <TLayout> > CreateQuery(LayoutParserOptions options, IQueryBuilder <TSchema> queryBuilder)
{
IParser <TSchema, T> parser = _layout.CreateParser(options, queryBuilder);
if (_required == false)
{
parser = parser.Optional();
}
return(new LayoutLayoutParser <TLayout, TSchema, T>(parser, this));
}
public Parser <TSchema, LayoutMatch <TLayout> > CreateQuery(LayoutParserOptions options, IQueryBuilder <TSchema> queryBuilder)
{
Parser <TSchema, TEntity> parser = queryBuilder.Select <TEntity>();
if (_required == false)
{
parser = parser.Optional();
}
return(new EntityLayoutParser <TLayout, TSchema, TEntity>(parser, this));
}
/// <summary>
/// Parse the parsed input from the beginning, create a new cursor, building the query on the fly
/// </summary>
/// <param name="entityResult"></param>
/// <param name="selector">The layout selector</param>
/// <param name="options"></param>
/// <typeparam name="TSchema"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <returns></returns>
public static Result <Cursor <TSchema>, TResult> Query <TSchema, TResult>(this EntityResult <TSchema> entityResult, QueryLayoutSelector <TSchema, TResult> selector,
LayoutParserOptions options = LayoutParserOptions.None)
where TSchema : Entity
where TResult : Layout
{
ILayoutParserFactory <TResult, TSchema> layout;
if (!entityResult.Schema.TryGetLayout(out layout))
{
throw new ArgumentException($"The layout was not found: {TypeCache<TResult>.ShortName}");
}
IParser <TSchema, TResult> query = entityResult.CreateQuery(q => layout.CreateParser(options, q));
var cursor = entityResult.GetCursor();
return(query.Parse(cursor));
}
public Parser <TSchema, TLayout> CreateParser(LayoutParserOptions options, IQueryBuilder <TSchema> queryBuilder)
{
var queries = _properties.Select(property => property.CreateQuery(options, queryBuilder)).ToArray();
return(new LayoutParser <TLayout, TSchema>(_factory, queries));
}
