public CliDependentParameterMemberDictionary(TParent parent, IDelegateType delegateType) { this.syncObject = new object(); this.parent = parent; this.delegateType = delegateType; this.duplicates = new TParameter[delegateType.Parameters.Count]; }
/// <summary> /// Adds a new <typeparamref name="TIntermediateSignature"/> with the <paramref name="name"/> /// and <paramref name="signature"/> provided. /// </summary> /// <param name="name">The <see cref="String"/> value which represents the unique identifier associated /// to the new <typeparamref name="TIntermediateSignature"/>.</param> /// <param name="signature">The <see cref="IDelegateType"/> which denotes the return-type /// and parameters of the <typeparamref name="TIntermediateSignature"/>.</param> /// <returns>A new <typeparamref name="TIntermediateSignature"/> with the <paramref name="name"/> provided /// which has the <paramref name="signature"/> provided.</returns> public TIntermediateSignature Add(string name, IDelegateType signature) { /* * * Setup, create a new series of typed names with the type-parameters of the signature * replaced with a string-variant. * */ return(DictionaryHelpers.AddIntermediateMethodByDelegate <TSignatureParameter, TIntermediateSignatureParameter, TSignature, TIntermediateSignature, TSignatureParent, TIntermediateSignatureParent>(name, signature, this.Add, this.Add)); }
public TEvent Find(string eventName, IDelegateType searchCriteria) { return((from e in this.Values where e.Name == eventName where e.SignatureSource == EventSignatureSource.Delegate && e.SignatureType == searchCriteria || e.SignatureSource == EventSignatureSource.Declared && e.Parameters.ParameterTypes.SequenceEqual(searchCriteria.Parameters.ParameterTypes) select e).FirstOrDefault()); }
public void ReferenceDeclaration(IDelegateType declaration) { if (declaration is IIntermediateDelegateType) { this.ReferenceDeclaration((IIntermediateDelegateType)declaration); } else { this.Formatter.ReferenceDeclaration(declaration); } }
public TEvent Find(string eventName, IDelegateType searchCriteria) { foreach (var key in this.Keys) { TEvent current = null; if (key.Name == eventName && (current = this[key]).SignatureType == searchCriteria) { return(current); } } return(null); }
public void ReferenceDeclaration(IDelegateType declaration) { referenceStack.Push(declaration); }
internal DependentParameterDictionary(TEvent parent, IDelegateType delegateType) : base(parent, delegateType) { }
public void ReferenceDeclaration(IDelegateType declaration) { }
public DelegateTypeWrapper(IDelegateType <TAttributeGroup, TGenericParameter, TTypeReference, TParameter> delegateType) { WrappedObject = delegateType; }
public DelegateTypeParameterMembers(IDelegateType targetDeclaration) : base(targetDeclaration) { }
protected override IDelegateTypeParameterMember GetWrapper(IDelegateTypeParameterMember parameter, IDelegateType parent) { return(new _Parameter(parameter, (_DelegateTypeBase)parent)); }
/// <summary> /// Translates a delegate-based declared type. /// </summary> /// <param name="delegateType">The <see cref="IDelegateType"/> to translate.</param> public abstract void TranslateType(IDelegateType delegateType);
public override void TranslateType(IDelegateType delegateType) { this.Provider.GenerateCodeFromType(delegateType.GenerateCodeDom(this.Options), base.Target, this.Options.Options); }
IIntermediateMethodSignatureMember IIntermediateMethodSignatureMemberDictionary.Add(string name, IDelegateType signature) { return(this.Add(name, signature)); }
IEventSignatureMember IEventSignatureMemberDictionary.Find(string eventName, IDelegateType searchCriteria) { return(this.Find(eventName, searchCriteria)); }
AddIntermediateMethodByDelegate < TSignatureParameter, TIntermediateSignatureParameter, TSignature, TIntermediateSignature, TSignatureParent, TIntermediateSignatureParent> ( string name, IDelegateType signature, Func <string, TIntermediateSignature> addHelper, Func <TypedName, TypedNameSeries, TIntermediateSignature> addHelperAlt ) where TSignatureParameter : IMethodSignatureParameterMember <TSignatureParameter, TSignature, TSignatureParent> where TIntermediateSignatureParameter : IIntermediateMethodSignatureParameterMember <TSignatureParameter, TIntermediateSignatureParameter, TSignature, TIntermediateSignature, TSignatureParent, TIntermediateSignatureParent>, TSignatureParameter where TSignature : IMethodSignatureMember <TSignatureParameter, TSignature, TSignatureParent> where TIntermediateSignature : IIntermediateMethodSignatureMember <TSignatureParameter, TIntermediateSignatureParameter, TSignature, TIntermediateSignature, TSignatureParent, TIntermediateSignatureParent>, TSignature where TSignatureParent : ISignatureParent <IGeneralGenericSignatureMemberUniqueIdentifier, TSignature, TSignatureParameter, TSignatureParent> where TIntermediateSignatureParent : IIntermediateSignatureParent <IGeneralGenericSignatureMemberUniqueIdentifier, TSignature, TIntermediateSignature, TSignatureParameter, TIntermediateSignatureParameter, TSignatureParent, TIntermediateSignatureParent>, TSignatureParent { /* * * If the method being added wants to mirror the declaration * of the delegate, and the delegate is a generic type with * no specific type references added: mirror the definition * down to the generic parameters. * */ if (signature.IsGenericConstruct && signature.IsGenericDefinition && signature.Parent == null) { var method = addHelper(name); var genericParameters = new IIntermediateGenericParameter[signature.TypeParameters.Count]; var originalGenericParameters = signature.TypeParameters.Values.ToArray(); for (int i = 0; i < originalGenericParameters.Length; i++) { genericParameters[i] = method.TypeParameters.Add(originalGenericParameters[i].Name); } var genericParameterCollection = new LockedTypeCollection(genericParameters); for (int i = 0; i < originalGenericParameters.Length; i++) { var originalGenericParameter = originalGenericParameters[i]; var currentGenericParameter = genericParameters[i]; foreach (var constraint in originalGenericParameter.Constraints) { currentGenericParameter.Constraints.Add(constraint.Disambiguify(genericParameterCollection, null, TypeParameterSources.Type)); } currentGenericParameter.SpecialConstraint = originalGenericParameter.SpecialConstraint; } method.Parameters.AddRange((from p in signature.Parameters.Values let paramType = p.ParameterType.Disambiguify(genericParameterCollection, null, TypeParameterSources.Type) select new TypedName(p.Name, paramType)).ToArray()); method.ReturnType = signature.ReturnType.Disambiguify(genericParameterCollection, null, TypeParameterSources.Type); return(method); } /* * * Otherwise, just copy the types defined in the parameters. * */ else if (!(signature.IsGenericConstruct && signature.IsGenericDefinition)) { return(addHelperAlt(new TypedName(name, signature.ReturnType), new TypedNameSeries((from p in signature.Parameters.Values select new TypedName(p.Name, p.ParameterType)).ToArray()))); } else { throw new NotSupportedException("Generic type provided must be a top-level type."); } }
/// <summary> /// Creates a new instance of <see cref="DelegateTypeParameterMember"/>. /// </summary> /// <param name="nameAndType">The name and data-type of the parameter.</param> /// <param name="parentTarget">The parent target of the <see cref="DelegateTypeParameterMember"/>.</param> public DelegateTypeParameterMember(TypedName nameAndType, IDelegateType parentTarget) : base(nameAndType.Name, parentTarget) { this.ParameterType = nameAndType.TypeReference; }