scodec
.
CodecTransformation
Id
Related Doc:
package CodecTransformation
object
Id
extends
CodecTransformation
Source
package.scala
Linear Supertypes
~>
[
Codec
,
Codec
],
Poly1
,
Poly
,
Serializable
,
Serializable
,
PolyApply
,
AnyRef
,
Any
Ordering
Alphabetic
By inheritance
Inherited
Id
~>
Poly1
Poly
Serializable
Serializable
PolyApply
AnyRef
Any
Hide All
Show all
Visibility
Public
All
Type Members
type
Case
[
A
]
=
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
HNil
]]
Definition Classes
Poly1
class
CaseBuilder
[
A
]
extends
AnyRef
Definition Classes
Poly1
trait
LowPriorityCaseBuilder
extends
AnyRef
Definition Classes
Poly
type
ProductCase
[
L <:
HList
]
=
shapeless.PolyDefns.Case
[
Id
.this.type,
L
]
Definition Classes
Poly
Value Members
final
def
!=
(
arg0:
Any
)
:
Boolean
Definition Classes
AnyRef → Any
final
def
##
()
:
Int
Definition Classes
AnyRef → Any
final
def
==
(
arg0:
Any
)
:
Boolean
Definition Classes
AnyRef → Any
def
andThen
(
f:
Poly
)
:
Compose
[
f
.type,
Id
.this.type]
Definition Classes
Poly
def
apply
[
X
]
(
c:
Codec
[
X
]
)
:
Codec
[
X
]
Definition Classes
Id
→ ~>
def
apply
[
R
]
(
implicit
c:
Aux
[
HNil
,
R
]
)
:
R
Definition Classes
Poly
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
,
r:
R
,
s:
S
,
t:
T
,
u:
U
,
v:
V
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
::
[
R
,
::
[
S
,
::
[
T
,
::
[
U
,
::
[
V
,
HNil
]]]]]]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
,
r:
R
,
s:
S
,
t:
T
,
u:
U
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
::
[
R
,
::
[
S
,
::
[
T
,
::
[
U
,
HNil
]]]]]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
,
r:
R
,
s:
S
,
t:
T
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
::
[
R
,
::
[
S
,
::
[
T
,
HNil
]]]]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
,
r:
R
,
s:
S
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
::
[
R
,
::
[
S
,
HNil
]]]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
,
r:
R
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
::
[
R
,
HNil
]]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
,
q:
Q
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
::
[
Q
,
HNil
]]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
,
p:
P
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
::
[
P
,
HNil
]]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
,
o:
O
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
::
[
O
,
HNil
]]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
,
n:
N
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
::
[
N
,
HNil
]]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
,
m:
M
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
::
[
M
,
HNil
]]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
,
l:
L
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
::
[
L
,
HNil
]]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
,
k:
K
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
::
[
K
,
HNil
]]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
,
j:
J
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
::
[
J
,
HNil
]]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
,
i:
I
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
::
[
I
,
HNil
]]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
,
h:
H
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
::
[
H
,
HNil
]]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
,
G
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
,
g:
G
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
::
[
G
,
HNil
]]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
,
F
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
,
f:
F
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
::
[
F
,
HNil
]]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
,
E
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
,
e:
E
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
::
[
E
,
HNil
]]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
,
D
]
(
a:
A
,
b:
B
,
c:
C
,
d:
D
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
::
[
D
,
HNil
]]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
,
C
]
(
a:
A
,
b:
B
,
c:
C
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
::
[
C
,
HNil
]]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
,
B
]
(
a:
A
,
b:
B
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
::
[
B
,
HNil
]]]
)
:
Result
Definition Classes
PolyApply
def
apply
[
A
]
(
a:
A
)
(
implicit
cse:
shapeless.PolyDefns.Case
[
Id
.this.type,
::
[
A
,
HNil
]]
)
:
Result
Definition Classes
PolyApply
final
def
asInstanceOf
[
T0
]
:
T0
Definition Classes
Any
def
at
[
A
]
:
CaseBuilder
[
A
]
Definition Classes
Poly1
def
caseAt
[
L <:
HList
]
(
implicit
c:
ProductCase
[
L
]
)
:
ProductCase
[
L
]
Definition Classes
Poly
implicit
def
caseUniv
[
T
]
:
Aux
[
Codec
[
T
],
Codec
[
T
]]
Definition Classes
~>
def
clone
()
:
AnyRef
Attributes
protected[
java.lang
]
Definition Classes
AnyRef
Annotations
@throws
(
...
)
def
compose
(
f:
Poly
)
:
Compose
[
Id
.this.type,
f
.type]
Definition Classes
Poly
final
def
eq
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
def
equals
(
arg0:
Any
)
:
Boolean
Definition Classes
AnyRef → Any
def
finalize
()
:
Unit
Attributes
protected[
java.lang
]
Definition Classes
AnyRef
Annotations
@throws
(
classOf[java.lang.Throwable]
)
final
def
getClass
()
:
Class
[_]
Definition Classes
AnyRef → Any
def
hashCode
()
:
Int
Definition Classes
AnyRef → Any
final
def
isInstanceOf
[
T0
]
:
Boolean
Definition Classes
Any
final
def
ne
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
final
def
notify
()
:
Unit
Definition Classes
AnyRef
final
def
notifyAll
()
:
Unit
Definition Classes
AnyRef
def
rotateLeft
[
N <:
Nat
]
:
RotateLeft
[
Id
.this.type,
N
]
Definition Classes
Poly
def
rotateRight
[
N <:
Nat
]
:
RotateRight
[
Id
.this.type,
N
]
Definition Classes
Poly
final
def
synchronized
[
T0
]
(
arg0: ⇒
T0
)
:
T0
Definition Classes
AnyRef
def
toString
()
:
String
Definition Classes
AnyRef → Any
def
use
[
T
,
L <:
HList
,
R
]
(
t:
T
)
(
implicit
cb:
Id.CaseBuilder
[
T
,
L
,
R
]
)
:
Aux
[
L
,
R
]
Definition Classes
Poly
final
def
wait
()
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
final
def
wait
(
arg0:
Long
,
arg1:
Int
)
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
final
def
wait
(
arg0:
Long
)
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
Inherited from
~>
[
Codec
,
Codec
]
Inherited from
Poly1
Inherited from
Poly
Inherited from
Serializable
Inherited from
Serializable
Inherited from
PolyApply
Inherited from
AnyRef
Inherited from
Any
Ungrouped