static SyntaxTokenWithValue()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxTokenWithValue <T>), r => new SyntaxTokenWithValue <T>(r));
}
static WithLotsOfChildren()
{
ObjectBinder.RegisterTypeReader(typeof(WithLotsOfChildren), r => new WithLotsOfChildren(r));
}
static MissingTokenWithTrivia()
{
ObjectBinder.RegisterTypeReader(typeof(MissingTokenWithTrivia), r => new MissingTokenWithTrivia(r));
}
public override T PerformExecuteSingle <T>(QueryDescription query, ObjectBinder objectBinder)
{
return(default(T));
}
static TypeWithTwoMembers()
{
ObjectBinder.RegisterTypeReader(typeof(TypeWithTwoMembers <T, S>), r => new TypeWithTwoMembers <T, S>(r));
}
static PrimitiveArrayMemberTest()
{
ObjectBinder.RegisterTypeReader(typeof(PrimitiveArrayMemberTest), r => new PrimitiveArrayMemberTest(r));
}
static SyntaxAnnotation()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxAnnotation), r => new SyntaxAnnotation(r));
}
static Node()
{
ObjectBinder.RegisterTypeReader(typeof(Node), r => new Node(r));
}
static SyntaxIdentifierWithTrivia()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifierWithTrivia), r => new SyntaxIdentifierWithTrivia(r));
}
static NamingStylePreferences()
{
ObjectBinder.RegisterTypeReader(typeof(NamingStylePreferences), ReadFrom);
}
public T ExecuteSingle <T>(QueryDescription query, ObjectBinder objectBinder)
{
// TODO: Evaluate query here because it means we can avoid running a whole query if all we need is the first etc.
return(ExecuteMany <T>(query, objectBinder).FirstOrDefault());
}
public T ExecuteScalar <T>(QueryDescription query, ObjectBinder objectBinder)
{
throw new NotImplementedException();
}
public ObjectEnumerator(ObjectBinder objectBinder, DataSourceSelectArguments arguments)
{
_objectBinder = objectBinder;
_arguments = arguments;
}
public abstract T PerformExecuteScalar <T>(QueryDescription query, ObjectBinder objectBinder);
static SyntaxIdentifierExtended()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifierExtended), r => new SyntaxIdentifierExtended(r));
}
public static IEnumerable <T> ExecuteMany <T>(this IEnumerable <IReadonlyEntityRepository> readonlyRepositories, ICoreReadonlyRelationsRepository groupRepo, Uri idRoot, QueryDescription query, ObjectBinder objectBinder)
where T : class, IReferenceByHiveId
{
var totalOutput = new HashSet <T>();
foreach (var reader in readonlyRepositories)
{
reader.ExecuteMany <T>(query, objectBinder).SkipWhile(SkipAndMergeFromProviders(reader.ProviderMetadata, totalOutput)).ForEach(x => totalOutput.Add(x));
}
return(totalOutput.DistinctBy(x => x.Id).Select(x => ProcessIdsAndGroupRelationProxyDelegate(groupRepo, idRoot, x)));
}
static DiagnosticInfo()
{
ObjectBinder.RegisterTypeReader(typeof(DiagnosticInfo), r => new DiagnosticInfo(r));
}
static TypeWithOneMember()
{
ObjectBinder.RegisterTypeReader(typeof(TypeWithOneMember <T>), r => new TypeWithOneMember <T>(r));
}
public ColumnCell (string property, bool expand)
{
Binder = ObjectBinder = new ObjectBinder () { Property = property };
Expand = expand;
}
static TypeWithManyMembers()
{
ObjectBinder.RegisterTypeReader(typeof(TypeWithManyMembers <T>), r => new TypeWithManyMembers <T>(r));
}
static SyntaxDiagnosticInfo()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxDiagnosticInfo), r => new SyntaxDiagnosticInfo(r));
}
static PrimitiveValueTest()
{
ObjectBinder.RegisterTypeReader(typeof(PrimitiveValueTest), r => new PrimitiveValueTest(r));
}
static SyntaxTokenWithTrivia()
{
ObjectBinder.RegisterTypeReader(typeof(SyntaxTokenWithTrivia), r => new SyntaxTokenWithTrivia(r));
}
public override IEnumerable <T> PerformExecuteMany <T>(QueryDescription query, ObjectBinder objectBinder)
{
return(Enumerable.Empty <T>());
}
public override IEnumerable <T> PerformExecuteMany <T>(QueryDescription query, ObjectBinder objectBinder)
{
//var direction = query.From.HierarchyScope;
var results = Helper.PerformGetByQuery <T>(query, objectBinder);
switch (query.ResultFilter.ResultFilterType)
{
case ResultFilterType.Count:
//this is weird but returns an integer
return(new[] { results.Count() }.Cast <T>());
case ResultFilterType.Take:
results = results.Take(query.ResultFilter.SelectorArgument);
break;
}
if (typeof(T).IsAssignableFrom(query.ResultFilter.ResultType))
{
return(results.Distinct().Select(node => FrameworkContext.TypeMappers.Map <T>(node)));
}
return(Enumerable.Empty <T>());
}
static LocalizableResourceString()
{
ObjectBinder.RegisterTypeReader(typeof(LocalizableResourceString), reader => new LocalizableResourceString(reader));
}
public virtual IQueryable <TSpecific> Query <TSpecific>(ObjectBinder objectBinder)
{
return(new Queryable <TSpecific>(new Executor(QueryableDataSource, objectBinder)));
}
static LocalizableStringWithArguments()
{
ObjectBinder.RegisterTypeReader(typeof(LocalizableStringWithArguments), reader => new LocalizableStringWithArguments(reader));
}
static CodeStyleOption2()
{
ObjectBinder.RegisterTypeReader(typeof(CodeStyleOption2 <T>), ReadFrom);
}
static MessageProvider()
{
ObjectBinder.RegisterTypeReader(typeof(MessageProvider), r => Instance);
}
public abstract IEnumerable <T> PerformExecuteMany <T>(QueryDescription query, ObjectBinder objectBinder);
