PageRenderTime 54ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/src/NRoles.Engine/Messages/Error.cs

https://bitbucket.org/Djidja/nroles
C# | 284 lines | 170 code | 32 blank | 82 comment | 0 complexity | badef693c2d42f5002b1694889979ab9 MD5 | raw file
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using Mono.Cecil;
  6. namespace NRoles.Engine {
  7. /// <summary>
  8. /// Represents an error message.
  9. /// </summary>
  10. public sealed class Error : Message {
  11. /// <summary>Error codes.</summary>
  12. public enum Code {
  13. /// <summary>
  14. /// Occurs when an uncaught exception is thrown from NRoles.
  15. /// This is probably a bug in NRoles.
  16. /// </summary>
  17. InternalError = 1,
  18. /// <summary>
  19. /// Occurs when a role has a parameterized constructor.
  20. /// </summary>
  21. RoleCannotContainParameterizedConstructor = 40,
  22. /// <summary>
  23. /// Occurs when a role inherits from a class.
  24. /// </summary>
  25. RoleInheritsFromClass = 41,
  26. /// <summary>
  27. /// Occurs when a composition does not implement an abstract role members.
  28. /// </summary>
  29. DoesNotImplementAbstractRoleMember = 42,
  30. /// <summary>
  31. /// Occurs when 2 or more members from different roles in a composition are in conflict.
  32. /// </summary>
  33. Conflict = 43,
  34. /// <summary>
  35. /// Occurs when all members from the same member group are excluded from a composition.
  36. /// </summary>
  37. AllMembersExcluded = 44,
  38. /// <summary>
  39. /// Occurs when there're methods with conflicting signatures in different roles in a composition.
  40. /// </summary>
  41. MethodsWithConflictingSignatures = 45,
  42. /// <summary>
  43. /// Occurs when a type inherits from a role.
  44. /// </summary>
  45. TypeCantInheritFromRole = 46,
  46. /// <summary>
  47. /// Occurs when a role is being instantiated. Roles are implicitly abstract and can't be instantiated.
  48. /// </summary>
  49. RoleInstantiated = 47,
  50. /// <summary>
  51. /// Occurs when a role composes itself.
  52. /// </summary>
  53. RoleComposesItself = 48,
  54. /// <summary>
  55. /// Occurs when a composition composes a role as a type parameter.
  56. /// </summary>
  57. CompositionWithTypeParameter = 49,
  58. /// <summary>
  59. /// Occurs when there're members in different roles in a composition with the same name.
  60. /// </summary>
  61. MembersWithSameName = 50,
  62. /// <summary>
  63. /// Occurs when a member declared in a role view is not found on the corresponding role.
  64. /// </summary>
  65. RoleViewMemberNotFoundInRole = 51,
  66. /// <summary>
  67. /// Occurs when a role member is aliased more than once.
  68. /// </summary>
  69. RoleMemberAliasedAgain = 52,
  70. /// <summary>
  71. /// Occurs when there's a timeout when waiting for PEVerify to complete.
  72. /// </summary>
  73. PEVerifyTimeout = 53,
  74. /// <summary>
  75. /// Occurs when PEVerify detects error in the generated assembly.
  76. /// This could mean that the assembly is unverifiable (as when it has unsafe code),
  77. /// or that there's a bug in the roles engine.
  78. /// </summary>
  79. PEVerifyError = 54,
  80. /// <summary>
  81. /// Occurs when the PEVerify executable is not found in the system.
  82. /// </summary>
  83. PEVerifyDoesntExist = 55,
  84. /// <summary>
  85. /// Occurs in the presence of warnings when they are being treated as errors.
  86. /// </summary>
  87. ErrorFromWarnings = 56,
  88. /// <summary>
  89. /// Occurs when a role view defines multiple roles. A role view can only define a
  90. /// single role.
  91. /// </summary>
  92. RoleViewWithMultipleRoles = 57,
  93. /// <summary>
  94. /// Occurs when a role view is not defined as an interface. Role view must be
  95. /// defined as interfaces.
  96. /// </summary>
  97. RoleViewIsNotAnInterface = 58,
  98. /// <summary>
  99. /// Occurs when a method in a role is a platform invoke method. This is the case with extern methods marked with the DllImport attribute. This is not supported.
  100. /// </summary>
  101. RoleHasPInvokeMethod = 59,
  102. /// <summary>
  103. /// Occurs when a composition does not provide its type to a role's self type constraint.
  104. /// </summary>
  105. SelfTypeConstraintNotSetToCompositionType = 60,
  106. /// <summary>
  107. /// Occurs when a role has a member marked as a placeholder.
  108. /// This is not allowed since roles can have abstract members instead.
  109. /// </summary>
  110. RoleHasPlaceholder = 61,
  111. /// <summary>
  112. /// Occurs when a role explicitly implements interface members. This scenario is not supported.
  113. /// </summary>
  114. RoleHasExplicitInterfaceImplementation = 666
  115. }
  116. private Error(Code number, string text) : base(MessageType.Error, (int)number, text) { }
  117. private Error(Code number, string text, params object[] parameters) :
  118. this(number, string.Format(text, parameters)) { }
  119. public static Message InternalError() {
  120. return new Error(
  121. Code.InternalError,
  122. "Oops, an internal error occurred.");
  123. }
  124. internal static Error RoleCannotContainParameterizedConstructor(object role, object constructor) {
  125. return new Error(
  126. Code.RoleCannotContainParameterizedConstructor,
  127. "Role '{0}' cannot contain parameterized constructor '{1}'.", role, constructor);
  128. }
  129. internal static Error RoleInheritsFromClass(object role, object baseClass) {
  130. return new Error(
  131. Code.RoleInheritsFromClass,
  132. "Role '{0}' cannot derive from class '{1}'. Roles can only derive from object, implement interfaces and compose other roles.", role, baseClass);
  133. }
  134. internal static Error DoesNotImplementAbstractRoleMember(object compositionClass, object abstractRoleMember) {
  135. return new Error(
  136. Code.DoesNotImplementAbstractRoleMember,
  137. "'{0}' does not implement abstract role member '{1}'.", compositionClass, abstractRoleMember);
  138. }
  139. internal static Error Conflict(object composition, object member, List<RoleCompositionMember> roleMembersInConflict) {
  140. var roles = string.Join("', '", roleMembersInConflict.Select(rmb => rmb.Role.ToString()).ToArray());
  141. return new Error(
  142. Code.Conflict,
  143. "Conflict found in role composition '{0}' for '{1}'. The conflict comes from: '{2}'", composition, member, roles);
  144. }
  145. internal static Error AllMembersExcluded(object compositionClass, object roleMember) {
  146. return new Error(
  147. Code.AllMembersExcluded,
  148. "'{0}' excludes all role members '{1}'.", compositionClass, roleMember);
  149. }
  150. internal static Error MethodsWithConflictingSignatures(object conflictingMethods) {
  151. return new Error(
  152. Code.MethodsWithConflictingSignatures,
  153. "Methods have conflicting signatures:{0}.", conflictingMethods);
  154. }
  155. internal static Error TypeCantInheritFromRole(object inheritingType, object roleType) {
  156. return new Error(
  157. Code.TypeCantInheritFromRole,
  158. "Type '{0}' cannot inherit from role '{1}'.", inheritingType, roleType);
  159. }
  160. internal static Error RoleInstantiated(object roleType, object instantiatingLocation) {
  161. return new Error(
  162. Code.RoleInstantiated,
  163. "Role '{0}' is being instantiated in '{1}'. Roles cannot be instantiated.", roleType, instantiatingLocation);
  164. }
  165. internal static Error RoleComposesItself(object roleType) {
  166. return new Error(
  167. Code.RoleComposesItself,
  168. "Role '{0}' cannot compose itself.", roleType);
  169. }
  170. internal static Error CompositionWithTypeParameter(object compositionType) {
  171. return new Error(
  172. Code.CompositionWithTypeParameter,
  173. "Class '{0}' cannot compose a role as a type parameter.", compositionType);
  174. }
  175. internal static Error MembersWithSameName(object members) {
  176. return new Error(
  177. Code.MembersWithSameName,
  178. "Members can't be declared with the same name:{0}.", members);
  179. }
  180. internal static Error RoleViewMemberNotFoundInRole(object role, object member) {
  181. return new Error(
  182. Code.RoleViewMemberNotFoundInRole,
  183. "Role view member '{0}' could not be found in the role '{1}'.", member, role);
  184. }
  185. internal static Error RoleMemberAliasedAgain(object roleView, object role, object member) {
  186. return new Error(
  187. Code.RoleMemberAliasedAgain,
  188. "The role member '{0}' of role '{1}' cannot be aliased multiple times (detected at role view '{2}').",
  189. member, role, roleView);
  190. }
  191. internal static Error PEVerifyTimeout(int timeoutInMillis) {
  192. return new Error(
  193. Code.PEVerifyTimeout,
  194. "PEVerify took too long and had to be terminated. The current timeout is of {0}s.",
  195. timeoutInMillis / 1000.0);
  196. }
  197. internal static Error PEVerifyError(object description) {
  198. return new Error(
  199. Code.PEVerifyError,
  200. "PEVerify found errors in the mutated assembly:\n{0}",
  201. description);
  202. }
  203. internal static Error PEVerifyDoesntExist() {
  204. return new Error(
  205. Code.PEVerifyDoesntExist,
  206. "The PEVerify executable was not found in the system.");
  207. }
  208. internal static Error ErrorFromWarnings() {
  209. return new Error(
  210. Code.ErrorFromWarnings,
  211. "Error generated from the presence of warnings.");
  212. }
  213. internal static Message RoleViewWithMultipleRoles(object roleView, List<TypeReference> allRolesForView) {
  214. return new Error(
  215. Code.RoleViewWithMultipleRoles,
  216. "The role view '{0}' adapts multiple roles. Use a single role per role view.",
  217. roleView);
  218. }
  219. internal static Message RoleViewIsNotAnInterface(object roleView) {
  220. return new Error(
  221. Code.RoleViewIsNotAnInterface,
  222. "The role view '{0}' must be declared as an interface.",
  223. roleView);
  224. }
  225. internal static Error RoleHasPInvokeMethod(object method) {
  226. return new Error(
  227. Code.RoleHasPInvokeMethod,
  228. "The role method '{0}' is a PInvoke method. This is not supported.",
  229. method);
  230. }
  231. internal static Error SelfTypeConstraintNotSetToCompositionType(object composition, object role, object selfType) {
  232. return new Error(
  233. Code.SelfTypeConstraintNotSetToCompositionType,
  234. "Composition '{0}' doesn't provide itself as the self-type parameter to role '{1}'. It uses '{2}' instead.",
  235. composition,
  236. role,
  237. selfType);
  238. }
  239. internal static Error RoleHasPlaceholder(object member) {
  240. return new Error(
  241. Code.RoleHasPlaceholder,
  242. "Role member '{0}' is marked as a placeholder. Roles cannot have placeholders, use an abstract member not marked as a placeholder instead.",
  243. member);
  244. }
  245. internal static Message RoleHasExplicitInterfaceImplementation(object role) {
  246. return new Error(
  247. Code.RoleHasExplicitInterfaceImplementation,
  248. "The role '{0}' explicitly implements interface members. This is not supported.",
  249. role);
  250. }
  251. }
  252. }