/**
 * Simple Sudoku solver.
 * 2010 by Stacy Prowell.
 * http://stacyprowell.com/
 */
package sjp.sudoku
 
/**
 * An exception indicating that the board has no solution.
 * @param msg  A message.
 * @author sprowell
 */
class BadBoardException(msg:String) extends Exception(msg)
 
/**
 * Helper class for search data.
 * @param fails  Number of failures detected so far during the search.
 * @author sprowell
 */
protected class SearchData(var fails:Int = 0)
 
/**
 * A ''board'' holds two items.
 * - The currently known cell values
 * - The set of possible values for each unknown cell
 * 
 * @author sprowell
 */
class Board {
 
  /** Size of board. */
  val N = 9
 
  /** Representation of an unknown cell. */
  val U = ' '
 
  /** Known values in the grid. */
  val known = Array.ofDim[Char](N,N)
  for (i <- 0 until N; j <- 0 until N) known(i)(j) = U
 
  /** Allowed possibilities for each cell. */
  val possible = Array.ofDim[Set[Char]](N,N)
  for (i <- 0 until N; j <- 0 until N) possible(i)(j) = '1' to '9' toSet
 
  /**
   * Generate a string representing the current state of a cell.
   * There are two possiblities.
   * - `(5,4)=9` if the cell value is known
   * - `(5,4) allows {3,9}` if the cell value is now known
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @return  The cell representation.
   */
  def cellToString(row:Int, col:Int) = {
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    (row,col) +
      (known(row)(col) match {
        case U => " allows {" + possible(row)(col).mkString(",") + "}"
        case c => "=" + c
      })
  }
 
  /**
   * Set a cell to the given value.  This also updates the set of possible
   * values for each cell.
   * @param row  The zero-based row.
   * @param col  The zero-based column.
   * @param ch  The character, 0-9.
   * @return  The updated board.
   */
  def set(row:Int, col:Int, ch:Char):Board = {
    /**
     * Tiny local function to exclude a value from the possibilities for
     * a cell.
     * @param rr  The zero-based row.
     * @param cc  The zero-based column.
     * @return  True if the cell is solved, false if it is not.
     * @throws  BadBoardException  There is no longer any viable solution.
     */
    def exclude(rr:Int, cc:Int, ex:Char) = {
      if (possible(rr)(cc) contains ex) {
        possible(rr)(cc) -= ex
        possible(rr)(cc).size match {
          case 0 => throw new BadBoardException(cellToString(rr,cc) +
            " has no possibilities")
          case 1 => true
          case _ => false
        }
      }
      false
    }
 
    // Check the arguments.
    require(row >= 0 && row < N)
    require(col >= 0 && col < N)
    require('1' <= ch && ch <= '9')
 
    // The proposed value must be allowed for the cell.
    if (known(row)(col) != U && known(row)(col) != ch)
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
    if (!possible(row)(col).contains(ch))
      throw new BadBoardException(cellToString(row,col) + " cannot be " + ch)
 
    // Record any cells that get solved along the way.
    var also = List[(Int,Int)]()
 
    // Cannot have same value in row or column.
    for (i <- 0 until N) {
      if (i != col && exclude(row,i,ch)) also = (row,i)::also
      if (i != row && exclude(i,col,ch)) also = (i,col)::also
    } // Exclude in row and column.
 
    // Cannot have same value in block.
    val (brow,bcol) = (row/3*3,col/3*3)
    for (i <- 0 to 2; j <- 0 to 2) {
      val (rr,cc) = (brow+i,bcol+j)
      if (rr != row && cc != col && exclude(rr,cc,ch)) also = (rr,cc)::also
    } // Exclude in block.
 
    // Fix up the cell.  Set known and the set of possibilities.
    known(row)(col) = ch ; possible(row)(col) = Set(ch)
 
    // Done.  Now check to see if we discovered any other values.
    // If so, then set those now, recursively.
    also foreach {
      case (rr,cc) => set(rr,cc,possible(rr)(cc).head)
    } // Set each discovered solved cell.
    this
  }
 
  /**
   * Create a duplicate of this board.
   * @return  An independent clone of this board.
   */
  override def clone = {
    val cl = new Board()
    for (i <- 0 until N; j <- 0 until N) {
      cl.known(i)(j) = known(i)(j)
      cl.possible(i)(j) = possible(i)(j) 
    } // Duplicate known and possible.
    cl
  }
 
  /**
   * Initialize a row.  This is only intended to be used from the
   * companion object's init.  The provided string can be any length;
   * only the first N or fewer characters are used.
   * @param row  The zero-based row.
   * @param vals  A string of the values in that row.
   * @return  The updated board.
   */
  private def init(row:Int, vals:String) = {
    require(row >= 0 && row < N)
    require(vals.length <= N)
    var col = 0
    vals.foreach{ch => if (ch != U) set(row,col,ch) ; col += 1}
    this
  }
 
  // Import used below.
  import java.io.{Writer,FileWriter}
 
  /**
   * Write the board to the given writer.
   * @param writer  The writer to get the output.
   */
  def write(writer:Writer) {
    writer.write(known.map(row => row.mkString("")).mkString("\n"))
    writer.flush()
  }
 
  /**
   * Write the board to the given file.
   * @param file  The file name.
   */
  def write(file:String) {
    write(new FileWriter(file))
  }
 
  /**
   * Pretty-print the board.
   * @return  String representing the current known state of the board.
   */
  override def toString() = {
    def rts(row:Int) =
      known(row).slice(0, 3).mkString("") + " | " +
      known(row).slice(3, 6).mkString("") + " | " +
      known(row).slice(6, 9).mkString("") + "\n"
 
    var str = ""
    for (rblock <- 0 until N by 3) {
      if (rblock != 0) str += "----+-----+----\n"
      for (roff <- 0 to 2) {
        str += rts(rblock+roff)
      }
    } // Format all blocks.
    str
  }
 
  /**
   * Search for a solution.
   * @return  Solution, if one is found.
   */
  def search():Option[Board] = search(new SearchData(0))
 
  /**
   * Search for a solution.
   * @param sd  Search data block.
   * @return  Solution, if one is found.
   */
  private def search(sd:SearchData):Option[Board] = {
    // Get the cells that are currently unknown, and get the possibilities
    // for each.
    def unknowns = {
      for (i <- 0 until N; j <- 0 until N if known(i)(j) == U)
        yield (i,j,possible(i)(j))
    }
 
    // If all cells are known... We are done!
    if (unknowns.length == 0) {
      printf("Solution found:  fails=%d\n", sd.fails)
      return Option(this)
    }
 
    // Randomly choose an unknown
    val (row, col, choices) = unknowns(scala.util.Random.nextInt(unknowns.length))
 
    // Try each choice for the unknown cell.
    choices foreach {
      ch =>
      // Copy the board and set the value.  Then recursively seek a
      // solution.  If we find one, we are done.
      val newboard = clone
      try {
        newboard.set(row, col, ch)
        val soln = newboard.search(sd)
        if (soln.isDefined) return soln
      } catch {
        case e:BadBoardException => sd.fails += 1
      }
    } // Trying each choice.
    None
  }
}
 
/**
 * Companion object to the board class.  Provides methods to make and
 * initialize a board.
 *
 * @author sprowell
 */
object Board {
 
  /**
   * Convenience method to make a new board.
   * @return  A new board.
   */
  def apply() = new Board()
 
  import scala.io.Source
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param file  The file path.
   * @return  The new board.
   */
  def read(file:String):Board = read(Source.fromFile(file))
 
  /**
   * Read a file into a new board.  The file should consist of nine lines,
   * with each line a sequence of digits and unknown markers (typically a
   * space).  This designates the initial board.
   * @param source  The source providing the data.
   * @return  The new board.
   */
  def read(source:Source):Board = {
    val board = new Board()
    var row = 0
    for (line <- source.getLines) {
      if (line.length > 0) board.init(row, line)
      row += 1
    } // Read all rows.
    board
  }
 
  /**
   * Interactively initialize a board by requesting nine lines of text
   * from the user.  Each line should consist of digits and unknown markers
   * (typically a space).  This is the initial board.
   * @return  The new board.
   */
  def init:Board = {
    val board = new Board
    for (row <- 0 until board.N) {
      val line = Console.readLine("Row %d: ", row)
      board.init(row, line)
    } // Read all rows.
    board
  }
}
 
/**
 * Application entry point when run from the prompt.  Initialize a board
 * using user input, solve it, and print the solution.
 *
 * @author sprowell
 */
object Sudoku {
  /**
   * Entry point when run from the prompt.
   * @param args  Command line arguments (ignored).
   */
  def main(args:Array[String]) {
    Board.init.search() match {
      case None => println("No solution.")
      case Some(b) => println(b)
    }
  }
}

class Property[T](var value:T) {
  def get:T = value
  def set(newval:T) = {
    value = newval
    this
  }
  def :=(newval:T) = set(newval)
  override def toString = "Property(" + value + ")"
}
implicit def Property2value[T](prop:Property[T]) = prop.get

def `=`(newval:T) = set(newval)

scala> val p = new Property(12)
scala> p `=` 13

scala> def ValueToProperty[T](value:T) = new Property(value)
 
scala> var p = new Property(12)
p: Property[Int] = Property(12)
 
scala> p = 171
p: Property[Int] = Property(171)

trait Watcher[T,U] {
  def notify(value:T, data:U)
}
trait Watchable[T,U] {
  var watchers:Map[Watcher[T,U],U] = Map()
  def register(watch:Watcher[T,U], data:U) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T,U](value:T) extends Property(value) with Watchable[T,U] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

class See[T,U]() extends Watcher[T,U] {
  def notify(value:T, data:U) = {
    println("Value is now " + value + " and data is " + data + ".")
  }
}

scala> val see = new See[Int,String]
see: See[Int,String] = See@fab91
 
scala> val watch = new WatchedProperty[Int,String](1)
watch: WatchedProperty[Int,String] = Property(1)
 
scala> watch register (see,"watch")
 
scala> watch := 12
Value is now 12 and data is watch.
res22: Property[Int] = Property(12)
 
scala> watch := 31
Value is now 31 and data is watch.
res23: Property[Int] = Property(31)

object WatchedProperty {
  def apply[T,U](value:T) = new WatchedProperty[T,U](value)
}

trait Watcher[T] {
  def notify(value:T, data:Any)
}
trait Watchable[T] {
  var watchers:Map[Watcher[T],Any] = Map()
  def register(watch:Watcher[T], data:Any) = {
    watchers += (watch -> data)
  }
  def notify(value:T) = {
    watchers foreach {
      case (watcher, data) => watcher.notify(value, data)
    }
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval:T)
    notify(newval)
    this
  }
}

trait Watchable[T] {
  var watchers:List[(T) => Unit] = List()
  def register(notify:(T) => Unit) {
    watchers += notify
  }
  def notify(value:T) = {
    watchers foreach (notify => notify(value))
  }
}
class WatchedProperty[T](value:T) extends Property(value) with Watchable[T] {
  override def set(newval:T) = {
    super.set(newval)
    notify(newval)
    this
  }
}

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> def see(x:Int) = println("Value changed to: " + x + ".")
see: (Int)Unit
 
scala> prop.register(see)
 
scala> prop.register((x:Int) => println("Lambda sees value: " + x + "."))
 
scala> prop := 413
Value changed to: 413.
Lambda sees value: 413.
res10: Property[Int] = Property(413)

class ChangeWatcher {
  def watch[T](prop:WatchedProperty[T], name:String) {
    prop register {
      (value:T) => println(name + ": " + value)
    }
  }
}

scala> val prop = new WatchedProperty(21)
prop: WatchedProperty[Int] = Property(21)
 
scala> val status = new WatchedProperty("okay")
status: WatchedProperty[java.lang.String] = Property(okay)
 
scala> val temp = new WatchedProperty(21.8)
temp: WatchedProperty[Double] = Property(21.8)
 
scala> val cw = new ChangeWatcher
cw: ChangeWatcher = ChangeWatcher@3da8bc
 
scala> cw.watch(prop, "prop")
 
scala> cw.watch(status, "status")
 
scala> cw.watch(temp, "temperature")
 
scala> status := "Danger!"
status: Danger!
res18: Property[java.lang.String] = Property(Danger!)
 
scala> temp := 73.2
temperature: 73.2
res19: Property[Double] = Property(73.2)

def show[T](implicit thetype:scala.reflect.Manifest[T]) {
  thetype.erasure.getMethods() foreach println
}
def help(x:AnyRef) {
  x.getClass().getMethods() foreach println
}

/**
 * Given some iterable object that provides strings, find the longest
 * string in the collection that can be reached from the empty string
 * by adding one character at a time such that every intermediate step
 * is also in the collection.
 *
 
 * For example, if the collection is {@code {@literal {}a,
 * at, cat, chat, chart, cart, car{@literal }}},
 * then the longst word is {@code chart}, and it's derivation is:
 * {@code a => at => cat => cart => chart}.  If there are multiple
 * longest words, then only one is detected.
 *
 
 * Note that if single letters are not in the collection, then no words
 * can be derived, and only the empty derivation is returned.
 *
 * @param strings    An iterable providing the strings.
 * @return    The derivation of the longest, from the shortest word to the
 *             longest.  If there is no longest word, then the empty
 *             derivation is returned.
 */
public List search(Iterable strings) {
    if (strings == null) {
        throw new NullPointerException("The string iterator is null.");
    }
 
    // Read each string from the iterable.  The strings assumed to be
    // single words, and the words are not assumed to occur in any
    // particular order.  We put the words we read into a heap, ordered
    // by length.  Our "heap" is a sorted map.
    //
    // Every entry in the map has an associated integer value, which
    // tells us the position of the last inserted character.  This can
    // be used to "unwind" the derivation of the word.  If there is not
    // (yet) any way to reach the word, then the word is mapped to -1.
    TreeMap heap =
        new TreeMap(new Comparator() {
            public int compare(String first, String second) {
                // Okay, we sort first by length, and then alphabetically.
                // This is necessary because of the way TreeMap tests
                // equality; it uses the comparator.  Thus we must only
                // return zero if the two are actually equal.  So, we
                // first order by length, and then for items of the same
                // length, we order using the natural comparator for
                // strings.
                int order = first.length() - second.length();
                if (order == 0) {
                    order = first.compareToIgnoreCase(second);
                }
                return order;
            }
        });
    for (String str : strings) {
        heap.put(str,-1);
    } // Add all strings to the heap.
 
    // Prime the pump by adding the empty string as "reachable."
    String longest = "";
    int length = 0;
    heap.put("", 0);
 
    // At this point the heap is constructed.  We now iterate over the
    // heap looking for connected words.  If we find one, we mark it.
    for (String str : heap.keySet()) {
        // Watch for a case where we skip a length.  If we do, we're done.
        if (str.length() > length+1) {
            break;
        }
        length = str.length();
 
        // Now we have a string, we need to find out if the string is
        // reachable from a previously-reached string.  We drop each
        // character, and then check if the resulting string is
        // present in the heap and is marked.
        for (int index = 0; index < str.length(); index++) {
            // Omit the character at position index.
            String test = str.substring(0,index) + str.substring(index+1);
            // See if the resulting test string is in the heap.
            Integer pos = heap.get(test);
 
            // Now there are three cases:
            // (1) The test string is not in the heap.
            // (2) The test string is in the heap, but not reachable.
            if (pos == null || pos < 0) {
                continue;
            }
            // (3) The test string is in the heap, and is reachable.
            // In this last case we know we can reach the current string
            // from the test string by adding the character at position
            // index, so put this in the heap.
            heap.put(str, index);
            // Note that whenever this happens, we might have just found
            // (one of) the longest words, so save it.
            longest = str;
            // We don't need to test any other positions.
            break;
        } // Construct new words by omitting each character.
    } // Search the heap for words.
 
    // Now we have (hopefully) found a long word.  We need to generate
    // the derivation and return it.
    List derivation = new LinkedList();
    while (longest.length() > 0) {
        // Get the insertion position from the heap.
        int pos = heap.get(longest);
        // Add the word to the derivation.
        derivation.add(0, longest);
        // Generate the prior string in the derivation.
        longest = longest.substring(0, pos) + longest.substring(pos+1);
    } // Build the derivation.
 
    // Done!  Return the derivation.
    return derivation;
}

>>> from multipart import Multipart
>>> m = Multipart()
>>> m.field('search','searchish term')
>>> m.file('greet','greet.txt','Hello multipart world!',{'Content-Type':'text/text'})
>>> ct,body = m.get()
>>> print ct
multipart/form-data; boundary=----------AaB03x
>>> print body
------------AaB03x
Content-Type: application/octet-stream
Content-Disposition: form-data; name="search"
 
searchish term
------------AaB03x
Content-Type: text/text
Content-Disposition: form-data; name="greet"; filename="greet.txt"
 
Hello multipart world!
------------AaB03x--

request = urllib2.Request(url='http://my.fake.server',
    headers={'Content-Type':ct},
    data=body)
reply = urllib2.urlopen(request)
print reply.read()

#!/usr/bin/python
'''
Classes for using multipart form data from Python, which does not (at the
time of writing) support this directly.
 
To use this, make an instance of Multipart and add parts to it via the factory
methods field and file.  When you are done, get the content via the get method.
 
@author: Stacy Prowell (http://stacyprowell.com)
'''
 
import mimetypes
 
class Part(object):
    '''
    Class holding a single part of the form.  You should never need to use
    this class directly; instead, use the factory methods in Multipart:
    field and file.
    '''
 
    # The boundary to use.  This is shamelessly taken from the standard.
    BOUNDARY = '----------AaB03x'
    CRLF = '\r\n'
    # Common headers.
    CONTENT_TYPE = 'Content-Type'
    CONTENT_DISPOSITION = 'Content-Disposition'
    # The default content type for parts.
    DEFAULT_CONTENT_TYPE = 'application/octet-stream'
 
    def __init__(self, name, filename, body, headers):
        '''
        Make a new part.  The part will have the given headers added initially.
 
        @param name: The part name.
        @type name: str
        @param filename: If this is a file, the name of the file.  Otherwise
                        None.
        @type filename: str
        @param body: The body of the part.
        @type body: str
        @param headers: Additional headers, or overrides, for this part.
                        You can override Content-Type here.
        @type headers: dict
        '''
        self._headers = headers.copy()
        self._name = name
        self._filename = filename
        self._body = body
        # We respect any content type passed in, but otherwise set it here.
        # We set the content disposition now, overwriting any prior value.
        if self._filename == None:
            self._headers[Part.CONTENT_DISPOSITION] = \
                ('form-data; name="%s"' % self._name)
            self._headers.setdefault(Part.CONTENT_TYPE,
                                     Part.DEFAULT_CONTENT_TYPE)
        else:
            self._headers[Part.CONTENT_DISPOSITION] = \
                ('form-data; name="%s"; filename="%s"' %
                 (self._name, self._filename))
            self._headers.setdefault(Part.CONTENT_TYPE,
                                     mimetypes.guess_type(filename)[0]
                                     or Part.DEFAULT_CONTENT_TYPE)
        return
 
    def get(self):
        '''
        Convert the part into a list of lines for output.  This includes
        the boundary lines, part header lines, and the part itself.  A
        blank line is included between the header and the body.
 
        @return: Lines of this part.
        @rtype: list
        '''
        lines = []
        lines.append('--' + Part.BOUNDARY)
        for (key, val) in self._headers.items():
            lines.append('%s: %s' % (key, val))
        lines.append('')
        lines.append(self._body)
        return lines
 
class Multipart(object):
    '''
    Encapsulate multipart form data.  To use this, make an instance and then
    add parts to it via the two methods (field and file).  When done, you can
    get the result via the get method.
 
    See http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.2 for
    details on multipart/form-data.
 
    Watch http://bugs.python.org/issue3244 to see if this is fixed in the
    Python libraries.
 
    @return: content type, body
    @rtype: tuple
    '''
 
    def __init__(self):
        self.parts = []
        return
 
    def field(self, name, value, headers={}):
        '''
        Create and append a field part.  This kind of part has a field name
        and value.
 
        @param name: The field name.
        @type name: str
        @param value: The field value.
        @type value: str
        @param headers: Headers to set in addition to disposition.
        @type headers: dict
        '''
        self.parts.append(Part(name, None, value, headers))
        return
 
    def file(self, name, filename, value, headers={}):
        '''
        Create and append a file part.  THis kind of part has a field name,
        a filename, and a value.
 
        @param name: The field name.
        @type name: str
        @param value: The field value.
        @type value: str
        @param headers: Headers to set in addition to disposition.
        @type headers: dict
        '''
        self.parts.append(Part(name, filename, value, headers))
        return
 
    def get(self):
        '''
        Get the multipart form data.  This returns the content type, which
        specifies the boundary marker, and also returns the body containing
        all parts and bondary markers.
 
        @return: content type, body
        @rtype: tuple
        '''
        all = []
        for part in self.parts:
            all += part.get()
        all.append('--' + Part.BOUNDARY + '--')
        all.append('')
        # We have to return the content type, since it specifies the boundary.
        content_type = 'multipart/form-data; boundary=%s' % Part.BOUNDARY
        return content_type, Part.CRLF.join(all)

package gypsum.util;
 
import java.util.Collection;
import java.util.Iterator;
 
/**
 * This class packages some implementation of {@link Collection} along with
 * the class object for the type parameter of the collection.  This allows
 * getting the type of objects in the collection using the {@link #getType()}
 * method, and then using the resulting class to perform casts.  This basically
 * creates a "reified" generic collection (of sorts).
 *
 * @param    Class of data held in this collection.
 * @author sprowell
 * @version $Revision$ $Date$
 */
public class TypedCollection implements Collection {
 
    private Class type;
    private Collection implementation;
 
    /**
     * Make a new instance.
     * @param type              The class object for the type of elements.
     * @param implementation    The implementation.
     */
    public TypedCollection(Class type, Collection implementation) {
        if (type == null) {
            throw new NullPointerException("The type is null.");
        }
        if (implementation == null) {
            throw new NullPointerException("The implementation is null.");
        }
        this.type = type;
        this.implementation = implementation;
    }
 
    /**
     * Get the type held in this collection.
     * @return  The type held in this collection.
     */
    public Class getType() {
        return type;
    }
 
    /**
     * Recover the original typed collection.  In order for this to work,
     * the correct class must be supplied; otherwise you will get a
     * {@link ClassCastException}.  Use this as follows.
     *
<pre>     * TypedCollection&lt;Foo&gt; coll = oldcoll.recover(oldcoll.getType());
     *
     *
 
     * This converts from {@code TypedCollection&lt;?&gt;} to
     * {@code TypedCollection&amp;ltT&gt;}, so you recover the generic type
     * parameter.
     *
 
     * This may seem backward, or even a little contrived.  Blame it on
     * the Java generics system.  The reason you must pass the class
     * object <em>in</em>, even though it is maintained here, is that
     * the compiler must know the type of the object <em>at the point
     * you use this method</em>.  Thus you can do the following.
     *
<pre>     * public void print(TypedCollection&lt;?&gt; coll) {
     *   if (coll.getType() == String.class) {
     *     TypedCollection&lt;String&gt; coll = coll.recover(String.class);
     *     for (String str : coll) {
     *       System.out.println(str);
     *     }
     *   }
     * }
     * &lt;/pre&gt;
     *
     * @param    The type of the desired collection.
     * @param kind  The class object for type T.
     * @return  The correctly cast generic collection.
     * @throws  ClassCastException
     *          This instance is <em>not</em> the type desired.
     */
    @SuppressWarnings("unchecked")
    public  TypedCollection recover(Class kind) {
        if (kind == type) {
            return (TypedCollection) this;
        }
        throw new ClassCastException("Incorrect cast.");
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#add(java.lang.Object)
     */
    @Override
    public boolean add(E arg) {
        return implementation.add(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#addAll(java.util.Collection)
     */
    @Override
    public boolean addAll(Collection arg) {
        return implementation.addAll(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#clear()
     */
    @Override
    public void clear() {
        implementation.clear();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#contains(java.lang.Object)
     */
    @Override
    public boolean contains(Object arg) {
        return implementation.contains(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#containsAll(java.util.Collection)
     */
    @Override
    public boolean containsAll(Collection c) {
        return implementation.containsAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#isEmpty()
     */
    @Override
    public boolean isEmpty() {
        return implementation.isEmpty();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#iterator()
     */
    @Override
    public Iterator iterator() {
        return implementation.iterator();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#remove(java.lang.Object)
     */
    @Override
    public boolean remove(Object o) {
        return implementation.remove(o);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#removeAll(java.util.Collection)
     */
    @Override
    public boolean removeAll(Collection c) {
        return implementation.removeAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#retainAll(java.util.Collection)
     */
    @Override
    public boolean retainAll(Collection c) {
        return implementation.retainAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#size()
     */
    @Override
    public int size() {
        return implementation.size();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#toArray()
     */
    @Override
    public Object[] toArray() {
        return implementation.toArray();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#toArray(T[])
     */
    @Override
    public  T[] toArray(T[] a) {
        return implementation.toArray(a);
    }
}