//设置package包名称以及导入依赖的类
package com.dbrsn.datatrain.file

import java.io.File

import cats.~>
import com.dbrsn.datatrain.dsl.FsComponent
import com.dbrsn.datatrain.model.ContentMetadataKey.ContentLengthMetadata
import com.dbrsn.datatrain.model.ContentMetadataKey.ContentMd5Metadata
import com.dbrsn.datatrain.model.MetadataKey
import com.dbrsn.datatrain.model.MetadataValue
import com.dbrsn.datatrain.util.SystemUtil
import com.google.common.io.Files

import scala.util.Try

trait FileComponent
  extends FsComponent {
  import FsDSL._

  type FileFsDSL[A] = FsDSL[A]

  override type FileExisted = File
  override type FileNotExisted = File
  override type DirExisted = File

  val FileMetadataInterpreter: File => PartialFunction[MetadataKey, Try[MetadataValue]] = (file: File) => PartialFunction {
    case ContentLengthMetadata =>
      Try(ContentLengthMetadata(file.length()))
    case ContentMd5Metadata    =>
      Try(ContentMd5Metadata(SystemUtil.base64Md5(file)))
  }

  class FileInterpreter(metadataInterpreter: File => MetadataKey => Try[MetadataValue]) extends (FileFsDSL ~> Try) {
    override def apply[A](fa: FileFsDSL[A]): Try[A] = fa match {
      case CreateTempDir                =>
        Try(Files.createTempDir())
      case Describe(dir, contentName)   =>
        Try(new File(dir, contentName))
      case DeleteFile(file)             =>
        Try {
          file.delete()
          ()
        }
      case DeleteDir(dir)               =>
        Try {
          dir.delete()
          ()
        }
      case ReadMetadata(file, metadata) =>
        metadataInterpreter(file)(metadata)
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.bwsw.cloudstack.common.curator

import com.bwsw.cloudstack.imp.dao.zookeeper.ZookeeperTestServer
import com.google.common.io.Files
import org.apache.curator.framework.{CuratorFramework, CuratorFrameworkFactory}
import org.apache.curator.retry.ExponentialBackoffRetry
import org.scalatest.{BeforeAndAfterAll, FlatSpec, Matchers}


class CuratorTests extends FlatSpec with Matchers with BeforeAndAfterAll {
  System.getProperty("java.io.tmpdir", "./target/")
  val ZOOKEEPER_PORT = 21810
  var zk: ZookeeperTestServer = null
  implicit var curator: CuratorFramework = null

  override def beforeAll() = {
    zk = new ZookeeperTestServer(ZOOKEEPER_PORT, Files.createTempDir().toString)
    curator = CuratorFrameworkFactory.builder()
      .retryPolicy(new ExponentialBackoffRetry(1000, 3))
      .namespace("tests")
      .connectString(s"127.0.0.1:$ZOOKEEPER_PORT").build()
    curator.start()
  }

  override def afterAll() = {
    curator.close()
    zk.stop
  }

} 

//设置package包名称以及导入依赖的类
package org.ucf.spark.ScalaAST
import scala.tools.nsc._
import io._
import scala.io.Source
import scala.reflect.runtime.{universe =>ru}
import scala.tools.reflect.ToolBox
import com.google.common.io.Files
import java.nio.charset.Charset
import java.io.File
import scala.reflect.internal.util.BatchSourceFile


object CompilerTree extends Global(new Settings()){
  new Run
  def parseToTree(path:String) = {
    val code  = AbstractFile.getFile(path)
    val bfs = new BatchSourceFile(code,code.toCharArray)
    val parser = new syntaxAnalyzer.UnitParser(new CompilationUnit(bfs))
    parser.smartParse()
  }
  def parseToString(path:String) = {
      showRaw(this.parseToTree(path))
  }
  def parseWithMirror(path:String) = {
    val source = Files.toString(new File(path),Charset.forName("UTF-8"))
    val toolBox = ru.runtimeMirror(getClass.getClassLoader).mkToolBox()
    toolBox.parse(source)
  }
  
  def parseWithMirrorTypeCheck(path:String) = {
    val source = Files.toString(new File(path),Charset.forName("UTF-8"))
    val toolBox = ru.runtimeMirror(getClass.getClassLoader).mkToolBox()
    toolBox.typecheck(toolBox.parse(source))
  }
  
  
  
} 

//设置package包名称以及导入依赖的类
package com.kakao.cuesheet.examples.util

import java.io.FileOutputStream

import com.google.common.io.{ByteStreams, Files}

import scala.util.control.NonFatal

object ExampleData {
  lazy val path: String = {
    try {
      val resource = "data.tsv"
      val tmpfile = Files.createTempDir().getAbsolutePath + resource
      val input = getClass.getResourceAsStream(resource)
      val output = new FileOutputStream(tmpfile)
      ByteStreams.copy(input, output)
      input.close()
      output.close()
      tmpfile
    } catch {
      case NonFatal(e) =>
        throw new RuntimeException("Could not copy example data file to temp directory", e)
    }
  }
} 

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

import java.io.File
import scala.concurrent.duration._
import scala.concurrent.Future

import com.google.common.io.Files
import org.eclipse.jgit.api.Git

private[i18n] final class Context(
    gitUrl: String,
    gitFile: String,
    asyncCache: lila.memo.AsyncCache.Builder,
    keys: I18nKeys
) {

  type Contexts = Map[String, String]

  def get: Fu[Contexts] = cache.get

  private val cache = asyncCache.single[Contexts](
    name = "i18n.contexts",
    fetch,
    expireAfter = _.ExpireAfterWrite(1 hour)
  )

  private def parse(text: String): Contexts =
    text.lines.toList.map(_.trim).filter(_.nonEmpty).map(_.split('=')).foldLeft(Map[String, String]()) {
      case (cs, Array(key, text)) if (keySet contains key) => cs + (key -> text)
      case (cs, Array(key, _)) =>
        // logwarn("i18n context skipped key " + key)
        cs
      case (cs, line) if line startsWith "//" => cs
      case (cs, line) =>
        // logwarn("i18n context skipped line " + line.mkString("="))
        cs
    }

  private lazy val keySet: Set[String] = keys.keys.map(_.en()).toSet

  private def fetch: Fu[Contexts] = gitClone map { dir =>
    val filePath = s"${dir.getAbsolutePath}/$gitFile"
    val content = fileContent(new File(filePath))
    dir.delete
    parse(content)
  }

  private def gitClone: Fu[File] = Future {
    val dir = Files.createTempDir
    dir.deleteOnExit
    Git.cloneRepository
      .setURI(gitUrl)
      .setDirectory(dir)
      .setBare(false)
      .call
    dir
  }

  private def fileContent(file: File) =
    scala.io.Source.fromFile(file.getCanonicalPath, "UTF-8").mkString
} 

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

import javax.inject.Inject

import com.google.common.io.Files
import models.{Place, PlaceData}
import play.api.data.Form
import play.api.data.Forms._
import play.api.libs.Files.TemporaryFile
import play.api.libs.json.Json
import play.api.mvc.Controller
import play.api.mvc.MultipartFormData.FilePart
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.commands.WriteResult
import reactivemongo.api.{Cursor, ReadPreference}
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ExecutionContext, Future}

class PlaceDAO @Inject() (val reactiveMongoApi: ReactiveMongoApi)
                         (implicit ec: ExecutionContext)
    extends Controller with MongoController with ReactiveMongoComponents{
  def create(placeData: PlaceData, picture: FilePart[TemporaryFile]): Future[WriteResult] = {
    placesCollection.flatMap(_.insert(Place(placeData.name, placeData.country, placeData.description,
      Files.toByteArray(picture.ref.file))))
  }

  def all(): Future[List[Place]] = placesCollection.flatMap(_.find(Json.obj())
        .cursor[Place](ReadPreference.primaryPreferred).collect[List](Int.MaxValue, Cursor.FailOnError[List[Place]]()))

  def placesCollection: Future[JSONCollection] = database.map(_.collection[JSONCollection]("places"))
}


object PlaceDAO {
  val createPlaceForm = Form(
    mapping(
      "name" -> nonEmptyText,
      "country" -> nonEmptyText,
      "description" -> nonEmptyText
    )(PlaceData.apply)(PlaceData.unapply)
  )
}