• Home
• org.scalamolecule
• molecule-boilerplate_2.13
• 0.13.0
• source code
• ExprBArMan_.scala

×

Project download

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.

molecule.boilerplate.api.expression.ExprBArMan_.scala Maven / Gradle / Ivy

// GENERATED CODE ********************************
package molecule.boilerplate.api.expression

import molecule.boilerplate.ast.Model._
import scala.language.higherKinds


trait ExprBArMan_1[A, t, Ns1[_, _], Ns2[_, _, _]]
  extends ExprBArTacOps_1[A, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_2[A, B, t, Ns1[_, _, _], Ns2[_, _, _, _]]
  extends ExprBArTacOps_2[A, B, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_3[A, B, C, t, Ns1[_, _, _, _], Ns2[_, _, _, _, _]]
  extends ExprBArTacOps_3[A, B, C, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_4[A, B, C, D, t, Ns1[_, _, _, _, _], Ns2[_, _, _, _, _, _]]
  extends ExprBArTacOps_4[A, B, C, D, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_5[A, B, C, D, E, t, Ns1[_, _, _, _, _, _], Ns2[_, _, _, _, _, _, _]]
  extends ExprBArTacOps_5[A, B, C, D, E, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_6[A, B, C, D, E, F, t, Ns1[_, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_6[A, B, C, D, E, F, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_7[A, B, C, D, E, F, G, t, Ns1[_, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_7[A, B, C, D, E, F, G, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_8[A, B, C, D, E, F, G, H, t, Ns1[_, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_8[A, B, C, D, E, F, G, H, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_9[A, B, C, D, E, F, G, H, I, t, Ns1[_, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_9[A, B, C, D, E, F, G, H, I, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_10[A, B, C, D, E, F, G, H, I, J, t, Ns1[_, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_10[A, B, C, D, E, F, G, H, I, J, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_11[A, B, C, D, E, F, G, H, I, J, K, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_11[A, B, C, D, E, F, G, H, I, J, K, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_12[A, B, C, D, E, F, G, H, I, J, K, L, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_12[A, B, C, D, E, F, G, H, I, J, K, L, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_13[A, B, C, D, E, F, G, H, I, J, K, L, M, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_13[A, B, C, D, E, F, G, H, I, J, K, L, M, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_14[A, B, C, D, E, F, G, H, I, J, K, L, M, N, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_14[A, B, C, D, E, F, G, H, I, J, K, L, M, N, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, t] = _exprBAr(Neq    , byteArray                               )
}


trait ExprBArMan_22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, t, Ns1[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _], Ns2[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
  extends ExprBArTacOps_22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, t, Ns1, Ns2] {
  def apply(                   ): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, t] = _exprBAr(NoValue, Array.empty[Byte].asInstanceOf[Array[t]])
  def apply(byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, t] = _exprBAr(Eq     , byteArray                               )
  def not  (byteArray: Array[t]): Ns1[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, t] = _exprBAr(Neq    , byteArray                               )
}