public DlgResult ShowDialog(object owner)
{
var win32owner = owner as IWin32Window;
if (win32owner != null)
{
return(EnumMapper.GetDlgResult(base.ShowDialog(win32owner)));
}
else
{
return(EnumMapper.GetDlgResult(base.ShowDialog()));
}
}
public MethodDbModel(MethodModel model)
{
Name = model.Name;
Item1 = EnumMapper.ConvertEnum <AccessLevelDbModelEnum, AccessLevelEnum>(model.Modifiers.Item1);
Item2 = EnumMapper.ConvertEnum <AbstractDbModelEnum, AbstractEnum>(model.Modifiers.Item2);
Item3 = EnumMapper.ConvertEnum <StaticDbModelEnum, StaticEnum>(model.Modifiers.Item3);
Item4 = EnumMapper.ConvertEnum <VirtualDbModelEnum, VirtualEnum>(model.Modifiers.Item4);
Item5 = EnumMapper.ConvertEnum <OverrideDbModelEnum, OverrideEnum>(model.Modifiers.Item5);
ReturnType = model.ReturnType;
Extension = model.Extension;
}
public override void Decorate()
{
if (Value != null)
{
try
{
Value = EnumMapper.FormatEnum(localizer, enumType, Value);
}
catch
{
}
}
}
public DlgResult ShowDialog(object owner)
{
var win32owner = owner as System.Windows.Forms.IWin32Window;
if (owner != null)
{
return(EnumMapper.GetDlgResult(_hostDialog.ShowDialog(win32owner)));
}
else
{
return(EnumMapper.GetDlgResult(_hostDialog.ShowDialog()));
}
}
public void EnumsCanBeMappedMultipleTimes(Type enumType)
{
var context = CreateContext();
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
var definitionA = EnumMapper.MapEnum(b, context, enumType);
var definitionB = EnumMapper.MapEnum(b, context, enumType);
Assert.Equal(definitionA, definitionB);
});
}
/// <summary>
/// Prompts the user to select a map size.
/// </summary>
/// <param name="builder"></param>
public static void GetMapSize(IGameOptionsBuilder builder)
{
int choice;
do
{
Console.WriteLine("Choose the map size: ");
Console.WriteLine("1. Large");
Console.WriteLine("2. Medium");
Console.WriteLine("3. Small");
choice = ReadChoice();
} while (choice < 1 || 3 < choice);
builder.SetMapSize(EnumMapper.GetMapSize(choice));
}
public static PwshCommandCompletion ToPwshCompletion(this CommandCompletion completion)
{
return(new PwshCommandCompletion()
{
CurrentMatchIndex = completion.CurrentMatchIndex,
ReplacementIndex = completion.ReplacementIndex,
ReplacementLength = completion.ReplacementLength,
CompletionMatches = completion.CompletionMatches
.Select(x => new PwshCompletionResult(x.CompletionText,
x.ListItemText,
EnumMapper.ToEnum <PwshCompletionResultType, CompletionResultType>(x.ResultType),
x.ToolTip))
.ToList()
});
}
/// <summary>
/// Prompts the user to choose a difficulty setting.
/// </summary>
/// <param name="builder"></param>
public static void GetDifficulty(IGameOptionsBuilder builder)
{
int choice;
do
{
Console.WriteLine("*--- Difficulty ---*");
Console.WriteLine("1. Easy");
Console.WriteLine("2. Normal");
Console.WriteLine("3. Hard");
Console.Write("Choose your difficulty: ");
choice = ReadChoice();
} while (choice < 1 || 3 < choice);
builder.SetDifficulty(EnumMapper.GetDifficulty(choice));
}
public void RenderMyNotifications(object sender, OpenReadCompletedEventArgs e)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(NotificationType[]));
NotificationType[] notifications = serializer.ReadObject(e.Result) as NotificationType[];
EnumMapper mapper = new EnumMapper("NotificationMappings.map");
NotificationCollection.Clear();
foreach (NotificationType type in notifications)
{
NotificationMapper.SetNotificationMessageForNotification(type, (NotificationEnum.Notifications)mapper.GetMappedValue(type.RawType));
NotificationCollection.Add(type);
}
IsLoading = false;
Visible = "Collapsed";
}
/// <summary>
/// Prompts the user to choose a tile style.
/// </summary>
/// <param name="builder"></param>
public static void GetTileStyle(IGameOptionsBuilder builder)
{
int choice;
do
{
Console.WriteLine("*--- Map Style ---*");
Console.WriteLine("1. Square brackets - [ ]");
Console.WriteLine("2. Parentheses - ( )");
Console.WriteLine("3. Curly braces - { }");
Console.Write("Choose the map style: ");
choice = ReadChoice();
} while (choice < 1 || 3 < choice);
builder.SetTileStyle(EnumMapper.GetTileStyle(choice));
}
public async Task <IActionResult> WalletInfo(WalletInfoRequestVM walletInfoRequestVM)
{
try
{
WalletInfoDTO walletInfoDTO = await WalletService.GetWalletInfo(walletInfoRequestVM.Jmbg, walletInfoRequestVM.Password);
WalletInfoResponseVM walletInfoResponseVM =
new WalletInfoResponseVM()
{
Jmbg = walletInfoDTO.Jmbg,
FirstName = walletInfoDTO.FirstName,
LastName = walletInfoDTO.LastName,
BankType = EnumMapper.MapBankType(walletInfoDTO.BankType),
BankAccount = walletInfoDTO.BankAccount,
Balance = walletInfoDTO.Balance,
UsedDepositThisMonth = walletInfoDTO.UsedDepositThisMonth,
MaximalDeposit = walletInfoDTO.MaximalDeposit,
UsedWithdrawThisMonth = walletInfoDTO.UsedWithdrawThisMonth,
MaximalWithdraw = walletInfoDTO.MaximalWithdraw,
IsBlocked = walletInfoDTO.IsBlocked,
TransactionVMs = walletInfoDTO.TransactionDTOs.Select(
transaction => new TransactionResposneVM()
{
Inflow = (EnumMapper.MapTransactionTypeFlow(transaction.Type) == "Inflow" ? transaction.Amount : 0M),
Outflow = (EnumMapper.MapTransactionTypeFlow(transaction.Type) == "Outflow" ? transaction.Amount : 0M),
Destination = transaction.Destination,
Source = transaction.Source,
TransactionDateTime = transaction.TransactionDateTime,
Type = EnumMapper.MapTransactionType(transaction.Type),
WalletBalance = transaction.WalletBalance
}
).OrderByDescending(t => t.TransactionDateTime).ToList()
};
ModelState.Clear();
return(View(new WalletInfoPageVM()
{
WalletInfoResponseVM = walletInfoResponseVM
}));
}
catch (Exception ex)
{
ViewData["IsSuccessful"] = "no";
ViewData["ErrorMessage"] = ex.Message;
return(View());
}
}
private void GenerateEnum(Type enumType)
{
var codeNamespace = GetNamespace(enumType);
var enumKey = EnumMapper.GetEnumTypeKey(enumType);
cw.Indented("export enum ");
var identifier = MakeFriendlyName(enumType, codeNamespace);
generatedTypes.Add((codeNamespace.IsEmptyOrNull() ? "" : codeNamespace + ".") + identifier);
cw.InBrace(delegate
{
var names = Enum.GetNames(enumType);
var values = (IList)Enum.GetValues(enumType);
var inserted = 0;
for (var i = 0; i < names.Length; i++)
{
var name = names[i];
var member = enumType.GetMember(name);
if (member != null && member.Length > 0 &&
member[0].GetAttribute <IgnoreAttribute>(false) != null)
{
continue;
}
if (inserted > 0)
{
sb.AppendLine(",");
}
cw.Indented(name);
sb.Append(" = ");
sb.Append(Convert.ToInt32(values[i]));
inserted++;
}
sb.AppendLine();
});
cw.Indented("Serenity.Decorators.registerEnum(");
sb.Append(enumType.Name);
sb.Append(", '");
sb.Append(enumKey);
sb.AppendLine("');");
}
public SavedXrmRecordConfiguration GetSavedXrmRecordConfiguration()
{
var xrmConfig = GetSavedTestEncryptedXrmConfiguration();
var enumMapper = new EnumMapper <XrmRecordAuthenticationProviderType, AuthenticationProviderType>();
var savedConfig = new SavedXrmRecordConfiguration()
{
Active = true,
AuthenticationProviderType = enumMapper.Map(xrmConfig.AuthenticationProviderType),
DiscoveryServiceAddress = xrmConfig.DiscoveryServiceAddress,
Domain = xrmConfig.Domain,
OrganizationUniqueName = OverrideOrganisation ?? xrmConfig.OrganizationUniqueName,
Password = xrmConfig.Password,
Username = xrmConfig.Username
};
return(savedConfig);
}
private static Func <object, object> GetConverter(IMapper mapper, PocoColumn pc, Type srcType, Type dstType)
{
Func <object, object> converter = null;
// Get converter from the mapper
if (pc != null)
{
converter = mapper.GetFromDbConverter(pc.PropertyInfo, srcType);
if (converter != null)
{
return(converter);
}
}
// Standard DateTime->Utc mapper
if (pc != null && pc.ForceToUtc && srcType == typeof(DateTime) && (dstType == typeof(DateTime) || dstType == typeof(DateTime?)))
{
return(delegate(object src) { return new DateTime(((DateTime)src).Ticks, DateTimeKind.Utc); });
}
// Forced type conversion including integral types -> enum
if (dstType.IsEnum && IsIntegralType(srcType))
{
if (srcType != typeof(int))
{
return(delegate(object src) { return Convert.ChangeType(src, typeof(int), null); });
}
}
else if (!dstType.IsAssignableFrom(srcType))
{
if (dstType.IsEnum && srcType == typeof(string))
{
return(delegate(object src) { return EnumMapper.EnumFromString(dstType, (string)src); });
}
else if (dstType == typeof(Guid) && srcType == typeof(string))
{
return(delegate(object src) { return Guid.Parse((string)src); });
}
else
{
return(delegate(object src) { return Convert.ChangeType(src, dstType, null); });
}
}
return(null);
}
public SavedXrmRecordConfiguration GetSavedXrmRecordConfiguration()
{
var xrmConfig = XrmConfiguration;
var enumMapper = new EnumMapper <XrmRecordAuthenticationProviderType, AuthenticationProviderType>();
var savedConfig = new SavedXrmRecordConfiguration()
{
Active = true,
AuthenticationProviderType = enumMapper.Map(xrmConfig.AuthenticationProviderType),
DiscoveryServiceAddress = xrmConfig.DiscoveryServiceAddress,
Domain = xrmConfig.Domain,
OrganizationUniqueName = OverrideOrganisation ?? xrmConfig.OrganizationUniqueName,
Password = new Password(xrmConfig.Password, false, true),
Username = xrmConfig.Username,
Name = "TESTSCRIPTCONNECTION"
};
return(savedConfig);
}
/// <summary>
/// Creates a map for a property or field given a MemberExpression reading the property or field.
/// This is used for map enums.
/// </summary>
/// <typeparam name="TProperty">The enum type of the property or field to map.</typeparam>
/// <param name="expression">A MemberExpression reading the property or field.</param>
/// <param name="ignoreCase">A flag indicating whether enum parsing is case insensitive.</param>
/// <returns>The map for the given property or field.</returns>
public OneToOneMap <TProperty> Map <TProperty>(Expression <Func <T, TProperty> > expression, bool ignoreCase) where TProperty : struct
{
if (!typeof(TProperty).GetTypeInfo().IsEnum)
{
throw new ArgumentException($"The type ${typeof(TProperty)} must be an Enum.", nameof(TProperty));
}
MemberExpression memberExpression = GetMemberExpression(expression);
var mapper = new EnumMapper(typeof(TProperty), ignoreCase);
ISingleCellValueReader defaultReader = AutoMapper.GetDefaultSingleCellValueReader(memberExpression.Member);
var map = new OneToOneMap <TProperty>(defaultReader)
.WithCellValueMappers(mapper)
.WithThrowingEmptyFallback()
.WithThrowingInvalidFallback();
AddMap(new ExcelPropertyMap <TProperty>(memberExpression.Member, map), expression);
return(map);
}
private static void Continue()
{
Console.WriteLine("Continue: Y | N");
AnswerOption answer = EnumMapper.ReadContinueOption(Console.ReadLine().ToLower().Trim());
switch (answer)
{
case AnswerOption.n:
case AnswerOption.unknown:
break;
case AnswerOption.y:
default:
Console.Clear();
Main();
break;
}
}
public void Mapping_NonExistingEnum_ThrowsMeaningfulException()
{
var enumType = typeof(FakeEnum);
var nonExistentName = "ThisValueDoesNotExistOnAnyEnum";
try
{
EnumMapper.EnumFromString(enumType, nonExistentName);
}
catch (KeyNotFoundException ex)
{
var message = ex.Message;
message.ShouldContain(nonExistentName, "missing value to convert");
message.ShouldContain(enumType.Name, "missing Enum to convert into");
return;
}
Assert.False(true, "Expedted InvalidOperationException");
}
public MethodMetadata(MethodModel model)
{
Name = model.Name;
GenericArguments = model.GenericArguments?.Select(TypeMetadata.EmitTypeMetadata);
Modifiers = new Tuple<AccessLevelEnumMetadata, AbstractEnumMetadata, StaticEnumMetadata,
VirtualEnumMetadata, OverrideEnumMetadata>(
EnumMapper.ConvertEnum<AccessLevelEnumMetadata, AccessLevelEnum>(model.Modifiers.Item1),
EnumMapper.ConvertEnum<AbstractEnumMetadata, AbstractEnum>(model.Modifiers.Item2),
EnumMapper.ConvertEnum<StaticEnumMetadata, StaticEnum>(model.Modifiers.Item3),
EnumMapper.ConvertEnum<VirtualEnumMetadata, VirtualEnum>(model.Modifiers.Item4),
EnumMapper.ConvertEnum<OverrideEnumMetadata, OverrideEnum>(model.Modifiers.Item5)
);
ReturnType = model.ReturnType;
Extension = model.Extension;
Parameters =
model.Parameters.Select(ParameterMetadata.EmitUniqueType);
}
private void GenerateEnum(Type enumType)
{
var codeNamespace = GetNamespace(enumType);
var enumKey = EnumMapper.GetEnumTypeKey(enumType);
cw.Indented("[EnumKey(\"");
sb.Append(enumKey);
sb.AppendLine("\"), PreserveMemberCase]");
cw.Indented("public enum ");
sb.AppendLine(enumType.Name);
cw.InBrace(delegate
{
var names = Enum.GetNames(enumType);
var values = (IList)Enum.GetValues(enumType);
var inserted = 0;
for (var i = 0; i < names.Length; i++)
{
var name = names[i];
var member = enumType.GetMember(name);
if (member != null && member.Length > 0 &&
member[0].GetAttribute <IgnoreAttribute>(false) != null)
{
continue;
}
if (inserted > 0)
{
sb.AppendLine(",");
}
cw.Indented(name);
sb.Append(" = ");
sb.Append(Convert.ToInt32(values[i]));
inserted++;
}
sb.AppendLine();
});
}
public async Task <IActionResult> Post([FromBody] PartnerInvitationRequestInfo request)
{
try
{
if (!ModelState.IsValid)
{
return(this.ApiErrorMessage400BadRequest(ModelState));
}
var jwtPayloadInfo = this.GetJwtPayloadInfo();
var userProfileId = await _bl.GetCachedUserId_byExternalReferenceIdAsync(jwtPayloadInfo.ExtReferenceId);
if (userProfileId == null)
{
return(this.ApiErrorMessage400BadRequestUserIdInTokenNotFound(jwtPayloadInfo.ExtReferenceId));
}
var bl_partnerInvitation = new BL_PartnerInvitation
{
DateOfBirth = request.DateOfBirth,
FirstName = request.FirstName,
InvitedByUserId = userProfileId,
LastName = request.LastName,
MobilePhone = request.MobilePhone,
TypeOfGender = EnumMapper.From(request.TypeOfGender),
};
await _bl.SetPartnerInvitationsAsync(bl_partnerInvitation);
return(this.ApiPostMessage204NotContent());
}
catch (BusinessLogicException ex)
{
HttpContext.Items.Add("ex", ex); //For instrumentation
return(this.ApiErrorMessage400BadRequest(ex));
}
catch (Exception ex)
{
HttpContext.Items.Add("ex", ex); //For instrumentation
return(this.ApiErrorMessage400BadRequest(ex));
}
}
public MethodSerializationModel(MethodModel model)
{
Name = model.Name;
GenericArguments = model.GenericArguments == null ? null :
model.GenericArguments.Select(TypeSerializationModel.EmitTypeSerializationModel);
Modifiers = new Tuple <AccessLevelSerializationModelEnum, AbstractSerializationModelEnum, StaticSerializationModelEnum,
VirtualSerializationModelEnum, OverrideSerializationModelEnum> (
EnumMapper.ConvertEnum <AccessLevelSerializationModelEnum, AccessLevelEnum>(model.Modifiers.Item1),
EnumMapper.ConvertEnum <AbstractSerializationModelEnum, AbstractEnum>(model.Modifiers.Item2),
EnumMapper.ConvertEnum <StaticSerializationModelEnum, StaticEnum>(model.Modifiers.Item3),
EnumMapper.ConvertEnum <VirtualSerializationModelEnum, VirtualEnum>(model.Modifiers.Item4),
EnumMapper.ConvertEnum <OverrideSerializationModelEnum, OverrideEnum>(model.Modifiers.Item5)
);
ReturnType = model.ReturnType;
Extension = model.Extension;
Parameters =
model.Parameters.Select(ParameterSerializationModel.EmitUniqueType);
}
public void Write(LoggingLevel level, string message, Exception exception, Type source)
{
var connectionKey = ConnectionKey;
var insertCommand = InsertCommand;
var parameters = new DynamicParameters(new Dictionary <string, object>()
{
{ "@date", DateTime.Now },
{ "@utcdate", DateTime.UtcNow },
{ "@level", EnumMapper.GetName(level) },
{ "@message", message },
{ "@exception", exception != null ? exception.ToString() : null },
{ "@source", source != null ? source.FullName : null },
{ "@thread", Thread.CurrentThread.ManagedThreadId }
});
lock (sync)
queue.Enqueue(parameters);
signal.Set();
}
public void EnumTypesAreMappedAccordingToSchemeRules(Type enumType, BuildEnum referenceBuilder)
{
var context = CreateContext();
var tree = TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
EnumMapper.MapEnum(b, context, enumType);
});
var expectedTree = TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
referenceBuilder(b);
});
Assert.Equal(expectedTree, tree);
}
public async Task <IActionResult> Post([FromBody] AppCenterRequestInfo request)
{
try
{
if (!ModelState.IsValid)
{
return(this.ApiErrorMessage400BadRequest(ModelState));
}
var jwtPayloadInfo = this.GetJwtPayloadInfo();
var userProfileId = await _bl.GetCachedUserId_byExternalReferenceIdAsync(jwtPayloadInfo.ExtReferenceId);
if (userProfileId == null)
{
return(this.ApiErrorMessage400BadRequestUserIdInTokenNotFound(jwtPayloadInfo.ExtReferenceId));
}
var bl_dto = new BL_AppCenterDetails
{
DeviceId = request.DeviceId,
DTUpdated = DateTimeOffset.MinValue,
TypeOfOs = EnumMapper.From(request.TypeDeviceOs),
UserprofileId = userProfileId
};
await _bl.SetAppCenterDetailsAsync(bl_dto);
return(this.ApiPutMessage204NotContent());
}
catch (BusinessLogicException ex)
{
HttpContext.Items.Add("ex", ex); //For instrumentation
return(this.ApiErrorMessage400BadRequest(ex));
}
catch (Exception ex)
{
HttpContext.Items.Add("ex", ex); //For instrumentation
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
private static void SetFormatting(IPropertySource source, PropertyItem item)
{
var formatterTypeAttr = source.GetAttribute <FormatterTypeAttribute>();
var enumType = source.EnumType;
var valueType = source.ValueType;
var basedOnField = source.BasedOnField;
if (formatterTypeAttr == null)
{
if (enumType != null)
{
item.FormatterType = "Enum";
item.FormatterParams["enumKey"] = EnumMapper.GetEnumTypeKey(enumType);
}
else if (valueType == typeof(DateTime) || valueType == typeof(DateTime?))
{
if (basedOnField is object &&
basedOnField is DateTimeField dtf &&
!dtf.DateOnly)
{
item.FormatterType = "DateTime";
}
else
{
item.FormatterType = "Date";
}
}
else if (valueType == typeof(bool))
{
item.FormatterType = "Checkbox";
}
else if (valueType == typeof(decimal) ||
valueType == typeof(double) ||
valueType == typeof(float) ||
valueType == typeof(int))
{
item.FormatterType = "Number";
}
}
public static void Initialize(IEnumerable <Assembly> assemblies,
string languageID = LocalText.InvariantLanguageID, ILocalTextRegistry registry = null)
#endif
{
assemblies = assemblies ?? ExtensibilityHelper.SelfAssemblies;
if (assemblies == null)
{
throw new ArgumentNullException("assemblies");
}
var provider = registry ?? Dependency.Resolve <ILocalTextRegistry>();
foreach (var assembly in assemblies)
{
foreach (var type in assembly.GetTypes())
{
if (type.IsEnum)
{
var enumKey = EnumMapper.GetEnumTypeKey(type);
foreach (var name in Enum.GetNames(type))
{
var member = type.GetMember(name);
if (member.Length == 0)
{
continue;
}
var descAttr = member[0].GetCustomAttribute <DescriptionAttribute>();
if (descAttr != null)
{
provider.Add(languageID, "Enums." + enumKey + "." + name, descAttr.Description);
}
}
}
}
}
}
/// <summary>
/// Return the endpoint to caller method
/// <param name="type">v3.0 Mailchimp EndPoint targetType, example: reports, lists etc</param>
/// <param name="subType" optional>Expects id for particular list/campaign etc</param>
/// <param name="id" optional>Expects id for particular list/campaign etc</param>
/// <param name="linkId" optional>NOT IMPLEMENTED YET</param>
/// </summary>
public static string EndPoint(TargetTypes type, SubTargetType subType, SubTargetType childSubType, string id = "", string param2 = "")
{
string targetType = EnumMapper.MapTarget(type);
string subCategory = EnumMapper.Map(subType);
string subChildCategory = EnumMapper.Map(childSubType);
var dataCenter = GetDatacenterPrefix();
if (id != "")
{
if (subCategory != "")
{
if (param2 != "")
{
if (subChildCategory != "")
{
return(String.Format("https://{0}.api.mailchimp.com/3.0/{1}/{2}/{3}/{4}/{5}", dataCenter, targetType, id, subCategory, param2, childSubType));
}
else
{
return(String.Format("https://{0}.api.mailchimp.com/3.0/{1}/{2}/{3}/{4}", dataCenter, targetType, id, subCategory, param2));
}
}
else
{
return(String.Format("https://{0}.api.mailchimp.com/3.0/{1}/{2}/{3}", dataCenter, targetType, id, subCategory));
}
}
else
{
return(String.Format("https://{0}.api.mailchimp.com/3.0/{1}/{2}", dataCenter, targetType, id));
}
}
else
{
return(String.Format("https://{0}.api.mailchimp.com/3.0/{1}", dataCenter, targetType));
}
}
private void GenerateEnum(Type enumType)
{
var codeNamespace = GetNamespace(enumType);
var enumKey = EnumMapper.GetEnumTypeKey(enumType);
cw.Indented("export enum ");
var identifier = MakeFriendlyName(enumType, codeNamespace);
generatedTypes.Add((codeNamespace.IsEmptyOrNull() ? "" : codeNamespace + ".") + identifier);
cw.InBrace(delegate
{
var names = Enum.GetNames(enumType);
var values = Enum.GetValues(enumType);
int i = 0;
foreach (var name in names)
{
if (i > 0)
{
sb.AppendLine(",");
}
cw.Indented(name);
sb.Append(" = ");
sb.Append(Convert.ToInt32(((IList)values)[i]));
i++;
}
sb.AppendLine();
});
cw.Indented("Serenity.Decorators.registerEnum(");
sb.Append(enumType.Name);
sb.Append(", '");
sb.Append(enumKey);
sb.AppendLine("');");
}
public TypeSerializationModel(TypeModel model)
{
TypeEnum = EnumMapper.ConvertEnum <TypeTypesSerializationModelEnum, TypeTypesEnum>(model.TypeEnum);
TypeName = model.TypeName;
NamespaceName = model.NamespaceName;
GenericArguments = model.GenericArguments == null ? null :
model.GenericArguments.Select(EmitTypeSerializationModel);
Modifiers = new Tuple <AccessLevelSerializationModelEnum, SealedSerializationModelEnum, AbstractSerializationModelEnum> (
EnumMapper.ConvertEnum <AccessLevelSerializationModelEnum, AccessLevelEnum>(model.Modifiers.Item1),
EnumMapper.ConvertEnum <SealedSerializationModelEnum, SealedEnum>(model.Modifiers.Item2),
EnumMapper.ConvertEnum <AbstractSerializationModelEnum, AbstractEnum>(model.Modifiers.Item3));
Attributes = model.Attributes.Select(AttributeSerializationModel.EmitUniqueType);
FullTypeName = model.FullTypeName;
DeclaringType = model.DeclaringType == null ? null : EmitTypeSerializationModel(model.DeclaringType);
BaseType = model.BaseType == null ? null : EmitTypeSerializationModel(model.BaseType);
ImplementedInterfaces =
model.ImplementedInterfaces.Select(EmitTypeSerializationModel);
Fields =
model.Fields.Select(FieldSerializationModel.EmitUniqueType);
Methods =
model.Methods.Select(MethodSerializationModel.EmitUniqueType);
Properties =
model.Properties.Select(PropertySerializationModel.EmitUniqueType);
Indexers =
model.Indexers.Select(IndexerSerializationModel.EmitUniqueType);
Events =
model.Events.Select(EventSerializationModel.EmitUniqueType);
Constructors =
model.Constructors.Select(ConstructorSerializationModel.EmitUniqueType);
NestedTypes =
model.NestedTypes.Select(EmitTypeSerializationModel);
}
