LawlessDateTimeTC

abstract def compare(x: A, y: A): Int

abstract def date(x: A): LocalDate

date part of x

abstract def dayOfMonth(x: A): Int

abstract def dayOfWeek(x: A): DayOfWeek

abstract def daysUntil(x: A, until: A): Long

Returns number of full days between two datetime values.

abstract def hour(x: A): Int

abstract def hoursUntil(x: A, until: A): Long

Returns number of full hours between two datetime values.

abstract def millisecond(x: A): Int

abstract def millisecondsUntil(x: A, until: A): Long

Returns number of milliseconds between two datetime values.

abstract def minute(x: A): Int

abstract def minutesUntil(x: A, until: A): Long

Returns number of full minutes between two datetime values.

abstract def month(x: A): Int

abstract def monthsUntil(x: A, until: A): Long

Returns number of full months between two datetime values.

abstract def plus(x: A, d: Duration): A

add (possibly negative) duration to this datetime

abstract def plusMonths(x: A, months: Int): A

Add (possibly negative) number of months to this datetime.

abstract def plusYears(x: A, years: Int): A

Add (possibly negative) number of years to this datetime.

abstract def second(x: A): Int

abstract def secondsUntil(x: A, until: A): Long

Returns number of full seconds between two datetime values.

abstract def time(x: A): LocalTime

time part of x

abstract def withDayOfMonth(x: A, dayOfMonth: Int): A

Create a copy of x with day of month altered.

abstract def withHour(x: A, hour: Int): A

Create a copy of x with hour of day altered.

abstract def withMillisecond(x: A, millisecond: Int): A

Create a copy of x with millisecond of second altered.

abstract def withMinute(x: A, minute: Int): A

Create a copy of x with minute if hour altered.

abstract def withMonth(x: A, month: Int): A

Create a copy of x with month altered.

abstract def withSecond(x: A, second: Int): A

Create a copy of x with second of minute altered.

abstract def withYear(x: A, year: Int): A

Create a copy of x with year altered.

abstract def year(x: A): Int

abstract def yearsUntil(x: A, until: A): Long

Returns number of full years between two datetime values.

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (LawlessDateTimeTC[A], B)

final def ==(arg0: Any): Boolean

def and(that: Eq[A]): Eq[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def comparison(x: A, y: A): Comparison

def ensuring(cond: (LawlessDateTimeTC[A]) ⇒ Boolean, msg: ⇒ Any): LawlessDateTimeTC[A]

def ensuring(cond: (LawlessDateTimeTC[A]) ⇒ Boolean): LawlessDateTimeTC[A]

def ensuring(cond: Boolean, msg: ⇒ Any): LawlessDateTimeTC[A]

def ensuring(cond: Boolean): LawlessDateTimeTC[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eqv(x: A, y: A): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def gt(x: A, y: A): Boolean

def gteqv(x: A, y: A): Boolean

def hashCode(): Int

def isAfter(x: A, y: A): Boolean

def isAfterOrEquals(x: A, y: A): Boolean

def isBefore(x: A, y: A): Boolean

def isBeforeOrEquals(x: A, y: A): Boolean

def isEqual(x: A, y: A): Boolean

final def isInstanceOf[T0]: Boolean

def lt(x: A, y: A): Boolean

def lteqv(x: A, y: A): Boolean

def max(x: A, y: A): A

def min(x: A, y: A): A

final def ne(arg0: AnyRef): Boolean

def neqv(x: A, y: A): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on[B](f: (B) ⇒ A): Order[B]

def or(that: Eq[A]): Eq[A]

def partialCompare(x: A, y: A): Double

def partialComparison(x: A, y: A): Option[Comparison]

def pmax(x: A, y: A): Option[A]

def pmin(x: A, y: A): Option[A]

def reverse: Order[A]

final def synchronized[T0](arg0: ⇒ T0): T0

def toOrdering: Ordering[A]

def toString(): String

def tryCompare(x: A, y: A): Option[Int]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def whenEqual(o: Order[A]): Order[A]

def →[B](y: B): (LawlessDateTimeTC[A], B)