Report key that is related to some error

Author: loverdos

src/main/scala/com/ckkloverdos/props/Props.scala

@@ -44,127 +44,127 @@ class Props(val map: Map[String, String])(implicit conv: Converters = Converters
 
   def getBoolean(key: String): Maybe[Boolean] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToBoolean(value)
+      handleKeyError(key, conv.convertToBoolean(value))
 
     case None ⇒
       NoVal
   }
 
   def getBooleanEx(key: String): Boolean = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToBooleanEx(value)
+      handleKeyError(key, conv.convertToBooleanEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getByte(key: String): Maybe[Byte] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToByte(value)
+      handleKeyError(key, conv.convertToByte(value))
 
     case None ⇒
       NoVal
   }
 
   def getByteEx(key: String): Byte = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToByteEx(value)
+      handleKeyError(key, conv.convertToByteEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getShort(key: String): Maybe[Short] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToShort(value)
+      handleKeyError(key, conv.convertToShort(value))
 
     case None ⇒
       NoVal
   }
 
   def getShortEx(key: String): Short = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToShortEx(value)
+      handleKeyError(key, conv.convertToShortEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getInt(key: String): Maybe[Int] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToInt(value)
+      handleKeyError(key, conv.convertToInt(value))
 
     case None ⇒
       NoVal
   }
 
   def getIntEx(key: String): Int = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToIntEx(value)
+      handleKeyError(key, conv.convertToIntEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getLong(key: String): Maybe[Long] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToLong(value)
+      handleKeyError(key, conv.convertToLong(value))
 
     case None ⇒
       NoVal
   }
 
   def getLongEx(key: String): Long = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToLongEx(value)
+      handleKeyError(key, conv.convertToLongEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getDouble(key: String): Maybe[Double] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToDouble(value)
+      handleKeyError(key, conv.convertToDouble(value))
 
     case None ⇒
       NoVal
   }
 
   def getDoubleEx(key: String): Double = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToDoubleEx(value)
+      handleKeyError(key, conv.convertToDoubleEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getFloat(key: String): Maybe[Float] = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToFloat(value)
+      handleKeyError(key, conv.convertToFloat(value))
 
     case None ⇒
       NoVal
   }
 
   def getFloatEx(key: String): Float = map.get(key) match {
     case Some(value) ⇒
-      conv.convertToFloatEx(value)
+      handleKeyError(key, conv.convertToFloatEx(value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
   }
 
   def getProps(key: String): Maybe[Props] = map.get(key) match {
     case Some(value) ⇒
-      conv.convert[Props](value)
+      handleKeyError(key, conv.convert[Props](value))
 
     case None ⇒
       NoVal
   }
 
   def getPropsEx(key: String): Props = map.get(key) match {
     case Some(value) ⇒
-      conv.convertEx[Props](value)
+      handleKeyError(key, conv.convertEx[Props](value))
 
     case None ⇒
       throw new IllegalArgumentException("Unknown key %s".format(key))
@@ -173,7 +173,7 @@ class Props(val map: Map[String, String])(implicit conv: Converters = Converters
 
   def getList(key: String, separatorRegex: String = "\\s*,\\s*") = map.get(key) match {
     case Some(value) ⇒
-      value.split(separatorRegex).toList
+      handleKeyError(key, value.split(separatorRegex).toList)
 
     case None ⇒
       Nil

src/main/scala/com/ckkloverdos/props/PropsBase.scala

@@ -62,4 +62,12 @@ trait PropsBase[K, V, P <: PropsBase[K, V,  P]] {
   def keysIterator: Iterator[K] = map.keysIterator
 
   def isEmpty = size == 0
+
+  protected[this] def handleKeyError[A](key: String, f: ⇒ A): A = {
+    try f
+    catch {
+      case e: Throwable ⇒
+        throw new Exception("For key %s".format(key), e)
+    }
+ }
 }