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 VirtualEnum virtualEnum)
{
if (virtualEnum == VirtualEnum.Virtual)
{
return("Virtual ");
}
return("");
}
public static VirtualEnumBaseDTO ToBaseDTO(this VirtualEnum enumType)
{
switch (enumType)
{
case VirtualEnum.NotVirtual:
return(VirtualEnumBaseDTO.NotVirtual);
case VirtualEnum.Virtual:
return(VirtualEnumBaseDTO.Virtual);
}
throw new Exception();
}
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));
}
public DatabaseMethod(MethodBase baseMethod)
{
Name = baseMethod.Name;
Extension = baseMethod.Extension;
ReturnType = DatabaseType.GetOrAdd(baseMethod.ReturnType);
GenericArguments = baseMethod.GenericArguments?.Select(DatabaseType.GetOrAdd).ToList();
Parameters = baseMethod.Parameters?.Select(t => new DatabaseParameter(t)).ToList();
AccessLevel = baseMethod.AccessLevel;
AbstractEnum = baseMethod.AbstractEnum;
StaticEnum = baseMethod.StaticEnum;
VirtualEnum = baseMethod.VirtualEnum;
}
internal static Enums.VirtualEnum ToLogicEnum(this VirtualEnum baseEnum)
{
switch (baseEnum)
{
case VirtualEnum.NotVirtual:
return(Enums.VirtualEnum.NotVirtual);
case VirtualEnum.Virtual:
return(Enums.VirtualEnum.Virtual);
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);
}
}
}
}
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));
}
public static string VirtualToString(VirtualEnum virtualEnum)
{
return(virtualEnum == VirtualEnum.Virtual ? "virtual" : "");
}
