code: public static <T, R> SwitchBuilder<T, R> switchBinding(ObservableValue<T> observable, Class<R> bindingType) {
          return new SwitchBuilder<>(observable);
      }
docs: Creates builder for a binding that works like a switch-case in java.
  
  Example:
  
  ```java
  IntegerProperty base = new SimpleIntegerProperty();
  
  ObservableValue<String> result = switchBinding(base, String.class)
  .bindCase(3, i -> "three")
  .bindCase(10, i -> "ten")
  .bindCase(1, i -> "one")
  .bindDefault(() -> "nothing")
  .build();
  ```
  
  this is the equivalent without observables:
  
  ```java
  int base = ...;
  
  switch(base) {
  case 3 :
  return "three";
  case 10:
  return "ten";
  case 1:
  return "one";
  default:
  return "nothing";
  }
  
  ```
  
  There are two differences between this switch binding and the switch statement in java:
  
  1. In the java switch statement only a limited number of types can be used. This binding has no such limitation.
  You can use every type in the observable that has a properly overwritten {@link Object#equals(Object)} and {@link Object#hashCode()} method.
  
  2. There is no "fall through" and therefore no "break" is needed. Only the callback for the matching case is executed.
  
  See [the switch documentation](http://docs.oracle.com/javase/tutorial/java/nutsandbolts/switch.html) for more information.
  
  
  @param observable the base observable that is used in the switch statement
  @param bindingType the type of the created observable.
  @param <T> the generic type of the base observable.
  @param <R> the generic type of the returned observable.
  @return a builder that is used to create the switch binding.