progress.scala: Miscellaneous WIP.

[tripe-android] / util.scala

/* -*-scala-*-
 *
 * Miscellaneous utilities
 *
 * (c) 2018 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the Trivial IP Encryption (TrIPE) Android app.
 *
 * TrIPE is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 of the License, or (at your
 * option) any later version.
 *
 * TrIPE is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with TrIPE.  If not, see <https://www.gnu.org/licenses/>.
 */

package uk.org.distorted; package object tripe {

/*----- Imports -----------------------------------------------------------*/

import scala.concurrent.duration.{Deadline, Duration};
import scala.util.control.{Breaks, ControlThrowable};

import java.io.{BufferedReader, Closeable, File, InputStream, Reader};
import java.net.{URL, URLConnection};
import java.nio.{ByteBuffer, CharBuffer};
import java.nio.charset.Charset;
import java.util.concurrent.locks.{Lock, ReentrantLock};

/*----- Miscellaneous useful things ---------------------------------------*/

val rng = new java.security.SecureRandom;

def unreachable(msg: String): Nothing = throw new AssertionError(msg);
def unreachable(): Nothing = unreachable("unreachable");
final val ok = ();
final class Brand;

/*----- Various pieces of implicit magic ----------------------------------*/

class InvalidCStringException(msg: String) extends Exception(msg);

object Implicits {

  /* --- Syntactic sugar for locks --- */

  implicit class LockOps(lk: Lock) {
    /* LK withLock { BODY }
     * LK.withLock(INTERRUPT) { BODY }
     * LK.withLock(DUR, [INTERRUPT]) { BODY } orElse { ALT }
     * LK.withLock(DL, [INTERRUPT]) { BODY } orElse { ALT }
     *
     * Acquire a lock while executing a BODY.  If a duration or deadline is
     * given then wait so long for the lock, and then give up and run ALT
     * instead.
     */

    def withLock[T](dur: Duration, interrupt: Boolean)
		   (body: => T): PendingLock[T] =
      new PendingLock(lk, if (dur > Duration.Zero) dur else Duration.Zero,
		      interrupt, body);
    def withLock[T](dur: Duration)(body: => T): PendingLock[T] =
      withLock(dur, true)(body);
    def withLock[T](dl: Deadline, interrupt: Boolean)
		   (body: => T): PendingLock[T] =
      new PendingLock(lk, dl.timeLeft, interrupt, body);
    def withLock[T](dl: Deadline)(body: => T): PendingLock[T] =
      withLock(dl, true)(body);
    def withLock[T](interrupt: Boolean)(body: => T): T = {
      if (interrupt) lk.lockInterruptibly();
      else lk.lock();
      try { body; } finally lk.unlock();
    }
    def withLock[T](body: => T): T = withLock(true)(body);
  }

  class PendingLock[T] private[Implicits]
	  (val lk: Lock, val dur: Duration,
	   val interrupt: Boolean, body: => T) {
    /* An auxiliary class for LockOps; provides the `orElse' qualifier. */

    def orElse(alt: => T): T = {
      val locked = (dur, interrupt) match {
	case (Duration.Inf, true) => lk.lockInterruptibly(); true
	case (Duration.Inf, false) => lk.lock(); true
	case (Duration.Zero, false) => lk.tryLock()
	case (_, true) => lk.tryLock(dur.length, dur.unit)
	case _ => unreachable("timed wait is always interruptible");
      }
      if (!locked) alt;
      else try { body; } finally lk.unlock();
    }
  }
}

/*----- Cleanup assistant -------------------------------------------------*/

class Cleaner {
  /* A helper class for avoiding deep nests of `try'/`finally'.
   *
   * Make a `Cleaner' instance CL at the start of your operation.  Apply it
   * to blocks of code -- as CL { ACTION } -- as you proceed, to accumulate
   * cleanup actions.   Finally, call CL.cleanup() to invoke the accumulated
   * actions, in reverse order.
   */

  var cleanups: List[() => Unit] = Nil;
  def apply(cleanup: => Unit) { cleanups +:= { () => cleanup; } }
  def cleanup() { cleanups foreach { _() } }
}

def withCleaner[T](body: Cleaner => T): T = {
  /* An easier way to use the `Cleaner' class.  Just
   *
   *	withCleaner { CL => BODY }
   *
   * The BODY can attach cleanup actions to the cleaner CL by saying
   * CL { ACTION } as usual.  When the BODY exits, normally or otherwise, the
   * cleanup actions are invoked in reverse order.
   */

  val cleaner = new Cleaner;
  try { body(cleaner) }
  finally { cleaner.cleanup(); }
}

def closing[T, U <: Closeable](thing: U)(body: U => T): T =
  try { body(thing) }
  finally { thing.close(); }

/*----- Control structures ------------------------------------------------*/

private case class ExitBlock[T](brand: Brand, result: T)
	extends ControlThrowable;

def block[T](body: (T => Nothing) => T): T = {
  /* block { exit[T] => ...; exit(x); ... }
   *
   * Execute the body until it calls the `exit' function or finishes.
   * Annoyingly, Scala isn't clever enough to infer the return type, so
   * you'll have to write it explicitly.
   */

  val mybrand = new Brand;
  try { body { result => throw new ExitBlock(mybrand, result) } }
  catch {
    case ExitBlock(brand, result) if brand eq mybrand =>
      result.asInstanceOf[T]
  }
}

def blockUnit(body: (=> Nothing) => Unit) {
  /* blockUnit { exit => ...; exit; ... }
   *
   * Like `block'; it just saves you having to write `exit[Unit] => ...;
   * exit(ok); ...'.
   */

  val mybrand = new Brand;
  try { body { throw new ExitBlock(mybrand, null) }; }
  catch { case ExitBlock(brand, result) if brand eq mybrand => ok; }
}

def loop[T](body: (T => Nothing) => Unit): T = {
  /* loop { exit[T] => ...; exit(x); ... }
   *
   * Repeatedly execute the body until it calls the `exit' function.
   * Annoyingly, Scala isn't clever enough to infer the return type, so
   * you'll have to write it explicitly.
   */

  block { exit => while (true) body(exit); unreachable }
}

def loopUnit(body: (=> Nothing) => Unit): Unit = {
  /* loopUnit { exit => ...; exit; ... }
   *
   * Like `loop'; it just saves you having to write `exit[Unit] => ...;
   * exit(()); ...'.
   */

  blockUnit { exit => while (true) body(exit); }
}

val BREAKS = new Breaks;
import BREAKS.{breakable, break};

/*----- A gadget for fetching URLs ----------------------------------------*/

class URLFetchException(msg: String) extends Exception(msg);

trait URLFetchCallbacks {
  def preflight(conn: URLConnection) { }
  def write(buf: Array[Byte], n: Int, len: Long): Unit;
  def done(win: Boolean) { }
}

def fetchURL(url: URL, cb: URLFetchCallbacks) {
  /* Fetch the URL, feeding the data through the callbacks CB. */

  withCleaner { clean =>
    var win: Boolean = false;
    clean { cb.done(win); }

    /* Set up the connection, and run a preflight check. */
    val c = url.openConnection();
    cb.preflight(c);

    /* Start fetching data. */
    val in = c.getInputStream; clean { in.close(); }
    val explen = c.getContentLength;

    /* Read a buffer at a time, and give it to the callback.  Maintain a
     * running total.
     */
    var len: Long = 0;
    blockUnit { exit =>
      for ((buf, n) <- blocks(in)) {
	cb.write(buf, n, len);
	len += n;
	if (explen != -1 && len > explen) exit;
      }
    }

    /* I can't find it documented anywhere that the existing machinery
     * checks the received stream against the advertised content length.
     * It doesn't hurt to check again, anyway.
     */
    if (explen != -1 && explen != len) {
      throw new URLFetchException(
	s"received $len /= $explen bytes from `$url'");
    }

    /* Glorious success is ours. */
    win = true;
  }
}

/*----- Threading things --------------------------------------------------*/

def thread[T](name: String, run: Boolean = true, daemon: Boolean = true)
	     (f: => T): Thread = {
  /* Make a thread with a given name, and maybe start running it. */

  val t = new Thread(new Runnable { def run() { f; } }, name);
  if (daemon) t.setDaemon(true);
  if (run) t.start();
  t
}

/*----- Quoting and parsing tokens ----------------------------------------*/

def quoteTokens(v: Seq[String]): String = {
  /* Return a string representing the token sequence V.
   *
   * The tokens are quoted as necessary.
   */

  val b = new StringBuilder;
  var sep = false;
  for (s <- v) {

    /* If this isn't the first word, then write a separating space. */
    if (!sep) sep = true;
    else b += ' ';

    /* Decide how to handle this token. */
    if (s.length > 0 &&
	(s forall { ch => (ch != ''' && ch != '"' && ch != '\\' &&
			   !ch.isWhitespace) })) {
      /* If this word is nonempty and contains no problematic characters,
       * we can write it literally.
       */

      b ++= s;
    } else {
      /* Otherwise, we shall have to do this the hard way.  We could be
       * cleverer about this, but it's not worth the effort.
       */

      b += '"';
      s foreach { ch =>
	if (ch == '"' || ch == '\\') b += '\\';
	b += ch;
      }
      b += '"';
    }
  }
  b.result
}

class InvalidQuotingException(msg: String) extends Exception(msg);

def nextToken(s: String, pos: Int = 0): Option[(String, Int)] = {
  /* Parse the next token from a string S.
   *
   * If there is a token in S starting at or after index POS, then return
   * it, and the index for the following token; otherwise return `None'.
   */

  val b = new StringBuilder;
  val n = s.length;
  var i = pos;
  var q = 0;

  /* Skip whitespace while we find the next token. */
  while (i < n && s(i).isWhitespace) i += 1;

  /* Maybe there just isn't anything to find. */
  if (i >= n) return None;

  /* There is something there.  Unpick the quoting and escaping. */
  while (i < n && (q != 0 || !s(i).isWhitespace)) {
    s(i) match {
      case '\\' =>
	if (i + 1 >= n) throw new InvalidQuotingException("trailing `\\'");
	b += s(i + 1); i += 2;
      case ch@('"' | ''') =>
	if (q == 0) q = ch;
	else if (q == ch) q = 0;
	else b += ch;
	i += 1;
      case ch =>
	b += ch;
	i += 1;
    }
  }

  /* Check that the quoting was valid. */
  if (q != 0) throw new InvalidQuotingException(s"unmatched `$q'");

  /* Skip whitespace before the next token. */
  while (i < n && s(i).isWhitespace) i += 1;

  /* We're done. */
  Some((b.result, i))
}

def splitTokens(s: String, pos: Int = 0): Seq[String] = {
  /* Return all of the tokens in string S into tokens, starting at POS. */

  val b = List.newBuilder[String];
  var i = pos;

  loopUnit { exit => nextToken(s, i) match {
    case Some((w, j)) => b += w; i = j;
    case None => exit;
  } }
  b.result
}

/*----- Other random things -----------------------------------------------*/

trait LookaheadIterator[T] extends BufferedIterator[T] {
  /* An iterator in terms of a single `maybe there's another item' function.
   *
   * It seems like every time I write an iterator in Scala, the only way to
   * find out whether there's a next item, for `hasNext', is to actually try
   * to fetch it.  So here's an iterator in terms of a function which goes
   * off and maybe returns a next thing.  It turns out to be easy to satisfy
   * the additional requirements for `BufferedIterator', so why not?
   */

  /* Subclass responsibility. */
  protected def fetch(): Option[T];

  /* The machinery.  `st' is `None' if there's no current item, null if we've
   * actually hit the end, or `Some(x)' if the current item is x.
   */
  private[this] var st: Option[T] = None;
  private[this] def peek() {
    /* Arrange to have a current item. */
    if (st == None) fetch() match {
      case None => st = null;
      case x@Some(_) => st = x;
    }
  }

  /* The `BufferedIterator' protocol. */
  override def hasNext: Boolean = { peek(); st != null }
  override def head: T =
    { peek(); if (st == null) throw new NoSuchElementException; st.get }
  override def next(): T = { val it = head; st = None; it }
}

def bufferedReader(r: Reader): BufferedReader = r match {
  case br: BufferedReader => br
  case _ => new BufferedReader(r)
}

def lines(r: BufferedReader): BufferedIterator[String] =
  new LookaheadIterator[String] {
    /* Iterates over the lines of text in a `Reader' object. */
    override protected def fetch() = Option(r.readLine());
  }
def lines(r: Reader): BufferedIterator[String] = lines(bufferedReader(r));

def blocks(in: InputStream, blksz: Int):
	BufferedIterator[(Array[Byte], Int)] =
  /* Iterates over (possibly irregularly sized) blocks in a stream. */
  new LookaheadIterator[(Array[Byte], Int)] {
    val buf = new Array[Byte](blksz)
    override protected def fetch() = {
      val n = in.read(buf);
      if (n < 0) None
      else Some((buf, n))
    }
  }
def blocks(in: InputStream):
	BufferedIterator[(Array[Byte], Int)] = blocks(in, 4096);

def blocks(in: BufferedReader, blksz: Int):
	BufferedIterator[(Array[Char], Int)] =
  /* Iterates over (possibly irregularly sized) blocks in a reader. */
  new LookaheadIterator[(Array[Char], Int)] {
    val buf = new Array[Char](blksz)
    override protected def fetch() = {
      val n = in.read(buf);
      if (n < 0) None
      else Some((buf, n))
    }
  }
def blocks(in: BufferedReader):
	BufferedIterator[(Array[Char], Int)] = blocks(in, 4096);
def blocks(r: Reader, blksz: Int): BufferedIterator[(Array[Char], Int)] =
  blocks(bufferedReader(r), blksz);
def blocks(r: Reader): BufferedIterator[(Array[Char], Int)] =
  blocks(bufferedReader(r));

def oxford(conj: String, things: Seq[String]): String = things match {
  case Seq() => "<nothing>"
  case Seq(a) => a
  case Seq(a, b) => s"$a $conj $b"
  case Seq(a, tail@_*) =>
    val sb = new StringBuilder;
    sb ++= a; sb ++= ", ";
    def iter(rest: Seq[String]) {
      rest match {
	case Seq() => unreachable;
	case Seq(a) => sb ++= conj; sb += ' '; sb ++= a;
	case Seq(a, tail@_*) => sb ++= a; sb ++= ", "; iter(tail);
      }
    }
    iter(tail);
    sb.result
}

/*----- That's all, folks -------------------------------------------------*/

}