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;
}
