public void GetUsers()
{
// Create the manager with the api key
Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
GenericParameters parameters = new GenericParameters()
{
};
// Run the query
string errorString;
Route4MeManager.GetUsersResponse dataObjects = route4Me.GetUsers(parameters, out errorString);
Console.WriteLine("");
if (dataObjects != null)
{
if (dataObjects.results != null)
{
Console.WriteLine("GetUsers executed successfully, {0} users returned", dataObjects.results.Length);
Console.WriteLine("");
}
else
{
Console.WriteLine("GetUsers error: {0}", errorString);
}
}
else
{
Console.WriteLine("GetUsers error: {0}", errorString);
}
}
public void GetUsers()
{
// Create the manager with the api key
Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
GenericParameters parameters = new GenericParameters()
{
};
// Run the query
string errorString;
User[] dataObjects = route4Me.GetUsers(parameters, out errorString);
Console.WriteLine("");
if (dataObjects != null)
{
Console.WriteLine("GetUsers executed successfully, {0} users returned", dataObjects.Length);
Console.WriteLine("");
//dataObjects.ForEach(user =>
//{
// Console.WriteLine("User ID: {0}", user.MemberId);
//});
}
else
{
Console.WriteLine("GetUsers error: {0}", errorString);
}
}
/// <inheritdoc/>
internal override string GetDisplayName(bool fullyQualify, bool includeGenericInfo, GenericTypeArgumentCollection genericArguments)
{
if (_primitiveTypeNames.TryGetValue(FullName, out string primitiveTypeName))
{
return(primitiveTypeName);
}
var rootName = Name;
var tickIndex = rootName.LastIndexOf('`');
if (0 <= tickIndex)
{
rootName = rootName.Substring(0, tickIndex);
}
if (includeGenericInfo)
{
var declaringTypeGenericArity = ContainingType == null ? 0 : ContainingType.GenericArity;
if (genericArguments != null)
{
rootName += genericArguments.GetGenericArgumentListDisplayText(includeGenericInfo, declaringTypeGenericArity, GenericParameters.Count - declaringTypeGenericArity);
}
else if (GenericParameters != null) // While initializing, this.GenericParameters could be null and we don't want this throwing an exception
{
rootName += GenericParameters.GetParameterListText(skipCount: declaringTypeGenericArity);
}
}
return(PostProcessUnqualifiedName(rootName, fullyQualify, includeGenericInfo, genericArguments));
}
public void Initialize()
{
//properties
foreach (var tsProperty in Properties)
{
tsProperty.Initialize();
}
//base types
DerivedInterfaces = Interfaces.Select(_mapType).Except(new[] { Types.Any, Types.Boolean, Types.Number, Types.String, Types.Void }).ToList();
//generic
foreach (var tsGenericParameter in GenericParameters)
{
tsGenericParameter.Initialize();
}
if (_type.IsGenericType)
{
InterFaceName += string.Format("<{0}>", string.Join(", ", GenericParameters.Select(p => p.ToTSString())));
}
//methods
foreach (var tsMethod in Methods)
{
tsMethod.Initialize();
}
}
public MethodName AddGenericParameter(string name)
{
return(WithGenericParameters(GenericParameters.ImmutableAdd(
GenericParameterName.New(this, GenericParameters.Count, name),
CloneGenericParameter)
));
}
void PrintGenericParameters(StringBuilder builder)
{
if (GenericParameterCount != 0)
{
GenericParameters.Print(builder, ",", "<", ">", (gp, b) => b.Append(gp.Name));
}
}
/// <summary>
/// An easily readable name
/// </summary>
public string GenerateName(bool prefixWithGlobal = false)
{
if (IsGenericParameter)
{
return(Name);
}
string theReturn = GenerateNameWithoutGenericsAndArrays();
if (IsGenericTypeDefinition)
{
theReturn = $"{theReturn}<{string.Join(",", GenericParameters.Select(t => t.Name))}>";
}
else if (IsConstructedGenericType)
{
theReturn = $"{theReturn}<{string.Join(",", Wrapped.Select(t => t.GenerateName(prefixWithGlobal)))}>";
}
if (ArrayDimensions > 0)
{
theReturn = theReturn + $"[{string.Join(",", Enumerable.Repeat(string.Empty, ArrayDimensions))}]";
}
if (prefixWithGlobal)
{
theReturn = "global::" + theReturn;
}
return(theReturn);
}
/// <inheritdoc/>
void IListListener <GenericParam> .OnClear()
{
foreach (var gp in GenericParameters.GetEnumerable_NoLock())
{
gp.Owner = null;
}
}
public async Task <IPagedList <T> > GetAllAsync(GenericParameters parameters)
{
return(await GenericPagedList <T> .ToPagedList(
_query,
parameters.PageNumber,
parameters.PageSize));
}
public void CopyTo(MethodDeclaration copy)
{
copy._name = _name;
copy._sigType = _sigType;
copy._flags = _flags;
copy._implFlags = _implFlags;
if (PInvoke != null)
{
PInvoke.CopyTo(copy.CreatePInvoke());
}
ReturnType.CopyTo(copy.ReturnType);
Parameters.CopyTo(copy.Parameters);
GenericParameters.CopyTo(copy.GenericParameters);
Overrides.CopyTo(copy.Overrides);
CustomAttributes.CopyTo(copy.CustomAttributes);
SecurityAttributes.CopyTo(copy.SecurityAttributes);
if (MethodBody.IsValid(this))
{
var methodBody = MethodBody.Load(this);
methodBody.Build(copy);
}
}
internal override bool DoesMatch(MetadataItemBase other)
{
if (base.DoesMatch(other) == false)
{
return(false);
}
var otherTyped = other as MethodData;
if (otherTyped == null)
{
return(false);
}
if (GenericParameters.DoesMatch(otherTyped.GenericParameters) == false)
{
return(false);
}
if (IsExtensionMethod != otherTyped.IsExtensionMethod)
{
return(false);
}
return(true);
}
/// <summary>
/// Retourne cette déclaration de classe sous la forme d'un string.
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder genParametersStr = new StringBuilder();
genParametersStr.Append("<");
foreach (string genParam in GenericParameters)
{
genParametersStr.Append(genParam);
if (genParam != GenericParameters.Last())
{
genParametersStr.Append(",");
}
}
genParametersStr.Append(">");
StringBuilder modifiersStr = new StringBuilder();
foreach (string modifier in Modifiers)
{
modifiersStr.Append(modifier);
modifiersStr.Append(" ");
}
return(modifiersStr.ToString() + Name + genParametersStr.ToString());
}
public async Task <IActionResult> Get([FromQuery] GenericParameters parameters)
{
var result = await _repository.GetAllAsync(parameters);
Response.Headers.Add("pagination", result.Pagination.ToString());
return(Ok(result.Items));
}
public async Task <IEnumerable <T> > Get(GenericParameters <T> p)
{
IQueryable <T> Db = DbSet;
Db = Filter.WhereFilter(Db, p.Filter);
Db = Sort.OrderBySort(Db, p.OrderBy, p.Asc);
return(await Page.DoPagingAsync(Db, p.PageNumber, p.PageSize));
}
public bool Equals(Signature other) => other != null && ReturnType == other.ReturnType && ClassName == other.ClassName && Name == other.Name && GenericParameters.SequenceEqual(other.GenericParameters) && Parameters.SequenceEqual(other.Parameters);
/// <summary>
/// Ensures the type is part of the module.
/// </summary>
public SemanticTypeDefinitionMask_I Ensure(RuntimicSystemModel semanticModel, ExecutionEnsureContext context)
{
if (context.TypeReference.FullName == "Root.Code.Containers.E01D.Sorting.SortingContainer_I`1<TContainer>")
{
}
if (context.TypeReference.IsGenericParameter) // DOES NOT USE UNDERLYING TYPE OR DECLARING TYPE
{
// You cannot create a generic parameter directly. It is created when its parent type creates it.
return(GenericParameters.Ensure(semanticModel, context.TypeReference));
}
if (context.TypeReference.IsGenericInstance)
{
return(GenericInstances.Ensure(semanticModel, (GenericInstanceType)context.TypeReference, context.DeclaringType));
}
// Ultimately the conversion process needs type and member infos
if (context.UnderlyingType == null)
{
context.UnderlyingType = Models.Types.GetUnderlyingType(semanticModel, context.TypeReference);
}
if (context.DeclaringType == null && context.UnderlyingType?.DeclaringType != null)
{
if (context.TypeReference.IsRequiredModifier)
{
// Call back to the execution's type system so it can determine where to make the type
//context.DeclaringType = (BoundTypeDefinitionMask_I)Execution.Metadata.Members.Types.Ensuring.Ensure(semanticModel, context.TypeReference.GetElementType(), context.UnderlyingType.DeclaringType, null);
throw new System.Exception("Fix");
}
else
{
// Call back to the execution's type system so it can determine where to make the type
//context.DeclaringType = (BoundTypeDefinitionMask_I)Execution.Metadata.Members.Types.Ensuring.Ensure(semanticModel, context.TypeReference.DeclaringType, context.UnderlyingType.DeclaringType, null);
throw new System.Exception("Fix");
}
}
if (context.TypeReference.IsRequiredModifier)
{
return(RequiredModifiers.Ensure(semanticModel, context.TypeReference, context.DeclaringType, context.UnderlyingType));
}
if (context.TypeReference.IsDefinition)
{
return(NonGenericInstances.Ensure(semanticModel, context.TypeReference, context.DeclaringType, context.UnderlyingType));
}
throw new Exception("Should never have happened. External references are now handled prior to calling this method bye the execution ensuring mechanism.");
// External
//var internalTypReference = Models.Types.External.Resolve(semanticModel, context.TypeReference);
//return Execution.Metadata.Members.Types.Ensuring.Ensure(semanticModel, internalTypReference, context.UnderlyingType, context.DeclaringType);
}
private Symbol GetGenericParamaterType(string name, Symbol context, SymbolFilter filter)
{
if (IsGeneric)
{
return(GenericParameters?.FirstOrDefault(p => p.Name == name));
}
return(null);
}
public TypeBrowserDialog(IServiceProvider serviceProvider, ITypeFilterProvider filterProvider, string selectedTypeName)
{
this.genericParameters = new GenericParameters();
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
this.InitializeDialog(serviceProvider, filterProvider, selectedTypeName);
}
private MethodInfo InstantiateWithOwnGenericParameters(MethodInfo method)
{
if (GenericParameters.Count == 0)
{
return(method);
}
return(method.MakeTypePipeGenericMethod(GenericParameters.ToArray()));
}
public PagedList <UserDto> GetAll(GenericParameters parameters)
{
//var users2=
// var users = _context.Users.AsEnumerable();
//var dtos = mapper.Map<IList<UserDto>>(users2);
return(PagedList <UserDto> .ToPagedList(FindAll(),
parameters.PageNumber,
parameters.PageSize));
}
public override int GetHashCode()
=> HashCode
.Combine
(
ReturnType,
ClassName,
Name,
GenericParameters.Aggregate(0, (p1, p2) => HashCode.Combine(p1, p2.GetHashCode())),
Parameters.Aggregate(0, (p1, p2) => HashCode.Combine(p1, p2.GetHashCode()))
);
TypeData MakeGenericTypeData(IReadOnlyList <TypeData> parameters)
{
if (!IsSupported)
{
return(this);
}
if (IsGenericParameter)
{
return(parameters[this.GenericParameterIndex]);
}
if (!IsGeneric)
{
return(this);
}
var result = new TypeData()
{
IsSupported = true,
Kind = Kind,
IsSealed = IsSealed,
IsReference = IsReference,
IsEnum = IsEnum,
IsInterface = IsInterface,
HasConverter = HasConverter,
IsISerializable = IsISerializable,
IsGeneric = true,
IsGenericTypeDefinition = false,
IsNullable = IsNullable,
Element = this,
GenericParameters = GenericParameters.Select(x => x.MakeGenericTypeData(parameters)).ToList().AsReadOnly(),
};
result.BaseType = BaseType?.MakeGenericTypeData(parameters);
result.Surrogate = Surrogate?.MakeGenericTypeData(parameters);
if (Surrogate == null &&
!IsInterface &&
!IsArray && !IsEnum &&
!IsGenericParameter)
{
foreach (var m in Members)
{
var rm = new Member(result);
rm.Name = m.Name;
rm.Type = m.Type.MakeGenericTypeData(parameters);
result.Members.Add(rm);
}
result.CollectionType = CollectionType;
result.Collection1 = Collection1?.MakeGenericTypeData(parameters);
result.Collection2 = Collection2?.MakeGenericTypeData(parameters);
}
return(result);
}
public RuntimeType RuntimeType()
{
if (target == null && !resolved)
{
resolved = true;
try
{
switch (Kind)
{
case PrimitiveType.None:
break;
case PrimitiveType.Object:
if (IsArray)
{
var type = Element.RuntimeType()?.Type;
if (ArrayRank == 1)
{
type = type?.MakeArrayType();
}
else if (ArrayRank > 1)
{
type = type?.MakeArrayType(ArrayRank);
}
target = Serialization.RuntimeType.GetType(type);
}
else if (IsGenericParameter)
{
// nothing
}
else if (IsGeneric && !IsGenericTypeDefinition)
{
var type = Element.RuntimeType()?.Type;
var parameters = GenericParameters.Select(x => x.RuntimeType()?.Type).ToArray();
if (type != null && parameters.All(x => x != null))
{
target = Serialization.RuntimeType.GetType(type.MakeGenericType(parameters));
}
}
else
{
target = Serialization.RuntimeType.GetType(FullName, Assembly);
}
break;
default:
target = Serialization.RuntimeType.GetType(PrimitiveConverter.GetType(Kind));
break;
}
}
catch (SystemException se) { Log.Error(se); }
}
return(target);
}
/// <summary>
/// The example refers to the process of getting the existing sub-users.
/// </summary>
public void GetUsers()
{
// Create the manager with the api key
var route4Me = new Route4MeManager(ActualApiKey);
var parameters = new GenericParameters();
// Run the query
Route4MeManager.GetUsersResponse dataObjects = route4Me.GetUsers(parameters, out string errorString);
PrintTestUsers(dataObjects, errorString);
}
public string GenerateReflectionName()
{
string theReturn = GenerateReflectionNameWithoutGenericsAndArrays();
if (IsGenericTypeDefinition)
{
if (GenericParameters.IsNullOrEmpty())
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
else
{
System.Diagnostics.Debugger.Launch();
}
#else
throw new InvalidOperationException($"the type {theReturn} is marked as IsGenericTypeDefinition but it's missing its GenericParameters types");
#endif
}
theReturn = $"{theReturn}`{GenericParameters.Length}";
}
else if (IsConstructedGenericType)
{
if (Wrapped.IsNullOrEmpty())
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
else
{
System.Diagnostics.Debugger.Launch();
}
#else
throw new InvalidOperationException($"the type {theReturn} is marked as IsConstructedGenericType but it's missing its Wrapped types ");
#endif
}
theReturn = $"{theReturn}`{Wrapped.Length}[{string.Join(",", Wrapped.Select(t => $"[{t.GenerateReflectionName()}]"))}]";
}
if (ArrayDimensions > 0)
{
return(theReturn + $"[{string.Join(",", Enumerable.Repeat(string.Empty, ArrayDimensions))}]");
}
else
{
return(theReturn);
}
}
private static ParseResult Match_ClosedGeneric(InputStream input)
{
var result = Sequence(ZeroOrOne(Match_CLRSyntax), Match_TypeParameters)(input);
if (result.Matched)
{
var genericParameters = new GenericParameters();
genericParameters.IsOpenGeneric = false;
genericParameters.Parameters.AddRange((List <TypeNameInfo>)(new SequenceResult(result)[1].ResultData));
return(new ParseResult(result.MatchedString, genericParameters));
}
return(result);
}
public override void AppendDeclaration(StringBuilder sb, int tabsOffset)
{
base.AppendDeclaration(sb, tabsOffset);
sb.Append("<");
GenericParameters[0].AppendDeclaration(sb, 0);
foreach (var item in GenericParameters.Skip(1))
{
sb.Append(", ");
item.AppendDeclaration(sb, 0);
}
sb.Append(">");
}
public TupleTypeSpec(TupleTypeSpec other)
: base(TypeSpecKind.Tuple)
{
Elements = new List <TypeSpec> ();
Elements.AddRange(other.Elements);
if (other.HasAttributes)
{
Attributes.AddRange(other.Attributes);
}
if (other.ContainsGenericParameters)
{
GenericParameters.AddRange(other.GenericParameters);
}
IsInOut = other.IsInOut;
}
public TypeBrowserDialog(IServiceProvider serviceProvider, ITypeFilterProvider filterProvider, string selectedTypeName, System.Workflow.ComponentModel.Compiler.TypeProvider typeProvider)
{
this.genericParameters = new GenericParameters();
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
this.localTypeProvider = typeProvider;
this.serviceProvider = serviceProvider;
Helpers.AddTypeProviderAssembliesFromRegistry(this.localTypeProvider, serviceProvider);
this.InitializeDialog(serviceProvider, filterProvider, selectedTypeName);
this.buttonBrowse.Visible = true;
this.buttonBrowse.Enabled = true;
this.buttonBrowse.BringToFront();
}
public TypeRef Clone() => new TypeRef()
{
ArrayDimensions = ArrayDimensions,
GenericParameters = GenericParameters?.Select(gp => gp.Clone()).ToArray(),
IsPrimitive = IsPrimitive,
IsConstructedGenericType = IsConstructedGenericType,
IsEnum = IsEnum,
IsGenericParameter = IsGenericParameter,
IsGenericTypeDefinition = IsGenericTypeDefinition,
IsWellKnown = IsWellKnown,
Name = Name,
Namespace = Namespace,
NestedIn = NestedIn?.Clone(),
Wrapped = Wrapped?.Select(w => w.Clone()).ToArray(),
IsInterface = IsInterface
};
public void CopyTo(TypeDeclaration copy)
{
copy._name = _name;
copy._namespace = _namespace;
copy._flags = _flags;
copy._packingSize = PackingSize;
copy._classSize = ClassSize;
copy._baseType = BaseType;
Interfaces.CopyTo(copy.Interfaces);
GenericParameters.CopyTo(copy.GenericParameters);
Methods.CopyTo(copy.Methods);
Fields.CopyTo(copy.Fields);
Properties.CopyTo(copy.Properties);
Events.CopyTo(copy.Events);
CustomAttributes.CopyTo(copy.CustomAttributes);
SecurityAttributes.CopyTo(copy.SecurityAttributes);
NestedTypes.CopyTo(copy.NestedTypes);
}
public void Process(ClassDefinition cd)
{
cd.Accept(this);
var parameters = GenericParameters.ToArray();
for (var i = 0; i < parameters.Length; ++i)
{
var param = parameters[i];
var gen = cd.GenericParameters.FirstOrDefault(gp => gp.Name.Equals(param.Name));
var found = gen != null;
if (!found)
{
gen = _codeBuilder.CreateGenericParameterDeclaration(i, param.Name);
}
foreach (IType baseType in param.GetTypeConstraints())
{
gen.BaseTypes.Add(_codeBuilder.CreateTypeReference(baseType));
}
if (param.MustHaveDefaultConstructor)
{
gen.Constraints |= GenericParameterConstraints.Constructable;
}
if (param.IsValueType)
{
gen.Constraints |= GenericParameterConstraints.ValueType;
}
else if (param.IsClass)
{
gen.Constraints |= GenericParameterConstraints.ReferenceType;
}
if (param.Variance == Variance.Covariant)
{
gen.Constraints |= GenericParameterConstraints.Covariant;
}
else if (param.Variance == Variance.Contravariant)
{
gen.Constraints |= GenericParameterConstraints.Contravariant;
}
if (!found)
{
cd.GenericParameters.Add(gen);
}
}
}
private static ParseResult Match_ClosedGeneric(InputStream input)
{
var result = Sequence(ZeroOrOne(Match_CLRSyntax), Match_TypeParameters)(input);
if (result.Matched)
{
var genericParameters = new GenericParameters();
genericParameters.IsOpenGeneric = false;
genericParameters.Parameters.AddRange((List<TypeNameInfo>)(new SequenceResult(result)[1].ResultData));
return new ParseResult(result.MatchedString, genericParameters);
}
return result;
}
private static ParseResult Match_EmptyBrackets(InputStream input)
{
var resultData = new GenericParameters();
ParseResult result = Sequence(Match_LeftBracket,
WithAction(ZeroOrMore(Match_Comma), r =>
{
int numParameters = r.MatchedString.Length + 1;
resultData.IsOpenGeneric = true;
for (int i = 0; i < numParameters; ++i)
{
resultData.Parameters.Add(null);
}
}),
Match_RightBracket)(input);
if (result.Matched)
{
return new ParseResult(result.MatchedString, resultData);
}
return result;
}
private static ParseResult Match_CLRSyntax(InputStream input)
{
var resultData = new GenericParameters();
ParseResult result = ParseBuilder.Sequence(Match_Backquote,
WithAction(OneOrMore(Match_Digit),
r =>
{
resultData.IsOpenGeneric = true;
int numParameters = int.Parse(r.MatchedString, CultureInfo.InvariantCulture);
for (int i = 0; i < numParameters; ++i)
{
resultData.Parameters.Add(null);
}
}))(input);
if (result.Matched)
{
return new ParseResult(result.MatchedString, resultData);
}
return result;
}
