From f57fceb1613e289beb67761ad23b31135bf40e50 Mon Sep 17 00:00:00 2001 From: Ben Wing Date: Thu, 31 Oct 2013 22:38:55 -0500 Subject: [PATCH 1/2] Add Object-primitive and primitive-Object maps --- build.xml | 239 ++++++++++++------ .../ObjectPrimitiveMapIterator.scala.tpl | 15 ++ .../PrimitiveObjectMapIterator.scala.tpl | 15 ++ .../mutable/ObjectPrimitiveMap.scala.tpl | 73 ++++++ .../mutable/PrimitiveObjectMap.scala.tpl | 73 ++++++ .../trove/collection/ByteObjectIterator.scala | 15 ++ .../trove/collection/CharObjectIterator.scala | 15 ++ .../collection/DoubleObjectIterator.scala | 15 ++ .../collection/FloatObjectIterator.scala | 15 ++ .../trove/collection/IntObjectIterator.scala | 15 ++ .../trove/collection/LongObjectIterator.scala | 15 ++ .../trove/collection/ObjectByteIterator.scala | 15 ++ .../trove/collection/ObjectCharIterator.scala | 15 ++ .../collection/ObjectDoubleIterator.scala | 15 ++ .../collection/ObjectFloatIterator.scala | 15 ++ .../trove/collection/ObjectIntIterator.scala | 15 ++ .../trove/collection/ObjectLongIterator.scala | 15 ++ .../trove/mutable/ByteObjectMap.scala | 73 ++++++ .../trove/mutable/CharObjectMap.scala | 73 ++++++ .../trove/mutable/DoubleObjectMap.scala | 73 ++++++ .../trove/mutable/FloatObjectMap.scala | 73 ++++++ .../codahale/trove/mutable/IntObjectMap.scala | 73 ++++++ .../trove/mutable/LongObjectMap.scala | 73 ++++++ .../trove/mutable/ObjectByteMap.scala | 73 ++++++ .../trove/mutable/ObjectCharMap.scala | 73 ++++++ .../trove/mutable/ObjectDoubleMap.scala | 73 ++++++ .../trove/mutable/ObjectFloatMap.scala | 73 ++++++ .../codahale/trove/mutable/ObjectIntMap.scala | 73 ++++++ .../trove/mutable/ObjectLongMap.scala | 73 ++++++ 29 files changed, 1398 insertions(+), 73 deletions(-) create mode 100644 src/main/resources/com/codahale/trove/collection/ObjectPrimitiveMapIterator.scala.tpl create mode 100644 src/main/resources/com/codahale/trove/collection/PrimitiveObjectMapIterator.scala.tpl create mode 100644 src/main/resources/com/codahale/trove/mutable/ObjectPrimitiveMap.scala.tpl create mode 100644 src/main/resources/com/codahale/trove/mutable/PrimitiveObjectMap.scala.tpl create mode 100644 src/main/scala/com/codahale/trove/collection/ByteObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/CharObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/DoubleObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/FloatObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/IntObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/LongObjectIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectByteIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectCharIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectDoubleIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectFloatIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectIntIterator.scala create mode 100644 src/main/scala/com/codahale/trove/collection/ObjectLongIterator.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ByteObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/CharObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/DoubleObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/FloatObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/IntObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/LongObjectMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectByteMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectCharMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectDoubleMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectFloatMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectIntMap.scala create mode 100644 src/main/scala/com/codahale/trove/mutable/ObjectLongMap.scala diff --git a/build.xml b/build.xml index 742c7f1..98f69d6 100644 --- a/build.xml +++ b/build.xml @@ -27,7 +27,7 @@ - + @@ -45,6 +45,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -53,42 +85,57 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -144,7 +191,7 @@ - + @@ -162,43 +209,89 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/resources/com/codahale/trove/collection/ObjectPrimitiveMapIterator.scala.tpl b/src/main/resources/com/codahale/trove/collection/ObjectPrimitiveMapIterator.scala.tpl new file mode 100644 index 0000000..651f1ab --- /dev/null +++ b/src/main/resources/com/codahale/trove/collection/ObjectPrimitiveMapIterator.scala.tpl @@ -0,0 +1,15 @@ +@header@ + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObject@valueType@Iterator + +case class Object@valueType@Iterator[A](val underlying: TObject@valueType@Iterator[A]) extends Iterator[(A, @valueType@)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/resources/com/codahale/trove/collection/PrimitiveObjectMapIterator.scala.tpl b/src/main/resources/com/codahale/trove/collection/PrimitiveObjectMapIterator.scala.tpl new file mode 100644 index 0000000..03a7824 --- /dev/null +++ b/src/main/resources/com/codahale/trove/collection/PrimitiveObjectMapIterator.scala.tpl @@ -0,0 +1,15 @@ +@header@ + +package com.codahale.trove.collection + +import gnu.trove.iterator.T@keyType@ObjectIterator + +case class @keyType@ObjectIterator[A](val underlying: T@keyType@ObjectIterator[A]) extends Iterator[(@keyType@, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/resources/com/codahale/trove/mutable/ObjectPrimitiveMap.scala.tpl b/src/main/resources/com/codahale/trove/mutable/ObjectPrimitiveMap.scala.tpl new file mode 100644 index 0000000..bbf2f4b --- /dev/null +++ b/src/main/resources/com/codahale/trove/mutable/ObjectPrimitiveMap.scala.tpl @@ -0,0 +1,73 @@ +@header@ + +package com.codahale.trove.mutable + +import gnu.trove.map.TObject@valueType@Map +import com.codahale.trove.collection.Object@valueType@Iterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObject@valueType@HashMap + +class Object@valueType@Map[A] private(private val underlying: TObject@valueType@Map[A]) + extends Map[A, @valueType@] + with MapLike[A, @valueType@, Object@valueType@Map[A]] { + + override def empty = Object@valueType@Map.empty[A] + + def +=(kv: (A, @valueType@)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: @valueType@) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new Object@valueType@Iterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object Object@valueType@Map { + type Coll = Map[_, _] + + def empty[A]: Object@valueType@Map[A] = new Object@valueType@Map[A](new TObject@valueType@HashMap[A]()) + + def apply[A](elems: (A, @valueType@)*): Object@valueType@Map[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new Object@valueType@MapBuilder[A](empty) + + class Object@valueType@MapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, @valueType@), Object@valueType@Map[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class Object@valueType@MapBuilder[A](map: Object@valueType@Map[A]) extends Builder[(A, @valueType@), Object@valueType@Map[A]] { + def +=(elem: (A, @valueType@)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: @valueType@) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, @valueType@), Object@valueType@Map[A]] = new Object@valueType@MapCanBuildFrom[A] +} diff --git a/src/main/resources/com/codahale/trove/mutable/PrimitiveObjectMap.scala.tpl b/src/main/resources/com/codahale/trove/mutable/PrimitiveObjectMap.scala.tpl new file mode 100644 index 0000000..b8ff970 --- /dev/null +++ b/src/main/resources/com/codahale/trove/mutable/PrimitiveObjectMap.scala.tpl @@ -0,0 +1,73 @@ +@header@ + +package com.codahale.trove.mutable + +import gnu.trove.map.T@keyType@ObjectMap +import com.codahale.trove.collection.@keyType@ObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.T@keyType@ObjectHashMap + +class @keyType@ObjectMap[A] private(private val underlying: T@keyType@ObjectMap[A]) + extends Map[@keyType@, A] + with MapLike[@keyType@, A, @keyType@ObjectMap[A]] { + + override def empty = @keyType@ObjectMap.empty[A] + + def +=(kv: (@keyType@, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: @keyType@) = { + underlying.remove(key) + this + } + + override def update(key: @keyType@, value: A) { + underlying.put(key, value) + } + + def get(key: @keyType@) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: @keyType@) = underlying.get(key) + + def iterator = new @keyType@ObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object @keyType@ObjectMap { + type Coll = Map[_, _] + + def empty[A]: @keyType@ObjectMap[A] = new @keyType@ObjectMap[A](new T@keyType@ObjectHashMap[A]()) + + def apply[A](elems: (@keyType@, A)*): @keyType@ObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new @keyType@ObjectMapBuilder[A](empty) + + class @keyType@ObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (@keyType@, A), @keyType@ObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class @keyType@ObjectMapBuilder[A](map: @keyType@ObjectMap[A]) extends Builder[(@keyType@, A), @keyType@ObjectMap[A]] { + def +=(elem: (@keyType@, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: @keyType@, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (@keyType@, A), @keyType@ObjectMap[A]] = new @keyType@ObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/collection/ByteObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/ByteObjectIterator.scala new file mode 100644 index 0000000..a106f80 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ByteObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TByteObjectIterator + +case class ByteObjectIterator[A](val underlying: TByteObjectIterator[A]) extends Iterator[(Byte, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/CharObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/CharObjectIterator.scala new file mode 100644 index 0000000..bb094a2 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/CharObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TCharObjectIterator + +case class CharObjectIterator[A](val underlying: TCharObjectIterator[A]) extends Iterator[(Char, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/DoubleObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/DoubleObjectIterator.scala new file mode 100644 index 0000000..15bd59d --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/DoubleObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TDoubleObjectIterator + +case class DoubleObjectIterator[A](val underlying: TDoubleObjectIterator[A]) extends Iterator[(Double, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/FloatObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/FloatObjectIterator.scala new file mode 100644 index 0000000..c8e5b20 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/FloatObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TFloatObjectIterator + +case class FloatObjectIterator[A](val underlying: TFloatObjectIterator[A]) extends Iterator[(Float, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/IntObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/IntObjectIterator.scala new file mode 100644 index 0000000..8c33a24 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/IntObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TIntObjectIterator + +case class IntObjectIterator[A](val underlying: TIntObjectIterator[A]) extends Iterator[(Int, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/LongObjectIterator.scala b/src/main/scala/com/codahale/trove/collection/LongObjectIterator.scala new file mode 100644 index 0000000..f44f8db --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/LongObjectIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TLongObjectIterator + +case class LongObjectIterator[A](val underlying: TLongObjectIterator[A]) extends Iterator[(Long, A)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectByteIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectByteIterator.scala new file mode 100644 index 0000000..beefaab --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectByteIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectByteIterator + +case class ObjectByteIterator[A](val underlying: TObjectByteIterator[A]) extends Iterator[(A, Byte)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectCharIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectCharIterator.scala new file mode 100644 index 0000000..b5b29da --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectCharIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectCharIterator + +case class ObjectCharIterator[A](val underlying: TObjectCharIterator[A]) extends Iterator[(A, Char)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectDoubleIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectDoubleIterator.scala new file mode 100644 index 0000000..d33073d --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectDoubleIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectDoubleIterator + +case class ObjectDoubleIterator[A](val underlying: TObjectDoubleIterator[A]) extends Iterator[(A, Double)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectFloatIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectFloatIterator.scala new file mode 100644 index 0000000..dbda855 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectFloatIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectFloatIterator + +case class ObjectFloatIterator[A](val underlying: TObjectFloatIterator[A]) extends Iterator[(A, Float)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectIntIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectIntIterator.scala new file mode 100644 index 0000000..361e47c --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectIntIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectIntIterator + +case class ObjectIntIterator[A](val underlying: TObjectIntIterator[A]) extends Iterator[(A, Int)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/collection/ObjectLongIterator.scala b/src/main/scala/com/codahale/trove/collection/ObjectLongIterator.scala new file mode 100644 index 0000000..fcd4f44 --- /dev/null +++ b/src/main/scala/com/codahale/trove/collection/ObjectLongIterator.scala @@ -0,0 +1,15 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.collection + +import gnu.trove.iterator.TObjectLongIterator + +case class ObjectLongIterator[A](val underlying: TObjectLongIterator[A]) extends Iterator[(A, Long)] { + def hasNext = underlying.hasNext + + def next() = { + underlying.advance() + (underlying.key(), underlying.value()) + } +} + diff --git a/src/main/scala/com/codahale/trove/mutable/ByteObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/ByteObjectMap.scala new file mode 100644 index 0000000..731f3d7 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ByteObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TByteObjectMap +import com.codahale.trove.collection.ByteObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TByteObjectHashMap + +class ByteObjectMap[A] private(private val underlying: TByteObjectMap[A]) + extends Map[Byte, A] + with MapLike[Byte, A, ByteObjectMap[A]] { + + override def empty = ByteObjectMap.empty[A] + + def +=(kv: (Byte, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Byte) = { + underlying.remove(key) + this + } + + override def update(key: Byte, value: A) { + underlying.put(key, value) + } + + def get(key: Byte) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Byte) = underlying.get(key) + + def iterator = new ByteObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ByteObjectMap { + type Coll = Map[_, _] + + def empty[A]: ByteObjectMap[A] = new ByteObjectMap[A](new TByteObjectHashMap[A]()) + + def apply[A](elems: (Byte, A)*): ByteObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ByteObjectMapBuilder[A](empty) + + class ByteObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Byte, A), ByteObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ByteObjectMapBuilder[A](map: ByteObjectMap[A]) extends Builder[(Byte, A), ByteObjectMap[A]] { + def +=(elem: (Byte, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Byte, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Byte, A), ByteObjectMap[A]] = new ByteObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/CharObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/CharObjectMap.scala new file mode 100644 index 0000000..58cf685 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/CharObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TCharObjectMap +import com.codahale.trove.collection.CharObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TCharObjectHashMap + +class CharObjectMap[A] private(private val underlying: TCharObjectMap[A]) + extends Map[Char, A] + with MapLike[Char, A, CharObjectMap[A]] { + + override def empty = CharObjectMap.empty[A] + + def +=(kv: (Char, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Char) = { + underlying.remove(key) + this + } + + override def update(key: Char, value: A) { + underlying.put(key, value) + } + + def get(key: Char) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Char) = underlying.get(key) + + def iterator = new CharObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object CharObjectMap { + type Coll = Map[_, _] + + def empty[A]: CharObjectMap[A] = new CharObjectMap[A](new TCharObjectHashMap[A]()) + + def apply[A](elems: (Char, A)*): CharObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new CharObjectMapBuilder[A](empty) + + class CharObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Char, A), CharObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class CharObjectMapBuilder[A](map: CharObjectMap[A]) extends Builder[(Char, A), CharObjectMap[A]] { + def +=(elem: (Char, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Char, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Char, A), CharObjectMap[A]] = new CharObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/DoubleObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/DoubleObjectMap.scala new file mode 100644 index 0000000..20f75a1 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/DoubleObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TDoubleObjectMap +import com.codahale.trove.collection.DoubleObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TDoubleObjectHashMap + +class DoubleObjectMap[A] private(private val underlying: TDoubleObjectMap[A]) + extends Map[Double, A] + with MapLike[Double, A, DoubleObjectMap[A]] { + + override def empty = DoubleObjectMap.empty[A] + + def +=(kv: (Double, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Double) = { + underlying.remove(key) + this + } + + override def update(key: Double, value: A) { + underlying.put(key, value) + } + + def get(key: Double) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Double) = underlying.get(key) + + def iterator = new DoubleObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object DoubleObjectMap { + type Coll = Map[_, _] + + def empty[A]: DoubleObjectMap[A] = new DoubleObjectMap[A](new TDoubleObjectHashMap[A]()) + + def apply[A](elems: (Double, A)*): DoubleObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new DoubleObjectMapBuilder[A](empty) + + class DoubleObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Double, A), DoubleObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class DoubleObjectMapBuilder[A](map: DoubleObjectMap[A]) extends Builder[(Double, A), DoubleObjectMap[A]] { + def +=(elem: (Double, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Double, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Double, A), DoubleObjectMap[A]] = new DoubleObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/FloatObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/FloatObjectMap.scala new file mode 100644 index 0000000..eaf8976 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/FloatObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TFloatObjectMap +import com.codahale.trove.collection.FloatObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TFloatObjectHashMap + +class FloatObjectMap[A] private(private val underlying: TFloatObjectMap[A]) + extends Map[Float, A] + with MapLike[Float, A, FloatObjectMap[A]] { + + override def empty = FloatObjectMap.empty[A] + + def +=(kv: (Float, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Float) = { + underlying.remove(key) + this + } + + override def update(key: Float, value: A) { + underlying.put(key, value) + } + + def get(key: Float) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Float) = underlying.get(key) + + def iterator = new FloatObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object FloatObjectMap { + type Coll = Map[_, _] + + def empty[A]: FloatObjectMap[A] = new FloatObjectMap[A](new TFloatObjectHashMap[A]()) + + def apply[A](elems: (Float, A)*): FloatObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new FloatObjectMapBuilder[A](empty) + + class FloatObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Float, A), FloatObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class FloatObjectMapBuilder[A](map: FloatObjectMap[A]) extends Builder[(Float, A), FloatObjectMap[A]] { + def +=(elem: (Float, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Float, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Float, A), FloatObjectMap[A]] = new FloatObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/IntObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/IntObjectMap.scala new file mode 100644 index 0000000..955bc35 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/IntObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TIntObjectMap +import com.codahale.trove.collection.IntObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TIntObjectHashMap + +class IntObjectMap[A] private(private val underlying: TIntObjectMap[A]) + extends Map[Int, A] + with MapLike[Int, A, IntObjectMap[A]] { + + override def empty = IntObjectMap.empty[A] + + def +=(kv: (Int, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Int) = { + underlying.remove(key) + this + } + + override def update(key: Int, value: A) { + underlying.put(key, value) + } + + def get(key: Int) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Int) = underlying.get(key) + + def iterator = new IntObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object IntObjectMap { + type Coll = Map[_, _] + + def empty[A]: IntObjectMap[A] = new IntObjectMap[A](new TIntObjectHashMap[A]()) + + def apply[A](elems: (Int, A)*): IntObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new IntObjectMapBuilder[A](empty) + + class IntObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Int, A), IntObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class IntObjectMapBuilder[A](map: IntObjectMap[A]) extends Builder[(Int, A), IntObjectMap[A]] { + def +=(elem: (Int, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Int, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Int, A), IntObjectMap[A]] = new IntObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/LongObjectMap.scala b/src/main/scala/com/codahale/trove/mutable/LongObjectMap.scala new file mode 100644 index 0000000..80384ad --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/LongObjectMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TLongObjectMap +import com.codahale.trove.collection.LongObjectIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TLongObjectHashMap + +class LongObjectMap[A] private(private val underlying: TLongObjectMap[A]) + extends Map[Long, A] + with MapLike[Long, A, LongObjectMap[A]] { + + override def empty = LongObjectMap.empty[A] + + def +=(kv: (Long, A)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: Long) = { + underlying.remove(key) + this + } + + override def update(key: Long, value: A) { + underlying.put(key, value) + } + + def get(key: Long) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: Long) = underlying.get(key) + + def iterator = new LongObjectIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object LongObjectMap { + type Coll = Map[_, _] + + def empty[A]: LongObjectMap[A] = new LongObjectMap[A](new TLongObjectHashMap[A]()) + + def apply[A](elems: (Long, A)*): LongObjectMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new LongObjectMapBuilder[A](empty) + + class LongObjectMapCanBuildFrom[A] extends CanBuildFrom[Coll, (Long, A), LongObjectMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class LongObjectMapBuilder[A](map: LongObjectMap[A]) extends Builder[(Long, A), LongObjectMap[A]] { + def +=(elem: (Long, A)) = { + map(elem._1) = elem._2 + this + } + + def update(key: Long, value: A) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (Long, A), LongObjectMap[A]] = new LongObjectMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectByteMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectByteMap.scala new file mode 100644 index 0000000..e741df1 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectByteMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectByteMap +import com.codahale.trove.collection.ObjectByteIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectByteHashMap + +class ObjectByteMap[A] private(private val underlying: TObjectByteMap[A]) + extends Map[A, Byte] + with MapLike[A, Byte, ObjectByteMap[A]] { + + override def empty = ObjectByteMap.empty[A] + + def +=(kv: (A, Byte)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Byte) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectByteIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectByteMap { + type Coll = Map[_, _] + + def empty[A]: ObjectByteMap[A] = new ObjectByteMap[A](new TObjectByteHashMap[A]()) + + def apply[A](elems: (A, Byte)*): ObjectByteMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectByteMapBuilder[A](empty) + + class ObjectByteMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Byte), ObjectByteMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectByteMapBuilder[A](map: ObjectByteMap[A]) extends Builder[(A, Byte), ObjectByteMap[A]] { + def +=(elem: (A, Byte)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Byte) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Byte), ObjectByteMap[A]] = new ObjectByteMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectCharMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectCharMap.scala new file mode 100644 index 0000000..d024d4f --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectCharMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectCharMap +import com.codahale.trove.collection.ObjectCharIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectCharHashMap + +class ObjectCharMap[A] private(private val underlying: TObjectCharMap[A]) + extends Map[A, Char] + with MapLike[A, Char, ObjectCharMap[A]] { + + override def empty = ObjectCharMap.empty[A] + + def +=(kv: (A, Char)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Char) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectCharIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectCharMap { + type Coll = Map[_, _] + + def empty[A]: ObjectCharMap[A] = new ObjectCharMap[A](new TObjectCharHashMap[A]()) + + def apply[A](elems: (A, Char)*): ObjectCharMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectCharMapBuilder[A](empty) + + class ObjectCharMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Char), ObjectCharMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectCharMapBuilder[A](map: ObjectCharMap[A]) extends Builder[(A, Char), ObjectCharMap[A]] { + def +=(elem: (A, Char)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Char) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Char), ObjectCharMap[A]] = new ObjectCharMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectDoubleMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectDoubleMap.scala new file mode 100644 index 0000000..5485b9d --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectDoubleMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectDoubleMap +import com.codahale.trove.collection.ObjectDoubleIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectDoubleHashMap + +class ObjectDoubleMap[A] private(private val underlying: TObjectDoubleMap[A]) + extends Map[A, Double] + with MapLike[A, Double, ObjectDoubleMap[A]] { + + override def empty = ObjectDoubleMap.empty[A] + + def +=(kv: (A, Double)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Double) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectDoubleIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectDoubleMap { + type Coll = Map[_, _] + + def empty[A]: ObjectDoubleMap[A] = new ObjectDoubleMap[A](new TObjectDoubleHashMap[A]()) + + def apply[A](elems: (A, Double)*): ObjectDoubleMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectDoubleMapBuilder[A](empty) + + class ObjectDoubleMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Double), ObjectDoubleMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectDoubleMapBuilder[A](map: ObjectDoubleMap[A]) extends Builder[(A, Double), ObjectDoubleMap[A]] { + def +=(elem: (A, Double)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Double) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Double), ObjectDoubleMap[A]] = new ObjectDoubleMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectFloatMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectFloatMap.scala new file mode 100644 index 0000000..84a60f5 --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectFloatMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectFloatMap +import com.codahale.trove.collection.ObjectFloatIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectFloatHashMap + +class ObjectFloatMap[A] private(private val underlying: TObjectFloatMap[A]) + extends Map[A, Float] + with MapLike[A, Float, ObjectFloatMap[A]] { + + override def empty = ObjectFloatMap.empty[A] + + def +=(kv: (A, Float)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Float) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectFloatIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectFloatMap { + type Coll = Map[_, _] + + def empty[A]: ObjectFloatMap[A] = new ObjectFloatMap[A](new TObjectFloatHashMap[A]()) + + def apply[A](elems: (A, Float)*): ObjectFloatMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectFloatMapBuilder[A](empty) + + class ObjectFloatMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Float), ObjectFloatMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectFloatMapBuilder[A](map: ObjectFloatMap[A]) extends Builder[(A, Float), ObjectFloatMap[A]] { + def +=(elem: (A, Float)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Float) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Float), ObjectFloatMap[A]] = new ObjectFloatMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectIntMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectIntMap.scala new file mode 100644 index 0000000..b239e4c --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectIntMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectIntMap +import com.codahale.trove.collection.ObjectIntIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectIntHashMap + +class ObjectIntMap[A] private(private val underlying: TObjectIntMap[A]) + extends Map[A, Int] + with MapLike[A, Int, ObjectIntMap[A]] { + + override def empty = ObjectIntMap.empty[A] + + def +=(kv: (A, Int)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Int) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectIntIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectIntMap { + type Coll = Map[_, _] + + def empty[A]: ObjectIntMap[A] = new ObjectIntMap[A](new TObjectIntHashMap[A]()) + + def apply[A](elems: (A, Int)*): ObjectIntMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectIntMapBuilder[A](empty) + + class ObjectIntMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Int), ObjectIntMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectIntMapBuilder[A](map: ObjectIntMap[A]) extends Builder[(A, Int), ObjectIntMap[A]] { + def +=(elem: (A, Int)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Int) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Int), ObjectIntMap[A]] = new ObjectIntMapCanBuildFrom[A] +} diff --git a/src/main/scala/com/codahale/trove/mutable/ObjectLongMap.scala b/src/main/scala/com/codahale/trove/mutable/ObjectLongMap.scala new file mode 100644 index 0000000..2b9004a --- /dev/null +++ b/src/main/scala/com/codahale/trove/mutable/ObjectLongMap.scala @@ -0,0 +1,73 @@ +// AUTOMATICALLY GENERATED FILE!!! DO NOT EDIT!!! + +package com.codahale.trove.mutable + +import gnu.trove.map.TObjectLongMap +import com.codahale.trove.collection.ObjectLongIterator +import scala.collection.generic.CanBuildFrom +import scala.collection.mutable._ +import gnu.trove.map.hash.TObjectLongHashMap + +class ObjectLongMap[A] private(private val underlying: TObjectLongMap[A]) + extends Map[A, Long] + with MapLike[A, Long, ObjectLongMap[A]] { + + override def empty = ObjectLongMap.empty[A] + + def +=(kv: (A, Long)) = { + underlying.put(kv._1, kv._2) + this + } + + def -=(key: A) = { + underlying.remove(key) + this + } + + override def update(key: A, value: Long) { + underlying.put(key, value) + } + + def get(key: A) = if (underlying.containsKey(key)) Some(underlying.get(key)) else None + + override def apply(key: A) = underlying.get(key) + + def iterator = new ObjectLongIterator[A](underlying.iterator()) + + override def size = underlying.size() +} + +object ObjectLongMap { + type Coll = Map[_, _] + + def empty[A]: ObjectLongMap[A] = new ObjectLongMap[A](new TObjectLongHashMap[A]()) + + def apply[A](elems: (A, Long)*): ObjectLongMap[A] = (newBuilder ++= elems).result + + def newBuilder[A] = new ObjectLongMapBuilder[A](empty) + + class ObjectLongMapCanBuildFrom[A] extends CanBuildFrom[Coll, (A, Long), ObjectLongMap[A]] { + def apply(from: Coll) = newBuilder + + def apply() = newBuilder + } + + class ObjectLongMapBuilder[A](map: ObjectLongMap[A]) extends Builder[(A, Long), ObjectLongMap[A]] { + def +=(elem: (A, Long)) = { + map(elem._1) = elem._2 + this + } + + def update(key: A, value: Long) { + map(key) = value + } + + def clear() { + map.clear() + } + + def result() = map + } + + implicit def canBuildFrom[A]: CanBuildFrom[Coll, (A, Long), ObjectLongMap[A]] = new ObjectLongMapCanBuildFrom[A] +} From 32dfae41b90a7f33653a4ce254fd103ee5b000c1 Mon Sep 17 00:00:00 2001 From: Ben Wing Date: Thu, 31 Oct 2013 22:36:47 -0500 Subject: [PATCH 2/2] Upgrade to Scala 2.10.3 and SBT --- build.sbt | 33 +++++++++++++++++++ pom.xml | 19 ++++++----- .../trove/immutable/PrimitiveSet.scala.tpl | 5 +-- .../codahale/trove/immutable/ByteSet.scala | 5 +-- .../codahale/trove/immutable/CharSet.scala | 5 +-- .../codahale/trove/immutable/DoubleSet.scala | 5 +-- .../codahale/trove/immutable/FloatSet.scala | 5 +-- .../com/codahale/trove/immutable/IntSet.scala | 5 +-- .../codahale/trove/immutable/LongSet.scala | 5 +-- 9 files changed, 65 insertions(+), 22 deletions(-) create mode 100644 build.sbt diff --git a/build.sbt b/build.sbt new file mode 100644 index 0000000..1a8d0e5 --- /dev/null +++ b/build.sbt @@ -0,0 +1,33 @@ +name := "trove-scala" + +version := "0.1.0" + +organization := "com.codahale" + +scalaVersion := "2.10.3" + +// crossPaths := false +// +retrieveManaged := true + +resolvers ++= Seq( + "repo.codahale.com" at "http://repo.codahale.com" +// Resolver for trove-scala source; nonexistent here yet +// "repo.codahale.com" at "http://repo.codahale.com", +// Resolver if you want to find stuff out of your local Maven cache +// "Local Maven Repository" at "file://"+Path.userHome+"/.m2/repository" + ) + +libraryDependencies ++= Seq( + "net.sf.trove4j" % "trove4j" % "3.0.3", + "com.simple" % "simplespec_2.10.2" % "0.8.4" + ) + +// turn on all warnings in Java code +javacOptions ++= Seq("-Xlint") + +// turn on all Scala warnings; also turn on deprecation warnings. +scalacOptions ++= Seq("-deprecation", "-Xlint", "-unchecked") + +// Add optimization +scalacOptions ++= Seq("-optimise") diff --git a/pom.xml b/pom.xml index b0063a4..c9432a6 100644 --- a/pom.xml +++ b/pom.xml @@ -5,12 +5,12 @@ 4.0.0 com.codahale - trove-scala_2.9.1 - 0.0.1-SNAPSHOT + trove-scala_2.10 + 0.0.2-SNAPSHOT Trove Collections for Scala ${scala.version} - 2.9.1 + 2.10.3 @@ -82,12 +82,12 @@ net.sf.trove4j trove4j - 3.0.0 + 3.0.3 - com.codahale - simplespec_${scala.version} - 0.5.2 + com.simple + simplespec_2.10.2 + 0.8.4 test @@ -121,7 +121,7 @@ org.scala-tools maven-scala-plugin - 2.15.3-SNAPSHOT + 2.15.2 @@ -136,6 +136,9 @@ -unchecked -deprecation + + -Xmx1024m + com.nativelibs4java diff --git a/src/main/resources/com/codahale/trove/immutable/PrimitiveSet.scala.tpl b/src/main/resources/com/codahale/trove/immutable/PrimitiveSet.scala.tpl index e73e002..f449dd5 100644 --- a/src/main/resources/com/codahale/trove/immutable/PrimitiveSet.scala.tpl +++ b/src/main/resources/com/codahale/trove/immutable/PrimitiveSet.scala.tpl @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.@type@SetFactory import gnu.trove.impl.unmodifiable.TUnmodifiable@type@Set import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.T@type@HashSet class @type@Set(private val underlying: TUnmodifiable@type@Set) @@ -15,7 +16,7 @@ class @type@Set(private val underlying: TUnmodifiable@type@Set) with Serializable { override def empty: @type@Set = @type@Set.empty - override def ++(xs: TraversableOnce[@type@]) = { + override def ++(xs: GenTraversableOnce[@type@]) = { val newSet = new T@type@HashSet(underlying) xs match { case s: @type@Set => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class @type@Set(private val underlying: TUnmodifiable@type@Set) new @type@Set(new TUnmodifiable@type@Set(newSet)) } - override def --(xs: TraversableOnce[@type@]) = { + override def --(xs: GenTraversableOnce[@type@]) = { val newSet = new T@type@HashSet(underlying) xs match { case s: @type@Set => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/ByteSet.scala b/src/main/scala/com/codahale/trove/immutable/ByteSet.scala index 05af699..909e774 100644 --- a/src/main/scala/com/codahale/trove/immutable/ByteSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/ByteSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.ByteSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableByteSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TByteHashSet class ByteSet(private val underlying: TUnmodifiableByteSet) @@ -15,7 +16,7 @@ class ByteSet(private val underlying: TUnmodifiableByteSet) with Serializable { override def empty: ByteSet = ByteSet.empty - override def ++(xs: TraversableOnce[Byte]) = { + override def ++(xs: GenTraversableOnce[Byte]) = { val newSet = new TByteHashSet(underlying) xs match { case s: ByteSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class ByteSet(private val underlying: TUnmodifiableByteSet) new ByteSet(new TUnmodifiableByteSet(newSet)) } - override def --(xs: TraversableOnce[Byte]) = { + override def --(xs: GenTraversableOnce[Byte]) = { val newSet = new TByteHashSet(underlying) xs match { case s: ByteSet => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/CharSet.scala b/src/main/scala/com/codahale/trove/immutable/CharSet.scala index fd2035a..773595d 100644 --- a/src/main/scala/com/codahale/trove/immutable/CharSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/CharSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.CharSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableCharSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TCharHashSet class CharSet(private val underlying: TUnmodifiableCharSet) @@ -15,7 +16,7 @@ class CharSet(private val underlying: TUnmodifiableCharSet) with Serializable { override def empty: CharSet = CharSet.empty - override def ++(xs: TraversableOnce[Char]) = { + override def ++(xs: GenTraversableOnce[Char]) = { val newSet = new TCharHashSet(underlying) xs match { case s: CharSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class CharSet(private val underlying: TUnmodifiableCharSet) new CharSet(new TUnmodifiableCharSet(newSet)) } - override def --(xs: TraversableOnce[Char]) = { + override def --(xs: GenTraversableOnce[Char]) = { val newSet = new TCharHashSet(underlying) xs match { case s: CharSet => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/DoubleSet.scala b/src/main/scala/com/codahale/trove/immutable/DoubleSet.scala index aabdaa6..9793530 100644 --- a/src/main/scala/com/codahale/trove/immutable/DoubleSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/DoubleSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.DoubleSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableDoubleSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TDoubleHashSet class DoubleSet(private val underlying: TUnmodifiableDoubleSet) @@ -15,7 +16,7 @@ class DoubleSet(private val underlying: TUnmodifiableDoubleSet) with Serializable { override def empty: DoubleSet = DoubleSet.empty - override def ++(xs: TraversableOnce[Double]) = { + override def ++(xs: GenTraversableOnce[Double]) = { val newSet = new TDoubleHashSet(underlying) xs match { case s: DoubleSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class DoubleSet(private val underlying: TUnmodifiableDoubleSet) new DoubleSet(new TUnmodifiableDoubleSet(newSet)) } - override def --(xs: TraversableOnce[Double]) = { + override def --(xs: GenTraversableOnce[Double]) = { val newSet = new TDoubleHashSet(underlying) xs match { case s: DoubleSet => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/FloatSet.scala b/src/main/scala/com/codahale/trove/immutable/FloatSet.scala index 47aade4..e3bef24 100644 --- a/src/main/scala/com/codahale/trove/immutable/FloatSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/FloatSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.FloatSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableFloatSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TFloatHashSet class FloatSet(private val underlying: TUnmodifiableFloatSet) @@ -15,7 +16,7 @@ class FloatSet(private val underlying: TUnmodifiableFloatSet) with Serializable { override def empty: FloatSet = FloatSet.empty - override def ++(xs: TraversableOnce[Float]) = { + override def ++(xs: GenTraversableOnce[Float]) = { val newSet = new TFloatHashSet(underlying) xs match { case s: FloatSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class FloatSet(private val underlying: TUnmodifiableFloatSet) new FloatSet(new TUnmodifiableFloatSet(newSet)) } - override def --(xs: TraversableOnce[Float]) = { + override def --(xs: GenTraversableOnce[Float]) = { val newSet = new TFloatHashSet(underlying) xs match { case s: FloatSet => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/IntSet.scala b/src/main/scala/com/codahale/trove/immutable/IntSet.scala index 1ccec4b..eb55932 100644 --- a/src/main/scala/com/codahale/trove/immutable/IntSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/IntSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.IntSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableIntSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TIntHashSet class IntSet(private val underlying: TUnmodifiableIntSet) @@ -15,7 +16,7 @@ class IntSet(private val underlying: TUnmodifiableIntSet) with Serializable { override def empty: IntSet = IntSet.empty - override def ++(xs: TraversableOnce[Int]) = { + override def ++(xs: GenTraversableOnce[Int]) = { val newSet = new TIntHashSet(underlying) xs match { case s: IntSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class IntSet(private val underlying: TUnmodifiableIntSet) new IntSet(new TUnmodifiableIntSet(newSet)) } - override def --(xs: TraversableOnce[Int]) = { + override def --(xs: GenTraversableOnce[Int]) = { val newSet = new TIntHashSet(underlying) xs match { case s: IntSet => newSet.removeAll(s.underlying) diff --git a/src/main/scala/com/codahale/trove/immutable/LongSet.scala b/src/main/scala/com/codahale/trove/immutable/LongSet.scala index 34d91f4..97b0c5c 100644 --- a/src/main/scala/com/codahale/trove/immutable/LongSet.scala +++ b/src/main/scala/com/codahale/trove/immutable/LongSet.scala @@ -6,6 +6,7 @@ import com.codahale.trove.collection import com.codahale.trove.generic.LongSetFactory import gnu.trove.impl.unmodifiable.TUnmodifiableLongSet import scala.collection.mutable.{SetBuilder, Builder} +import scala.collection.GenTraversableOnce import gnu.trove.set.hash.TLongHashSet class LongSet(private val underlying: TUnmodifiableLongSet) @@ -15,7 +16,7 @@ class LongSet(private val underlying: TUnmodifiableLongSet) with Serializable { override def empty: LongSet = LongSet.empty - override def ++(xs: TraversableOnce[Long]) = { + override def ++(xs: GenTraversableOnce[Long]) = { val newSet = new TLongHashSet(underlying) xs match { case s: LongSet => newSet.addAll(s.underlying) @@ -30,7 +31,7 @@ class LongSet(private val underlying: TUnmodifiableLongSet) new LongSet(new TUnmodifiableLongSet(newSet)) } - override def --(xs: TraversableOnce[Long]) = { + override def --(xs: GenTraversableOnce[Long]) = { val newSet = new TLongHashSet(underlying) xs match { case s: LongSet => newSet.removeAll(s.underlying)