/*-------------------- Constructors ---------------------------------*/
public GenericParamConstraint(GenericParam parent, Class constraint)
{
this.parent = parent;
this.constraint = constraint;
tabIx = MDTable.GenericParamConstraint;
}
internal override void Resolve(PEReader buff)
{
parent = (GenericParam)buff.GetElement(MDTable.GenericParam,parentIx);
parent.AddConstraint((Class)buff.GetCodedElement(CIx.TypeDefOrRef,constraintIx));
}
/// <summary>
/// Add a method to this class
/// </summary>
/// <param name="name">method name</param>
/// <param name="genPars">generic parameters</param>
/// <param name="retType">return type</param>
/// <param name="pars">parameter types</param>
/// <param name="optPars">optional parameter types</param>
/// <returns>a descriptor for this method</returns>
public MethodRef AddVarArgMethod(string name, GenericParam[] genPars, Type retType, Type[] pars, Type[] optPars)
{
MethodRef meth = AddMethod(name,genPars,retType,pars);
meth.MakeVarArgMethod(null,optPars);
return meth;
}
internal static void Read(PEReader buff, TableRow[] gpars)
{
for (int i=0; i < gpars.Length; i++)
gpars[i] = new GenericParam(buff);
}
internal void AddGenericParam(GenericParam par)
{
genericParams.Add(par);
//par.SetClassParam(this,genericParams.Count-1);
}
/// <summary>
/// Add a method to this class
/// </summary>
/// <param name="name">method name</param>
/// <param name="genPars">generic parameters</param>
/// <param name="retType">return type</param>
/// <param name="pars">parameter types</param>
/// <returns>a descriptor for this method</returns>
public MethodRef AddMethod(string name, GenericParam[] genPars, Type retType, Type[] pars)
{
MethodRef meth = AddMethod(name,retType,pars);
if ((genPars != null) && (genPars.Length > 0)) {
for (int i=0; i < genPars.Length; i++) {
genPars[i].SetMethParam(meth,i);
}
meth.SetGenericParams(genPars);
}
return meth;
}
/// <summary>
/// Add a method to this class
/// </summary>
/// <param name="mAtts">attributes for this method</param>
/// <param name="iAtts">implementation attributes for this method</param>
/// <param name="name">method name</param>
/// <param name="genPars">generic parameters</param>
/// <param name="retType">return type</param>
/// <param name="pars">parameters</param>
/// <returns>a descriptor for this new method</returns>
public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name,
GenericParam[] genPars, Type retType, Param[] pars)
{
MethodDef meth = AddMethod(name,genPars,retType,pars);
meth.AddMethAttribute(mAtts);
meth.AddImplAttribute(iAtts);
return meth;
}
internal void AddGenericParam(GenericParam par)
{
if (genericParams == null) genericParams = new ArrayList();
genericParams.Add(par);
//sig.callConv |= CallConv.Generic;
//sig.numGenPars = (uint)genericParams.Count;
}
/// <summary>
/// Add a "global" method to this module
/// </summary>
/// <param name="mAtts">method attributes</param>
/// <param name="iAtts">method implementation attributes</param>
/// <param name="name">method name</param>
/// <param name="genPars">generic parameters</param>
/// <param name="retType">return type</param>
/// <param name="pars">method parameters</param>
/// <returns>a descriptor for this new "global" method</returns>
public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name, GenericParam[] genPars, Type retType, Param[] pars)
{
MethodDef newMeth = defaultClass.AddMethod(mAtts,iAtts,name,genPars,retType,pars);
return newMeth;
}
public GenericParam AddGenericParam(string name)
{
GenericParam gp = new GenericParam(name,this,genericParams.Count);
genericParams.Add(gp);
return gp;
}
/// <summary>
/// Add a "global" method to this module
/// </summary>
/// <param name="name">method name</param>
/// <param name="genPars">generic parameters</param>
/// <param name="retType">return type</param>
/// <param name="pars">method parameters</param>
/// <returns>a descriptor for this new "global" method</returns>
public MethodDef AddMethod(string name, GenericParam[] genPars, Type retType, Param[] pars)
{
MethodDef newMeth = defaultClass.AddMethod(name,genPars,retType,pars);
return newMeth;
}
internal void InsertGenericParam(GenericParam genPar)
{
if (genericParams == null) genericParams = new ArrayList();
for (int i=0; i < genericParams.Count - genPar.Index; i++) {
genericParams.Add(null);
}
genericParams.Insert((int)genPar.Index,genPar);
}
internal void SetGenericParams(GenericParam[] pars)
{
genericParams = new ArrayList(pars);
sig.callConv |= CallConv.Generic;
sig.numGenPars = (uint)genericParams.Count;
}
internal GenericParTypeSpec(GenericParam gPar)
: base(gPar.GetTypeIndex())
{
this.gPar = gPar;
}
public virtual void SetGenericParams(GenericParam[] genPars)
{
for (int i=0; i < genPars.Length; i++) {
genPars[i].SetClassParam(this,i);
}
genericParams = new ArrayList(genPars);
}
internal GenericParam GetGenericParam(MethodDef meth)
{
if (gPar == null) {
if (isClassPar) {
ClassDef methClass = (ClassDef)meth.GetParent();
gPar = methClass.GetGenericParam((int)index);
} else {
gPar = meth.GetGenericParam((int)index);
}
}
return gPar;
}
/// <summary>
/// Add a generic type to this method
/// </summary>
/// <param name="name">the name of the generic type</param>
/// <returns>the descriptor for the generic type</returns>
public GenericParam AddGenericParam(string name)
{
if (genericParams == null) genericParams = new ArrayList();
GenericParam gp = new GenericParam(name,this,genericParams.Count);
sig.callConv |= CallConv.Generic;
genericParams.Add(gp);
sig.numGenPars = (uint)genericParams.Count;
return gp;
}