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" : ""); }