final class PosLong extends AnyVal
An AnyVal
for positive Long
s.
Note: a PosLong
may not equal 0. If you want positive number or 0, use PosZLong.
Because PosLong
is an AnyVal
it
will usually be as efficient as an Long
, being
boxed only when an Long
would have been boxed.
The PosLong.apply
factory method is implemented
in terms of a macro that checks literals for validity at
compile time. Calling PosLong.apply
with a
literal Long
value will either produce a valid
PosLong
instance at run time or an error at
compile time. Here's an example:
scala> import anyvals._ import anyvals._ scala> PosLong(42L) res0: org.scalactic.anyvals.PosLong = PosLong(42L) scala> PosLong(0L) <console>:14: error: PosLong.apply can only be invoked on a positive (i > 0L) integer literal, like PosLong(42L). PosLong(0L) ^
PosLong.apply
cannot be used if the value being
passed is a variable (i.e., not a literal), because
the macro cannot determine the validity of variables at
compile time (just literals). If you try to pass a variable
to PosLong.apply
, you'll get a compiler error
that suggests you use a different factor method,
PosLong.from
, instead:
scala> val x = 42LL x: Long = 42L scala> PosLong(x) <console>:15: error: PosLong.apply can only be invoked on an long literal, like PosLong(42L). Please use PosLong.from instead. PosLong(x) ^
The PosLong.from
factory method will inspect the
value at runtime and return an
Option[PosLong]
. If the value is valid,
PosLong.from
will return a
Some[PosLong]
, else it will return a
None
. Here's an example:
scala> PosLong.from(x) res3: Option[org.scalactic.anyvals.PosLong] = Some(PosLong(42L)) scala> val y = 0LL y: Long = 0L scala> PosLong.from(y) res4: Option[org.scalactic.anyvals.PosLong] = None
The PosLong.apply
factory method is marked
implicit, so that you can pass literal Long
s
into methods that require PosLong
, and get the
same compile-time checking you get when calling
PosLong.apply
explicitly. Here's an example:
scala> def invert(pos: PosLong): Long = Long.MaxValue - pos invert: (pos: org.scalactic.anyvals.PosLong)Long scala> invert(1L) res5: Long = 9223372036854775806 scala> invert(Long.MaxValue) res6: Long = 0 scala> invert(0LL) <console>:15: error: PosLong.apply can only be invoked on a positive (i > 0L) integer literal, like PosLong(42LL). invert(0LL) ^
This example also demonstrates that the PosLong
companion object also defines implicit widening conversions
when either no loss of precision will occur or a similar
conversion is provided in Scala. (For example, the implicit
conversion from Long
to Double in
Scala can lose precision.) This makes it convenient to use a
PosLong
where a Long
or wider type
is needed. An example is the subtraction in the body of the
invert
method defined above, Long.MaxValue
- pos
. Although Long.MaxValue
is a
Long
, which has no -
method that
takes a PosLong
(the type of pos
),
you can still subtract pos
, because the
PosLong
will be implicitly widened to
Long
.
- Source
- PosLong.scala
- Alphabetic
- By Inheritance
- PosLong
- AnyVal
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- def %(x: Double): Double
Returns the remainder of the division of this value by
x
. - def %(x: Float): Float
Returns the remainder of the division of this value by
x
. - def %(x: Long): Long
Returns the remainder of the division of this value by
x
. - def %(x: Int): Long
Returns the remainder of the division of this value by
x
. - def %(x: Char): Long
Returns the remainder of the division of this value by
x
. - def %(x: Short): Long
Returns the remainder of the division of this value by
x
. - def %(x: Byte): Long
Returns the remainder of the division of this value by
x
. - def &(x: Long): Long
Returns the bitwise AND of this value and
x
.Returns the bitwise AND of this value and
x
.(0xf0 & 0xaa) == 0xa0 // in binary: 11110000 // & 10101010 // -------- // 10100000
Example: - def &(x: Int): Long
Returns the bitwise AND of this value and
x
.Returns the bitwise AND of this value and
x
.(0xf0 & 0xaa) == 0xa0 // in binary: 11110000 // & 10101010 // -------- // 10100000
Example: - def &(x: Char): Long
Returns the bitwise AND of this value and
x
.Returns the bitwise AND of this value and
x
.(0xf0 & 0xaa) == 0xa0 // in binary: 11110000 // & 10101010 // -------- // 10100000
Example: - def &(x: Short): Long
Returns the bitwise AND of this value and
x
.Returns the bitwise AND of this value and
x
.(0xf0 & 0xaa) == 0xa0 // in binary: 11110000 // & 10101010 // -------- // 10100000
Example: - def &(x: Byte): Long
Returns the bitwise AND of this value and
x
.Returns the bitwise AND of this value and
x
.(0xf0 & 0xaa) == 0xa0 // in binary: 11110000 // & 10101010 // -------- // 10100000
Example: - def *(x: Double): Double
Returns the product of this value and
x
. - def *(x: Float): Float
Returns the product of this value and
x
. - def *(x: Long): Long
Returns the product of this value and
x
. - def *(x: Int): Long
Returns the product of this value and
x
. - def *(x: Char): Long
Returns the product of this value and
x
. - def *(x: Short): Long
Returns the product of this value and
x
. - def *(x: Byte): Long
Returns the product of this value and
x
. - def +(x: Double): Double
Returns the sum of this value and
x
. - def +(x: Float): Float
Returns the sum of this value and
x
. - def +(x: Long): Long
Returns the sum of this value and
x
. - def +(x: Int): Long
Returns the sum of this value and
x
. - def +(x: Char): Long
Returns the sum of this value and
x
. - def +(x: Short): Long
Returns the sum of this value and
x
. - def +(x: Byte): Long
Returns the sum of this value and
x
. - def +(x: String): String
Converts this
PosLong
's value to a string then concatenates the given string. - def -(x: Double): Double
Returns the difference of this value and
x
. - def -(x: Float): Float
Returns the difference of this value and
x
. - def -(x: Long): Long
Returns the difference of this value and
x
. - def -(x: Int): Long
Returns the difference of this value and
x
. - def -(x: Char): Long
Returns the difference of this value and
x
. - def -(x: Short): Long
Returns the difference of this value and
x
. - def -(x: Byte): Long
Returns the difference of this value and
x
. - def /(x: Double): Double
Returns the quotient of this value and
x
. - def /(x: Float): Float
Returns the quotient of this value and
x
. - def /(x: Long): Long
Returns the quotient of this value and
x
. - def /(x: Int): Long
Returns the quotient of this value and
x
. - def /(x: Char): Long
Returns the quotient of this value and
x
. - def /(x: Short): Long
Returns the quotient of this value and
x
. - def /(x: Byte): Long
Returns the quotient of this value and
x
. - def <(x: Double): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Float): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Long): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Int): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Char): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Short): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <(x: Byte): Boolean
Returns
true
if this value is less than x,false
otherwise. - def <<(x: Long): Long
Returns this value bit-shifted left by the specified number of bits, filling in the new right bits with zeroes.
Returns this value bit-shifted left by the specified number of bits, filling in the new right bits with zeroes.
6 << 3 == 48 // in binary: 0110 << 3 == 0110000
Example: - def <<(x: Int): Long
Returns this value bit-shifted left by the specified number of bits, filling in the new right bits with zeroes.
Returns this value bit-shifted left by the specified number of bits, filling in the new right bits with zeroes.
6 << 3 == 48 // in binary: 0110 << 3 == 0110000
Example: - def <=(x: Double): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Float): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Long): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Int): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Char): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Short): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - def <=(x: Byte): Boolean
Returns
true
if this value is less than or equal to x,false
otherwise. - final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- def >(x: Double): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Float): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Long): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Int): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Char): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Short): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >(x: Byte): Boolean
Returns
true
if this value is greater than x,false
otherwise. - def >=(x: Double): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Float): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Long): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Int): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Char): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Short): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >=(x: Byte): Boolean
Returns
true
if this value is greater than or equal to x,false
otherwise. - def >>(x: Long): Long
Returns this value bit-shifted left by the specified number of bits, filling in the right bits with the same value as the left-most bit of this.
Returns this value bit-shifted left by the specified number of bits, filling in the right bits with the same value as the left-most bit of this. The effect of this is to retain the sign of the value.
-21 >> 3 == -3 // in binary: 11111111 11111111 11111111 11101011 >> 3 == // 11111111 11111111 11111111 11111101
Example: - def >>(x: Int): Long
Returns this value bit-shifted left by the specified number of bits, filling in the right bits with the same value as the left-most bit of this.
Returns this value bit-shifted left by the specified number of bits, filling in the right bits with the same value as the left-most bit of this. The effect of this is to retain the sign of the value.
-21 >> 3 == -3 // in binary: 11111111 11111111 11111111 11101011 >> 3 == // 11111111 11111111 11111111 11111101
Example: - def >>>(x: Long): Long
Returns this value bit-shifted right by the specified number of bits, filling the new left bits with zeroes.
Returns this value bit-shifted right by the specified number of bits, filling the new left bits with zeroes.
21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010
, -21 >>> 3 == 536870909 // in binary: 11111111 11111111 11111111 11101011 >>> 3 == // 00011111 11111111 11111111 11111101
Examples: - def >>>(x: Int): Long
Returns this value bit-shifted right by the specified number of bits, filling the new left bits with zeroes.
Returns this value bit-shifted right by the specified number of bits, filling the new left bits with zeroes.
21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010
, -21 >>> 3 == 536870909 // in binary: 11111111 11111111 11111111 11101011 >>> 3 == // 00011111 11111111 11111111 11111101
Examples: - def ^(x: Long): Long
Returns the bitwise XOR of this value and
x
.Returns the bitwise XOR of this value and
x
.(0xf0 ^ 0xaa) == 0x5a // in binary: 11110000 // ^ 10101010 // -------- // 01011010
Example: - def ^(x: Int): Long
Returns the bitwise XOR of this value and
x
.Returns the bitwise XOR of this value and
x
.(0xf0 ^ 0xaa) == 0x5a // in binary: 11110000 // ^ 10101010 // -------- // 01011010
Example: - def ^(x: Char): Long
Returns the bitwise XOR of this value and
x
.Returns the bitwise XOR of this value and
x
.(0xf0 ^ 0xaa) == 0x5a // in binary: 11110000 // ^ 10101010 // -------- // 01011010
Example: - def ^(x: Short): Long
Returns the bitwise XOR of this value and
x
.Returns the bitwise XOR of this value and
x
.(0xf0 ^ 0xaa) == 0x5a // in binary: 11110000 // ^ 10101010 // -------- // 01011010
Example: - def ^(x: Byte): Long
Returns the bitwise XOR of this value and
x
.Returns the bitwise XOR of this value and
x
.(0xf0 ^ 0xaa) == 0x5a // in binary: 11110000 // ^ 10101010 // -------- // 01011010
Example: - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def ensuringValid(f: (Long) => Long): PosLong
Applies the passed
Long => Long
function to the underlyingLong
value, and if the result is positive, returns the result wrapped in aPosLong
, else throwsAssertionError
.Applies the passed
Long => Long
function to the underlyingLong
value, and if the result is positive, returns the result wrapped in aPosLong
, else throwsAssertionError
.This method will inspect the result of applying the given function to this
PosLong
's underlyingLong
value and if the result is positive, it will return aPosLong
representing that value. Otherwise, theLong
value returned by the given function is not positive, this method will throwAssertionError
.This method differs from a vanilla
assert
orensuring
call in that you get something you didn't already have if the assertion succeeds: a type that promises anLong
is positive. With this method, you are asserting that you are convinced the result of the computation represented by applying the given function to thisPosLong
's value will not overflow. Instead of overflowing silently likeLong
, this method will signal an overflow with a loudAssertionError
.- f
the
Long => Long
function to apply to thisPosLong
's underlyingLong
value.- returns
the result of applying this
PosLong
's underlyingLong
value to to the passed function, wrapped in aPosLong
if it is positive (else throwsAssertionError
).
- Exceptions thrown
AssertionError
if the result of applying thisPosLong
's underlyingLong
value to to the passed function is not positive.
- def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def max(that: PosLong): PosLong
Returns
this
ifthis > that
orthat
otherwise. - def min(that: PosLong): PosLong
Returns
this
ifthis < that
orthat
otherwise. - def to(end: Long, step: Long): Inclusive[Long]
Create an inclusive
Range
from thisPosLong
value to the specifiedend
with the specifiedstep
value.Create an inclusive
Range
from thisPosLong
value to the specifiedend
with the specifiedstep
value.- end
The final bound of the range to make.
- step
The number to increase by for each step of the range.
- returns
A scala.collection.immutable.NumericRange.Inclusive[Long] from
this
up to and includingend
.
- def to(end: Long): Inclusive[Long]
Create an inclusive
Range
from thisPosLong
value to the specifiedend
with step value 1.Create an inclusive
Range
from thisPosLong
value to the specifiedend
with step value 1.- end
The final bound of the range to make.
- returns
A scala.collection.immutable.NumericRange.Inclusive[Long] from
this
up to and includingend
.
- def toBinaryString: String
Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 2.Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 2.The unsigned
long
value is thisPosLong
's underlyingLong
plus 264 if the underlyingLong
is negative; otherwise, it is equal to the underlyingLong
. This value is converted to a string of ASCII digits in binary (base 2) with no extra leading0
s. If the unsigned magnitude is zero, it is represented by a single zero character'0'
('\u0030'
); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The characters'0'
('\u0030'
) and'1'
('\u0031'
) are used as binary digits.- returns
the string representation of the unsigned
long
value represented by thisPosLong
's underlyingLong
in binary (base 2).
- def toByte: Byte
Converts this
PosLong
to aByte
. - def toChar: Char
Converts this
PosLong
to aChar
. - def toDouble: Double
Converts this
PosLong
to aDouble
. - def toFloat: Float
Converts this
PosLong
to aFloat
. - def toHexString: String
Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 16.Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 16.The unsigned
long
value is thisPosLong
's underlyingLong
plus 264 if the underlyingLong
is negative; otherwise, it is equal to the underlyingLong
. This value is converted to a string of ASCII digits in hexadecimal (base 16) with no extra leading0
s. If the unsigned magnitude is zero, it is represented by a single zero character'0'
('\u0030'
); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as hexadecimal digits:0123456789abcdef
These are the characters
'\u0030'
through'\u0039'
and'\u0061'
through'\u0066'
. If uppercase letters are desired, thetoUpperCase
method may be called on the result.- returns
the string representation of the unsigned
long
value represented by thisPosLong
's underlyingLong
in hexadecimal (base 16).
- def toInt: Int
Converts this
PosLong
to anInt
. - def toLong: Long
Converts this
PosLong
to aLong
. - def toOctalString: String
Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 8.Returns a string representation of this
PosLong
's underlyingLong
as an unsigned integer in base 8.The unsigned
long
value is thisPosLong
's underlyingLong
plus 264 if the underlyingLong
is negative; otherwise, it is equal to the underlyingLong
. This value is converted to a string of ASCII digits in octal (base 8) with no extra leading0
s.If the unsigned magnitude is zero, it is represented by a single zero character
'0'
('\u0030'
); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as octal digits:01234567
These are the characters
'\u0030'
through'\u0037'
.- returns
the string representation of the unsigned
long
value represented by thisPosLong
's underlyingLong
in octal (base 8).
- def toShort: Short
Converts this
PosLong
to aShort
. - def toString(): String
A string representation of this
PosLong
.A string representation of this
PosLong
.- Definition Classes
- PosLong → Any
- def unary_+: PosLong
Returns this value, unmodified.
- def unary_-: NegLong
Returns the negation of this value.
- def unary_~: Long
Returns the bitwise negation of this value.
Returns the bitwise negation of this value.
~5 == -6 // in binary: ~00000101 == // 11111010
Example: - def until(end: Long, step: Long): Exclusive[Long]
Create a
Range
from thisPosLong
value until the specifiedend
(exclusive) with the specifiedstep
value.Create a
Range
from thisPosLong
value until the specifiedend
(exclusive) with the specifiedstep
value.- end
The final bound of the range to make.
- step
The number to increase by for each step of the range.
- returns
A scala.collection.immutable.NumericRange.Exclusive[Long] from
this
up to but not includingend
.
- def until(end: Long): Exclusive[Long]
Create a
Range
from thisPosLong
value until the specifiedend
(exclusive) with step value 1.Create a
Range
from thisPosLong
value until the specifiedend
(exclusive) with step value 1.- end
The final bound of the range to make.
- returns
A scala.collection.immutable.NumericRange.Exclusive[Long] from
this
up to but not includingend
.
- val value: Long
- def |(x: Long): Long
Returns the bitwise OR of this value and
x
.Returns the bitwise OR of this value and
x
.(0xf0 | 0xaa) == 0xfa // in binary: 11110000 // | 10101010 // -------- // 11111010
Example: - def |(x: Int): Long
Returns the bitwise OR of this value and
x
.Returns the bitwise OR of this value and
x
.(0xf0 | 0xaa) == 0xfa // in binary: 11110000 // | 10101010 // -------- // 11111010
Example: - def |(x: Char): Long
Returns the bitwise OR of this value and
x
.Returns the bitwise OR of this value and
x
.(0xf0 | 0xaa) == 0xfa // in binary: 11110000 // | 10101010 // -------- // 11111010
Example: - def |(x: Short): Long
Returns the bitwise OR of this value and
x
.Returns the bitwise OR of this value and
x
.(0xf0 | 0xaa) == 0xfa // in binary: 11110000 // | 10101010 // -------- // 11111010
Example: - def |(x: Byte): Long
Returns the bitwise OR of this value and
x
.Returns the bitwise OR of this value and
x
.(0xf0 | 0xaa) == 0xfa // in binary: 11110000 // | 10101010 // -------- // 11111010
Example: