//设置package包名称以及导入依赖的类
package io.circe.spray

import io.circe.{ Decoder, Encoder, RootEncoder }


case class RootDecoder[A](underlying: Decoder[A])

final object RootDecoder extends LowPriorityRootDecoders {
  implicit def rootDecoderWithRootEncoder[A](implicit decoder: Decoder[A], encoder: RootEncoder[A]): RootDecoder[A] =
    RootDecoder(decoder)
}

private[spray] sealed class LowPriorityRootDecoders {
  implicit def rootDecoderBlocker1[A](implicit decoder: Decoder[A], encoder: Encoder[A]): RootDecoder[A] =
    RootDecoder(decoder)
  implicit def rootDecoderBlocker2[A](implicit decoder: Decoder[A], encoder: Encoder[A]): RootDecoder[A] =
    RootDecoder(decoder)
  implicit def rootDecoder[A](implicit decoder: Decoder[A]): RootDecoder[A] = RootDecoder(decoder)
} 

//设置package包名称以及导入依赖的类
package aecor.example

import io.circe.{ Decoder, Encoder }
import shapeless.Unwrapped

trait AnyValCirceEncoding {
  implicit def anyValEncoder[V, U](implicit ev: V <:< AnyVal,
                                   V: Unwrapped.Aux[V, U],
                                   encoder: Encoder[U]): Encoder[V] = {
    val _ = ev
    encoder.contramap(V.unwrap)
  }

  implicit def anyValDecoder[V, U](implicit ev: V <:< AnyVal,
                                   V: Unwrapped.Aux[V, U],
                                   decoder: Decoder[U]): Decoder[V] = {
    val _ = ev
    decoder.map(V.wrap)
  }
}

object AnyValCirceEncoding extends AnyValCirceEncoding

object CirceSupport
    extends de.heikoseeberger.akkahttpcirce.FailFastCirceSupport
    with AnyValCirceEncoding 

//设置package包名称以及导入依赖的类
package org.danielnixon.progressive.shared.api

import io.circe.{ Decoder, Encoder }
import io.circe.generic.semiauto.{ deriveDecoder, deriveEncoder }
import org.danielnixon.progressive.shared.Wart

final case class FormSettings(
  ajax: Boolean = true,
  target: Option[Target] = None,
  refreshTarget: Option[Target] = Some(Target.ClosestRefresh),
  busyMessage: Option[String] = None,
  focusTarget: Boolean = true,
  reloadPage: Boolean = false,
  confirmMessage: Option[String] = None,
  confirmedAction: Option[String] = None,
  ajaxAction: Option[String] = None,
  remove: Boolean = false,
  resetForm: Boolean = false
)

@SuppressWarnings(Array(Wart.Nothing))
object FormSettings {
  implicit val decoder: Decoder[FormSettings] = deriveDecoder[FormSettings]
  implicit val encoder: Encoder[FormSettings] = deriveEncoder[FormSettings]

  def asJson(target: FormSettings): String = Json.asJson(target)

  def fromJson(json: String): Option[FormSettings] = Json.fromJson(json)
} 

//设置package包名称以及导入依赖的类
package org.danielnixon.progressive.shared.api

import io.circe.{ Decoder, Encoder }
import io.circe.generic.semiauto.{ deriveDecoder, deriveEncoder }
import org.danielnixon.progressive.shared.Wart

final case class LinkSettings(
  target: Target,
  busyMessage: Option[String] = None,
  focusTarget: Boolean = true,
  href: Option[String] = None
)

@SuppressWarnings(Array(Wart.AsInstanceOf, Wart.Nothing))
object LinkSettings {
  implicit val decoder: Decoder[LinkSettings] = deriveDecoder[LinkSettings]
  implicit val encoder: Encoder[LinkSettings] = deriveEncoder[LinkSettings]

  def asJson(target: LinkSettings): String = Json.asJson(target)

  def fromJson(json: String): Option[LinkSettings] = Json.fromJson(json)
} 

//设置package包名称以及导入依赖的类
package org.danielnixon.progressive.shared.api

import io.circe.{ Decoder, Encoder }
import io.circe.generic.semiauto.{ deriveDecoder, deriveEncoder }
import org.danielnixon.progressive.shared.Wart

final case class SubmitButtonSettings(
  target: Option[Target] = None,
  busyMessage: Option[String] = None
)

@SuppressWarnings(Array(Wart.Nothing))
object SubmitButtonSettings {
  implicit val decoder: Decoder[SubmitButtonSettings] = deriveDecoder[SubmitButtonSettings]
  implicit val encoder: Encoder[SubmitButtonSettings] = deriveEncoder[SubmitButtonSettings]

  def asJson(target: SubmitButtonSettings): String = Json.asJson(target)

  def fromJson(json: String): Option[SubmitButtonSettings] = Json.fromJson(json)
} 

//设置package包名称以及导入依赖的类
package org.http4s.akka

import io.circe.{Decoder, Encoder, Json}
import io.circe.parser._
import org.http4s.{Charset, DefaultCharset, UrlForm}
import org.http4s.websocket.WebsocketBits._
import play.twirl.api._


  implicit def circeableFrameFormat[A: Encoder : Decoder]: FrameFormatter[A] = jsonFrameFormatter.transform[A](
    Encoder[A].apply(_),
    Decoder[A].decodeJson(_).toTry.get
  )
  
  //=== TWIRL ===
  implicit val htmlFrameFormatter: FrameFormatter[Html] = stringFrameFormatter.transform(_.body, Html.apply)
  implicit val xmlFrameFormatter: FrameFormatter[Xml] = stringFrameFormatter.transform(_.body, Xml.apply)
  implicit val txtFrameFormatter: FrameFormatter[Txt] = stringFrameFormatter.transform(_.body, Txt.apply)
  implicit val javaScriptFrameFormatter: FrameFormatter[JavaScript] = stringFrameFormatter.transform(_.body, JavaScript.apply)
} 

//设置package包名称以及导入依赖的类
package io.taig.akka.http.phoenix

import io.circe.{ Decoder, Encoder }

sealed case class Event( name: String )

object Event {
    object Close extends Event( "phx_close" )
    object Error extends Event( "phx_error" )
    object Join extends Event( "phx_join" )
    object Reply extends Event( "phx_reply" )
    object Leave extends Event( "phx_leave" )

    val all = Close :: Error :: Join :: Reply :: Leave :: Nil

    implicit val encoderEvent: Encoder[Event] = {
        Encoder[String].contramap( _.name )
    }

    implicit val decoderEvent: Decoder[Event] = {
        Decoder[String].map { name ?
            all.find( _.name == name ).getOrElse( Event( name ) )
        }
    }
} 

//设置package包名称以及导入依赖的类
package io.taig.akka.http.phoenix

import io.circe.{ Decoder, Encoder }
import cats.implicits._

case class Topic( name: String, identifier: Option[String] ) {
    def isSubscribedTo( topic: Topic ): Boolean = topic match {
        case Topic( `name`, `identifier` ) ? true
        case Topic( `name`, None )         ? true
        case _                             ? false
    }

    def serialize = name + identifier.map( ":" + _ ).getOrElse( "" )

    override def toString = s"Topic($serialize)"
}

object Topic {
    implicit val encoderTopic: Encoder[Topic] = {
        Encoder[String].contramap( _.serialize )
    }

    implicit val decoderTopic: Decoder[Topic] = {
        Decoder[String].emap { topic ?
            Either.fromOption( parse( topic ), "Invalid format" )
        }
    }

    val Phoenix = Topic( "phoenix" )

    val Pattern = "(\\w+)(?::(\\w+))?".r

    def apply( name: String, identifier: String ): Topic = {
        Topic( name, Some( identifier ) )
    }

    def apply( name: String ): Topic = Topic( name, None )

    def parse( topic: String ): Option[Topic] = {
        topic match {
            case Pattern( name, identifier ) ?
                Some( Topic( name, Option( identifier ) ) )
            case _ ? None
        }
    }
} 

//设置package包名称以及导入依赖的类
package com.lookout.ratelimitingfilter

import com.twitter.finagle.http.{Response, Status}
import com.twitter.finagle.RefusedByRateLimiter
import com.twitter.io.Buf
import com.twitter.logging.Logger
import io.circe.{Decoder, Encoder}
import io.circe.syntax._

final case class RefusedByRateLimiterError(
  message: String
) extends Exception(message) {
  def toResponse: Response = RefusedByRateLimiterError.toResponse(this)
}

object RefusedByRateLimiterError {
  val LOG = Logger.get(getClass)

  implicit val errorEncoder: Encoder[RefusedByRateLimiterError] =
    Encoder.forProduct1("message") { err => err.message }

  implicit val errorDecoder: Decoder[RefusedByRateLimiterError] =
    Decoder.forProduct1[String, RefusedByRateLimiterError]("message") {
      case (message: String) => RefusedByRateLimiterError(message)
    }

  def toResponse(error: RefusedByRateLimiterError): Response = {
    val response = Response(Status.TooManyRequests)
    val content = error.asJson.noSpaces
    LOG.info(content)
    response.content = Buf.Utf8(content)
    response.contentType = "application/json"
    response
  }
} 

//设置package包名称以及导入依赖的类
package kartograffel.shared.model

import eu.timepit.refined.W
import eu.timepit.refined.api.Refined
import eu.timepit.refined.numeric.Interval
import io.circe.generic.semiauto._
import io.circe.{Decoder, Encoder}
import io.circe.refined._
import kartograffel.shared.model.Position.{Latitude, Longitude}

final case class Position(
    latitude: Latitude,
    longitude: Longitude
)

object Position {
  type Latitude = Double Refined Interval.Closed[W.`-90.0`.T, W.`90.0`.T]

  type Longitude = Double Refined Interval.Closed[W.`-180.0`.T, W.`180.0`.T]

  implicit val positionDecoder: Decoder[Position] =
    deriveDecoder

  implicit val positionEncoder: Encoder[Position] =
    deriveEncoder
} 

//设置package包名称以及导入依赖的类
package kartograffel.shared.model

import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
import io.circe.{Decoder, Encoder}

final case class Graffel(
    id: Graffel.Id,
    position: Position
)

object Graffel {
  final case class Id(value: String) extends AnyVal

  implicit val graffelIdDecoder: Decoder[Id] =
    Decoder.decodeString.map(Id.apply)

  implicit val graffelIdEncoder: Encoder[Id] =
    Encoder.encodeString.contramap(_.value)

  implicit val graffelDecoder: Decoder[Graffel] =
    deriveDecoder

  implicit val graffelEncoder: Encoder[Graffel] =
    deriveEncoder
} 

//设置package包名称以及导入依赖的类
package com.outr.arango.managed

import java.util.concurrent.atomic.AtomicBoolean

import com.outr.arango.rest.LogEvent
import com.outr.arango.{Arango, ArangoCursor, ArangoDB, ArangoGraph, ArangoSession, Credentials, DocumentOption, Edge, Macros, Query, ReplicationMonitor}
import io.circe.Decoder
import io.youi.net.URL
import reactify.{Channel, Observable}

import scala.concurrent.duration._
import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.language.experimental.macros

class Graph(name: String,
            db: String = Arango.defaultDatabase,
            url: URL = Arango.defaultURL,
            credentials: Option[Credentials] = Arango.defaultCredentials,
            timeout: FiniteDuration = 15.seconds) {
  private[managed] lazy val arango: Arango = new Arango(url)
  private[managed] lazy val sessionFuture: Future[ArangoSession] = arango.session(credentials)
  private[managed] lazy val dbFuture: Future[ArangoDB] = sessionFuture.map(_.db(db))
  private[managed] lazy val graphFuture: Future[ArangoGraph] = dbFuture.map(_.graph(name))

  protected[managed] lazy val instance: ArangoGraph = Await.result[ArangoGraph](graphFuture, timeout)

  private[managed] var managedCollections = List.empty[AbstractCollection[_]]
  private[managed] lazy val monitor: ReplicationMonitor = instance.db.replication.monitor
  def collections: List[AbstractCollection[_]] = managedCollections

  val initialized: Channel[Boolean] = Channel[Boolean]
  lazy val realTime: RealTime = new RealTime(this)

  private val initCalled = new AtomicBoolean(false)

  
  def delete(dropCollections: Boolean = true): Future[Boolean] = graphFuture.flatMap { graph =>
    graph.delete(dropCollections).map(!_.error)
  }

  def cursor: ArangoCursor = instance.db.cursor
  def call[T](query: Query)(implicit decoder: Decoder[T]): Future[T] = instance.db.call[T](query)
  def first[T](query: Query)(implicit decoder: Decoder[T]): Future[Option[T]] = instance.db.first[T](query)
  def execute(query: Query): Future[Boolean] = instance.db.execute(query)

  def synchronous[T](future: Future[T], timeout: FiniteDuration = 10.seconds): T = Arango.synchronous(future, timeout)
} 

//设置package包名称以及导入依赖的类
package com.outr.arango.managed

import com.outr.arango.{DocumentOption, Macros}
import com.outr.arango.rest.CreateInfo
import io.circe.Decoder.Result
import io.circe.{Decoder, Encoder, HCursor, Json}

import scala.language.experimental.macros

class PolymorphicVertexCollection[T <: PolymorphicDocumentOption]
                                    (graph: Graph, name: String, val types: List[PolymorphicType[T]])
                                    extends VertexCollection[T](graph, name) {
  private lazy val typeMap: Map[String, PolymorphicType[T]] = types.map(t => t.value -> t).toMap
  override implicit val encoder: Encoder[T] = new Encoder[T] {
    override def apply(a: T): Json = typeMap(a._type).encoder(a)
  }
  override implicit val decoder: Decoder[T] = new Decoder[T] {
    override def apply(c: HCursor): Result[T] = {
      val decoder = for {
        t <- Decoder[String].prepare(_.downField("_type"))
        d <- typeMap.get(t).fold(
          Decoder.failedWithMessage[T]("_type not found in polymorphic document")
        )(_.decoder)
      } yield d
      decoder(c)
    }
  }

  override protected def updateDocument(document: T, info: CreateInfo): T = typeMap(document._type).updateDocument(document, info)
}

trait PolymorphicDocumentOption extends DocumentOption {
  def _type: String
}

trait PolymorphicType[T] {
  def value: String
  def encoder: Encoder[T]
  def decoder: Decoder[T]
  def updateDocument(document: T, info: CreateInfo): T
} 

//设置package包名称以及导入依赖的类
package com.outr.arango

import com.outr.arango.rest.{QueryRequest, QueryRequestOptions, QueryResponse}
import io.circe.{Decoder, Json}
import io.circe.generic.auto._
import io.youi.http.Method

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

class ArangoCursor(arangoDB: ArangoDB) {
  def apply[T](query: Query,
               count: Boolean = false,
               batchSize: Option[Int] = None,
               cache: Option[Boolean] = None,
               memoryLimit: Option[Long] = None,
               ttl: Option[Int] = None,
               options: QueryRequestOptions = QueryRequestOptions())
              (implicit decoder: Decoder[T]): Future[QueryResponse[T]] = {
    val bindVars = Json.obj(query.args.map {
      case (key, value) => {
        val argValue: Json = value match {
          case Value.Null => Json.Null
          case StringValue(s) => Json.fromString(s)
          case IntValue(i) => Json.fromInt(i)
          case LongValue(l) => Json.fromLong(l)
          case DoubleValue(d) => Json.fromDoubleOrNull(d)
        }
        key -> argValue
      }
    }.toSeq: _*)
    val request = QueryRequest(
      query = query.value,
      bindVars = bindVars,
      count = count,
      batchSize = batchSize,
      cache = cache,
      memoryLimit = memoryLimit,
      ttl = ttl,
      options = options
    )
    arangoDB.restful[QueryRequest, QueryResponse[T]]("cursor", request)
  }

  def paged[T](query: Query,
               batchSize: Int = 100,
               cache: Option[Boolean] = None,
               memoryLimit: Option[Long] = None,
               ttl: Option[Int] = None,
               options: QueryRequestOptions = QueryRequestOptions())
              (implicit decoder: Decoder[T]): Future[QueryResponsePagination[T]] = {
    val count = true
    apply[T](query, count, Some(batchSize), cache, memoryLimit, ttl, options).map(r => QueryResponsePagination[T](this, r))
  }

  def get[T](id: String)
            (implicit decoder: Decoder[T]): Future[QueryResponse[T]] = {
    arangoDB.call[QueryResponse[T]](s"cursor/$id", Method.Put)
  }
} 

//设置package包名称以及导入依赖的类
package com.outr.arango

import com.outr.arango.rest.QueryResponse
import io.circe.Decoder

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

case class QueryResponsePagination[T](cursor: ArangoCursor,
                                      response: QueryResponse[T],
                                      offset: Int = 0)(implicit decoder: Decoder[T]) extends Iterable[T] {
  lazy val start: Int = offset
  lazy val end: Int = math.max(offset, offset + response.result.size - 1)
  def results: List[T] = response.result
  def total: Int = response.count.get
  def hasNext: Boolean = response.hasMore
  def next(): Future[QueryResponsePagination[T]] = if (response.hasMore) {
    cursor.get[T](response.id.get).map(r => copy(response = r, offset = end + 1))
  } else {
    Future.failed(throw new RuntimeException("No more results."))
  }

  override def iterator: Iterator[T] = new QueryResponseIterator[T](this)
} 

//设置package包名称以及导入依赖的类
package com.outr.arango

import com.outr.arango.rest.{ArangoUser, CreateDatabaseRequest, Result}
import io.circe.{Decoder, Encoder}
import io.circe.generic.auto._
import io.youi.http.{HttpRequest, HttpResponse, Method}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

class ArangoDB(val session: ArangoSession, val db: String) {
  protected[arango] def restful[Request, Response](name: String,
                                                   request: Request,
                                                   params: Map[String, String] = Map.empty,
                                                   errorHandler: Option[(HttpRequest, HttpResponse) => Response] = None,
                                                   method: Method = Method.Post)
                                                  (implicit encoder: Encoder[Request], decoder: Decoder[Response]): Future[Response] = {
    session.restful[Request, Response](Some(db), name, request, params, errorHandler, method)
  }

  protected[arango] def call[Response](name: String,
                                       method: Method,
                                       params: Map[String, String] = Map.empty,
                                       errorHandler: Option[(HttpRequest, HttpResponse) => Response] = None)
                                      (implicit decoder: Decoder[Response]): Future[Response] = {
    session.call[Response](Some(db), name, method, params, errorHandler)
  }

  def create(users: ArangoUser*): Future[Result[Boolean]] = {
    val request = CreateDatabaseRequest(db, users.toList)
    session.restful[CreateDatabaseRequest, Result[Boolean]](None, "database", request)
  }

  def drop(): Future[Result[Boolean]] = {
    session.call[Result[Boolean]](None, s"database/$db", Method.Delete)
  }

  def collection(name: String): ArangoCollection = new ArangoCollection(this, name)

  lazy val cursor: ArangoCursor = new ArangoCursor(this)
  lazy val replication: ArangoReplication = new ArangoReplication(this)

  
  def execute(query: Query): Future[Boolean] = {
    cursor[Unit](query, count = true).map { response =>
      assert(response.count.contains(0), s"Response count was not zero: ${response.count}.")
      !response.error
    }
  }

  lazy val graph: ArangoGraphs = new ArangoGraphs(this)
} 

//设置package包名称以及导入依赖的类
package org.mdoc.common.model

import cats.data.Xor
import io.circe.{ Decoder, DecodingFailure, Encoder }
import scodec.bits.ByteVector

object circe {

  implicit val byteVectorDecoder: Decoder[ByteVector] =
    Decoder.instance { cursor =>
      Decoder[String].apply(cursor).flatMap { str =>
        ByteVector.fromBase64Descriptive(str) match {
          case Right(bytes) => Xor.right(bytes)
          case Left(err) => Xor.left(DecodingFailure(err, cursor.history))
        }
      }
    }

  implicit val byteVectorEncoder: Encoder[ByteVector] =
    Encoder[String].contramap(_.toBase64)
} 

//设置package包名称以及导入依赖的类
package org.mdoc.common.model

import cats.data.Xor
import io.circe.{ Decoder, Encoder, Json }
import org.mdoc.common.model.circe._
import org.scalacheck.Prop._
import org.scalacheck.Properties
import scodec.bits.ByteVector

object CirceSpec extends Properties("circe") {

  property("Decoder[ByteVector] success") = secure {
    Decoder[ByteVector].decodeJson(Json.string("SGVsbG8=")) ?=
      Xor.right(ByteVector("Hello".getBytes))
  }

  property("Decoder[ByteVector] failure") = secure {
    Decoder[ByteVector].decodeJson(Json.string("???")).isLeft
  }

  property("Encoder[ByteVector]") = secure {
    Encoder[ByteVector].apply(ByteVector("Hello".getBytes)) ?=
      Json.string("SGVsbG8=")
  }
} 

//设置package包名称以及导入依赖的类
package net.scalax.fsn.slick.helpers

import io.circe.{ Decoder, Encoder }
import io.circe.generic.auto._
import net.scalax.fsn.json.atomic.{ CompareToStringConvert, JsonReader, JsonWriter, SlickCompare }
import net.scalax.fsn.json.operation.FAtomicHelper

trait FJsonAtomicHelper[E] extends FAtomicHelper[E] {

  def writeJ(implicit encoder: Encoder[E]) = path.appendAtomic(new JsonWriter[E] {
    override val writer = encoder
  })

  def readJ(implicit decoder: Decoder[E]) = path.appendAtomic(new JsonReader[E] {
    override val reader = decoder
  })

  def readSlickComp(implicit decoder: Decoder[E], strCv1: EqType[E, String] = null, optStrCv1: EqType[E, Option[String]] = null) = {
    path.appendAllAtomic(
      new SlickCompare[E] {
        override val reader = Decoder[FilterModel[E]]
      },
      new CompareToStringConvert[E] {
        override val strCv = strCv1
        override val optStrCv = optStrCv1
      }
    )
  }

} 

//设置package包名称以及导入依赖的类
package net.scalax.fsn.parameter.atomic

import io.circe.{ Decoder, HCursor }
import io.circe.generic.auto._

sealed trait FParam[T] {
  def data: T
  def paramComp: FCompAbs
}

object FParam {

  implicit def decodeFParam[T](implicit decoder: Decoder[T]): Decoder[FParam[T]] = new Decoder[FParam[T]] {
    final def apply(c: HCursor): Decoder.Result[FParam[T]] = {
      c.as[FInParam[T]]
    }
  }