ch.ninecode.cim.CIMParser.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of CIMReader Show documentation
Show all versions of CIMReader Show documentation
Expose CIM data files as Spark RDD
package ch.ninecode.cim
import java.util.regex.Pattern
import com.esotericsoftware.kryo.Serializer
import ch.ninecode.model.Element
/**
* Provides common infrastructure for parsing CIM elements.
* Subclasses (actually their companion objects) must implement the parse method.
* Other methods are helpers for parsing the regular XML structure of CIM rdf files.
*/
trait CIMParser
{
import CIMParser._
type Expression = (Pattern, Int)
type Field = Option[String]
trait FielderFunction
{
def apply ()(implicit context:CIMContext): Field
}
type Fielder = FielderFunction
type Fields = Option[List[String]]
trait FielderFunctionMultiple
{
def apply ()(implicit context:CIMContext): Fields
}
type FielderMultiple = FielderFunctionMultiple
val fields: Array[String] = Array ()
val relations: List[CIMRelationship] = List ()
def serializer: Serializer[_ <: Product]
/**
* Create the integer array of bitfields from field names.
*
* @param strings the names of the fields to set the bits for
* @return the bitfield array corresponding to the given field names
*/
def fieldsToBitfields (strings: String*): Array[Int] =
{
val bits = new Array[Int] ((fields.length + 31) / 32)
strings.foreach (
fieldname =>
{
val index = fields.indexOf (fieldname)
if (-1 != index)
bits(index / 32) |= (1 << (index % 32))
else
{
// ToDo: better error handling
println (s"""field "$fieldname not fould in fields array of ${getClass.getName}""")
}
}
)
bits
}
/**
* Regular expression to parse an element.
* For example: 0.224
* @param cls The class name.
* @param name The element name (without namespace prefix).
* @return The compiled regex pattern and the index of the match group.
*/
def element (cls: String, name: String): Expression =
{
val trigger = s"$namespace:$cls.$name"
(Pattern.compile ("""<""" + trigger + """>([\s\S]*?)<\/""" + trigger + """>"""), 1)
}
/**
* Regular expression to parse an attribute.
* For example: and the empty string are considered false.
* @param context The context for reporting in case of an unparseable boolean.
* @return The boolean value.
*/
def toBoolean (string: String) (implicit context: CIMContext): Boolean =
{
var ret = false
if ((null != string) && ("" != string))
try
ret = string.toBoolean
catch
{
case _: Throwable => throw new Exception (s"unparsable boolean ($string) found while parsing at line ${context.line_number()}")
}
ret
}
/**
* Convert a string into an integer.
* @param string The string to convert. Should be just digits although whitespace at the beginning or end is tolerated.
* @param context The context for reporting in case of an unparseable integer.
* @return The integer value.
*/
def toInteger (string: String) (implicit context: CIMContext): Int =
{
var ret: Int = 0
if ((null != string) && ("" != string))
try
ret = string.trim.toInt
catch
{
case _: Throwable => throw new Exception (s"unparsable integer ($string) found while parsing at line ${context.line_number()}")
}
ret
}
/**
* Convert a string into a floating point value.
* @param string The string to convert. Should be a valid floating point formatted number although whitespace at the beginning or end is tolerated.
* @param context The context for reporting in case of an unparseable double.
* @return The double value.
*/
def toDouble (string: String) (implicit context: CIMContext): Double =
{
var ret = 0.0
if ((null != string) && ("" != string))
try
ret = string.trim.toDouble
catch
{
case _: Throwable => throw new Exception (s"unparsable double ($string) found while parsing at line ${context.line_number()}")
}
ret
}
}
/**
* Holds constant members of the Parser trait.
* Includes constants for use by subclasses and the parser.
* This parser companion object is only needed because Scala doesn't have a static declaration,
* and instead invents a "companion object" to hold the trait or class
* members that should be accessible without an instantiated object.
*/
object CIMParser
{
/**
* The CIM namespace ("cim").
*/
val namespace: String = "cim"
/**
* The regular expression for parsing top level elements.
*/
val rddex: Pattern = Pattern.compile ("""\s*<(""" + namespace + """:[^>\.\s]+)([>\s][\s\S]*?)<\/\1>\s*""") // important to consume leading and trailing whitespace
}