//设置package包名称以及导入依赖的类
package us.illyohs.sinked.helper

import java.io.{File, FileWriter, IOException, Writer}
import java.util

import com.google.gson.{FieldNamingPolicy, Gson, GsonBuilder}
import org.spongepowered.api.Sponge
import us.illyohs.sinked.Sinked
import us.illyohs.sinked.channel.Channel

object ChannelHelper {

  val chanList:util.List[Channel] = new  util.ArrayList[Channel]()

  val sinked:Sinked = null
  val channelPath = "./channels/"

  val channelDir = new File(channelPath)

  def initChannel: Unit = {
    chanList.add(new GlobalChannel)
    chanList.add(new LocalChannel)
    if (!channelDir.exists()) {
      //      sinked.getLogger.warn("Channel directory not found!")
      //      sinked.getLogger.info("Now creating channel directory")

      channelDir.mkdir()
      val gson: Gson = new GsonBuilder()
        .setPrettyPrinting()
        .serializeNulls()
        .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
        .create()
      for (i <- 0 to 1) {
        val ch = chanList.get(i)
        val json = gson.toJson(ch)
        val w: Writer = new FileWriter(channelPath + ch.getName + ".json")
        try {
          w.write(json)
          w.close()
          //          sinked.getLogger.info("Created default channel: " +ch.getName)
        } catch {
          case e: IOException => e.printStackTrace()
        }
      }
      //      createDefualtjons
    }
  }


  case class GlobalChannel() extends Channel("Global", "", "G", "", "", false, true, false, false, true)
  case class LocalChannel() extends Channel("Local", "", "L", "", "", false, true, false, false, false)
} 

//设置package包名称以及导入依赖的类
package controllers

  import java.io.{StringWriter, Writer}

  import com.github.tototoshi.csv.CSVWriter
  import org.intracer.wmua.{ImageWithRating, Round, User}

  object Csv {

    def writeStringBuffer(data: Seq[Seq[Any]]): StringBuffer = {
      val writer = new StringWriter()
      write(data, writer)
      writer.getBuffer
    }

    def writeRow(data: Seq[Any]): String = {
      val writer = new StringWriter()
      val csv = CSVWriter.open(writer)
      csv.writeRow(data)
      csv.close()
      writer.getBuffer.toString
    }

    def write(data: Seq[Seq[Any]], writer: Writer): Unit = {
      val csv = CSVWriter.open(writer)
      csv.writeAll(data)
      csv.close()
    }

    def exportRates(files: Seq[ImageWithRating], jurors: Seq[User], round: Round): Seq[Seq[String]] = {
      val header = Seq("Rank", "File", "Overall") ++ jurors.map(_.fullname)

      val ranks = ImageWithRating.rankImages(files, round)
      val rows = for ((file, rank) <- files.zip(ranks))
        yield Seq(rank, file.image.title, file.rateString(round)) ++ jurors.map(file.jurorRateStr)

      header +: rows
    }

    def addBom(data: Seq[Seq[String]]): Seq[Seq[String]] = {
      val BOM = "\ufeff"
      val header = data.head
      val headerWithBom = (BOM + header.head) +: header.tail
      headerWithBom +: data.tail
    }
  } 

//设置package包名称以及导入依赖的类
package pl.mojepanstwo.sap.toakoma

import java.io.{FileWriter, Writer}

import com.github.tototoshi.csv._

import scala.reflect.runtime.{universe => ru}
import scala.io.Source

case class Config(header: String = "#",
                  delimiter: Char = defaultCSVFormat.delimiter,
                  quoteChar: Char = defaultCSVFormat.quoteChar,
                  treatEmptyLineAsNil: Boolean = defaultCSVFormat.treatEmptyLineAsNil,
                  escapeChar: Char = defaultCSVFormat.escapeChar,
                  lineTerminator: String = defaultCSVFormat.lineTerminator,
                  quoting: Quoting = defaultCSVFormat.quoting) extends CSVFormat

object ObjectCSV {
  def apply(config: Config = new Config()) = new ObjectCSV(config)
}

protected class ObjectCSV(config: Config) {

  def readCSV[T: ru.TypeTag](resPath: String): IndexedSeq[T] = {
    val objectConverter = new ObjectConverter
    val csvReader = CSVReader.open(Source.fromResource(resPath))(config)
    val data = csvReader.all()
    val header = data.head
    if (!header.head.startsWith(config.header)) {
      throw new Exception("Expected a commented out header. Found: " + header)
    }
    val headerWithoutComments = Array(header.head.substring(1)) ++ header.tail
    val objects = data.view.tail.map(row => objectConverter.toObject[T](row, headerWithoutComments))
    objects.toVector
  }
} 

//设置package包名称以及导入依赖的类
package com.github.madoc.create_sbt_project.io

import java.io.Writer

import com.github.madoc.create_sbt_project.io.Write.{StringEscapedWrite, WithLineSeparatedByDoubleLineBreaksWrite}

trait Write {
  def apply(str:String):Write
  def apply(ch:Char):Write = apply(ch toString)
  def apply[A](the:A)(implicit output:Output[A]):Write = {output(the)(this); this}
  def line(str:String):Write = apply(str).lineBreak()
  def lineBreak():Write = apply('\n')

  def inQuotes[U](f:Write?U):Write = {apply('"'); f(this); apply('"')}
  def stringEscaped:Write = new StringEscapedWrite(this)
  def withLinesSeparatedByDoubleLineBreaks:Write = new WithLineSeparatedByDoubleLineBreaksWrite(this)

  def asJavaIOWriter:Writer = {
    val self = this
    new Writer() {
      def write(cbuf:Array[Char], off:Int, len:Int) {self(new String(cbuf, off, len))}
      def flush() {}
      def close() {}
    }
  }
}
object Write {
  class WriteToAppendable(appendable:Appendable) extends Write {
    def apply(str:String) = {appendable append str; this}
    override def apply(ch:Char) = {appendable append ch; this}
  }

  class StringEscapedWrite(writeUnescaped:Write) extends Write {
    def apply(str:String) = {str foreach apply; this}
    override def apply(ch:Char) = {ch match {
      case '\n' ? writeUnescaped("\\n"); case '\r' ? writeUnescaped("\\r"); case '\t' ? writeUnescaped("\\t")
      case '\\' ? writeUnescaped("\\\\"); case '"' ? writeUnescaped("\\\""); case _ ? writeUnescaped(ch)
    }; this}
  }

  class WithLineSeparatedByDoubleLineBreaksWrite(writeNormal:Write) extends Write {
    private var isRightAfterLineBreak = false
    def apply(str:String) = {str foreach apply; this}
    override def apply(ch:Char) =
      if(ch=='\n') {isRightAfterLineBreak=true; writeNormal(ch); this}
      else {
        if(isRightAfterLineBreak) {writeNormal('\n'); isRightAfterLineBreak=false}
        writeNormal(ch); this
      }
  }
} 

//设置package包名称以及导入依赖的类
import java.io.Writer

import scala.io.Source

object Using {
  def apply[A, B](resource: A)(process: A => B)(implicit closer: Closer[A]): B =
    try {
      process(resource)
    } finally {
      closer.close(resource)
    }
}

case class Closer[-A](close: A => Unit)

object Closer {
  implicit val sourceCloser: Closer[Source] = Closer(_.close())
  implicit val writerCloser: Closer[Writer] = Closer(_.close())
} 

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

import java.io.{BufferedWriter, File, FileWriter, Writer}

trait WriteSupport {

  def withWriter(path: String)(f: Writer => Unit): Unit ={
    var writer: Writer = null
    try {
      val file = new File(path)
      if (!file.exists()) file.createNewFile()
      writer = new BufferedWriter(new FileWriter(file))
      f(writer)
      writer.flush()
    } finally {
      if (writer != null) writer.close()
    }
  }
} 

//设置package包名称以及导入依赖的类
package mjis

import java.io.Writer

trait Finding {
  def pos: Position
  def severity: Severity
  def msg: String

  override def toString = s"$pos $severity: $msg"
}

object Finding {
  def printAll(findings: Seq[Finding], sourceLines: Iterable[String], writer: Writer): Unit = {
    var curLine = 1
    var curSourceLines = sourceLines
    findings sortBy (_.pos) foreach (f => {
      writer.write(f.toString)
      writer.write(System.lineSeparator)
      if (f.pos.line >= 1) {
        curSourceLines = curSourceLines.drop(f.pos.line - curLine)
        curLine = f.pos.line
        curSourceLines.headOption match {
          case Some(lineContents) =>
            writer.write(f.pos.longString(lineContents))
            writer.write(System.lineSeparator)
          case _ =>
        }
      }
    })
  }
} 

//设置package包名称以及导入依赖的类
package de.aquanauten.insights

import java.io.{BufferedWriter, File, FileWriter, Writer}

object ResultWriter {

  def writeFile(fileName: String)(writeFn: Writer => Unit): Unit = {
    val file = new File(fileName)
    file.getParentFile.mkdirs()
    val writer = new BufferedWriter(new FileWriter(file))
    try {writeFn(writer)} finally {writer.close()}
  }

  def writeDependencies(packageFile: String, packageDependencies: Dependencies): Unit = {
    // write dot file
    writeFile(packageFile + ".dot") (_.write(Rendering.render(packageDependencies)(DotRendering.DependencyRendering)))
    // write plantuml file
    writeFile(packageFile + ".puml") (_.write(Rendering.render(packageDependencies)(PlantUMLRendering.DependencyRendering)))
    // write json file
    writeFile(packageFile + ".json") (_.write(Rendering.render(packageDependencies)(JsonRendering.DependencyRendering)))
  }

  def writeClasses(targetDir: String, classFile: String, compileUnit: CompileUnit): Unit = {
    // global view
    writeFile(s"$targetDir/$classFile.json") { _.write(JsonRendering.render(compileUnit)) }
    writeFile(s"$targetDir/$classFile.puml") { _.write(PlantUMLRendering.render(compileUnit)) }

    // per package view
    compileUnit.classes.groupBy(_.packageName).foreach { case (packageName, classes) =>
      writeFile(s"$targetDir/package/puml/$packageName.puml")(_.write(PlantUMLRendering.render(CompileUnit(classes))))
    }
  }
} 

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

import java.io.{ BufferedWriter, ByteArrayOutputStream, OutputStreamWriter, StringWriter, Writer }
import java.nio.ByteBuffer


package object jackson extends WithJacksonMapper with JacksonParser with JacksonCompat {

  private[this] def writeJson(w: Writer, j: Json): Unit = {
    val gen = jsonGenerator(w)
    makeWriter(mapper).writeValue(gen, j)
    w.flush()
  }

  final def jacksonPrint(json: Json): String = {
    val sw = new StringWriter
    writeJson(sw, json)
    sw.toString
  }

  private[this] class EnhancedByteArrayOutputStream extends ByteArrayOutputStream {
    def toByteBuffer: ByteBuffer = ByteBuffer.wrap(this.buf, 0, this.size)
  }

  final def jacksonPrintByteBuffer(json: Json): ByteBuffer = {
    val bytes = new EnhancedByteArrayOutputStream
    writeJson(new BufferedWriter(new OutputStreamWriter(bytes, "UTF-8")), json)
    bytes.toByteBuffer
  }
} 

//设置package包名称以及导入依赖的类
package com.hypertino.hyperbus.model

import java.io.{Reader, Writer}

import com.hypertino.binders.json.JsonBindersFactory
import com.hypertino.binders.value.{Obj, Value}
import com.hypertino.hyperbus.serialization.{ResponseDeserializer, SerializationOptions}

trait DynamicBody extends Body {
  def content: Value

  def serialize(writer: Writer)(implicit so: SerializationOptions): Unit = {
    import com.hypertino.binders.json.JsonBinders._
    import so._
    content.writeJson(writer)
  }

  def copy(
            contentType: Option[String] = this.contentType,
            content: Value = this.content
          ): DynamicBody = {
    DynamicBody(content, contentType)
  }
}

object DynamicBody {
  def apply(content: Value, contentType: Option[String]): DynamicBody = DynamicBodyContainer(contentType, content)

  def apply(content: Value): DynamicBody = DynamicBodyContainer(None, content)

  def apply(reader: Reader, contentType: Option[String]): DynamicBody = {
    JsonBindersFactory.findFactory().withReader(reader) { deserializer =>
      apply(deserializer.unbind[Value], contentType)
    }
  }

  def unapply(dynamicBody: DynamicBody) = Some((dynamicBody.contentType, dynamicBody.content))
}

private[model] case class DynamicBodyContainer(contentType: Option[String], content: Value) extends DynamicBody 

//设置package包名称以及导入依赖的类
package com.hypertino.hyperbus.model

import java.io.{Reader, Writer}

import com.hypertino.binders.value._
import com.hypertino.hyperbus.serialization.{DeserializeException, SerializationOptions}

trait EmptyBody extends DynamicBody {
  override def serialize(writer: Writer)(implicit so: SerializationOptions): Unit = writer.write("{}")
}

case object EmptyBody extends EmptyBody {
  def contentType: Option[String] = None
  def content = Null
  def apply(reader: Reader, contentType: Option[String]): EmptyBody = {
    val body = DynamicBody.apply(reader, contentType)
    if (body.content.isEmpty)
      EmptyBody
    else {
      throw DeserializeException(s"EmptyBody is expected, but got: '${body.content}'")
    }
  }
} 

//设置package包名称以及导入依赖的类
package fr.hmil.roshttp.tools.io

import java.io.{ByteArrayOutputStream, OutputStream, Writer, _}

import scala.annotation.tailrec
import scala.reflect.ClassTag


  def pipe(in: Reader, out: Writer): Unit = {
    val buffer = newBuffer[Char]

    @tailrec
    def loop(): Unit = {
      val size = in.read(buffer)
      if (size > 0) {
        out.write(buffer, 0, size)
        loop()
      }
    }
    loop()
  }

  @inline
  private def newBuffer[T: ClassTag] = new Array[T](4096)
} 

//设置package包名称以及导入依赖的类
package com.lonelyplanet.prometheus.api

import java.io.{StringWriter, Writer}
import java.util

import akka.http.scaladsl.marshalling.{ToEntityMarshaller, Marshaller}
import akka.http.scaladsl.model._
import io.prometheus.client.Collector.MetricFamilySamples
import io.prometheus.client.CollectorRegistry
import io.prometheus.client.exporter.common.TextFormat

case class MetricFamilySamplesEntity(samples: util.Enumeration[MetricFamilySamples])

object MetricFamilySamplesEntity {
  private val mediaTypeParams = Map("version" -> "0.0.4")
  private val mediaType = MediaType.customWithFixedCharset("text", "plain", HttpCharsets.`UTF-8`, params = mediaTypeParams)

  def fromRegistry(collectorRegistry: CollectorRegistry): MetricFamilySamplesEntity = {
    MetricFamilySamplesEntity(collectorRegistry.metricFamilySamples())
  }

  def toPrometheusTextFormat(e: MetricFamilySamplesEntity): String = {
    val writer: Writer = new StringWriter()
    TextFormat.write004(writer, e.samples)

    writer.toString
  }

  implicit val metricsFamilySamplesMarshaller: ToEntityMarshaller[MetricFamilySamplesEntity] = {
    Marshaller.withFixedContentType(mediaType) { s =>
      HttpEntity(mediaType, toPrometheusTextFormat(s))
    }
  }

} 

//设置package包名称以及导入依赖的类
package lp.template.common

import java.io.{PrintWriter, StringWriter, Writer}


object Apps {
  def getExceptionDetails(e: Throwable): String = {
    val stackTrace: String = getStackTrace(e)
    val s: String = "Exception details:%n  %s".format(stackTrace)

    // Remove trailing newline.
    s.trim
  }

  def getStackTrace(e: Throwable): String = {
    val sw: Writer = new StringWriter
    val pw: PrintWriter = new PrintWriter(sw)
    e.printStackTrace(pw)
    sw.toString
  }
} 

//设置package包名称以及导入依赖的类
package controllers

import java.io.{StringWriter, Writer}

import com.github.tototoshi.csv.CSVWriter
import org.intracer.finance.{Dictionary, Operation}

object Csv {

  def writeStringBuffer(data: Seq[Seq[Any]]): StringBuffer = {
    val writer = new StringWriter()
    write(data, writer)
    writer.getBuffer
  }

  def writeRow(data: Seq[Any]): String = {
    val writer = new StringWriter()
    val csv = CSVWriter.open(writer)
    csv.writeRow(data)
    csv.close()
    writer.getBuffer.toString
  }

  def write(data: Seq[Seq[Any]], writer: Writer): Unit = {
    val csv = CSVWriter.open(writer)
    csv.writeAll(data)
    csv.close()
  }

  def exportOperations(operations: Seq[Operation]): Seq[Seq[String]] = {
    val header = Seq("Date", "Project", "Category", "Grant", "GrantItem", "Amount", "Account", "Description")

    val rows = operations.map { o =>
      Seq(
        o.date.toString.substring(0, 10),
        o.to.projectName,
        o.to.categoryName,
        o.to.grantName,
        o.to.grantItem.map(_.name).getOrElse(""),
        o.amount.map(_.toString).getOrElse(""),
        o.to.account.name,
        o.to.description
      )
    }

    header +: rows
  }

  def addBom(data: Seq[Seq[String]]): Seq[Seq[String]] = {
    val BOM = "\ufeff"
    val header = data.head
    val headerWithBom = (BOM + header.head) +: header.tail
    headerWithBom +: data.tail
  }
} 

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

import java.io.Reader
import java.io.Writer

import org.xml.sax.{XMLReader, Attributes, InputSource}
import org.xml.sax.helpers.XMLReaderFactory

import org.dom4j.io.XMLWriter


object Starscream {
  private implicit class FilterChain(val reader: XMLReader) {
    def chain(newReader: XMLReader => XMLReader): FilterChain =
      new FilterChain(newReader(reader))
  }

  def transformSVGFromReaderToWriter(
      reader: Reader,
      writer: Writer,
      scale:Float = 1.0f,
      minimum:Float = Float.MinValue)
      : Unit = {
    val filter =
      XMLReaderFactory.createXMLReader()
        .chain(new ScaleFilter(_, scale))
        .chain(new MinimumFilter(_, minimum))
        .chain(new StripWhitespaceFilter(_, "id"))
        .chain(new StripWhitespaceFilter(_, "href"))
        .reader
    val xmlWriter = new XMLWriter(writer)
    filter.setContentHandler(xmlWriter)
    filter.parse(new InputSource(reader))
  }
} 

//设置package包名称以及导入依赖的类
package com.hypertino.binders.json

import java.io.{Reader, Writer}

import com.hypertino.binders.core.{BindOptions, Deserializer, Serializer}
import com.hypertino.binders.json.api.{JsonBindersFactoryApi, JsonGeneratorApi, JsonParserApi}
import com.hypertino.inflector.naming.{Converter, PlainConverter}

import scala.scalajs.js
import scala.scalajs.js.JSON

trait JsonBindersFactory[C <: Converter, S <: Serializer[C], D <: Deserializer[C]]
  extends JsonBindersFactoryApi[C, S, D] {

  override def withStringParser[T](jsonString: String)
                                  (codeBlock: D ? T)
                                  (implicit bindOptions: BindOptions): T = {
    val adapter = new JsParserAdapter(JSON.parse(jsonString))
    val jds = createDeserializer(adapter)
    codeBlock(jds)
  }

  override def withReader[T](reader: Reader)
                            (codeBlock: (D) ? T)
                            (implicit bindOptions: BindOptions): T = {
    val stringBuilder = new StringBuilder
    val len = 256
    val buffer = new Array[Char](len)
    var readed = len
    while (readed == len) {
      readed = reader.read(buffer, 0, len)
      stringBuilder.append(buffer, 0, readed)
    }
    withStringParser(stringBuilder.toString())(codeBlock)
  }

  def withJsonObjectParser[T](jsonObject: js.Dynamic)
                             (codeBlock: D ? T)
                             (implicit bindOptions: BindOptions): T = {
    withJsonParserApi(new JsParserAdapter(jsonObject))(codeBlock)
  }

  override def withWriter(writer: Writer)
                         (codeBlock: S ? Unit)
                         (implicit bindOptions: BindOptions): Unit = {
    withJsonGeneratorApi(new JsGeneratorAdapter(writer))(codeBlock)
  }
}

object JsonBindersFactory {
  implicit val defaultJsonBindersFactory = new DefaultJsonBindersFactory[PlainConverter.type]
  def findFactory[C <: Converter, S <: Serializer[C], D <: Deserializer[C]]()
    (implicit factory: JsonBindersFactory[C, S, D]): JsonBindersFactory[C, S, D] = factory
} 

//设置package包名称以及导入依赖的类
package com.hypertino.binders.json.api

import java.io.{Reader, StringReader, StringWriter, Writer}

import com.hypertino.binders.core.{BindOptions, Deserializer, Serializer}
import com.hypertino.inflector.naming.Converter

trait JsonBindersFactoryApi[C <: Converter, S <: Serializer[C], D <: Deserializer[C]] {
  def createSerializer(jsonGenerator: JsonGeneratorApi)(implicit bindOptions: BindOptions): S
  def createDeserializer(jsonParser: JsonParserApi)(implicit bindOptions: BindOptions): D
  def prettyPrint: Boolean = false

  def withStringParser[T](jsonString: String)(codeBlock: D ? T)(implicit bindOptions: BindOptions): T  = {
    val reader = new StringReader(jsonString)
    try {
      withReader[T](reader)(codeBlock)
    } finally {
      reader.close()
    }
  }

  def withStringGenerator(codeBlock: S ? Unit)(implicit bindOptions: BindOptions): String = {
    val writer = new StringWriter()
    try {
      withWriter(writer)(codeBlock)
    } finally {
      writer.close()
    }
    writer.toString
  }

  def withJsonParserApi[T](jsonParserApi: JsonParserApi)(codeBlock: D ? T)(implicit bindOptions: BindOptions): T = {
    val jds = createDeserializer(jsonParserApi)
    codeBlock(jds)
  }

  def withJsonGeneratorApi(jsonGeneratorApi: JsonGeneratorApi)(codeBlock: S ? Unit)(implicit bindOptions: BindOptions): Unit = {
    val js = createSerializer(jsonGeneratorApi)
    codeBlock(js)
  }

  def withReader[T](reader: Reader)(codeBlock: D ? T)(implicit bindOptions: BindOptions): T

  def withWriter(writer: Writer)(codeBlock: S ? Unit)(implicit bindOptions: BindOptions): Unit
}