Source: core/kekule.exceptions.js

  1. /**
  2.  * @fileoverview
  3.  * This file is for exception and error handling in Kekule.
  4.  * @author Partridge Jiang
  5.  */
  7. /*
  8.  * requires /lan/classes.js
  9.  * requires /core/kekule.common.js
  10.  */
  13. /**
  14.  * @description Class for exception handler.
  15.  * @class Kekule.ExceptionHandler
  16.  * @augments ObjectEx
  17.  */
  18. Kekule.ExceptionHandler = Class.create(ObjectEx,
  19. /** @lends Kekule.ExceptionHandler# */
  20. {
  21. 	/** @private */
  22. 	CLASS_NAME: 'Kekule.ExceptionHandler',
  23. 	/** @private */
  24. 	//instance: null,
  25. 	/** @private */
  26. 	initProperties: function()
  27. 	{
  28. 		//this.defineProp('enableDetail', {datatype: DataType.BOOL});
  29. 		/**
  30. 		 * Invoked when an exception is throwed by ExceptionHandler
  31. 		 *   event param of it has field: {exception: Kekule.Exception}
  32. 		 * If a listener modify the event param and add a new field e.stop = true,
  33. 		 *   then the exception will not thrown to JavaScript language system.
  34. 		 * @name Kekule.ExceptionHandler#exceptionThrown
  35. 		 * @event
  36. 		 */
  37. 		this.defineEvent('exceptionThrown');
  38. 	},
  39. 	/** @private */
  40. 	notifyExceptionThrown: function(e, exceptionLevel)
  41. 	{
  42. 		var eventArg = {'exception': e, 'level': exceptionLevel};
  43. 		this.invokeEvent('exceptionThrown', eventArg);
  44. 		return eventArg;
  45. 	},
  46. 	/**
  47. 	 * Throw an exception and invoke onExeption event
  48. 	 * @param {Object} e Exception object.
  49. 	 */
  50. 	throwException: function(e, exceptionLevel)
  51. 	{
  52. 		var EL = Kekule.ExceptionLevel;
  53. 		if (!exceptionLevel)
  54. 			exceptionLevel = EL.ERROR;
  55. 		var eventArg = this.notifyExceptionThrown(e, exceptionLevel || EL.ERROR);
  56. 		if (!eventArg.stop)
  57. 		{
  58. 			/*
  59. 			alert(e);
  60. 			throw e;
  61. 			*/
  62. 			if ((!exceptionLevel) || (exceptionLevel === EL.ERROR))
  63. 			{
  64. 				var eo = e;
  65. 				if (typeof(e) === 'string')
  66. 					eo = new Kekule.Exception(e);
  67. 				throw eo;
  68. 			}
  69. 			else
  70. 			{
  71. 				if (typeof(console) !== 'undefined')
  72. 				{
  73. 					if (typeof(e) !== 'string')
  74. 						e = e.message;
  75. 					var method = (exceptionLevel === EL.WARNING)? 'warn':
  76. 						(exceptionLevel === EL.NOTE)? 'info':
  77. 							'log';
  78. 					if (method)
  79. 						console[method](e);
  80. 					else
  81. 						console.log(e);
  82. 				}
  83. 			}
  84. 		}
  85. 	},
  86. 	/**
  87. 	 * Throw an exception and invoke onExeption event, same as {@link Kekule.ExceptionHandler.throwException}
  88. 	 */
  89. 	raise: function(e, exceptionLevel)
  90. 	{
  91. 		return this.throwException(e, exceptionLevel || Kekule.ExceptionLevel.ERROR);
  92. 	}
  93. });
  94. /** Get a singleton instance of Kekule.ExceptionHandler. */
  95. Kekule.ExceptionHandler.getInstance = function()
  96. {
  97. 	if (!this.instance)
  98. 		this.instance = new Kekule.ExceptionHandler();
  99. 	return this.instance;
  100. };
  101. Kekule.exceptionHandler = Kekule.ExceptionHandler.getInstance();
  103. /**
  104.  * Base class for exception in Kekule
  105.  * @class
  106.  * @param {String} message Message of exception.
  107.  * @param {String} name Name of exception.
  108.  *
  109.  * @property {String} message Message of exception, read only.
  110.  */
  111. Kekule.Exception = function(message, name)
  112. {
  113. 	this.message = message;
  114. 	this.name = name;
  115. };
  116. Kekule.Exception.prototype = new Error();
  117. Kekule.Exception.prototype.constructor = Kekule.Exception;
  118. Object.extend(Kekule.Exception.prototype,
  119. 	{
  120. 		/** @lends Kekule.Exception# */
  121. 		getMessage: function()
  122. 		{
  123. 			return this.message;
  124. 		}
  125. 	}
  126. );
  128. /**
  129.  * Class for a critical error.
  130.  * @class
  131.  * @augments Kekule.Exception
  132.  * @param {String} message Message of exception.
  133.  * @param {String} name Name of exception.
  134.  */
  135. Kekule.Error = function(message, name)
  136. {
  137. 	this.message = message;
  138. 	this.name = name;
  139. };
  140. Kekule.Error.prototype = Kekule.Exception.prototype;
  141. Kekule.Error.prototype.constructor = Kekule.Error;
  143. /**
  144.  * Class for a error about chemistry
  145.  * @class
  146.  * @augments Kekule.Error
  147.  * @param {String} message Message of exception.
  148.  * @param {String} name Name of exception.
  149.  */
  150. Kekule.ChemError = function(message, name)
  151. {
  152. 	this.message = message;
  153. 	this.name = name;
  154. };
  155. Kekule.ChemError.prototype = Kekule.Error.prototype; // new Kekule.Error();
  156. Kekule.ChemError.prototype.constructor = Kekule.ChemError;
  158. // TODO: for debug only
  159. // If console is not defined, just add one to avoid exception in some browser
  160. if (typeof(console) == 'undefined')
  161. {
  162. 	console = {
  163. 		log: function() {},
  164. 		warn: function() {},
  165. 		info: function() {},
  166. 		error: function() {}
  167. 	};
  169. }