static Tuple <AccessLevel, SealedEnum, AbstractEnum> EmitModifiers(Type type)
{
//set defaults
AccessLevel _access = AccessLevel.IsPrivate;
AbstractEnum _abstract = AbstractEnum.NotAbstract;
SealedEnum _sealed = SealedEnum.NotSealed;
// check if not default
if (type.IsPublic)
{
_access = AccessLevel.IsPublic;
}
else if (type.IsNestedPublic)
{
_access = AccessLevel.IsPublic;
}
else if (type.IsNestedFamily)
{
_access = AccessLevel.IsProtected;
}
else if (type.IsNestedFamANDAssem)
{
_access = AccessLevel.IsProtectedInternal;
}
if (type.IsSealed)
{
_sealed = SealedEnum.Sealed;
}
if (type.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
return(new Tuple <AccessLevel, SealedEnum, AbstractEnum>(_access, _sealed, _abstract));
}
private Tuple <AccessLevel, SealedEnum, AbstractEnum> EmitModifiers(Type type)
{
AccessLevel accessModifier = Model.AccessLevel.Private;
if (type.IsPublic || type.IsNestedPublic)
{
accessModifier = Model.AccessLevel.Public;
}
else if (type.IsNestedFamily)
{
accessModifier = Model.AccessLevel.Protected;
}
else
{
accessModifier = Model.AccessLevel.Internal;
}
SealedEnum sealedModifier = Model.SealedEnum.NotSealed;
if (type.IsSealed)
{
sealedModifier = Model.SealedEnum.Sealed;
}
AbstractEnum abstractModifier = Model.AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
abstractModifier = Model.AbstractEnum.Abstract;
}
return(new Tuple <AccessLevel, SealedEnum, AbstractEnum>(accessModifier, sealedModifier, abstractModifier));
}
private static Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel accessModifier = Model.AccessLevel.Private;
if (method.IsPublic)
{
accessModifier = Model.AccessLevel.Public;
}
else if (method.IsFamily)
{
accessModifier = Model.AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
accessModifier = Model.AccessLevel.Internal;
}
AbstractEnum abstractModifier = Model.AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
abstractModifier = Model.AbstractEnum.Abstract;
}
StaticEnum staticModifier = Model.StaticEnum.NonStatic;
if (method.IsStatic)
{
staticModifier = Model.StaticEnum.Static;
}
VirtualEnum virtualModifier = Model.VirtualEnum.NonVirtual;
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(accessModifier, abstractModifier, staticModifier, virtualModifier));
}
public TupleFour(AccessLevel accessLevel, AbstractEnum abstractEnum, StaticEnum staticEnum, VirtualEnum virtualEnum)
{
this.accessLevel = accessLevel;
this.abstractEnum = abstractEnum;
this.staticEnum = staticEnum;
this.virtualEnum = virtualEnum;
}
internal static string Stringify(this AbstractEnum sealedEnum)
{
if (sealedEnum == AbstractEnum.Abstract)
{
return("Abstract ");
}
return("");
}
public void Should_return_derived_type()
{
EnumWithDerivedType.Get(2).Should().Be(EnumWithDerivedType.ItemOfDerivedType);
AbstractEnum.Get(1).Should().Be(AbstractEnum.Item);
ExtensibleTestEnum.Get("DerivedItem").Should().Be(ExtensibleTestEnum.DerivedItem);
ExtendedTestEnum.Get("DerivedItem").Should().Be(ExtendedTestEnum.DerivedItem);
DifferentAssemblyExtendedTestEnum.Get("DerivedItem").Should().Be(DifferentAssemblyExtendedTestEnum.DerivedItem);
}
public static AbstractEnumBaseDTO ToBaseDTO(this AbstractEnum enumType)
{
switch (enumType)
{
case AbstractEnum.Abstract:
return(AbstractEnumBaseDTO.Abstract);
case AbstractEnum.NotAbstract:
return(AbstractEnumBaseDTO.NotAbstract);
}
throw new Exception();
}
public static Tuple <AccessLevel, SealedEnum, AbstractEnum> MapToObject(this Tuple <AccessLevelBaseDTO, SealedEnumBaseDTO, AbstractEnumBaseDTO> tuple)
{
if (tuple == null)
{
return(null);
}
AccessLevel accessLevelBase = tuple.Item1.MapToObject();
SealedEnum sealedEnumBase = tuple.Item2.MapToObject();
AbstractEnum abstractEnumBase = tuple.Item3.MapToObject();
return(new Tuple <AccessLevel, SealedEnum, AbstractEnum>(accessLevelBase, sealedEnumBase, abstractEnumBase));
}
public static Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> MapToObject(this Tuple <AccessLevelBaseDTO, AbstractEnumBaseDTO, StaticEnumBaseDTO, VirtualEnumBaseDTO> tuple)
{
if (tuple == null)
{
return(null);
}
AccessLevel accessLevelBase = tuple.Item1.MapToObject();
AbstractEnum abstractEnumBase = tuple.Item2.MapToObject();
StaticEnum staticEnumBase = tuple.Item3.MapToObject();
VirtualEnum virtualEnumBase = tuple.Item4.MapToObject();
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(accessLevelBase, abstractEnumBase, staticEnumBase, virtualEnumBase));
}
internal static Enums.AbstractEnum ToLogicEnum(this AbstractEnum baseEnum)
{
switch (baseEnum)
{
case AbstractEnum.Abstract:
return(Enums.AbstractEnum.Abstract);
case AbstractEnum.NotAbstract:
return(Enums.AbstractEnum.NotAbstract);
default:
throw new Exception();
}
}
private void InsertRedundantData(DbAssemblyMetadata loadedRoot)
{
foreach (DbNamespaceMetadata _namespace in loadedRoot.EFNamespaces)
{
foreach (DbTypeMetadata type in _namespace.EFTypes)
{
type.NamespaceName = _namespace.Name;
AbstractEnum isAbstract = AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
SealedEnum isSealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
isSealed = SealedEnum.Sealed;
}
type.Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(
type.AccessLevel, isSealed, isAbstract);
foreach (DbMethodMetadata method in type.EFMethodsAndConstructors)
{
isAbstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
StaticEnum isStatic = StaticEnum.NotStatic;
if (method.IsStatic)
{
isStatic = StaticEnum.Static;
}
VirtualEnum isVirtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
isVirtual = VirtualEnum.Virtual;
}
method.Modifiers = new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum>(
method.AccessLevel, isAbstract, isStatic, isVirtual);
}
}
}
}
static TypeModifiers EmitModifiers(Type type)
{
AccessLevel _access = AccessLevel.Private;
if (type.IsPublic)
{
_access = AccessLevel.Public;
}
else if (type.IsNestedPublic)
{
_access = AccessLevel.Public;
}
else if (type.IsNestedFamily)
{
_access = AccessLevel.Protected;
}
else if (type.IsNestedFamANDAssem)
{
_access = AccessLevel.ProtectedInternal;
}
SealedEnum _sealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
_sealed = SealedEnum.Sealed;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
StaticEnum _static = StaticEnum.NotStatic;
if (type.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
_static = StaticEnum.Static;
}
return(new TypeModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
SealedEnum = _sealed,
AccessLevel = _access
});
}
private static MethodModifiers EmitModifiers(MethodBase method)
{
AccessLevel _access = AccessLevel.Private;
if (method.IsPublic)
{
_access = AccessLevel.Public;
}
else if (method.IsFamily)
{
_access = AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
_access = AccessLevel.ProtectedInternal;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
StaticEnum _static = StaticEnum.NotStatic;
if (method.IsStatic)
{
_static = StaticEnum.Static;
}
VirtualEnum _virtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
_virtual = VirtualEnum.Virtual;
}
return(new MethodModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
VirtualEnum = _virtual,
AccessLevel = _access
});
}
private static MethodModifiers EmitModifiers(MethodBase method)
{
AccessLevel access = method.IsPublic ? AccessLevel.Public :
method.IsFamily ? AccessLevel.Protected :
method.IsAssembly ? AccessLevel.Internal : AccessLevel.Private;
AbstractEnum _abstract = method.IsAbstract ? AbstractEnum.Abstract : AbstractEnum.NotAbstract;
StaticEnum _static = method.IsStatic ? StaticEnum.Static : StaticEnum.NotStatic;
VirtualEnum _virtual = method.IsVirtual ? VirtualEnum.Virtual : VirtualEnum.NotVirtual;
return(new MethodModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
VirtualEnum = _virtual,
AccessLevel = access
});
}
private Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel access = AccessLevel.IsPrivate;
if (method.IsPublic)
{
access = AccessLevel.IsPublic;
}
else if (method.IsFamily)
{
access = AccessLevel.IsProtected;
}
else if (method.IsFamilyAndAssembly)
{
access = AccessLevel.IsProtectedInternal;
}
AbstractEnum isAbstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
StaticEnum isStatic = StaticEnum.NotStatic;
if (method.IsStatic)
{
isStatic = StaticEnum.Static;
}
VirtualEnum isVirtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
isVirtual = VirtualEnum.Virtual;
}
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(access, isAbstract, isStatic, isVirtual));
}
private Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel _access = AccessLevel.Private;
if (method.IsPublic)
{
_access = AccessLevel.Public;
}
else if (method.IsFamily)
{
_access = AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
_access = AccessLevel.Internal;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
else if (method.IsFinal)
{
_abstract = AbstractEnum.Sealed;
}
StaticEnum _static = StaticEnum.NotStatic;
if (method.IsStatic)
{
_static = StaticEnum.Static;
}
VirtualEnum _virtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
_virtual = VirtualEnum.Virtual;
}
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(_access, _abstract, _static, _virtual));
}
private Tuple <AccessLevel, SealedEnum, AbstractEnum> EmitModifiers(Type type)
{
AccessLevel accessLevel = AccessLevel.IsPrivate;
// check if not default
if (type.IsPublic)
{
accessLevel = AccessLevel.IsPublic;
}
else if (type.IsNestedPublic)
{
accessLevel = AccessLevel.IsPublic;
}
else if (type.IsNestedFamily)
{
accessLevel = AccessLevel.IsProtected;
}
else if (type.IsNestedFamANDAssem)
{
accessLevel = AccessLevel.IsProtectedInternal;
}
SealedEnum sealedEnum = SealedEnum.NotSealed;
if (type.IsSealed)
{
sealedEnum = SealedEnum.Sealed;
}
AbstractEnum abstractEnum = AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
abstractEnum = AbstractEnum.Abstract;
}
return(new Tuple <AccessLevel, SealedEnum, AbstractEnum>(accessLevel, sealedEnum, abstractEnum));
}
static Tuple <AccessLevelEnum, SealedEnum, AbstractEnum> EmitModifiers(Type type)
{
AccessLevelEnum _access = AccessLevelEnum.IsPrivate;
if (type.IsPublic)
{
_access = AccessLevelEnum.IsPublic;
}
else if (type.IsNestedPublic)
{
_access = AccessLevelEnum.IsPublic;
}
else if (type.IsNestedFamily)
{
_access = AccessLevelEnum.IsProtected;
}
else if (type.IsNestedFamANDAssem)
{
_access = AccessLevelEnum.IsProtectedInternal;
}
SealedEnum _sealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
_sealed = SealedEnum.Sealed;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
return(new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(_access, _sealed, _abstract));
}
public void Should_throw_if_item_is_invalid()
{
TestEnum.Get("invalid").Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(TestEnum)}\" with identifier \"invalid\" is not valid.");
StructStringEnum.Get("invalid").Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(StructStringEnum)}\" with identifier \"invalid\" is not valid.");
AbstractEnum.Get(42).Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(AbstractEnum)}\" with identifier \"42\" is not valid.");
StructIntegerEnum.Get(42).Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(StructIntegerEnum)}\" with identifier \"42\" is not valid.");
// we cannot prevent construction of a struct
new StructIntegerEnumWithZero().Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(StructIntegerEnumWithZero)}\" with identifier \"0\" is not valid.");
ExtensibleTestValidatableEnum.Get("invalid").Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(ExtensibleTestValidatableEnum)}\" with identifier \"invalid\" is not valid.");
ExtendedTestValidatableEnum.Get("invalid").Invoking(e => e.EnsureValid())
.Should().Throw <InvalidOperationException>().WithMessage($"The current enumeration item of type \"{nameof(ExtendedTestValidatableEnum)}\" with identifier \"invalid\" is not valid.");
}
private static TypeModifiers EmitModifiers(Type type)
{
AccessLevel _access = type.IsPublic || type.IsNestedPublic ? AccessLevel.Public :
type.IsNestedFamily ? AccessLevel.Protected :
type.IsNestedPrivate ? AccessLevel.Private :
AccessLevel.Internal;
StaticEnum _static = type.IsSealed && type.IsAbstract ? StaticEnum.Static : StaticEnum.NotStatic;
SealedEnum _sealed = SealedEnum.NotSealed;
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (_static == StaticEnum.NotStatic)
{
_sealed = type.IsSealed ? SealedEnum.Sealed : SealedEnum.NotSealed;
_abstract = type.IsAbstract ? AbstractEnum.Abstract : AbstractEnum.NotAbstract;
}
return(new TypeModifiers()
{
AbstractEnum = _abstract,
AccessLevel = _access,
SealedEnum = _sealed,
StaticEnum = _static
});
}
public static string AbstractToString(AbstractEnum abstractEnum)
{
return(abstractEnum == AbstractEnum.Abstract ? "abstract" : "");
}
