/// <summary>
/// Create a query parser, which can be used to query a parsed document into a matching structure.
/// </summary>
/// <param name="buildQuery">Callback to build the query</param>
/// <typeparam name="T">The query result type</typeparam>
/// <returns>A parser containing the built query</returns>
public static Parser <TSchema, T> Create <T>(QueryBuilderCallback <TSchema, T> buildQuery)
{
if (buildQuery == null)
{
throw new ArgumentNullException(nameof(buildQuery));
}
var queryBuilder = new QueryBuilder <TSchema>();
Parser <TSchema, T> result = buildQuery(queryBuilder);
if (result == null)
{
throw new MacheteException("The query builder returned null");
}
return(result);
}
/// <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="buildQuery">Callback to build the query</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, QueryBuilderCallback <TSchema, T> buildQuery)
where TSchema : Entity
{
return(Query <TSchema> .Create(buildQuery));
}
/// <summary>
/// Parse the parsed input from the beginning, create a new cursor, building the query on the fly
/// </summary>
/// <param name="parsed"></param>
/// <param name="buildQuery"></param>
/// <typeparam name="TSchema"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <returns></returns>
public static Result <Cursor <TSchema>, TResult> Query <TSchema, TResult>(this Parsed <TSchema> parsed, QueryBuilderCallback <TSchema, TResult> buildQuery)
where TSchema : Entity
{
var query = Query <TSchema> .Create(buildQuery);
var cursor = parsed.GetCursor();
return(query.Parse(cursor));
}
/// <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="buildQuery"></param>
/// <typeparam name="TSchema"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <returns></returns>
public static Result <Cursor <TSchema>, TResult> Query <TSchema, TResult>(this EntityResult <TSchema> entityResult, QueryBuilderCallback <TSchema, TResult> buildQuery)
where TSchema : Entity
{
var query = Query <TSchema> .Create(entityResult.Schema, buildQuery);
var cursor = entityResult.GetCursor();
return(query.Parse(cursor));
}
/// <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="schema">A parsed text</param>
/// <param name="buildQuery">Callback to build the query</param>
/// <typeparam name="T">The query result type</typeparam>
/// <typeparam name="TSchema">The schema type</typeparam>
/// <returns></returns>
public static IParser <TSchema, T> CreateQuery <TSchema, T>(this ISchema <TSchema> schema, QueryBuilderCallback <TSchema, T> buildQuery)
where TSchema : Entity
{
return(Query <TSchema> .Create(schema, buildQuery));
}
