private bool ParseTypePathGenerics(ref TypeLookup retn)
{
if (tokenStream.Current != ExpressionTokenType.LessThan)
{
return(false);
}
int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.LessThan, ExpressionTokenType.GreaterThan);
if (advance == -1)
{
// Abort();
return(false);
}
tokenStream.Save();
ExpressionParser subParser = CreateSubParser(advance);
bool valid = subParser.ParseTypePathGenericStep(ref retn);
subParser.Release();
if (!valid)
{
Abort();
}
//tokenStream.Advance();
return(true);
}
public RegisteredType(
TypeSystemObjectBase type,
bool isInferred,
TypeRegistry typeRegistry,
TypeLookup typeLookup,
IDescriptorContext descriptorContext,
ITypeInterceptor typeInterceptor,
string?scope)
{
Type = type;
_typeRegistry = typeRegistry;
_typeLookup = typeLookup;
IsInferred = isInferred;
DescriptorContext = descriptorContext;
TypeInterceptor = typeInterceptor;
IsExtension = Type is INamedTypeExtensionMerger;
IsSchema = Type is ISchema;
Scope = scope;
if (type is INamedType nt)
{
IsNamedType = true;
IsIntrospectionType = nt.IsIntrospectionType();
Kind = nt.Kind;
}
else if (type is DirectiveType)
{
IsDirectiveType = true;
Kind = TypeKind.Directive;
}
}
public void Partition_sequence_returns_sequence_with_duplicates()
{
// Fixture setup
var expectedSequence = new[]
{
new KeyValuePair <string, IEnumerable <string> >("i", new[] { "10", "10", "30", "40" })
};
var specs = new[]
{
new OptionSpecification(string.Empty, "stringvalue", false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '\0', null, string.Empty, string.Empty, new List <string>(), typeof(string), TargetType.Scalar, string.Empty, flagCounter: false, hidden: false),
new OptionSpecification("i", string.Empty, false, string.Empty, Maybe.Just(3), Maybe.Just(4), '\0', null, string.Empty, string.Empty, new List <string>(), typeof(IEnumerable <int>), TargetType.Sequence, string.Empty, flagCounter: false, hidden: false)
};
// Exercize system
var result = TokenPartitioner.Partition(
new[] { Token.Name("i"), Token.Value("10"), Token.Value("10"), Token.Value("30"), Token.Value("40") },
name => TypeLookup.FindTypeDescriptorAndSibling(name, specs, StringComparer.Ordinal)
);
// Verify outcome
var options = result.Item1;
Assert.True(expectedSequence.All(a => options.Any(r => a.Key.Equals(r.Key) && a.Value.SequenceEqual(r.Value))));
// Teardown
}
public PostgreSQLDbGenerator(TypeLookup typeLookup, EntityUtils entityUtils, PostgreSQLExecutor sqlExecutorMaster,
PostgreSQLExecutor sqlExecutor) : base(entityUtils, sqlExecutorMaster, sqlExecutor)
{
_typeLookup = typeLookup;
_sqlExecutor = sqlExecutor;
_entityTypes = _entityUtils.GetEntityTypes();
}
public override void VisitCastCPPModel(CastCPPModel model)
{
var type = TypeLookup.LookupCPPTypeName(model.Type);
var expression = Invoke <ExpressionBuilder>(model.Expression).Expression;
Expression = $"({type}){expression}";
}
private bool ParseNewExpression(ref ASTNode retn)
{
if (tokenStream.Current != ExpressionTokenType.New)
{
return(false);
}
tokenStream.Save();
tokenStream.Advance();
TypeLookup typeLookup = new TypeLookup(); // todo -- allocates a list :(
bool valid = ParseTypePath(ref typeLookup);
if (!valid || tokenStream.Current != ExpressionTokenType.ParenOpen)
{
typeLookup.Release();
tokenStream.Restore();
return(false);
}
LightList <ASTNode> parameters = null;
if (!ParseListExpression(ref parameters, ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose))
{
Abort();
}
retn = ASTNode.NewExpressionNode(typeLookup, parameters);
return(true);
}
public static Type ResolveType(TypeLookup typeLookup, IReadOnlyList <string> namespaces = null, Type scopeType = null)
{
if (typeLookup.resolvedType != null)
{
return(typeLookup.resolvedType);
}
FilterAssemblies();
// base type will valid or an exception will be thrown
Type baseType = ResolveBaseTypePath(typeLookup, namespaces);
if (typeLookup.generics != null && typeLookup.generics.Count != 0)
{
if (!baseType.IsGenericTypeDefinition)
{
throw new TypeResolutionException($"{baseType} is not a generic type definition but we are trying to resolve a generic type with it because generic arguments were provided");
}
baseType = ReflectionUtil.CreateGenericType(baseType, ResolveGenericTypes(typeLookup, namespaces, scopeType));
}
if (typeLookup.isArray)
{
baseType = baseType.MakeArrayType();
}
return(baseType);
}
/// <summary>
/// Resolves a type
/// </summary>
/// <param name="type">The type to resolve</param>
/// <returns>The TypeScript type definition</returns>
protected virtual TsType OnResolve(ITypeSymbol type)
{
if (TypeLookup.TryGetValue(type, out var tsType))
{
return(tsType);
}
if (IsGuid(type))
{
return(TsPrimitive.String);
}
else if (TypeFilter != null && !TypeFilter(type)) // should this assembly be considered?
{
tsType = TsPrimitive.Any;
}
else if (type is INamedTypeSymbol namedType && namedType.IsGenericType)
{
if ($"{namedType.ContainingNamespace}.{namedType.MetadataName}" == typeof(Task <>).FullName)
{
//Ignore the type "Task" and use the type argument instead.
tsType = Resolve(namedType.TypeArguments[0]);
}
else
{
var tsGenericType = new TsGenericType(new TsName(type.Name));
foreach (var argument in namedType.TypeArguments)
{
var tsArgType = Resolve(argument);
tsGenericType.TypeArguments.Add(tsArgType);
}
tsType = tsGenericType;
}
}
private void ReadChunk(BinaryReader br, List <BaseChunk> chunks)
{
// no point parsing last 8 bytes as it's either padding or an empty chunk
if (br.BaseStream.Length - br.BaseStream.Position <= 8)
{
return;
}
string tag = br.ReadString(4);
if (TypeLookup.ContainsKey(tag))
{
br.BaseStream.Position -= 4;
var chunk = (BaseChunk)Activator.CreateInstance(TypeLookup[tag], br, Version);
if (Version == 0 && chunk is VERS vers)
{
Version = vers.Version;
}
chunks.Add(chunk);
}
else
{
throw new Exception($"Unknown type {tag}");
}
}
static unsafe MonoObject *LookupType(TypeLookup type)
{
Type rv = null;
switch (type)
{
case TypeLookup.Foundation_NSNumber:
rv = typeof(Foundation.NSNumber);
break;
case TypeLookup.Foundation_NSValue:
rv = typeof(Foundation.NSValue);
break;
case TypeLookup.System_String:
rv = typeof(string);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
log_coreclr($"LookupType ({type}) => {rv}");
return((MonoObject *)GetMonoObject(rv));
}
public override void VisitMethodCPPModel(MethodCPPModel model)
{
Context.Method = model;
var pars = string.Join(", ", model.Parameters.Select(arg =>
{
var pass = "";
switch (arg.Pass)
{
case ArgumentPassCPPModel.Ref:
pass = "******";
break;
case ArgumentPassCPPModel.Pointer:
pass = "******";
break;
case ArgumentPassCPPModel.Raw:
pass = "******";
break;
}
return($"{TypeLookup.LookupCPPTypeName(arg.ParameterType)}{pass}{arg.Name}");
}));
AppendLine($"{TypeLookup.LookupCPPTypeName(model.ReturnType)} {Context.Class.Name}::{model.Name}({pars})");
OpenBlock();
VisitChildren(model.Members);
CloseBlock();
}
public static ASTNode GenericTypePath(TypeLookup genericPath)
{
GenericTypePathNode node = s_GenericTypePathNode.Get();
node.genericPath = genericPath;
return(node);
}
public bool TryGetSearchParameter(string resourceType, string code, out SearchParameterInfo searchParameter)
{
searchParameter = null;
return(TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> searchParameters) &&
searchParameters.TryGetValue(code, out searchParameter));
}
private bool ParseTypeOfExpression(ref ASTNode retn)
{
if (tokenStream.Current != ExpressionTokenType.TypeOf || tokenStream.Next != ExpressionTokenType.ParenOpen)
{
return(false);
}
tokenStream.Advance();
int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose);
if (advance == -1)
{
Abort();
return(false);
}
tokenStream.Save();
ExpressionParser subParser = CreateSubParser(advance);
TypeLookup typeLookup = new TypeLookup();
bool valid = subParser.ParseTypePath(ref typeLookup);
subParser.Release();
if (!valid)
{
Abort(); // hard fail since typeof token has no other paths to go
tokenStream.Restore();
return(false);
}
retn = ASTNode.TypeOfNode(typeLookup);
return(true);
}
public override void VisitFieldCPPModel(FieldCPPModel model)
{
if (model.FieldType.IsArray)
{
var size = "";
switch (model.Initializer)
{
case ArrayCreationExpressionCPPModel ac:
size = Invoke <ExpressionBuilder>(ac.Rank).Expression;
break;
default:
Unsupported(model, "Array initializer not suported");
break;
}
AppendLine($"{TypeLookup.LookupCPPTypeName(model.FieldType.GetElementType())} {Context.Class.Name}::{model.Name}[{size}] = {{0}};");
}
else
{
var initializer = Invoke <ExpressionBuilder>(model.Initializer).Expression;
AppendLine($"{TypeLookup.LookupCPPTypeName(model.FieldType)} {Context.Class.Name}::{model.Name} = {initializer};");
}
}
public async Task Interface_With_Fragments()
{
// arrange
var path = HotChocolate.Path.New("root");
DocumentNode document = Utf8GraphQLParser.Parse(
FileResource.Open("Multiple_Fragments_Query.graphql"));
var operation = document.Definitions
.OfType <OperationDefinitionNode>()
.First();
var field = operation.SelectionSet.Selections
.OfType <FieldNode>()
.First();
var query = new QueryDescriptor(
"Simple_Query",
"Foo.Bar.Ns",
"1234",
"12345",
new byte[] { 1, 2, 3 },
document);
var schema = SchemaBuilder.New()
.AddDocumentFromString(FileResource.Open("StarWars.graphql"))
.Use(next => context => Task.CompletedTask)
.Create();
var context = new ModelGeneratorContext(
schema,
query,
"StarWarsClient",
"Foo.Bar.Ns");
var character = schema.GetType <InterfaceType>("Character");
// act
var generator = new InterfaceModelGenerator();
generator.Generate(
context,
operation,
character,
character,
field,
context.CollectFields(character, field.SelectionSet, path),
path);
// assert
var typeLookup = new TypeLookup(
LanguageVersion.CSharp_8_0,
CollectFieldsVisitor.MockLookup(document, context.FieldTypes),
"Foo.Bar");
string output = await WriteAllAsync(context.Descriptors, typeLookup);
output.MatchSnapshot();
}
/// <summary>
///
/// Tries to get the card list for a given dictionary key. Generic so that the key can be suited for any of the constructed dictionaries
///
/// </summary>
public List <CardData> GetDictionaryList <T>(T key, CardFilter listFilter = null)
{
var dictionaryList = new List <CardData>();
var type = typeof(T);
switch (type)
{
case Type _ when type == typeof(Tags):
TagLookup.TryGetValue((Tags)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(Synergies):
SynergyLookup.TryGetValue((Synergies)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(Classes.ClassList):
ClassLookup.TryGetValue((Classes.ClassList)(object) key, out dictionaryList);
break;
case Type _ when type == typeof(ClassResources):
ClassPlayableLookup.TryGetValue((ClassResources)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(CardResources):
ResourceLookup.TryGetValue((CardResources)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(Sets):
SetLookup.TryGetValue((Sets)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(Rarity):
RarityLookup.TryGetValue((Rarity)(object)key, out dictionaryList);
break;
case Type _ when type == typeof(CardTypes):
TypeLookup.TryGetValue((CardTypes)(object)key, out dictionaryList);
break;
default:
throw new Exception("Not a valid Dictionary Type");
}
if (dictionaryList != null)
{
if (listFilter != null)
{
return(FilterCardList(dictionaryList.OrderCardList(), listFilter));
}
else
{
return(dictionaryList.OrderCardList());
}
}
else
{
return(new List <CardData>());
}
}
public static TypeNode TypeOfNode(TypeLookup typeLookup)
{
TypeNode typeOfNode = s_TypeNodePool.Get();
typeOfNode.typeLookup = typeLookup;
typeOfNode.type = ASTNodeType.TypeOf;
return(typeOfNode);
}
public static UnaryExpressionNode DirectCastNode(TypeLookup typeLookup, ASTNode expression)
{
UnaryExpressionNode unaryNode = s_UnaryNodePool.Get();
unaryNode.type = ASTNodeType.DirectCast;
unaryNode.typeLookup = typeLookup;
unaryNode.expression = expression;
return(unaryNode);
}
public IEnumerable <SearchParameterInfo> GetSearchParameters(string resourceType)
{
if (TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> value))
{
return(value.Values);
}
throw new ResourceNotSupportedException(resourceType);
}
public static NewExpressionNode NewExpressionNode(TypeLookup typeLookup, LightList <ASTNode> parameters)
{
NewExpressionNode retn = s_NewExpressionNodePool.Get();
retn.typeLookup = typeLookup;
retn.parameters = parameters;
retn.type = ASTNodeType.New;
return(retn);
}
public SearchParameterInfo GetSearchParameter(string resourceType, string code)
{
if (TypeLookup.TryGetValue(resourceType, out ConcurrentDictionary <string, SearchParameterInfo> lookup) &&
lookup.TryGetValue(code, out SearchParameterInfo searchParameter))
{
return(searchParameter);
}
throw new SearchParameterNotSupportedException(resourceType, code);
}
public void ResolveArrayType()
{
TypeLookup lookup = new TypeLookup();
lookup.typeName = "String";
lookup.namespaceName = "System";
lookup.isArray = true;
Type t = TypeProcessor.ResolveType(lookup);
Assert.AreEqual(typeof(string[]), t);
}
private void AddAdditionalTypesAsKnown(params Tuple <Type, TsPrimitive>[] typesToBeAdded)
{
foreach (var type in typesToBeAdded)
{
var typeByMetadata = _compilation.GetTypeByMetadataName(type.Item1.FullName);
if (typeByMetadata != null)
{
TypeLookup.Add(typeByMetadata, type.Item2);
}
}
}
public XsdtPrimitiveDataType GetDataType(Type t)
{
if (TypeLookup.ContainsValue(t))
{
return((from x in TypeLookup where x.Value == t select x.Key).FirstOrDefault());
}
else
{
return(XsdtPrimitiveDataType.XsdtUnknown);
}
}
public override void VisitFieldCPPModel(FieldCPPModel model)
{
if (model.FieldType.IsArray)
{
AppendLine($"{CPPModelTools.Modifiers(model.Modifiers)} {TypeLookup.LookupCPPTypeName(model.FieldType.GetElementType())} {model.Name}[];");
}
else
{
AppendLine($"{CPPModelTools.Modifiers(model.Modifiers)} {TypeLookup.LookupCPPTypeName(model.FieldType)} {model.Name};");
}
}
private static CoreType GetUnderlyingType(Type type)
{
return(underlyingTypes.GetOrAdd(type, (t) =>
{
if (!TypeLookup.CoreTypeLookup(Enum.GetUnderlyingType(t), out CoreType underlyingType))
{
throw new NotImplementedException("Should not happen");
}
return underlyingType;
}));
}
static bool IsClassOfType(Type type, TypeLookup match)
{
var rv = false;
switch (match)
{
case TypeLookup.System_Array:
rv = type.IsArray;
break;
case TypeLookup.System_String:
rv = type == typeof(System.String);
break;
case TypeLookup.System_IntPtr:
rv = type == typeof(System.IntPtr);
break;
case TypeLookup.Foundation_NSNumber:
rv = typeof(Foundation.NSNumber).IsAssignableFrom(type);
break;
case TypeLookup.Foundation_NSObject:
rv = typeof(Foundation.NSObject).IsAssignableFrom(type);
break;
case TypeLookup.Foundation_NSString:
rv = typeof(Foundation.NSString).IsAssignableFrom(type);
break;
case TypeLookup.Foundation_NSValue:
rv = typeof(Foundation.NSValue).IsAssignableFrom(type);
break;
case TypeLookup.ObjCRuntime_INativeObject:
rv = typeof(ObjCRuntime.INativeObject).IsAssignableFrom(type);
break;
case TypeLookup.ObjCRuntime_NativeHandle:
rv = typeof(ObjCRuntime.NativeHandle).IsAssignableFrom(type);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
log_coreclr($"IsClassOfType ({type}, {match}) => {rv}");
return(rv);
}
public static bool TryParseTypeName(string typeName, out TypeLookup typeLookup)
{
StructList <ExpressionToken> list = StructList <ExpressionToken> .Get();
ExpressionTokenizer.Tokenize(typeName, list);
ExpressionParser parser = new ExpressionParser(new TokenStream(list));
typeLookup = default;
bool valid = parser.ParseTypePath(ref typeLookup);
parser.Release();
list.Release();
return(valid);
}
protected StandardRepository(TypeLookup typeLookup, SQLConstants sqlConstants, EntityUtils entityUtils, ExpressionUtils expressionUtils,
ISQLExecutor <TCommand, TConnection, TParameter> sqlExecutor, List <string> updateableFields = null)
{
_typeLookup = typeLookup;
_sqlConstants = sqlConstants;
_entityUtils = entityUtils;
_expressionUtils = expressionUtils;
SQLExecutor = sqlExecutor;
UpdateableFields = updateableFields;
var entityType = typeof(T);
Fields = _entityUtils.GetProperties(entityType);
BaseFields = _entityUtils.GetBaseProperties();
}
