/// <summary>
/// Applies attributes to the proxied method's return type.
/// </summary>
/// <param name="methodBuilder">The method builder to use.</param>
/// <param name="targetMethod">The proxied method.</param>
/// <see cref="IProxyTypeBuilder.ProxyTargetAttributes"/>
protected virtual void ApplyMethodReturnTypeAttributes(MethodBuilder methodBuilder, MethodInfo targetMethod)
{
ParameterBuilder parameterBuilder = methodBuilder.DefineParameter(0, ParameterAttributes.Retval, null);
foreach (object attr in GetMethodReturnTypeAttributes(targetMethod))
{
if (attr is CustomAttributeBuilder)
{
parameterBuilder.SetCustomAttribute((CustomAttributeBuilder)attr);
}
else if (attr is CustomAttributeData)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((CustomAttributeData)attr));
}
else if (attr is Attribute)
{
parameterBuilder.SetCustomAttribute(
ReflectionUtils.CreateCustomAttribute((Attribute)attr));
}
}
}
public void TestThrowsExceptionForNegativePosition()
{
string strParamName = null;
int paramPos = 0;
strParamName = TestLibrary.Generator.GetString(false, false, true, MinStringLength, MaxStringLength);
paramPos = TestLibrary.Generator.GetInt32();
if (paramPos > 0)
{
paramPos = 0 - paramPos;
}
TypeBuilder typeBuilder = GetTestTypeBuilder();
MethodBuilder builder = typeBuilder.DefineMethod(
PosTestDynamicMethodName,
TestMethodAttributes);
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
ParameterBuilder paramBuilder = builder.DefineParameter(paramPos, ParameterAttributes.HasDefault, strParamName);
});
}
public void ParseStageOpdracht_ValidInputParameters_ReturnsStageopdracht()
{
//Arrange
List <object> parameters = new List <object>();
parameters.Add(ParameterBuilder.String()); //locatie
var locatie = ParameterBuilder.String();
var omschrijving = ParameterBuilder.String();
var voorwaarden = ParameterBuilder.String();
var thema = ParameterBuilder.String();
var omschOmgeving = ParameterBuilder.String();
var omgeving = ParameterBuilder.String();
var aantalMederwerkersIt = ParameterBuilder.Int();
var aantalMedewerkers = ParameterBuilder.Int();
var aantalStagiairs = ParameterBuilder.Int();
var afstudeerrichting = ParameterBuilder.Afstudeerrichting();
var inleidendeActiviteit = ParameterBuilder.InleidendeActiviteit();
var opdrachtgeverId = ParameterBuilder.Int();
//Act
var result = _parseService.ParseStageOpdracht(locatie, omschrijving, voorwaarden, thema, omschOmgeving,
omgeving, aantalMederwerkersIt, aantalMedewerkers, aantalStagiairs, afstudeerrichting,
inleidendeActiviteit, opdrachtgeverId) as Stageopdracht;
//Assert
Assert.That(result.Locatie, Is.EqualTo(locatie));
Assert.That(result.Omschrijving, Is.EqualTo(omschrijving));
Assert.That(result.Randvoorwaarden, Is.EqualTo(voorwaarden));
Assert.That(result.Onderzoeksthema, Is.EqualTo(thema));
Assert.That(result.BeschrijvingTechnischeOmgeving, Is.EqualTo(omschOmgeving));
Assert.That(result.Omgeving, Is.EqualTo(omgeving));
Assert.That(result.AantalITWerknemers, Is.EqualTo(aantalMederwerkersIt));
Assert.That(result.AantalWerknemers, Is.EqualTo(aantalMedewerkers));
Assert.That(result.AantalGewensteStagiairs, Is.EqualTo(aantalStagiairs));
Assert.That(result.VoorkeurAfstudeerrichting, Is.EqualTo(afstudeerrichting));
Assert.That(result.InleidendeActiviteiten, Is.EqualTo(inleidendeActiviteit));
Assert.That(result.OpdrachtgeverId, Is.EqualTo(opdrachtgeverId));
}
/// <summary>
/// Adds constructors to new type that match all constructors on base type.
/// Parameters are passed to base type.
/// </summary>
/// <returns></returns>
public IEmptyObject AddPassThroughCtors()
{
foreach (ConstructorInfo _ctor in _parentType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
ParameterInfo[] _params = _ctor.GetParameters();
Type[] _paramTypes = _params.Select(p => p.ParameterType).ToArray();
Type[][] _reqModifiers = _params.Select(p => p.GetRequiredCustomModifiers()).ToArray();
Type[][] _optModifiers = _params.Select(p => p.GetOptionalCustomModifiers()).ToArray();
ConstructorBuilder _ctorBuild = _tBuilder.DefineConstructor(MethodAttributes.Public, _ctor.CallingConvention, _paramTypes, _reqModifiers, _optModifiers);
for (int i = 0; i < _params.Length; i++)
{
ParameterInfo _param = _params[i];
ParameterBuilder _prmBuild = _ctorBuild.DefineParameter(i + 1, _param.Attributes, _param.Name);
if (((int)_param.Attributes & (int)ParameterAttributes.HasDefault) != 0)
{
_prmBuild.SetConstant(_param.RawDefaultValue);
}
foreach (CustomAttributeBuilder _attr in GetCustomAttrBuilders(_param.CustomAttributes))
{
_prmBuild.SetCustomAttribute(_attr);
}
}
//ConstructorBuilder _cBuilder = _tBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Any, argTypes);
ILGenerator _ctorGen = _ctorBuild.GetILGenerator();
_ctorGen.Emit(OpCodes.Nop);
//arg0=new obj, arg1-arg3=passed params. Push onto stack for call to base class
_ctorGen.Emit(OpCodes.Ldarg_0);
for (int i = 1; i <= _params.Length; i++)
{
_ctorGen.Emit(OpCodes.Ldarg, i);
}
_ctorGen.Emit(OpCodes.Call, _ctor);
_ctorGen.Emit(OpCodes.Ret);
}
return(this);
}
public virtual void UpdateTaskSuspensionStateByProcessDefinitionKeyAndTenantId(string processDefinitionKey, string processDefinitionTenantId, ISuspensionState suspensionState)
{
//IDictionary<string, object> parameters = new Dictionary<string, object>();
//parameters["processDefinitionKey"] = processDefinitionKey;
//parameters["isProcessDefinitionTenantIdSet"] = true;
//parameters["processDefinitionTenantId"] = processDefinitionTenantId;
//parameters["suspensionState"] = suspensionState.StateCode;
var predicateTask = ParameterBuilder.True <TaskEntity>();
var predicateProc = ParameterBuilder.True <ProcessDefinitionEntity>();
if (!string.IsNullOrEmpty(processDefinitionKey))
{
predicateProc = predicateProc.AndParam(c => c.Key == processDefinitionKey);
predicateProc = !string.IsNullOrEmpty(processDefinitionTenantId) ? predicateProc.AndParam(c => c.TenantId == processDefinitionTenantId) : predicateProc.AndParam(c => c.TenantId == null);
predicateTask = predicateTask.AndParam(c => DbContext.Set <ProcessDefinitionEntity>().Where(predicateProc).Select(p => p.Id).ToList().Contains(c.ProcessDefinitionId));
}
Find(predicateTask).ForEach(d =>
{
d.Revision = d.RevisionNext;
d.SuspensionState = suspensionState.StateCode;
});
}
/// <summary>
/// insert one SysGroup to database
/// </summary>
public override void Insert(SqlTransaction transaction, SysGroupInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [sys_group] (");
sb.Append("[group_id],");
sb.Append("[group_name],");
sb.Append("[is_admin],");
sb.Append("[description] ");
sb.Append(" ) values ( ");
sb.Append("@GroupId,");
sb.Append("@GroupName,");
sb.Append("@IsAdmin,");
sb.Append("@Description ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@GroupId", entity.GroupId);
paramList.Add("@GroupName", entity.GroupName);
paramList.Add("@IsAdmin", entity.IsAdmin);
paramList.Add("@Description", entity.Description);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
/// <summary>
/// insert one Form1 to database
/// </summary>
public override void Insert(SqlTransaction transaction, Form1Info entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [form_1] (");
sb.Append("[form_no],");
sb.Append("[amount],");
sb.Append("[leader],");
sb.Append("[manager] ");
sb.Append(" ) values ( ");
sb.Append("@FormNo,");
sb.Append("@Amount,");
sb.Append("@Leader,");
sb.Append("@Manager ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@FormNo", entity.FormNo);
paramList.Add("@Amount", entity.Amount);
paramList.Add("@Leader", entity.Leader);
paramList.Add("@Manager", entity.Manager);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
/// <summary>
/// insert one Participant to database
/// </summary>
public override void Insert(SqlTransaction transaction, ParticipantInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [participant] (");
sb.Append("[participant_id],");
sb.Append("[participant_kind],");
sb.Append("[relation_id],");
sb.Append("[active_id] ");
sb.Append(" ) values ( ");
sb.Append("@ParticipantId,");
sb.Append("@ParticipantKind,");
sb.Append("@RelationId,");
sb.Append("@ActiveId ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@ParticipantId", entity.ParticipantId);
paramList.Add("@ParticipantKind", entity.ParticipantKind);
paramList.Add("@RelationId", entity.RelationId);
paramList.Add("@ActiveId", entity.ActiveId);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
public void ParseBedrijfsPromotor_ValidInputParameters_ReturnsBedrijfsPromotor()
{
//Arrange
var naam = ParameterBuilder.String();
var voornaam = ParameterBuilder.String();
var email = ParameterBuilder.String();
var telefoon = ParameterBuilder.String();
var titel = ParameterBuilder.String();
var bedrijfsId = ParameterBuilder.Int();
//Act
var result =
_parseService.ParseBedrijfsPromotor(naam, voornaam, email, telefoon, titel, bedrijfsId) as
Bedrijfspromotor;
//Assert
Assert.That(result.Achternaam, Is.EqualTo(naam));
Assert.That(result.Voornaam, Is.EqualTo(voornaam));
Assert.That(result.Email, Is.EqualTo(email));
Assert.That(result.Telefoonnummer, Is.EqualTo(telefoon));
Assert.That(result.Title, Is.EqualTo(titel));
Assert.That(result.BedrijfInDienstId, Is.EqualTo(bedrijfsId));
}
public virtual void UpdateExecutionSuspensionStateByProcessDefinitionKey(string processDefinitionKey, ISuspensionState suspensionState)
{
//IDictionary<string, object> parameters = new Dictionary<string, object>();
//parameters["processDefinitionKey"] = processDefinitionKey;
//parameters["isTenantIdSet"] = false;
//parameters["suspensionState"] = suspensionState.StateCode
//DbEntityManager.Update(typeof(ExecutionEntity), "updateExecutionSuspensionStateByParameters", ConfigureParameterizedQuery(parameters)); ;
var predicateProc = ParameterBuilder.True <ProcessDefinitionEntity>();
var predicateExec = ParameterBuilder.True <ExecutionEntity>();
if (!string.IsNullOrEmpty(processDefinitionKey))
{
predicateProc = predicateProc.AndParam(c => c.Key == processDefinitionKey);
predicateExec = predicateExec.AndParam(c => DbContext.Set <ProcessDefinitionEntity>().Where(predicateProc).Select(p => p.Id).ToList().Contains(c.ProcessDefinitionId));
}
Find(predicateExec).ForEach(d =>
{
d.Revision = d.RevisionNext;
d.SuspensionState = suspensionState.StateCode;
});
//DbContext.SaveChanges();
}
private static void DefineMethod(TypeBuilder proxyTB, IPersistentVector sig)
{
Symbol mname = (Symbol)sig.nth(0);
Type[] paramTypes = GenClass.CreateTypeArray((ISeq)sig.nth(1));
Type retType = (Type)sig.nth(2);
ISeq pmetas = (ISeq)(sig.count() >= 4 ? sig.nth(3) : null);
MethodBuilder mb = proxyTB.DefineMethod(mname.Name, MethodAttributes.Abstract | MethodAttributes.Public | MethodAttributes.Virtual, retType, paramTypes);
SetCustomAttributes(mb, GenInterface.ExtractAttributes(RT.meta(mname)));
int i = 1;
for (ISeq s = pmetas; s != null; s = s.next(), i++)
{
IPersistentMap meta = GenInterface.ExtractAttributes((IPersistentMap)s.first());
if (meta != null && meta.count() > 0)
{
ParameterBuilder pb = mb.DefineParameter(i, ParameterAttributes.None, String.Format("p_{0}", i));
GenInterface.SetCustomAttributes(pb, meta);
}
}
}
protected virtual SqlPreCommandSimple InsertRelationalTableScript(Table table, DatabaseName newDatabaseName, TableMList rt)
{
ParameterBuilder pb = Connector.Current.ParameterBuilder;
var created = table.Mixins[typeof(DisconnectedCreatedMixin)].Columns().Single();
string command = @"INSERT INTO {0} ({1})
SELECT {2}
FROM {3} as [relationalTable]
JOIN {4} [table] on [relationalTable].{5} = [table].{6}
WHERE [table].{7} = 1".FormatWith(
rt.Name,
rt.Columns.Values.ToString(c => c.Name.SqlEscape(), ", "),
rt.Columns.Values.ToString(c => "[relationalTable]." + c.Name.SqlEscape(), ", "),
rt.Name.OnDatabase(newDatabaseName),
table.Name.OnDatabase(newDatabaseName),
rt.BackReference.Name.SqlEscape(),
table.PrimaryKey.Name.SqlEscape(),
created.Name.SqlEscape());
var sql = new SqlPreCommandSimple(command);
return(sql);
}
public List <Transaction> Detail(string payout_id, PayoutReportDetailSearchParams searchParams)
{
string url = "/reports/payout/" + payout_id + "/detail";
if (searchParams != null)
{
if (searchParams.Offset < 0)
{
throw new ArgumentOutOfRangeException("offset");
}
if (searchParams.Limit < 1 || searchParams.Limit > 100)
{
throw new ArgumentOutOfRangeException("limit");
}
url = ParameterBuilder.ApplyParameterToUrl(url, "limit", searchParams.Limit.ToString());
url = ParameterBuilder.ApplyParameterToUrl(url, "offset", searchParams.Offset.ToString());
if (searchParams.DetailType != null)
{
url = ParameterBuilder.ApplyParameterToUrl(url, "detail_type", searchParams.DetailType);
}
}
return(base.List <Transaction>(url));
}
/// <summary>
/// insert one FormCodeList to database
/// </summary>
public override void Insert(SqlTransaction transaction, FormCodeListInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [form_code_List] (");
sb.Append("[form_kind],");
sb.Append("[code_kind],");
sb.Append("[code_detail_des],");
sb.Append("[code_detail_value] ");
sb.Append(" ) values ( ");
sb.Append("@FormKind,");
sb.Append("@CodeKind,");
sb.Append("@CodeDetailDes,");
sb.Append("@CodeDetailValue ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@FormKind", entity.FormKind);
paramList.Add("@CodeKind", entity.CodeKind);
paramList.Add("@CodeDetailDes", entity.CodeDetailDes);
paramList.Add("@CodeDetailValue", entity.CodeDetailValue);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
/// <summary>
/// insert one SysCodeList to database
/// </summary>
public override void Insert(SqlTransaction transaction, SysCodeList entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [sys_code_list] (");
sb.Append("[main_key],");
sb.Append("[sub_key],");
sb.Append("[content],");
sb.Append("[description] ");
sb.Append(" ) values ( ");
sb.Append("@MainKey,");
sb.Append("@SubKey,");
sb.Append("@Content,");
sb.Append("@Description ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@MainKey", entity.MainKey);
paramList.Add("@SubKey", entity.SubKey);
paramList.Add("@Content", entity.Content);
paramList.Add("@Description", entity.Description);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
public void Setup()
{
_mocker = AutoMock.GetLoose();
var claimsPrincipal = new ClaimsPrincipalBuilder()
.WithRole(AppRoles.JudgeRole)
.WithClaim(ClaimTypes.GivenName, "John")
.WithClaim(ClaimTypes.Surname, "Doe")
.WithClaim("name", "John D")
.Build();
var context = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = claimsPrincipal
}
};
_mocker.Mock <IMapperFactory>().Setup(x => x.Get <UserProfile, UserProfileResponse>()).Returns(_mocker.Create <UserProfileToUserProfileResponseMapper>());
var parameters = new ParameterBuilder(_mocker).AddObject(new DictionaryUserCache()).Build();
_sut = _mocker.Create <ProfilesController>(parameters);
_sut.ControllerContext = context;
}
/// <summary>
/// insert one SysDept to database
/// </summary>
public override void Insert(SqlTransaction transaction, SysDeptInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [sys_dept] (");
sb.Append("[dept_id],");
sb.Append("[dept_code],");
sb.Append("[dept_name],");
sb.Append("[parent_id] ");
sb.Append(" ) values ( ");
sb.Append("@DeptId,");
sb.Append("@DeptCode,");
sb.Append("@DeptName,");
sb.Append("@ParentId ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@DeptId", entity.DeptId);
paramList.Add("@DeptCode", entity.DeptCode);
paramList.Add("@DeptName", entity.DeptName);
paramList.Add("@ParentId", entity.ParentId);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
internal static void BuildParameter(ParameterBuilder builder, ParameterInfo parameter)
{
Debug.Assert(parameter != null);
Debug.Assert(builder != null);
//
// Build...
//
builder.Name = parameter.Name;
builder.ParameterType = parameter.ParameterType;
builder.IsParamArray = parameter.IsDefined(typeof(ParamArrayAttribute), true);
//
// Modify...
//
object[] modifiers = GetCustomAttributes(parameter, typeof(IParameterModifier), true);
foreach (IParameterModifier modifier in modifiers)
{
modifier.Modify(builder);
}
}
/// <summary>
/// insert one WorkflowActivity to database
/// </summary>
public override void Insert(SqlTransaction transaction, WorkflowActivityInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [WorkFlow_Activity] (");
sb.Append("[ActivityID],");
sb.Append("[ActivityName],");
sb.Append("[WorkFlowID],");
sb.Append("[ActivityType] ");
sb.Append(" ) values ( ");
sb.Append("@Activityid,");
sb.Append("@Activityname,");
sb.Append("@Workflowid,");
sb.Append("@Activitytype ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@Activityid", entity.Activityid);
paramList.Add("@Activityname", entity.Activityname);
paramList.Add("@Workflowid", entity.Workflowid);
paramList.Add("@Activitytype", entity.Activitytype);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
/// <summary>
/// insert one Active to database
/// </summary>
public override void Insert(SqlTransaction transaction, ActiveInfo entity)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(200);
sb.Append("insert into [active] (");
sb.Append("[active_id],");
sb.Append("[active_name],");
sb.Append("[active_type],");
sb.Append("[form_id] ");
sb.Append(" ) values ( ");
sb.Append("@ActiveId,");
sb.Append("@ActiveName,");
sb.Append("@ActiveType,");
sb.Append("@FormId ) ");
ParameterBuilder paramList = new ParameterBuilder(4);
paramList.Add("@ActiveId", entity.ActiveId);
paramList.Add("@ActiveName", entity.ActiveName);
paramList.Add("@ActiveType", entity.ActiveType);
paramList.Add("@FormId", entity.FormId);
SqlHelper.ExecuteNonQuery(transaction, CommandType.Text, sb.ToString(), paramList.ToArray());
}
public void TestForEveryParameterAtributeFlag()
{
string strParamName = null;
ParameterAttributes[] attributes = new ParameterAttributes[] {
ParameterAttributes.HasDefault,
ParameterAttributes.HasFieldMarshal,
ParameterAttributes.In,
ParameterAttributes.None,
ParameterAttributes.Optional,
ParameterAttributes.Out,
ParameterAttributes.Retval
};
Type[] paramTypes = new Type[attributes.Length];
for (int i = 0; i < paramTypes.Length; ++i)
{
paramTypes[i] = typeof(int);
}
TypeBuilder typeBuilder = GetTestTypeBuilder();
MethodBuilder builder = typeBuilder.DefineMethod(
PosTestDynamicMethodName,
TestMethodAttributes,
typeof(void),
paramTypes);
for (int i = 1; i < attributes.Length; ++i)
{
strParamName = _generator.GetString(false, false, true, MinStringLength, MaxStringLength);
ParameterBuilder paramBuilder = builder.DefineParameter(i, attributes[i], strParamName);
Assert.NotNull(paramBuilder);
VerifyParameterBuilder(paramBuilder, strParamName, attributes[i], i);
}
}
public void LoadArticles()
{
var mockService = new Mock <IArticleService>();
var testArticles = new List <Article>()
{
new Article()
{
Id = 1,
Text = "Bla",
Heading = "Heading",
CreatedAt = DateTime.Now,
CreatedById = 1
}
};
mockService.Setup(x => x.GetAll()).Returns(testArticles);
var testParameter = new ArticlesOverviewParameter()
{
BackgroundColorHex = "#cccccc"
};
var testModule = new Domain.Module()
{
Parameter = ParameterBuilder.Serialize(testParameter)
};
var fakeView = new FakeArticlesView();
var presenter = new ArticleOverviewPresenter(fakeView, testModule, mockService.Object);
presenter.LoadArticles();
Assert.AreEqual(fakeView.Articles.Count, testArticles.Count);
Assert.AreEqual(fakeView.BackgroundColorHex, testParameter.BackgroundColorHex);
}
private void ResolveProjection(ParameterBuilder builder, LambdaExpression lambdaExpression, Type sourceType)
{
Contract.Requires(lambdaExpression != null);
var selectFunction = lambdaExpression.Body as NewExpression;
if (selectFunction != null)
{
#if !NETFX_CORE
var properties = sourceType.GetProperties();
#else
var properties = sourceType.GetTypeInfo().DeclaredProperties;
#endif
var members = selectFunction.Members
.Select(x => properties.FirstOrDefault(y => y.Name == x.Name) ?? x)
.Select(x => _memberNameResolver.ResolveName(x))
.ToArray();
var args = selectFunction.Arguments.OfType <MemberExpression>()
.Select(x => properties.FirstOrDefault(y => y.Name == x.Member.Name) ?? x.Member)
.Select(x => _memberNameResolver.ResolveName(x))
.ToArray();
if (members.Intersect(args).Count() != members.Length)
{
throw new InvalidOperationException("Projection into new member names is not supported.");
}
builder.SelectParameter = string.Join(",", args);
}
var propertyExpression = lambdaExpression.Body as MemberExpression;
if (propertyExpression != null)
{
builder.SelectParameter = string.IsNullOrWhiteSpace(builder.SelectParameter)
? _memberNameResolver.ResolveName(propertyExpression.Member)
: builder.SelectParameter + "," + _memberNameResolver.ResolveName(propertyExpression.Member);
}
}
/// <summary>
/// Copies parameter attributes. This is used to copy marshalling attributes and other relevant data.
/// </summary>
/// <param name="builder"></param>
/// <param name="parameter"></param>
private static void CopyParameterAttributes(ParameterBuilder builder, ParameterInfo parameter)
{
#if NET35
var attribData = CustomAttributeData.GetCustomAttributes(parameter);
#else
var attribData = parameter.GetCustomAttributesData();
#endif
foreach (var attrib in attribData) //.CustomAttributes)
{
if (attrib.NamedArguments == null || attrib.NamedArguments.Count == 0)
{
continue;
}
// The marshaller will prefer to use the MarshalType over MarshalTypeRef.
// and will automatically set MarshalType if you specify MarshalTypeRef.
// this will make it unable to locate the type (since without assembly specification, it will look in the dynamic assembly)
// Therefore we have to remove MarshalType if both MarshalType and MarshalTypeRef is set.
var namedArguments = FixMarshalTypeAttributes(attrib.NamedArguments).ToArray();
var attribBuilder = new CustomAttributeBuilder(
attrib.Constructor,
attrib.ConstructorArguments.Select(a => a.Value).ToArray(),
attrib.NamedArguments.Where(a => a.MemberInfo.MemberType != MemberTypes.Field)
.Select(s => s.MemberInfo)
.OfType <PropertyInfo>()
.ToArray(),
attrib.NamedArguments.Where(a => a.MemberInfo.MemberType != MemberTypes.Field)
.Select(s => s.TypedValue)
.Select(s => s.Value)
.ToArray(),
namedArguments.Where(a => a.MemberInfo.MemberType == MemberTypes.Field).Select(s => s.MemberInfo).OfType <FieldInfo>().ToArray(),
namedArguments.Where(a => a.MemberInfo.MemberType == MemberTypes.Field).Select(s => s.TypedValue).Select(s => s.Value).ToArray());
builder.SetCustomAttribute(attribBuilder);
}
}
public void Should_return_response_with_settings()
{
var securitySettings = new AzureAdConfiguration
{
ClientId = "ClientId",
ClientSecret = "ClientSecret",
TenantId = "TenantId",
Authority = "Authority",
ApplicationInsights = new ApplicationInsightsConfiguration {
InstrumentationKey = "AiKey"
}
};
var servicesConfiguration = new HearingServicesConfiguration
{
VideoApiUrl = "https://vh-video-api/"
};
var kinlyConfiguration = new KinlyConfiguration
{
JoinByPhoneFromDate = "2021-02-09"
};
var parameters = new ParameterBuilder(_mocker).AddObject(Options.Create(securitySettings))
.AddObject(Options.Create(servicesConfiguration))
.AddObject(kinlyConfiguration).Build();
var configSettingsController = _mocker.Create <ConfigSettingsController>(parameters);
var actionResult = (OkObjectResult)configSettingsController.GetClientConfigurationSettings().Result;
var clientSettings = (ClientSettingsResponse)actionResult.Value;
clientSettings.ClientId.Should().Be(securitySettings.ClientId);
clientSettings.TenantId.Should().Be(securitySettings.TenantId);
clientSettings.VideoApiUrl.Should().Be(servicesConfiguration.VideoApiUrl);
clientSettings.JoinByPhoneFromDate.Should().Be(kinlyConfiguration.JoinByPhoneFromDate);
}
public RawImageDialog()
{
InitializeComponent();
_encodingsBuilder = new ParameterBuilder(encodingParameters);
_palEncodingBuilder = new ParameterBuilder(palEncodingParameters);
_swizzlesBuilder = new ParameterBuilder(swizzleParameters);
_encodingsBuilder.ValueChanged += _encodingsBuilder_ValueChanged;
_swizzlesBuilder.ValueChanged += _swizzlesBuilder_ValueChanged;
encodings.DataStore = GetEncodings().Select(x => new ExtensionTypeElement(x)).ToList();
palEncodings.DataStore = GetPaletteEncodings().Select(x => new ExtensionTypeElement(x)).ToList();
swizzles.DataStore = GetSwizzles().Select(x => new ExtensionTypeElement(x)).ToList();
encodings.SelectedValueChanged += Encodings_SelectedValueChanged;
palEncodings.SelectedValueChanged += PalEncodings_SelectedValueChanged;
swizzles.SelectedValueChanged += Swizzles_SelectedValueChanged;
encodings.SelectedValue = encodings.DataStore.First();
palEncodings.SelectedValue = palEncodings.DataStore.First();
swizzles.SelectedValue = swizzles.DataStore.First();
widthText.TextChanged += WidthText_TextChanged;
heightText.TextChanged += HeightText_TextChanged;
offsetText.TextChanged += OffsetText_TextChanged;
palOffsetText.TextChanged += PalOffsetText_TextChanged;;
#region Commands
openFileCommand.Executed += OpenFileCommand_Executed;
closeFileCommand.Executed += CloseFileCommand_Executed;
extractImageCommand.Executed += ExtractImageCommand_Executed;
processCommand.Executed += ProcessCommand_Executed;
#endregion
}
/// <inheritdoc/>
public IParameterBuilderWithParameter And <TParam, TValue>(params Expression <Func <TParam, TValue> >[] accessorExpressions)
{
if (accessorExpressions == null)
{
throw new ArgumentNullException("accessorExpressions");
}
ParameterBuilder builder = this;
foreach (var a in accessorExpressions)
{
// attempt to get the name of the parameter off of a simple expression
string alias = null;
MemberExpression expression = a.Body as MemberExpression;
if (expression != null)
{
alias = expression.Member.Name;
}
builder = AndImpl(null, alias, a);
}
return(builder);
}
public void ParseBedrijf_ValidInputParameters_ReturnsBedrijf()
{
//Arrange
var name = ParameterBuilder.String();
var adress = ParameterBuilder.String();
var postalCode = ParameterBuilder.Int();
var city = ParameterBuilder.String();
var phoneNumber = ParameterBuilder.String();
var email = ParameterBuilder.String();
var handShake = ParameterBuilder.Bool();
//Act
var result = _parseService.ParseBedrijf
(name, adress, postalCode, city, phoneNumber, email, handShake) as Bedrijf;
//Assert
Assert.That(result.Bedrijfsnaam, Is.EqualTo(name));
Assert.That(result.Adres, Is.EqualTo(adress));
Assert.That(result.Postcode, Is.EqualTo(postalCode));
Assert.That(result.Gemeente, Is.EqualTo(city));
Assert.That(result.Telefoonnummer, Is.EqualTo(phoneNumber));
Assert.That(result.Email, Is.EqualTo(email));
Assert.That(result.AanwezigheidHandshake, Is.EqualTo(handShake));
}
/// <inheritdoc />
public IParameterBuilder BuildParameter(ICommandBuilder command, ParameterInfo parameterInfo)
{
command.NotNull(nameof(command));
parameterInfo.NotNull(nameof(parameterInfo));
if (!IsParameter(command, parameterInfo))
{
throw new ArgumentException(nameof(parameterInfo), $"{parameterInfo.Name} is not a valid parameter.");
}
var name = GetName(parameterInfo);
var description = GetDescription(parameterInfo);
var remarks = GetRemarks(parameterInfo);
var isRemainder = GetRemainder(parameterInfo);
var isParams = GetParams(parameterInfo);
var isOptional = GetOptional(parameterInfo);
var defaultValue = GetDefaultValue(parameterInfo);
var typeParserType = GetTypeParserType(parameterInfo);
var attributes = GetAttributes(parameterInfo);
var preconditions = GetPreconditions(attributes);
var builder = new ParameterBuilder()
.WithParameterInfo(parameterInfo)
.WithName(name)
.WithDescription(description)
.WithRemarks(remarks)
.WithRemainder(isRemainder)
.WithParams(isParams)
.WithOptional(isOptional)
.WithDefaultValue(defaultValue)
.WithTypeParserType(typeParserType)
.WithAttributes(attributes)
.WithPreconditions(preconditions);
return(builder);
}
public void TestWithGenericAndNonGenericParameters()
{
string methodName = null;
string strParamName = null;
methodName = TestLibrary.Generator.GetString(false, false, true, MinStringLength, MaxStringLength);
strParamName = TestLibrary.Generator.GetString(false, false, true, MinStringLength, MaxStringLength);
Type[] paramTypes = new Type[] { typeof(int) };
TypeBuilder typeBuilder = GetTestTypeBuilder();
MethodBuilder builder = typeBuilder.DefineMethod(
methodName,
TestMethodAttributes,
typeof(void),
paramTypes);
string[] typeParamNames = { "T" };
GenericTypeParameterBuilder[] parameters = builder.DefineGenericParameters(typeParamNames);
ParameterBuilder paramBuilder = builder.DefineParameter(
1,
ParameterAttributes.HasDefault,
strParamName);
Assert.True(builder.IsGenericMethodDefinition);
}
/// <summary>
/// Add a parameter for this operation
/// </summary>
/// <param name="parameter">
/// The parameter.
/// </param>
/// <returns>
/// The <see cref="OperationBuilder"/>.
/// </returns>
public OperationBuilder Parameter(Action<ParameterBuilder> parameter)
{
var builder = new ParameterBuilder();
parameter(builder);
return this.Parameter(builder.Build());
}
public JunctionBuilder(JunctionType type, ParameterBuilder other)
: this(type)
{
Other = other;
}
//Examples of generated code
// public static XWeak constructor1(XComponentContext ctx)
// {
// XMultiComponentFactory factory = ctx.getServiceManager();
// if (factory == null)
// throw new com.sun.star.uno.DeploymentException("bla", null);
// return (XWeak) factory.createInstanceWithContext("service_specifier", ctx);
// }
// public static XWeak constructor2(XComponentContext ctx, int a, int b)
// {
// XMultiComponentFactory factory = ctx.getServiceManager();
// if (factory == null)
// throw new com.sun.star.uno.DeploymentException("bla", null);
// Any a1;
// a1 = new Any( typeof(int), a);
// Any a2;
// a2 = new Any( typeof(int), b);
// Any[] arAny = new Any[2];
// arAny[0] = a1;
// arAny[1] = a2;
// return (XWeak) factory.createInstanceWithArgumentsAndContext("service_specifier", arAny, ctx);
// }
// public static XWeak constructor3(XComponentContext ctx, params Any[] c)
// {
// XMultiComponentFactory factory = ctx.getServiceManager();
// if (factory == null)
// throw new com.sun.star.uno.DeploymentException("bla", null);
// return (XWeak) factory.createInstanceWithArgumentsAndContext("service_specifier", c, ctx);
// }
Type complete_service_type(service_entry entry)
{
TypeBuilder type_builder = entry.m_type_builder;
XServiceTypeDescription2 xServiceType = entry.m_xType;
// Create the private default constructor
ConstructorBuilder ctor_builder =
type_builder.DefineConstructor(
(MethodAttributes.Private |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName),
CallingConventions.Standard, null);
ILGenerator code = ctor_builder.GetILGenerator();
code.Emit(OpCodes.Ldarg_0); // push this
code.Emit(OpCodes.Call,
type_builder.BaseType.GetConstructor(new Type[0]));
code.Emit(OpCodes.Ret);
// Create the service constructors.
// optain the interface which makes up this service, it is the
// return type of the constructor functions
XInterfaceTypeDescription2 xIfaceType =
xServiceType.getInterface() as XInterfaceTypeDescription2;
if (xIfaceType == null)
xIfaceType = resolveInterfaceTypedef(xServiceType.getInterface());
Type retType = get_type(xIfaceType);
// Create the ConstructorInfo for a DeploymentException
Type typeDeploymentExc =
get_type("unoidl.com.sun.star.uno.DeploymentException", true);
Type[] typeCtor = new Type[] { typeof(System.String),
typeof(System.Object) };
ConstructorInfo ctorDeploymentException =
typeDeploymentExc.GetConstructor(typeCtor);
XServiceConstructorDescription[] ctors =
xServiceType.getConstructors();
Type type_uno_exception =
get_type("unoidl.com.sun.star.uno.Exception", true);
for (int i = ctors.Length - 1; i >= 0; --i)
{
bool bParameterArray = false;
Type typeAny = typeof(uno.Any);
XServiceConstructorDescription ctorDes = ctors[i];
// obtain the parameter types
XParameter[] xParams = ctorDes.getParameters();
Type[] typeParameters = new Type[xParams.Length + 1];
typeParameters[0] =
get_type("unoidl.com.sun.star.uno.XComponentContext", true);
for (int iparam = 0; iparam != xParams.Length; ++iparam)
{
if (xParams[iparam].isRestParameter())
typeParameters[iparam + 1] = typeof(uno.Any[]);
else
typeParameters[iparam + 1] =
get_type(xParams[iparam].getType());
}
// define method
string ctorName;
if (ctorDes.isDefaultConstructor())
ctorName = "create";
else
ctorName = ctorDes.getName();
MethodBuilder method_builder = type_builder.DefineMethod(
ctorName,
(MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.Static),
retType,
typeParameters);
// define UNO exception attribute (exceptions)
CustomAttributeBuilder attrBuilder =
get_service_exception_attribute(ctorDes);
if (attrBuilder != null)
method_builder.SetCustomAttribute(attrBuilder);
// define parameter attributes (paramarray), names etc.
// The first parameter is the XComponentContext, which cannot be
// obtained from reflection.
// The context is not part of the idl description
/* ParameterBuilder param_builder = */
method_builder.DefineParameter(
1, ParameterAttributes.In, "the_context");
ParameterBuilder[] parameterBuilders =
new ParameterBuilder[xParams.Length];
for (int iparam = 0; iparam != xParams.Length + 1; ++iparam)
{
parameterBuilders[iparam] = method_builder.DefineParameter(
iparam + 2, ParameterAttributes.In,
xParams[iparam].getName());
if (xParams[iparam].isRestParameter())
{
bParameterArray = true;
// set the ParameterArrayAttribute
ConstructorInfo ctor_info =
typeof(System.ParamArrayAttribute).GetConstructor(
new Type[0]);
CustomAttributeBuilder attr_builder =
new CustomAttributeBuilder(ctor_info, new object[0]);
parameterBuilders[iparam].SetCustomAttribute(attr_builder);
break;
}
}
ILGenerator ilGen = method_builder.GetILGenerator();
// Define locals
// XMultiComponentFactory
LocalBuilder local_factory = ilGen.DeclareLocal(
get_type("unoidl.com.sun.star.lang.XMultiComponentFactory",
true));
// The return type
LocalBuilder local_return_val = ilGen.DeclareLocal(retType);
// Obtain the XMultiComponentFactory and throw an exception if we
// do not get one
ilGen.Emit(OpCodes.Ldarg_0);
MethodInfo methodGetServiceManager = get_type(
"unoidl.com.sun.star.uno.XComponentContext", true)
.GetMethod("getServiceManager");
ilGen.Emit(OpCodes.Callvirt, methodGetServiceManager);
ilGen.Emit(OpCodes.Stloc, local_factory);
ilGen.Emit(OpCodes.Ldloc, local_factory);
Label label1 = ilGen.DefineLabel();
ilGen.Emit(OpCodes.Brtrue, label1);
ilGen.Emit(OpCodes.Ldstr,
String.Format("The service unoidl.{0} could not be created. The context failed to supply the service manager.",
xServiceType.getName()));
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Newobj, ctorDeploymentException);
ilGen.Emit(OpCodes.Throw);
ilGen.MarkLabel(label1);
// We create a try/catch around the createInstanceWithContext,
// etc. functions
// There are 3 cases
// 1. function do not specify exceptions. Then
// RuntimeExceptions are retrhown and other exceptions
// produce a DeploymentException.
// 2. function specify Exception. Then all exceptions fly
// through
// 3. function specifies exceptions but no Exception. Then
// these are rethrown and other exceptions, except
// RuntimeException, produce a deployment exception.
// In case there are no parameters we call
// XMultiComponentFactory.createInstanceWithContext
ArrayList exceptionTypes =
get_service_ctor_method_exceptions_reduced(
ctorDes.getExceptions());
if (! exceptionTypes.Contains(type_uno_exception))
{
ilGen.BeginExceptionBlock();
}
if (xParams.Length == 0)
{
ilGen.Emit(OpCodes.Ldloc, local_factory);
ilGen.Emit(OpCodes.Ldstr, to_cts_name(xServiceType.getName()));
ilGen.Emit(OpCodes.Ldarg_0);
MethodInfo methodCIWAAC =
local_factory.LocalType.GetMethod(
"createInstanceWithArgumentsAndContext");
ilGen.Emit(OpCodes.Callvirt, methodCIWAAC);
}
else if (bParameterArray)
{
// Service constructor with parameter array
ilGen.Emit(OpCodes.Ldloc, local_factory);
ilGen.Emit(OpCodes.Ldstr, to_cts_name(xServiceType.getName()));
ilGen.Emit(OpCodes.Ldarg_1);
ilGen.Emit(OpCodes.Ldarg_0);
MethodInfo methodCIWAAC =
local_factory.LocalType.GetMethod(
"createInstanceWithArgumentsAndContext");
ilGen.Emit(OpCodes.Callvirt, methodCIWAAC);
}
else
{
// Any param1, Any param2, etc.
// For each parameter, except the component context, and
// the parameter array an Any is created.
LocalBuilder[] localAnys = new LocalBuilder[xParams.Length];
for (int iparam = 0; iparam < xParams.Length; ++iparam)
{
localAnys[iparam] = ilGen.DeclareLocal(typeAny);
}
// Any[]. This array is filled with the created Anys
// which contain the parameters and the values
// contained in the parameter array
LocalBuilder local_anyParams =
ilGen.DeclareLocal(typeof(uno.Any[]));
// Create the Any for every argument, except for the
// parameter array. localAnys contains the LocalBuilder for
// all these parameters. We call the ctor Any(Type, Object)
Type[] typesCtorAny = { typeof(System.Type),
typeof(System.Object) };
ConstructorInfo ctorAny =
typeAny.GetConstructor(typesCtorAny);
for (int j = 0; j < localAnys.Length; ++j)
{
ilGen.Emit(OpCodes.Ldloca, localAnys[j]);
ilGen.Emit(OpCodes.Ldtoken, typeParameters[j+1]);
Type[] typeParams = { typeof(System.RuntimeTypeHandle) };
ilGen.Emit(OpCodes.Call,
typeof(System.Type).GetMethod(
"GetTypeFromHandle", typeParams));
ilGen.Emit(OpCodes.Ldarg, j + 1);
// if the parameter is a value type then we need
// to box it, because the Any ctor takes an Object
if (typeParameters[j+1].IsValueType)
ilGen.Emit(OpCodes.Box, typeParameters[j+1]);
ilGen.Emit(OpCodes.Call, ctorAny);
}
// Create the Any[] that is passed to the
// createInstanceWithContext[AndArguments] function
ilGen.Emit(OpCodes.Ldc_I4, localAnys.Length);
ilGen.Emit(OpCodes.Newarr, typeAny);
ilGen.Emit(OpCodes.Stloc, local_anyParams);
// Assign all anys created from the parameters array
// to the Any[]
for (int j = 0; j < localAnys.Length; ++j)
{
ilGen.Emit(OpCodes.Ldloc, local_anyParams);
ilGen.Emit(OpCodes.Ldc_I4, j);
ilGen.Emit(OpCodes.Ldelema, typeAny);
ilGen.Emit(OpCodes.Ldloc, localAnys[j]);
ilGen.Emit(OpCodes.Stobj, typeAny);
}
// call createInstanceWithContextAndArguments
ilGen.Emit(OpCodes.Ldloc, local_factory);
ilGen.Emit(OpCodes.Ldstr, to_cts_name(xServiceType.getName()));
ilGen.Emit(OpCodes.Ldloc, local_anyParams);
ilGen.Emit(OpCodes.Ldarg_0);
MethodInfo methodCIWAAC =
local_factory.LocalType.GetMethod(
"createInstanceWithArgumentsAndContext");
ilGen.Emit(OpCodes.Callvirt, methodCIWAAC);
}
// cast the object returned by the functions
// createInstanceWithContext or
// createInstanceWithArgumentsAndContext to the interface type
ilGen.Emit(OpCodes.Castclass, retType);
ilGen.Emit(OpCodes.Stloc, local_return_val);
// catch exceptions thrown by createInstanceWithArgumentsAndContext
// and createInstanceWithContext
if (!exceptionTypes.Contains(type_uno_exception))
{
// catch (unoidl.com.sun.star.uno.RuntimeException) {throw;}
ilGen.BeginCatchBlock(
get_type(
"unoidl.com.sun.star.uno.RuntimeException", true));
ilGen.Emit(OpCodes.Pop);
ilGen.Emit(OpCodes.Rethrow);
// catch and rethrow all other defined Exceptions
foreach (Type excType in exceptionTypes)
{
if (excType.IsInstanceOfType(
get_type(
"unoidl.com.sun.star.uno.RuntimeException",
true)))
{
// we have a catch for RuntimeException already defined
continue;
}
// catch Exception and rethrow
ilGen.BeginCatchBlock(excType);
ilGen.Emit(OpCodes.Pop);
ilGen.Emit(OpCodes.Rethrow);
}
// catch (unoidl.com.sun.star.uno.Exception)
// { throw DeploymentException... }
ilGen.BeginCatchBlock(type_uno_exception);
// define the local variable that keeps the exception
LocalBuilder local_exception = ilGen.DeclareLocal(
type_uno_exception);
// Store the exception
ilGen.Emit(OpCodes.Stloc, local_exception);
// prepare the construction of the exception
ilGen.Emit(OpCodes.Ldstr,
"The context (com.sun.star.uno.XComponentContext)" +
"failed to supply the service " +
to_cts_name(xServiceType.getName()) +
": ");
// add to the string the Exception.Message
ilGen.Emit(OpCodes.Ldloc, local_exception);
ilGen.Emit(OpCodes.Callvirt,
type_uno_exception.GetProperty("Message")
.GetGetMethod());
Type[] concatParams = new Type[] { typeof(System.String),
typeof(System.String) };
ilGen.Emit(OpCodes.Call,
typeof(System.String).GetMethod("Concat",
concatParams));
// load context argument
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Newobj, ctorDeploymentException);
ilGen.Emit(OpCodes.Throw); // Exception(typeDeploymentExc);
ilGen.EndExceptionBlock();
}
// Check if the service instance was create and throw an
// exception if not.
Label label_service_created = ilGen.DefineLabel();
ilGen.Emit(OpCodes.Ldloc, local_return_val);
ilGen.Emit(OpCodes.Brtrue_S, label_service_created);
ilGen.Emit(OpCodes.Ldstr,
"The context (com.sun.star.uno.XComponentContext)" +
"failed to supply the service unoidl." +
to_cts_name(xServiceType.getName()) +
".");
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Newobj, ctorDeploymentException);
ilGen.Emit(OpCodes.Throw); // Exception(typeDeploymentExc);
ilGen.MarkLabel(label_service_created);
ilGen.Emit(OpCodes.Ldloc, local_return_val);
ilGen.Emit(OpCodes.Ret);
}
// remove from incomplete types map
m_incomplete_services.Remove(type_builder.FullName);
if (Climaker.g_verbose)
{
Console.WriteLine("> emitting service type {0}",
type_builder.FullName);
}
return type_builder.CreateType();
}
private static void VerifyParameterBuilder(ParameterBuilder parameter, string expectedName, ParameterAttributes expectedAttributes, int expectedPosition)
{
// This constant maps to ParameterAttributes.ReservedMask that is not available in the contract.
const int ReservedMaskParameterAttribute = 0xF000;
Assert.Equal(expectedName, parameter.Name);
int removedReservedAttributes = (int)expectedAttributes & ~ReservedMaskParameterAttribute;
Assert.Equal(removedReservedAttributes, (parameter.Attributes & removedReservedAttributes));
Assert.Equal(expectedPosition, parameter.Position);
}
/// <summary>
/// Add a parameter for this operation
/// </summary>
/// <param name="parameter">
/// The parameter.
/// </param>
/// <returns>
/// The <see cref="PathItemBuilder"/>.
/// </returns>
public PathItemBuilder Parameter(ParameterBuilder parameter)
{
return this.Parameter(parameter.Build());
}
internal override void Apply(ClassLoaderWrapper loader, ParameterBuilder pb, object annotation)
{
if (type.IsSubclassOf(Types.SecurityAttribute))
{
// you can't add declarative security to a parameter
}
else if (type == JVM.Import(typeof(System.Runtime.InteropServices.DefaultParameterValueAttribute)))
{
// TODO with the current custom attribute annotation restrictions it is impossible to use this CA,
// but if we make it possible, we should also implement it here
throw new NotImplementedException();
}
else
{
pb.SetCustomAttribute(MakeCustomAttributeBuilder(loader, annotation));
}
}
internal override void Apply(ClassLoaderWrapper loader, ParameterBuilder pb, object annotation)
{
Annotation annot = type.Annotation;
foreach (object ann in UnwrapArray(annotation))
{
annot.Apply(loader, pb, ann);
}
}
internal override void Apply(ClassLoaderWrapper loader, ParameterBuilder pb, object annotation)
{
}
internal override void ApplyReturnValue(ClassLoaderWrapper loader, MethodBuilder mb, ref ParameterBuilder pb, object annotation)
{
// TODO make sure the descriptor is correct
Annotation ann = type.Annotation;
object[] arr = (object[])annotation;
for (int i = 2; i < arr.Length; i += 2)
{
if ("value".Equals(arr[i]))
{
if (pb == null)
{
pb = mb.DefineParameter(0, ParameterAttributes.None, null);
}
object[] value = (object[])arr[i + 1];
if (value[0].Equals(AnnotationDefaultAttribute.TAG_ANNOTATION))
{
ann.Apply(loader, pb, value);
}
else
{
for (int j = 1; j < value.Length; j++)
{
ann.Apply(loader, pb, value[j]);
}
}
break;
}
}
}
