Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.ignite.scalar.ScalarConversions.scala Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ignite.scalar
import org.apache.ignite.{IgniteCache, Ignite}
import org.apache.ignite.cluster.ClusterGroup
import org.apache.ignite.compute.ComputeJob
import org.apache.ignite.internal.util.lang._
import org.apache.ignite.lang._
import org.apache.ignite.scalar.lang._
import org.apache.ignite.scalar.pimps._
import org.jetbrains.annotations._
import java.util.TimerTask
import scala.collection._
import scala.util.control.Breaks._
/**
* ==Overview==
* Mixin for `scalar` object providing `implicit` and `explicit` conversions between
* Java and Scala Ignite components.
*
* It is very important to review this class as it defines what `implicit` conversions
* will take place when using Scalar. Note that object `scalar` mixes in this
* trait and therefore brings with it all implicits into the scope.
*/
trait ScalarConversions {
/**
* Helper transformer from Java collection to Scala sequence.
*
* @param c Java collection to transform.
* @param f Transforming function.
*/
def toScalaSeq[A, B](@Nullable c: java.util.Collection[A], f: A => B): Seq[B] = {
assert(f != null)
if (c == null)
return null
val iter = c.iterator
val lst = new mutable.ListBuffer[B]
while (iter.hasNext) lst += f(iter.next)
lst.toSeq
}
/**
* Helper transformer from Java iterator to Scala sequence.
*
* @param i Java iterator to transform.
* @param f Transforming function.
*/
def toScalaSeq[A, B](@Nullable i: java.util.Iterator[A], f: A => B): Seq[B] = {
assert(f != null)
if (i == null)
return null
val lst = new mutable.ListBuffer[B]
while (i.hasNext) lst += f(i.next)
lst.toSeq
}
/**
* Helper converter from Java iterator to Scala sequence.
*
* @param i Java iterator to convert.
*/
def toScalaSeq[A](@Nullable i: java.util.Iterator[A]): Seq[A] =
toScalaSeq(i, (e: A) => e)
/**
* Helper transformer from Java iterable to Scala sequence.
*
* @param i Java iterable to transform.
* @param f Transforming function.
*/
def toScalaSeq[A, B](@Nullable i: java.lang.Iterable[A], f: A => B): Seq[B] = {
assert(f != null)
if (i == null) return null
toScalaSeq(i.iterator, f)
}
/**
* Helper converter from Java iterable to Scala sequence.
*
* @param i Java iterable to convert.
*/
def toScalaSeq[A](@Nullable i: java.lang.Iterable[A]): Seq[A] =
toScalaSeq(i, (e: A) => e)
// /**
// * Helper converter from Java collection to Scala sequence.
// *
// * @param c Java collection to convert.
// */
// def toScalaSeq[A](@Nullable c: java.util.Collection[A]): Seq[A] =
// toScalaSeq(c, (e: A) => e)
/**
* Helper converter from Java entry collection to Scala iterable of pair.
*
* @param c Java collection to convert.
*/
def toScalaItr[K, V](@Nullable c: java.util.Collection[java.util.Map.Entry[K, V]]): Iterable[(K, V)] = {
val lst = new mutable.ListBuffer[(K, V)]
c.toArray().foreach {
case f: java.util.Map.Entry[K, V] => lst += Tuple2(f.getKey(), f.getValue())
}
lst
}
/**
* Helper transformer from Scala sequence to Java collection.
*
* @param s Scala sequence to transform.
* @param f Transforming function.
*/
def toJavaCollection[A, B](@Nullable s: Seq[A], f: A => B): java.util.Collection[B] = {
assert(f != null)
if (s == null) return null
val lst = new java.util.ArrayList[B](s.length)
s.foreach(a => lst.add(f(a)))
lst
}
/**
* Helper converter from Scala sequence to Java collection.
*
* @param s Scala sequence to convert.
*/
def toJavaCollection[A](@Nullable s: Seq[A]): java.util.Collection[A] =
toJavaCollection(s, (e: A) => e)
/**
* Helper transformer from Scala iterator to Java collection.
*
* @param i Scala iterator to transform.
* @param f Transforming function.
*/
def toJavaCollection[A, B](@Nullable i: Iterator[A], f: A => B): java.util.Collection[B] = {
assert(f != null)
if (i == null) return null
val lst = new java.util.ArrayList[B]
i.foreach(a => lst.add(f(a)))
lst
}
/**
* Converts from `Symbol` to `String`.
*
* @param s Symbol to convert.
*/
implicit def fromSymbol(s: Symbol): String =
if (s == null)
null
else
s.toString().substring(1)
/**
* Introduction of `^^` operator for `Any` type that will call `break`.
*
* @param v `Any` value.
*/
implicit def toReturnable(v: Any) = new {
// Ignore the warning below.
def ^^ {
break()
}
}
/**
* Explicit converter for `TimerTask`. Note that since `TimerTask` implements `Runnable`
* we can't use the implicit conversion.
*
* @param f Closure to convert.
* @return Time task instance.
*/
def timerTask(f: => Unit): TimerTask = new TimerTask {
def run() {
f
}
}
/**
* Extension for `Tuple2`.
*
* @param t Tuple to improve.
*/
implicit def toTuple2x[T1, T2](t: (T1, T2)) = new {
def isSome: Boolean =
t._1 != null || t._2 != null
def isNone: Boolean =
!isSome
def isAll: Boolean =
t._1 != null && t._2 != null
def opt1: Option[T1] =
Option(t._1)
def opt2: Option[T2] =
Option(t._2)
}
/**
* Extension for `Tuple3`.
*
* @param t Tuple to improve.
*/
implicit def toTuple3x[T1, T2, T3](t: (T1, T2, T3)) = new {
def isSome: Boolean =
t._1 != null || t._2 != null || t._3 != null
def isNone: Boolean =
!isSome
def isAll: Boolean =
t._1 != null && t._2 != null && t._3 != null
def opt1: Option[T1] =
Option(t._1)
def opt2: Option[T2] =
Option(t._2)
def opt3: Option[T3] =
Option(t._3)
}
// /**
// * Implicit converter from cache KV-pair predicate to cache entry predicate. Note that predicate
// * will use peek()
// *
// * @param p Cache KV-pair predicate to convert.
// */
// implicit def toEntryPred[K, V](p: (K, V) => Boolean): (_ >: Cache.Entry[K, V]) => Boolean =
// (e: Cache.Entry[K, V]) => p(e.getKey, e.getValue)
/**
* Implicit converter from vararg of one-argument Scala functions to Java `GridPredicate`s.
*
* @param s Sequence of one-argument Scala functions to convert.
*/
implicit def toVarArgs[T](s: Seq[T => Boolean]): Seq[IgnitePredicate[_ >: T]] =
s.map((f: T => Boolean) => toPredicate(f))
/**
* Implicit converter from vararg of two-argument Scala functions to Java `GridPredicate2`s.
*
* @param s Sequence of two-argument Scala functions to convert.
*/
implicit def toVarArgs2[T1, T2](s: Seq[(T1, T2) => Boolean]): Seq[IgniteBiPredicate[_ >: T1, _ >: T2]] =
s.map((f: (T1, T2) => Boolean) => toPredicate2(f))
/**
* Implicit converter from vararg of three-argument Scala functions to Java `GridPredicate3`s.
*
* @param s Sequence of three-argument Scala functions to convert.
*/
implicit def toVarArgs3[T1, T2, T3](s: Seq[(T1, T2, T3) => Boolean]):
Seq[GridPredicate3[_ >: T1, _ >: T2, _ >: T3]] =
s.map((f: (T1, T2, T3) => Boolean) => toPredicate3(f))
/**
* Implicit converter from Scala function and Java `GridReducer`.
*
* @param r Scala function to convert.
*/
implicit def toReducer[E, R](r: Seq[E] => R): IgniteReducer[E, R] =
new ScalarReducer(r)
/**
* Implicit converter from Java `GridReducer` to Scala function.
*
* @param r Java `GridReducer` to convert.
*/
implicit def fromReducer[E, R](r: IgniteReducer[E, R]): Seq[E] => R =
new ScalarReducerFunction[E, R](r)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param r Java-side reducer to pimp.
*/
implicit def reducerDotScala[E, R](r: IgniteReducer[E, R]) = new {
def scala: Seq[E] => R =
fromReducer(r)
}
/**
* Implicit converter from Scala function and Java `GridReducer2`.
*
* @param r Scala function to convert.
*/
implicit def toReducer2[E1, E2, R](r: (Seq[E1], Seq[E2]) => R): IgniteReducer2[E1, E2, R] =
new ScalarReducer2(r)
/**
* Implicit converter from Java `GridReducer2` to Scala function.
*
* @param r Java `GridReducer2` to convert.
*/
implicit def fromReducer2[E1, E2, R](r: IgniteReducer2[E1, E2, R]): (Seq[E1], Seq[E2]) => R =
new ScalarReducer2Function[E1, E2, R](r)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param r Java-side reducer to pimp.
*/
implicit def reducer2DotScala[E1, E2, R](r: IgniteReducer2[E1, E2, R]) = new {
def scala: (Seq[E1], Seq[E2]) => R =
fromReducer2(r)
}
/**
* Implicit converter from Scala function and Java `GridReducer3`.
*
* @param r Scala function to convert.
*/
implicit def toReducer3[E1, E2, E3, R](r: (Seq[E1], Seq[E2], Seq[E3]) => R): IgniteReducer3[E1, E2, E3, R] =
new ScalarReducer3(r)
/**
* Implicit converter from Java `GridReducer3` to Scala function.
*
* @param r Java `GridReducer3` to convert.
*/
implicit def fromReducer3[E1, E2, E3, R](r: IgniteReducer3[E1, E2, E3, R]): (Seq[E1], Seq[E2], Seq[E3]) => R =
new ScalarReducer3Function[E1, E2, E3, R](r)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param r Java-side reducer to pimp.
*/
implicit def reducer3DotScala[E1, E2, E3, R](r: IgniteReducer3[E1, E2, E3, R]) = new {
def scala: (Seq[E1], Seq[E2], Seq[E3]) => R =
fromReducer3(r)
}
/**
* Implicit converter from `Grid` to `ScalarGridPimp` "pimp".
*
* @param impl Grid to convert.
*/
implicit def toScalarGrid(impl: Ignite): ScalarGridPimp =
ScalarGridPimp(impl)
/**
* Implicit converter from `GridProjection` to `ScalarProjectionPimp` "pimp".
*
* @param impl Grid projection to convert.
*/
implicit def toScalarProjection(impl: ClusterGroup): ScalarProjectionPimp[ClusterGroup] =
ScalarProjectionPimp(impl)
/**
* Implicit converter from `Cache` to `ScalarCachePimp` "pimp".
*
* @param impl Grid cache to convert.
*/
implicit def toScalarCache[K, V](impl: IgniteCache[K, V]): ScalarCachePimp[K, V] =
ScalarCachePimp[K, V](impl)
/**
* Implicit converter from Scala function to `ComputeJob`.
*
* @param f Scala function to convert.
*/
implicit def toJob(f: () => Any): ComputeJob =
new ScalarJob(f)
/**
* Implicit converter from Scala tuple to `GridTuple2`.
*
* @param t Scala tuple to convert.
*/
implicit def toTuple2[A, B](t: (A, B)): IgniteBiTuple[A, B] =
new IgniteBiTuple[A, B](t._1, t._2)
/**
* Implicit converter from `GridTuple2` to Scala tuple.
*
* @param t `GridTuple2` to convert.
*/
implicit def fromTuple2[A, B](t: IgniteBiTuple[A, B]): (A, B) =
(t.get1, t.get2)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param t Java-side tuple to pimp.
*/
implicit def tuple2DotScala[A, B](t: IgniteBiTuple[A, B]) = new {
def scala: (A, B) =
fromTuple2(t)
}
/**
* Implicit converter from Scala tuple to `GridTuple3`.
*
* @param t Scala tuple to convert.
*/
implicit def toTuple3[A, B, C](t: (A, B, C)): GridTuple3[A, B, C] =
new GridTuple3[A, B, C](t._1, t._2, t._3)
/**
* Implicit converter from `GridTuple3` to Scala tuple.
*
* @param t `GridTuple3` to convert.
*/
implicit def fromTuple3[A, B, C](t: GridTuple3[A, B, C]): (A, B, C) =
(t.get1, t.get2, t.get3)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param t Java-side tuple to pimp.
*/
implicit def tuple3DotScala[A, B, C](t: GridTuple3[A, B, C]) = new {
def scala: (A, B, C) =
fromTuple3(t)
}
/**
* Implicit converter from Scala tuple to `GridTuple4`.
*
* @param t Scala tuple to convert.
*/
implicit def toTuple4[A, B, C, D](t: (A, B, C, D)): GridTuple4[A, B, C, D] =
new GridTuple4[A, B, C, D](t._1, t._2, t._3, t._4)
/**
* Implicit converter from `GridTuple4` to Scala tuple.
*
* @param t `GridTuple4` to convert.
*/
implicit def fromTuple4[A, B, C, D](t: GridTuple4[A, B, C, D]): (A, B, C, D) =
(t.get1, t.get2, t.get3, t.get4)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param t Java-side tuple to pimp.
*/
implicit def tuple4DotScala[A, B, C, D](t: GridTuple4[A, B, C, D]) = new {
def scala: (A, B, C, D) =
fromTuple4(t)
}
/**
* Implicit converter from Scala tuple to `GridTuple5`.
*
* @param t Scala tuple to convert.
*/
implicit def toTuple5[A, B, C, D, E](t: (A, B, C, D, E)): GridTuple5[A, B, C, D, E] =
new GridTuple5[A, B, C, D, E](t._1, t._2, t._3, t._4, t._5)
/**
* Implicit converter from `GridTuple5` to Scala tuple.
*
* @param t `GridTuple5` to convert.
*/
implicit def fromTuple5[A, B, C, D, E](t: GridTuple5[A, B, C, D, E]): (A, B, C, D, E) =
(t.get1, t.get2, t.get3, t.get4, t.get5)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param t Java-side tuple to pimp.
*/
implicit def tuple5DotScala[A, B, C, D, E](t: GridTuple5[A, B, C, D, E]) = new {
def scala: (A, B, C, D, E) =
fromTuple5(t)
}
/**
* Implicit converter from Scala function to `GridInClosure`.
*
* @param f Scala function to convert.
*/
implicit def toInClosure[T](f: T => Unit): IgniteInClosure[T] =
f match {
case (p: ScalarInClosureFunction[T]) => p.inner
case _ => new ScalarInClosure[T](f)
}
/**
* Implicit converter from Scala function to `GridInClosureX`.
*
* @param f Scala function to convert.
*/
def toInClosureX[T](f: T => Unit): IgniteInClosureX[T] =
f match {
case (p: ScalarInClosureXFunction[T]) => p.inner
case _ => new ScalarInClosureX[T](f)
}
/**
* Implicit converter from `GridInClosure` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosure[T](f: IgniteInClosure[T]): T => Unit =
new ScalarInClosureFunction[T](f)
/**
* Implicit converter from `GridInClosureX` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosureX[T](f: IgniteInClosureX[T]): T => Unit =
new ScalarInClosureXFunction[T](f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosureDotScala[T](f: IgniteInClosure[T]) = new {
def scala: T => Unit =
fromInClosure(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosureXDotScala[T](f: IgniteInClosureX[T]) = new {
def scala: T => Unit =
fromInClosureX(f)
}
/**
* Implicit converter from Scala function to `GridInClosure2`.
*
* @param f Scala function to convert.
*/
implicit def toInClosure2[T1, T2](f: (T1, T2) => Unit): IgniteBiInClosure[T1, T2] =
f match {
case (p: ScalarInClosure2Function[T1, T2]) => p.inner
case _ => new ScalarInClosure2[T1, T2](f)
}
/**
* Implicit converter from Scala function to `GridInClosure2X`.
*
* @param f Scala function to convert.
*/
implicit def toInClosure2X[T1, T2](f: (T1, T2) => Unit): IgniteInClosure2X[T1, T2] =
f match {
case (p: ScalarInClosure2XFunction[T1, T2]) => p.inner
case _ => new ScalarInClosure2X[T1, T2](f)
}
/**
* Implicit converter from `GridInClosure2` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosure2[T1, T2](f: IgniteBiInClosure[T1, T2]): (T1, T2) => Unit =
new ScalarInClosure2Function(f)
/**
* Implicit converter from `GridInClosure2X` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosure2X[T1, T2](f: IgniteInClosure2X[T1, T2]): (T1, T2) => Unit =
new ScalarInClosure2XFunction(f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosure2DotScala[T1, T2](f: IgniteBiInClosure[T1, T2]) = new {
def scala: (T1, T2) => Unit =
fromInClosure2(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosure2XDotScala[T1, T2](f: IgniteInClosure2X[T1, T2]) = new {
def scala: (T1, T2) => Unit =
fromInClosure2X(f)
}
/**
* Implicit converter from Scala function to `GridInClosure3`.
*
* @param f Scala function to convert.
*/
implicit def toInClosure3[T1, T2, T3](f: (T1, T2, T3) => Unit): GridInClosure3[T1, T2, T3] =
f match {
case (p: ScalarInClosure3Function[T1, T2, T3]) => p.inner
case _ => new ScalarInClosure3[T1, T2, T3](f)
}
/**
* Implicit converter from Scala function to `GridInClosure3X`.
*
* @param f Scala function to convert.
*/
def toInClosure3X[T1, T2, T3](f: (T1, T2, T3) => Unit): GridInClosure3X[T1, T2, T3] =
f match {
case (p: ScalarInClosure3XFunction[T1, T2, T3]) => p.inner
case _ => new ScalarInClosure3X[T1, T2, T3](f)
}
/**
* Implicit converter from `GridInClosure3` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosure3[T1, T2, T3](f: GridInClosure3[T1, T2, T3]): (T1, T2, T3) => Unit =
new ScalarInClosure3Function(f)
/**
* Implicit converter from `GridInClosure3X` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromInClosure3X[T1, T2, T3](f: GridInClosure3X[T1, T2, T3]): (T1, T2, T3) => Unit =
new ScalarInClosure3XFunction(f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosure3DotScala[T1, T2, T3](f: GridInClosure3[T1, T2, T3]) = new {
def scala: (T1, T2, T3) => Unit =
fromInClosure3(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def inClosure3XDotScala[T1, T2, T3](f: GridInClosure3X[T1, T2, T3]) = new {
def scala: (T1, T2, T3) => Unit =
fromInClosure3X(f)
}
/**
* Implicit converter from Scala function to `GridOutClosure`.
*
* @param f Scala function to convert.
*/
implicit def toCallable[R](f: () => R): IgniteCallable[R] =
f match {
case p: ScalarOutClosureFunction[R] => p.inner
case _ => new ScalarOutClosure[R](f)
}
/**
* Implicit converter from Scala function to `GridOutClosureX`.
*
* @param f Scala function to convert.
*/
def toOutClosureX[R](f: () => R): IgniteOutClosureX[R] =
f match {
case (p: ScalarOutClosureXFunction[R]) => p.inner
case _ => new ScalarOutClosureX[R](f)
}
/**
* Implicit converter from `GridOutClosure` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromOutClosure[R](f: IgniteCallable[R]): () => R =
new ScalarOutClosureFunction[R](f)
/**
* Implicit converter from `GridOutClosureX` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromOutClosureX[R](f: IgniteOutClosureX[R]): () => R =
new ScalarOutClosureXFunction[R](f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def outClosureDotScala[R](f: IgniteCallable[R]) = new {
def scala: () => R =
fromOutClosure(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def outClosureXDotScala[R](f: IgniteOutClosureX[R]) = new {
def scala: () => R =
fromOutClosureX(f)
}
/**
* Implicit converter from Scala function to `GridAbsClosure`.
*
* @param f Scala function to convert.
*/
implicit def toRunnable(f: () => Unit): IgniteRunnable =
f match {
case (f: ScalarAbsClosureFunction) => f.inner
case _ => new ScalarAbsClosure(f)
}
/**
* Implicit converter from Scala function to `GridAbsClosureX`.
*
* @param f Scala function to convert.
*/
def toAbsClosureX(f: () => Unit): GridAbsClosureX =
f match {
case (f: ScalarAbsClosureXFunction) => f.inner
case _ => new ScalarAbsClosureX(f)
}
/**
* Implicit converter from `GridAbsClosure` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromAbsClosure(f: GridAbsClosure): () => Unit =
new ScalarAbsClosureFunction(f)
/**
* Implicit converter from `GridAbsClosureX` to Scala wrapping function.
*
* @param f Grid closure to convert.
*/
implicit def fromAbsClosureX(f: GridAbsClosureX): () => Unit =
new ScalarAbsClosureXFunction(f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side absolute closure to pimp.
*/
implicit def absClosureDotScala(f: GridAbsClosure) = new {
def scala: () => Unit =
fromAbsClosure(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side absolute closure to pimp.
*/
implicit def absClosureXDotScala(f: GridAbsClosureX) = new {
def scala: () => Unit =
fromAbsClosureX(f)
}
/**
* Implicit converter from Scala predicate to `GridAbsPredicate`.
*
* @param f Scala predicate to convert.
*/
implicit def toAbsPredicate(f: () => Boolean): GridAbsPredicate =
f match {
case (p: ScalarAbsPredicateFunction) => p.inner
case _ => new ScalarAbsPredicate(f)
}
/**
* Implicit converter from Scala predicate to `GridAbsPredicateX`.
*
* @param f Scala predicate to convert.
*/
implicit def toAbsPredicateX(f: () => Boolean): GridAbsPredicateX =
f match {
case (p: ScalarAbsPredicateXFunction) => p.inner
case _ => new ScalarAbsPredicateX(f)
}
/**
* Implicit converter from `GridAbsPredicate` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromAbsPredicate(p: GridAbsPredicate): () => Boolean =
new ScalarAbsPredicateFunction(p)
/**
* Implicit converter from `GridAbsPredicateX` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromAbsPredicateX(p: GridAbsPredicateX): () => Boolean =
new ScalarAbsPredicateXFunction(p)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def absPredicateDotScala(p: GridAbsPredicate) = new {
def scala: () => Boolean =
fromAbsPredicate(p)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def absPredicateXDotScala(p: GridAbsPredicateX) = new {
def scala: () => Boolean =
fromAbsPredicateX(p)
}
/**
* Implicit converter from `java.lang.Runnable` to `GridAbsClosure`.
*
* @param r Java runnable to convert.
*/
implicit def toAbsClosure2(r: java.lang.Runnable): GridAbsClosure =
GridFunc.as(r)
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
implicit def toPredicate[T](f: T => Boolean) =
f match {
case null => null
case (p: ScalarPredicateFunction[T]) => p.inner
case _ => new ScalarPredicate[T](f)
}
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
def toPredicateX[T](f: T => Boolean) =
f match {
case (p: ScalarPredicateXFunction[T]) => p.inner
case _ => new ScalarPredicateX[T](f)
}
/**
* Implicit converter from `GridPredicate` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicate[T](p: IgnitePredicate[T]): T => Boolean =
new ScalarPredicateFunction[T](p)
/**
* Implicit converter from `GridPredicate` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicateX[T](p: IgnitePredicateX[T]): T => Boolean =
new ScalarPredicateXFunction[T](p)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicateDotScala[T](p: IgnitePredicate[T]) = new {
def scala: T => Boolean =
fromPredicate(p)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicateXDotScala[T](p: IgnitePredicateX[T]) = new {
def scala: T => Boolean =
fromPredicateX(p)
}
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
implicit def toPredicate2[T1, T2](f: (T1, T2) => Boolean) =
f match {
case (p: ScalarPredicate2Function[T1, T2]) => p.inner
case _ => new ScalarPredicate2[T1, T2](f)
}
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
def toPredicate2X[T1, T2](f: (T1, T2) => Boolean) =
f match {
case (p: ScalarPredicate2XFunction[T1, T2]) => p.inner
case _ => new ScalarPredicate2X[T1, T2](f)
}
/**
* Implicit converter from `GridPredicate2X` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicate2[T1, T2](p: IgniteBiPredicate[T1, T2]): (T1, T2) => Boolean =
new ScalarPredicate2Function[T1, T2](p)
/**
* Implicit converter from `GridPredicate2X` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicate2X[T1, T2](p: IgnitePredicate2X[T1, T2]): (T1, T2) => Boolean =
new ScalarPredicate2XFunction[T1, T2](p)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicate2DotScala[T1, T2](p: IgniteBiPredicate[T1, T2]) = new {
def scala: (T1, T2) => Boolean =
fromPredicate2(p)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicate2XDotScala[T1, T2](p: IgnitePredicate2X[T1, T2]) = new {
def scala: (T1, T2) => Boolean =
fromPredicate2X(p)
}
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
implicit def toPredicate3[T1, T2, T3](f: (T1, T2, T3) => Boolean) =
f match {
case (p: ScalarPredicate3Function[T1, T2, T3]) => p.inner
case _ => new ScalarPredicate3[T1, T2, T3](f)
}
/**
* Implicit converter from Scala predicate to Scala wrapping predicate.
*
* @param f Scala predicate to convert.
*/
def toPredicate32[T1, T2, T3](f: (T1, T2, T3) => Boolean) =
f match {
case (p: ScalarPredicate3XFunction[T1, T2, T3]) => p.inner
case _ => new ScalarPredicate3X[T1, T2, T3](f)
}
/**
* Implicit converter from `GridPredicate3X` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicate3[T1, T2, T3](p: GridPredicate3[T1, T2, T3]): (T1, T2, T3) => Boolean =
new ScalarPredicate3Function[T1, T2, T3](p)
/**
* Implicit converter from `GridPredicate3X` to Scala wrapping predicate.
*
* @param p Grid predicate to convert.
*/
implicit def fromPredicate3X[T1, T2, T3](p: GridPredicate3X[T1, T2, T3]): (T1, T2, T3) => Boolean =
new ScalarPredicate3XFunction[T1, T2, T3](p)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicate3DotScala[T1, T2, T3](p: GridPredicate3[T1, T2, T3]) = new {
def scala: (T1, T2, T3) => Boolean =
fromPredicate3(p)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param p Java-side predicate to pimp.
*/
implicit def predicate3XDotScala[T1, T2, T3](p: GridPredicate3X[T1, T2, T3]) = new {
def scala: (T1, T2, T3) => Boolean =
fromPredicate3X(p)
}
/**
* Implicit converter from Scala closure to `GridClosure`.
*
* @param f Scala closure to convert.
*/
implicit def toClosure[A, R](f: A => R): IgniteClosure[A, R] =
f match {
case (c: ScalarClosureFunction[A, R]) => c.inner
case _ => new ScalarClosure[A, R](f)
}
/**
* Implicit converter from Scala closure to `GridClosureX`.
*
* @param f Scala closure to convert.
*/
def toClosureX[A, R](f: A => R): IgniteClosureX[A, R] =
f match {
case (c: ScalarClosureXFunction[A, R]) => c.inner
case _ => new ScalarClosureX[A, R](f)
}
/**
* Implicit converter from `GridClosure` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosure[A, R](f: IgniteClosure[A, R]): A => R =
new ScalarClosureFunction[A, R](f)
/**
* Implicit converter from `GridClosureX` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosureX[A, R](f: IgniteClosureX[A, R]): A => R =
new ScalarClosureXFunction[A, R](f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closureDotScala[A, R](f: IgniteClosure[A, R]) = new {
def scala: A => R =
fromClosure(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closureXDotScala[A, R](f: IgniteClosureX[A, R]) = new {
def scala: A => R =
fromClosureX(f)
}
/**
* Implicit converter from Scala closure to `GridClosure2`.
*
* @param f Scala closure to convert.
*/
implicit def toClosure2[A1, A2, R](f: (A1, A2) => R): IgniteBiClosure[A1, A2, R] =
f match {
case (p: ScalarClosure2Function[A1, A2, R]) => p.inner
case _ => new ScalarClosure2[A1, A2, R](f)
}
/**
* Implicit converter from Scala closure to `GridClosure2X`.
*
* @param f Scala closure to convert.
*/
def toClosure2X[A1, A2, R](f: (A1, A2) => R): IgniteClosure2X[A1, A2, R] =
f match {
case (p: ScalarClosure2XFunction[A1, A2, R]) => p.inner
case _ => new ScalarClosure2X[A1, A2, R](f)
}
/**
* Implicit converter from `GridClosure2X` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosure2[A1, A2, R](f: IgniteBiClosure[A1, A2, R]): (A1, A2) => R =
new ScalarClosure2Function[A1, A2, R](f)
/**
* Implicit converter from `GridClosure2X` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosure2X[A1, A2, R](f: IgniteClosure2X[A1, A2, R]): (A1, A2) => R =
new ScalarClosure2XFunction[A1, A2, R](f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closure2DotScala[A1, A2, R](f: IgniteBiClosure[A1, A2, R]) = new {
def scala: (A1, A2) => R =
fromClosure2(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closure2XDotScala[A1, A2, R](f: IgniteClosure2X[A1, A2, R]) = new {
def scala: (A1, A2) => R =
fromClosure2X(f)
}
/**
* Implicit converter from Scala closure to `GridClosure3X`.
*
* @param f Scala closure to convert.
*/
implicit def toClosure3[A1, A2, A3, R](f: (A1, A2, A3) => R): GridClosure3[A1, A2, A3, R] =
f match {
case (p: ScalarClosure3Function[A1, A2, A3, R]) => p.inner
case _ => new ScalarClosure3[A1, A2, A3, R](f)
}
/**
* Implicit converter from Scala closure to `GridClosure3X`.
*
* @param f Scala closure to convert.
*/
def toClosure3X[A1, A2, A3, R](f: (A1, A2, A3) => R): GridClosure3X[A1, A2, A3, R] =
f match {
case (p: ScalarClosure3XFunction[A1, A2, A3, R]) => p.inner
case _ => new ScalarClosure3X[A1, A2, A3, R](f)
}
/**
* Implicit converter from `GridClosure3` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosure3[A1, A2, A3, R](f: GridClosure3[A1, A2, A3, R]): (A1, A2, A3) => R =
new ScalarClosure3Function[A1, A2, A3, R](f)
/**
* Implicit converter from `GridClosure3X` to Scala wrapping closure.
*
* @param f Grid closure to convert.
*/
implicit def fromClosure3X[A1, A2, A3, R](f: GridClosure3X[A1, A2, A3, R]): (A1, A2, A3) => R =
new ScalarClosure3XFunction[A1, A2, A3, R](f)
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closure3DotScala[A1, A2, A3, R](f: GridClosure3[A1, A2, A3, R]) = new {
def scala: (A1, A2, A3) => R =
fromClosure3(f)
}
/**
* Pimp for adding explicit conversion method `scala`.
*
* @param f Java-side closure to pimp.
*/
implicit def closure3XDotScala[A1, A2, A3, R](f: GridClosure3X[A1, A2, A3, R]) = new {
def scala: (A1, A2, A3) => R =
fromClosure3X(f)
}
}
