scala.util.hashing.byteswap32 Scala Examples
The following examples show how to use scala.util.hashing.byteswap32.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
Example 1
| Source File: JavaUtils.scala From drizzle-spark with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.{util => ju}
import java.util.Map.Entry
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
if (option.isDefined) {
Optional.of(option.get)
} else {
Optional.empty[T]
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 2
| Source File: JavaUtils.scala From sparkoscope with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.{util => ju}
import java.util.Map.Entry
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
if (option.isDefined) {
Optional.of(option.get)
} else {
Optional.empty[T]
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 3
| Source File: JavaUtils.scala From SparkCore with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import com.google.common.base.Optional
import java.{util => ju}
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
option match {
case Some(value) => Optional.of(value)
case None => Optional.absent()
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]) =
new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size = underlying.size
override def get(key: AnyRef): B = try {
underlying get key.asInstanceOf[A] match {
case None => null.asInstanceOf[B]
case Some(v) => v
}
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
def size = self.size
def iterator = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext = ui.hasNext
def next() = {
val (k, v) = ui.next
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
def getKey = k
def getValue = v
def setValue(v1 : B) = self.put(k, v1)
override def hashCode = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any) = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm remove k
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 4
| Source File: JavaUtils.scala From multi-tenancy-spark with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.{util => ju}
import java.util.Map.Entry
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
if (option.isDefined) {
Optional.of(option.get)
} else {
Optional.empty[T]
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 5
| Source File: JavaUtils.scala From iolap with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.util.Map.Entry
import com.google.common.base.Optional
import java.{util => ju}
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
option match {
case Some(value) => Optional.of(value)
case None => Optional.absent()
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 6
| Source File: JavaUtils.scala From spark1.52 with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.util.Map.Entry
import com.google.common.base.Optional
import java.{util => ju}
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
option match {
case Some(value) => Optional.of(value)
case None => Optional.absent()
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 7
| Source File: JavaUtils.scala From Spark-2.3.1 with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.{util => ju}
import java.util.Map.Entry
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
if (option.isDefined) {
Optional.of(option.get)
} else {
Optional.empty[T]
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
// Delegate to implementation because AbstractMap implementation iterates over whole key set
override def containsKey(key: AnyRef): Boolean = try {
underlying.contains(key.asInstanceOf[A])
} catch {
case _: ClassCastException => false
}
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case _: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
override def hasNext: Boolean = ui.hasNext
override def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
override def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
Example 8
| Source File: JavaUtils.scala From BigDatalog with Apache License 2.0 | 5 votes |
|
package org.apache.spark.api.java
import java.util.Map.Entry
import com.google.common.base.Optional
import java.{util => ju}
import scala.collection.mutable
private[spark] object JavaUtils {
def optionToOptional[T](option: Option[T]): Optional[T] =
option match {
case Some(value) => Optional.of(value)
case None => Optional.absent()
}
// Workaround for SPARK-3926 / SI-8911
def mapAsSerializableJavaMap[A, B](underlying: collection.Map[A, B]): SerializableMapWrapper[A, B]
= new SerializableMapWrapper(underlying)
// Implementation is copied from scala.collection.convert.Wrappers.MapWrapper,
// but implements java.io.Serializable. It can't just be subclassed to make it
// Serializable since the MapWrapper class has no no-arg constructor. This class
// doesn't need a no-arg constructor though.
class SerializableMapWrapper[A, B](underlying: collection.Map[A, B])
extends ju.AbstractMap[A, B] with java.io.Serializable { self =>
override def size: Int = underlying.size
override def get(key: AnyRef): B = try {
underlying.getOrElse(key.asInstanceOf[A], null.asInstanceOf[B])
} catch {
case ex: ClassCastException => null.asInstanceOf[B]
}
override def entrySet: ju.Set[ju.Map.Entry[A, B]] = new ju.AbstractSet[ju.Map.Entry[A, B]] {
override def size: Int = self.size
override def iterator: ju.Iterator[ju.Map.Entry[A, B]] = new ju.Iterator[ju.Map.Entry[A, B]] {
val ui = underlying.iterator
var prev : Option[A] = None
def hasNext: Boolean = ui.hasNext
def next(): Entry[A, B] = {
val (k, v) = ui.next()
prev = Some(k)
new ju.Map.Entry[A, B] {
import scala.util.hashing.byteswap32
override def getKey: A = k
override def getValue: B = v
override def setValue(v1 : B): B = self.put(k, v1)
override def hashCode: Int = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16)
override def equals(other: Any): Boolean = other match {
case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue
case _ => false
}
}
}
def remove() {
prev match {
case Some(k) =>
underlying match {
case mm: mutable.Map[A, _] =>
mm.remove(k)
prev = None
case _ =>
throw new UnsupportedOperationException("remove")
}
case _ =>
throw new IllegalStateException("next must be called at least once before remove")
}
}
}
}
}
}
