-
Notifications
You must be signed in to change notification settings - Fork 348
/
copyout.scala
213 lines (192 loc) · 10.4 KB
/
copyout.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
// Copyright (c) 2013-2020 Rob Norris and Contributors
// This software is licensed under the MIT License (MIT).
// For more information see LICENSE or https://opensource.org/licenses/MIT
package doobie.postgres.free
import cats.{~>, Applicative, Semigroup, Monoid}
import cats.effect.kernel.{ CancelScope, Poll, Sync }
import cats.free.{ Free => FF } // alias because some algebras have an op called Free
import doobie.util.log.LogEvent
import doobie.WeakAsync
import scala.concurrent.Future
import scala.concurrent.duration.FiniteDuration
import org.postgresql.copy.{ CopyOut => PGCopyOut }
// This file is Auto-generated using FreeGen2.scala
object copyout { module =>
// Algebra of operations for PGCopyOut. Each accepts a visitor as an alternative to pattern-matching.
sealed trait CopyOutOp[A] {
def visit[F[_]](v: CopyOutOp.Visitor[F]): F[A]
}
// Free monad over CopyOutOp.
type CopyOutIO[A] = FF[CopyOutOp, A]
// Module of instances and constructors of CopyOutOp.
object CopyOutOp {
// Given a PGCopyOut we can embed a CopyOutIO program in any algebra that understands embedding.
implicit val CopyOutOpEmbeddable: Embeddable[CopyOutOp, PGCopyOut] =
new Embeddable[CopyOutOp, PGCopyOut] {
def embed[A](j: PGCopyOut, fa: FF[CopyOutOp, A]) = Embedded.CopyOut(j, fa)
}
// Interface for a natural transformation CopyOutOp ~> F encoded via the visitor pattern.
// This approach is much more efficient than pattern-matching for large algebras.
trait Visitor[F[_]] extends (CopyOutOp ~> F) {
final def apply[A](fa: CopyOutOp[A]): F[A] = fa.visit(this)
// Common
def raw[A](f: PGCopyOut => A): F[A]
def embed[A](e: Embedded[A]): F[A]
def raiseError[A](e: Throwable): F[A]
def handleErrorWith[A](fa: CopyOutIO[A])(f: Throwable => CopyOutIO[A]): F[A]
def monotonic: F[FiniteDuration]
def realTime: F[FiniteDuration]
def delay[A](thunk: => A): F[A]
def suspend[A](hint: Sync.Type)(thunk: => A): F[A]
def forceR[A, B](fa: CopyOutIO[A])(fb: CopyOutIO[B]): F[B]
def uncancelable[A](body: Poll[CopyOutIO] => CopyOutIO[A]): F[A]
def poll[A](poll: Any, fa: CopyOutIO[A]): F[A]
def canceled: F[Unit]
def onCancel[A](fa: CopyOutIO[A], fin: CopyOutIO[Unit]): F[A]
def fromFuture[A](fut: CopyOutIO[Future[A]]): F[A]
def fromFutureCancelable[A](fut: CopyOutIO[(Future[A], CopyOutIO[Unit])]): F[A]
def performLogging(event: LogEvent): F[Unit]
// PGCopyOut
def cancelCopy: F[Unit]
def getFieldCount: F[Int]
def getFieldFormat(a: Int): F[Int]
def getFormat: F[Int]
def getHandledRowCount: F[Long]
def isActive: F[Boolean]
def readFromCopy: F[Array[Byte]]
def readFromCopy(a: Boolean): F[Array[Byte]]
}
// Common operations for all algebras.
final case class Raw[A](f: PGCopyOut => A) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.raw(f)
}
final case class Embed[A](e: Embedded[A]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.embed(e)
}
final case class RaiseError[A](e: Throwable) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.raiseError(e)
}
final case class HandleErrorWith[A](fa: CopyOutIO[A], f: Throwable => CopyOutIO[A]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.handleErrorWith(fa)(f)
}
case object Monotonic extends CopyOutOp[FiniteDuration] {
def visit[F[_]](v: Visitor[F]) = v.monotonic
}
case object Realtime extends CopyOutOp[FiniteDuration] {
def visit[F[_]](v: Visitor[F]) = v.realTime
}
case class Suspend[A](hint: Sync.Type, thunk: () => A) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.suspend(hint)(thunk())
}
case class ForceR[A, B](fa: CopyOutIO[A], fb: CopyOutIO[B]) extends CopyOutOp[B] {
def visit[F[_]](v: Visitor[F]) = v.forceR(fa)(fb)
}
case class Uncancelable[A](body: Poll[CopyOutIO] => CopyOutIO[A]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.uncancelable(body)
}
case class Poll1[A](poll: Any, fa: CopyOutIO[A]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.poll(poll, fa)
}
case object Canceled extends CopyOutOp[Unit] {
def visit[F[_]](v: Visitor[F]) = v.canceled
}
case class OnCancel[A](fa: CopyOutIO[A], fin: CopyOutIO[Unit]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.onCancel(fa, fin)
}
case class FromFuture[A](fut: CopyOutIO[Future[A]]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.fromFuture(fut)
}
case class FromFutureCancelable[A](fut: CopyOutIO[(Future[A], CopyOutIO[Unit])]) extends CopyOutOp[A] {
def visit[F[_]](v: Visitor[F]) = v.fromFutureCancelable(fut)
}
case class PerformLogging(event: LogEvent) extends CopyOutOp[Unit] {
def visit[F[_]](v: Visitor[F]) = v.performLogging(event)
}
// PGCopyOut-specific operations.
case object CancelCopy extends CopyOutOp[Unit] {
def visit[F[_]](v: Visitor[F]) = v.cancelCopy
}
case object GetFieldCount extends CopyOutOp[Int] {
def visit[F[_]](v: Visitor[F]) = v.getFieldCount
}
final case class GetFieldFormat(a: Int) extends CopyOutOp[Int] {
def visit[F[_]](v: Visitor[F]) = v.getFieldFormat(a)
}
case object GetFormat extends CopyOutOp[Int] {
def visit[F[_]](v: Visitor[F]) = v.getFormat
}
case object GetHandledRowCount extends CopyOutOp[Long] {
def visit[F[_]](v: Visitor[F]) = v.getHandledRowCount
}
case object IsActive extends CopyOutOp[Boolean] {
def visit[F[_]](v: Visitor[F]) = v.isActive
}
case object ReadFromCopy extends CopyOutOp[Array[Byte]] {
def visit[F[_]](v: Visitor[F]) = v.readFromCopy
}
final case class ReadFromCopy1(a: Boolean) extends CopyOutOp[Array[Byte]] {
def visit[F[_]](v: Visitor[F]) = v.readFromCopy(a)
}
}
import CopyOutOp._
// Smart constructors for operations common to all algebras.
val unit: CopyOutIO[Unit] = FF.pure[CopyOutOp, Unit](())
def pure[A](a: A): CopyOutIO[A] = FF.pure[CopyOutOp, A](a)
def raw[A](f: PGCopyOut => A): CopyOutIO[A] = FF.liftF(Raw(f))
def embed[F[_], J, A](j: J, fa: FF[F, A])(implicit ev: Embeddable[F, J]): FF[CopyOutOp, A] = FF.liftF(Embed(ev.embed(j, fa)))
def raiseError[A](err: Throwable): CopyOutIO[A] = FF.liftF[CopyOutOp, A](RaiseError(err))
def handleErrorWith[A](fa: CopyOutIO[A])(f: Throwable => CopyOutIO[A]): CopyOutIO[A] = FF.liftF[CopyOutOp, A](HandleErrorWith(fa, f))
val monotonic = FF.liftF[CopyOutOp, FiniteDuration](Monotonic)
val realtime = FF.liftF[CopyOutOp, FiniteDuration](Realtime)
def delay[A](thunk: => A) = FF.liftF[CopyOutOp, A](Suspend(Sync.Type.Delay, () => thunk))
def suspend[A](hint: Sync.Type)(thunk: => A) = FF.liftF[CopyOutOp, A](Suspend(hint, () => thunk))
def forceR[A, B](fa: CopyOutIO[A])(fb: CopyOutIO[B]) = FF.liftF[CopyOutOp, B](ForceR(fa, fb))
def uncancelable[A](body: Poll[CopyOutIO] => CopyOutIO[A]) = FF.liftF[CopyOutOp, A](Uncancelable(body))
def capturePoll[M[_]](mpoll: Poll[M]) = new Poll[CopyOutIO] {
def apply[A](fa: CopyOutIO[A]) = FF.liftF[CopyOutOp, A](Poll1(mpoll, fa))
}
val canceled = FF.liftF[CopyOutOp, Unit](Canceled)
def onCancel[A](fa: CopyOutIO[A], fin: CopyOutIO[Unit]) = FF.liftF[CopyOutOp, A](OnCancel(fa, fin))
def fromFuture[A](fut: CopyOutIO[Future[A]]) = FF.liftF[CopyOutOp, A](FromFuture(fut))
def fromFutureCancelable[A](fut: CopyOutIO[(Future[A], CopyOutIO[Unit])]) = FF.liftF[CopyOutOp, A](FromFutureCancelable(fut))
def performLogging(event: LogEvent) = FF.liftF[CopyOutOp, Unit](PerformLogging(event))
// Smart constructors for CopyOut-specific operations.
val cancelCopy: CopyOutIO[Unit] = FF.liftF(CancelCopy)
val getFieldCount: CopyOutIO[Int] = FF.liftF(GetFieldCount)
def getFieldFormat(a: Int): CopyOutIO[Int] = FF.liftF(GetFieldFormat(a))
val getFormat: CopyOutIO[Int] = FF.liftF(GetFormat)
val getHandledRowCount: CopyOutIO[Long] = FF.liftF(GetHandledRowCount)
val isActive: CopyOutIO[Boolean] = FF.liftF(IsActive)
val readFromCopy: CopyOutIO[Array[Byte]] = FF.liftF(ReadFromCopy)
def readFromCopy(a: Boolean): CopyOutIO[Array[Byte]] = FF.liftF(ReadFromCopy1(a))
// Typeclass instances for CopyOutIO
implicit val WeakAsyncCopyOutIO: WeakAsync[CopyOutIO] =
new WeakAsync[CopyOutIO] {
val monad = FF.catsFreeMonadForFree[CopyOutOp]
override val applicative = monad
override val rootCancelScope = CancelScope.Cancelable
override def pure[A](x: A): CopyOutIO[A] = monad.pure(x)
override def flatMap[A, B](fa: CopyOutIO[A])(f: A => CopyOutIO[B]): CopyOutIO[B] = monad.flatMap(fa)(f)
override def tailRecM[A, B](a: A)(f: A => CopyOutIO[Either[A, B]]): CopyOutIO[B] = monad.tailRecM(a)(f)
override def raiseError[A](e: Throwable): CopyOutIO[A] = module.raiseError(e)
override def handleErrorWith[A](fa: CopyOutIO[A])(f: Throwable => CopyOutIO[A]): CopyOutIO[A] = module.handleErrorWith(fa)(f)
override def monotonic: CopyOutIO[FiniteDuration] = module.monotonic
override def realTime: CopyOutIO[FiniteDuration] = module.realtime
override def suspend[A](hint: Sync.Type)(thunk: => A): CopyOutIO[A] = module.suspend(hint)(thunk)
override def forceR[A, B](fa: CopyOutIO[A])(fb: CopyOutIO[B]): CopyOutIO[B] = module.forceR(fa)(fb)
override def uncancelable[A](body: Poll[CopyOutIO] => CopyOutIO[A]): CopyOutIO[A] = module.uncancelable(body)
override def canceled: CopyOutIO[Unit] = module.canceled
override def onCancel[A](fa: CopyOutIO[A], fin: CopyOutIO[Unit]): CopyOutIO[A] = module.onCancel(fa, fin)
override def fromFuture[A](fut: CopyOutIO[Future[A]]): CopyOutIO[A] = module.fromFuture(fut)
override def fromFutureCancelable[A](fut: CopyOutIO[(Future[A], CopyOutIO[Unit])]): CopyOutIO[A] = module.fromFutureCancelable(fut)
}
implicit def MonoidCopyOutIO[A : Monoid]: Monoid[CopyOutIO[A]] = new Monoid[CopyOutIO[A]] {
override def empty: CopyOutIO[A] = Applicative[CopyOutIO].pure(Monoid[A].empty)
override def combine(x: CopyOutIO[A], y: CopyOutIO[A]): CopyOutIO[A] =
Applicative[CopyOutIO].product(x, y).map { case (x, y) => Monoid[A].combine(x, y) }
}
implicit def SemigroupCopyOutIO[A : Semigroup]: Semigroup[CopyOutIO[A]] = new Semigroup[CopyOutIO[A]] {
override def combine(x: CopyOutIO[A], y: CopyOutIO[A]): CopyOutIO[A] =
Applicative[CopyOutIO].product(x, y).map { case (x, y) => Semigroup[A].combine(x, y) }
}
}