diff options
Diffstat (limited to 'library/src/dotty/runtime/vc/VCPrototype.scala')
-rw-r--r-- | library/src/dotty/runtime/vc/VCPrototype.scala | 486 |
1 files changed, 486 insertions, 0 deletions
diff --git a/library/src/dotty/runtime/vc/VCPrototype.scala b/library/src/dotty/runtime/vc/VCPrototype.scala new file mode 100644 index 000000000..212046ef8 --- /dev/null +++ b/library/src/dotty/runtime/vc/VCPrototype.scala @@ -0,0 +1,486 @@ +package dotty.runtime.vc + +import scala.reflect.ClassTag + +abstract class VCPrototype { +} + + +abstract class VCArrayPrototype[T <: VCPrototype] extends Object with Cloneable { + def apply(idx: Int): Object + def update(idx: Int, el: T): Unit + def length: Int + override def clone(): Object = super.clone() +} + + +abstract class VCFloatPrototype(val underlying: Float) extends VCPrototype {} + +abstract class VCFloatCasePrototype(underlying: Float) extends VCFloatPrototype(underlying) with Product1[Float] { + + final def _1: Float = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCFloatCompanion[T <: VCFloatPrototype] extends ClassTag[T] { + def box(underlying: Float): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCFloatArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Float) = underlying + final def hashCode$extension(underlying: Float) = underlying.hashCode() + final def toString$extension(underlying: Float) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Float): String +} + +final class VCFloatArray[T <: VCFloatPrototype] private (val arr: Array[Float], val ct: VCFloatCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCFloatCompanion[T], sz: Int) = + this(new Array[Float](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + def length: Int = arr.length + + override def clone(): VCFloatArray[T] = { + new VCFloatArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCObjectPrototype(val underlying: Object) extends VCPrototype {} + +abstract class VCObjectCasePrototype(underlying: Object) extends VCObjectPrototype(underlying) with Product1[Object] { + + final def _1: Object = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCObjectCompanion[T <: VCObjectPrototype] extends ClassTag[T] { + def box(underlying: Object): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCObjectArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Object) = underlying + final def hashCode$extension(underlying: Object) = underlying.hashCode() + final def toString$extension(underlying: Object) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Object): String +} + +final class VCObjectArray[T <: VCObjectPrototype] private (val arr: Array[Object], val ct: VCObjectCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCObjectCompanion[T], sz: Int) = + this(new Array[Object](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + + def length: Int = arr.length + + override def clone(): VCObjectArray[T] = { + new VCObjectArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCShortPrototype(val underlying: Short) extends VCPrototype {} + +abstract class VCShortCasePrototype(underlying: Short) extends VCShortPrototype(underlying) with Product1[Short] { + + final def _1: Short = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCShortCompanion[T <: VCShortPrototype] extends ClassTag[T] { + def box(underlying: Short): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCShortArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Short) = underlying + final def hashCode$extension(underlying: Short) = underlying.hashCode() + final def toString$extension(underlying: Short) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Short): String +} + +final class VCShortArray[T <: VCShortPrototype] private (val arr: Array[Short], val ct: VCShortCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCShortCompanion[T], sz: Int) = + this(new Array[Short](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + + def length: Int = arr.length + + override def clone(): VCShortArray[T] = { + new VCShortArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } + +} + + +abstract class VCLongPrototype(val underlying: Long) extends VCPrototype {} + +abstract class VCLongCasePrototype(underlying: Long) extends VCLongPrototype(underlying) with Product1[Long] { + + final def _1: Long = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCLongCompanion[T <: VCLongPrototype] extends ClassTag[T] { + def box(underlying: Long): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCLongArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Long) = underlying + final def hashCode$extension(underlying: Long) = underlying.hashCode() + final def toString$extension(underlying: Long) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Long): String +} + +final class VCLongArray[T <: VCLongPrototype] private (val arr: Array[Long], val ct: VCLongCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCLongCompanion[T], sz: Int) = + this(new Array[Long](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + + def length: Int = arr.length + + override def clone(): VCLongArray[T] = { + new VCLongArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCIntPrototype(val underlying: Int) extends VCPrototype {} + +abstract class VCIntCasePrototype(underlying: Int) extends VCIntPrototype(underlying) with Product1[Int] { + + final def _1: Int = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCIntCompanion[T <: VCIntPrototype] extends ClassTag[T] { + def box(underlying: Int): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCIntArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Int) = underlying + final def hashCode$extension(underlying: Int) = underlying.hashCode() + final def toString$extension(underlying: Int) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Int): String +} + +final class VCIntArray[T <: VCIntPrototype] private (val arr: Array[Int], val ct: VCIntCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCIntCompanion[T], sz: Int) = + this(new Array[Int](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + def length: Int = arr.length + + override def clone(): VCIntArray[T] = { + new VCIntArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCDoublePrototype(val underlying: Double) extends VCPrototype {} + +abstract class VCDoubleCasePrototype(underlying: Double) extends VCDoublePrototype(underlying) with Product1[Double] { + + final def _1: Double = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCDoubleCompanion[T <: VCDoublePrototype] extends ClassTag[T] { + def box(underlying: Double): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCDoubleArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Double) = underlying + final def hashCode$extension(underlying: Double) = underlying.hashCode() + final def toString$extension(underlying: Double) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Double): String +} + +final class VCDoubleArray[T <: VCDoublePrototype] private (val arr: Array[Double], val ct: VCDoubleCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCDoubleCompanion[T], sz: Int) = + this(new Array[Double](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + def length: Int = arr.length + + override def clone(): VCDoubleArray[T] = { + new VCDoubleArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCBooleanPrototype(val underlying: Boolean) extends VCPrototype {} + +abstract class VCBooleanCasePrototype(underlying: Boolean) extends VCBooleanPrototype(underlying) with Product1[Boolean] { + + final def _1: Boolean = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCBooleanCompanion[T <: VCBooleanPrototype] extends ClassTag[T] { + def box(underlying: Boolean): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCBooleanArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Boolean) = underlying + final def hashCode$extension(underlying: Boolean) = underlying.hashCode() + final def toString$extension(underlying: Boolean) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Boolean): String +} + +final class VCBooleanArray[T <: VCBooleanPrototype] private (val arr: Array[Boolean], val ct: VCBooleanCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCBooleanCompanion[T], sz: Int) = + this(new Array[Boolean](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + + def length: Int = arr.length + + override def clone(): VCBooleanArray[T] = { + new VCBooleanArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCCharPrototype(val underlying: Char) extends VCPrototype {} + +abstract class VCCharCasePrototype(underlying: Char) extends VCCharPrototype(underlying) with Product1[Char] { + + final def _1: Char = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } + + // subclasses are expected to implement equals, productPrefix, and canEqual +} + +abstract class VCCharCompanion[T <: VCCharPrototype] extends ClassTag[T] { + def box(underlying: Char): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCCharArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Char) = underlying + final def hashCode$extension(underlying: Char) = underlying.hashCode() + final def toString$extension(underlying: Char) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Char): String +} + +final class VCCharArray[T <: VCCharPrototype] private (val arr: Array[Char], val ct: VCCharCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCCharCompanion[T], sz: Int) = + this(new Array[Char](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + def length: Int = arr.length + + override def clone(): VCCharArray[T] = { + new VCCharArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } +} + + +abstract class VCBytePrototype(val underlying: Byte) extends VCPrototype {} + +abstract class VCByteCasePrototype(underlying: Byte) extends VCBytePrototype(underlying) with Product1[Byte] { + + final def _1: Byte = underlying + + override final def hashCode(): Int = { + underlying.hashCode() + } + + override final def toString: String = { + s"$productPrefix($underlying)" + } +} + +abstract class VCByteCompanion[T <: VCBytePrototype] extends ClassTag[T] { + def box(underlying: Byte): T + final def unbox(boxed: T) = boxed.underlying + + implicit def classTag: this.type = this + override def newArray(len: Int): Array[T] = + new VCByteArray(this, len).asInstanceOf[Array[T]] + + + final def _1$extension(underlying: Byte) = underlying + final def hashCode$extension(underlying: Byte) = underlying.hashCode() + final def toString$extension(underlying: Byte) = s"${productPrefix$extension(underlying)}($underlying)" + def productPrefix$extension(underlying: Byte): String +} + +final class VCByteArray[T <: VCBytePrototype] private (val arr: Array[Byte], val ct: VCByteCompanion[T]) + extends VCArrayPrototype[T] { + def this(ct: VCByteCompanion[T], sz: Int) = + this(new Array[Byte](sz), ct) + + def apply(idx: Int) = + ct.box(arr(idx)) + def update(idx: Int, elem: T) = + arr(idx) = ct.unbox(elem) + def length: Int = arr.length + + override def clone(): VCByteArray[T] = { + new VCByteArray[T](arr.clone(), ct) + } + + override def toString: String = { + "[" + ct.runtimeClass + } + +} + |