diff options
author | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-05-05 19:53:07 +0200 |
---|---|---|
committer | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-05-05 20:08:31 +0200 |
commit | a40da8fc916baa1c068598bb4e50a684b89e5b2c (patch) | |
tree | b1ce1b7f61caa97b12130f572363eb38062bef1f | |
parent | 0e71743b1622716a99f4783ac5cb41c5012f5a49 (diff) | |
download | dotty-a40da8fc916baa1c068598bb4e50a684b89e5b2c.tar.gz dotty-a40da8fc916baa1c068598bb4e50a684b89e5b2c.tar.bz2 dotty-a40da8fc916baa1c068598bb4e50a684b89e5b2c.zip |
Merge all VC prototypes into single file
-rw-r--r-- | src/dotty/runtime/vc/VCBooleanPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCBytePrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCCharPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCDoublePrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCFloatPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCIntPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCLongPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCObjectPrototype.scala | 60 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCPrototype.scala | 474 | ||||
-rw-r--r-- | src/dotty/runtime/vc/VCShortPrototype.scala | 60 |
10 files changed, 474 insertions, 540 deletions
diff --git a/src/dotty/runtime/vc/VCBooleanPrototype.scala b/src/dotty/runtime/vc/VCBooleanPrototype.scala deleted file mode 100644 index 9c90fb304..000000000 --- a/src/dotty/runtime/vc/VCBooleanPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCBytePrototype.scala b/src/dotty/runtime/vc/VCBytePrototype.scala deleted file mode 100644 index a8a24dab0..000000000 --- a/src/dotty/runtime/vc/VCBytePrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCCharPrototype.scala b/src/dotty/runtime/vc/VCCharPrototype.scala deleted file mode 100644 index 796821f56..000000000 --- a/src/dotty/runtime/vc/VCCharPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCDoublePrototype.scala b/src/dotty/runtime/vc/VCDoublePrototype.scala deleted file mode 100644 index 2a3f90f07..000000000 --- a/src/dotty/runtime/vc/VCDoublePrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCFloatPrototype.scala b/src/dotty/runtime/vc/VCFloatPrototype.scala deleted file mode 100644 index c3e110110..000000000 --- a/src/dotty/runtime/vc/VCFloatPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCIntPrototype.scala b/src/dotty/runtime/vc/VCIntPrototype.scala deleted file mode 100644 index 44f746ed4..000000000 --- a/src/dotty/runtime/vc/VCIntPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCLongPrototype.scala b/src/dotty/runtime/vc/VCLongPrototype.scala deleted file mode 100644 index 83690bcfd..000000000 --- a/src/dotty/runtime/vc/VCLongPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCObjectPrototype.scala b/src/dotty/runtime/vc/VCObjectPrototype.scala deleted file mode 100644 index fd0c8728a..000000000 --- a/src/dotty/runtime/vc/VCObjectPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} diff --git a/src/dotty/runtime/vc/VCPrototype.scala b/src/dotty/runtime/vc/VCPrototype.scala index 61ed93b92..0a3abe5a2 100644 --- a/src/dotty/runtime/vc/VCPrototype.scala +++ b/src/dotty/runtime/vc/VCPrototype.scala @@ -1,5 +1,7 @@ package dotty.runtime.vc +import scala.reflect.ClassTag + abstract class VCPrototype { } @@ -10,3 +12,475 @@ abstract class VCArrayPrototype[T <: VCPrototype] extends Object with Cloneable 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 + } + +} + diff --git a/src/dotty/runtime/vc/VCShortPrototype.scala b/src/dotty/runtime/vc/VCShortPrototype.scala deleted file mode 100644 index 519e6d5c8..000000000 --- a/src/dotty/runtime/vc/VCShortPrototype.scala +++ /dev/null @@ -1,60 +0,0 @@ -package dotty.runtime.vc - -import scala.reflect.ClassTag - -import scala.runtime.Statics - -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)" - } - - // subclasses are expected to implement equals, productPrefix, and canEqual -} - -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 - } - - // Todo: what was the reason for 255 classes in my original proposal? arr.toString! - // todo: need to discuss do we want to be compatible with ugly format of jvm here? -} |