PropertyListView.java

  1. package sprouts.impl;

  3. import org.jspecify.annotations.Nullable;
  4. import sprouts.Observable;
  5. import sprouts.Observer;
  6. import sprouts.*;

  8. import java.lang.ref.WeakReference;
  9. import java.util.*;
  10. import java.util.function.Function;
  11. import java.util.stream.Collectors;

  13. final class PropertyListView<T extends @Nullable Object> implements Viewables<T> {

  15.     public static <T, U> Viewables<U> of(U nullObject, U errorObject, Vals<T> source, Function<T, @Nullable U> mapper) {
  16.         Objects.requireNonNull(nullObject);
  17.         Objects.requireNonNull(errorObject);

  19.         final Class<U> targetType = Util.expectedClassFromItem(nullObject);
  20.         Function<T, U> nonNullMapper = Util.nonNullMapper(nullObject, errorObject, mapper);

  22.         PropertyListView<U> view = new PropertyListView<>(targetType, source.allowsNull(), source);
  23.         Function<Val<T>, Var<U>> sourcePropToViewProp = prop -> {
  24.             return (Var<U>) prop.view(nullObject, errorObject, nonNullMapper);
  25.         };
  26.         for (int i = 0; i < source.size(); i++) {
  27.             Var<U> viewable = sourcePropToViewProp.apply(source.at(i));
  28.             view._variables.add(i, viewable);
  29.         }

  31.         WeakReference<Vals<T>> weakSource = new WeakReference<>(source);
  32.         Viewables.cast(source).onChange(Action.ofWeak(view, (innerView, delegate) -> {
  33.             Vals<T> innerSource = weakSource.get();
  34.             if (innerSource == null) {
  35.                 return;
  36.             }
  37.             switch (delegate.change()) {
  38.                 case NONE:
  39.                     break;
  40.                 case REMOVE:
  41.                     onRemove(delegate, innerView);
  42.                     break;
  43.                 case ADD:
  44.                     onAdd(delegate, innerSource, innerView, targetType, sourcePropToViewProp);
  45.                     break;
  46.                 case SET:
  47.                     onSet(delegate, innerSource, innerView, sourcePropToViewProp);
  48.                     break;
  49.                 case CLEAR:
  50.                     innerView.clear();
  51.                     break;
  52.                 case SORT:
  53.                     innerView.sort();
  54.                     break;
  55.                 case REVERSE:
  56.                     innerView.reversed();
  57.                     break;
  58.                 case DISTINCT:
  59.                     innerView.makeDistinct();
  60.                     break;
  61.                 default:
  62.                     onUpdateAll(innerSource, innerView, sourcePropToViewProp);
  63.             }
  64.         }));
  65.         return Viewables.cast(view);
  66.     }

  68.     private static <T, U> void onRemove(ValsDelegate<T> delegate, PropertyListView<U> view) {
  69.         assert delegate.change() == SequenceChange.REMOVE;
  70.         int index = delegate.index().orElse(-1);
  71.         if (delegate.oldValues().isEmpty() || index < 0)
  72.             throw new UnsupportedOperationException(); // todo: implement

  74.         view.removeAt(index, delegate.oldValues().size());
  75.     }

  77.     private static <T, U> void onAdd(
  78.             ValsDelegate<T>          delegate,
  79.             Vals<T>                  source,
  80.             PropertyListView<U>      view,
  81.             Class<U>                 targetType,
  82.             Function<Val<T>, Var<U>> sourcePropToViewProp
  83.     ) {
  84.         assert delegate.change() == SequenceChange.ADD;
  85.         int index = delegate.index().orElse(-1);

  87.         if (delegate.newValues().isEmpty() || index < 0)
  88.             throw new UnsupportedOperationException(); // todo: implement

  90.         Vars<U> newViews = Vars.of(targetType);

  92.         for (int i = 0; i < delegate.newValues().size(); i++) {
  93.             Val<T> t = source.at(index + i);
  94.             newViews.add(sourcePropToViewProp.apply(t));
  95.         }

  97.         view.addAllAt(index, newViews);
  98.     }

  100.     private static <T, U> void onSet(
  101.             ValsDelegate<T>          delegate,
  102.             Vals<T>                  source,
  103.             PropertyListView<U>      view,
  104.             Function<Val<T>, Var<U>> sourcePropToViewProp
  105.     ) {
  106.         assert delegate.change() == SequenceChange.SET;
  107.         int index = delegate.index().orElse(-1);

  109.         if (delegate.newValues().isEmpty() || index < 0)
  110.             throw new UnsupportedOperationException(); // todo: implement

  112.         Vars<U> newViews = Vars.of(view.type());

  114.         for (int i = 0; i < delegate.newValues().size(); i++) {
  115.             Val<T> t = source.at(index + i);
  116.             newViews.add(sourcePropToViewProp.apply(t));
  117.         }

  119.         view.setAllAt(index, newViews);
  120.     }

  122.     private static <T, U> void onUpdateAll(
  123.             Vals<T>                  source,
  124.             PropertyListView<U>      view,
  125.             Function<Val<T>, Var<U>> sourcePropToViewProp
  126.     ) {
  127.         view.clear();
  128.         for (int i = 0; i < source.size(); i++) {
  129.             Val<T> t = source.at(i);
  130.             view.add(sourcePropToViewProp.apply(t));
  131.         }
  132.     }


  135.     private final List<Var<T>> _variables = new ArrayList<>();
  136.     private final boolean      _allowsNull;
  137.     private final Class<T>     _type;

  139.     private final PropertyListChangeListeners<T> _changeListeners = new PropertyListChangeListeners<>();
  140.     private final ParentListRef<Vals<?>> _parentRef;


  143.     @SafeVarargs
  144.     private PropertyListView(Class<T> type, boolean allowsNull, Vals<?> source, Var<T>... vals) {
  145.         _type        = type;
  146.         _allowsNull  = allowsNull;
  147.         _parentRef   = ParentListRef.of(source);
  148.         _variables.addAll(Arrays.asList(vals));
  149.         _checkNullSafety();
  150.     }

  152.     /** {@inheritDoc} */
  153.     @Override public final Var<T> at( int index ) {
  154.         return _variables.get(index);
  155.     }

  157.     /** {@inheritDoc} */
  158.     @Override public final Class<T> type() {
  159.         return _type;
  160.     }

  162.     /** {@inheritDoc} */
  163.     @Override public final int size() {
  164.         return _variables.size();
  165.     }

  167.     private void removeAt( int index, int size ) {
  168.         removeRange(index, index + size);
  169.     }

  171.     private void add( Var<T> var ) {
  172.         Objects.requireNonNull(var);
  173.         addAt( size(), var );
  174.     }

  176.     private void addAt( int index, Var<T> value ) {
  177.         if ( this.allowsNull() != value.allowsNull() )
  178.             throw new IllegalArgumentException("The null safety of the given property does not match this list.");
  179.         _checkNullSafetyOf(value);
  180.         _variables.add(index, value);
  181.         _triggerAction( SequenceChange.ADD, index, value, null );
  182.     }

  184.     private void removeRange(int from, int to) {
  185.         if ( from < 0 || to > _variables.size() || from > to )
  186.             throw new IndexOutOfBoundsException("From: " + from + ", To: " + to + ", Size: " + _variables.size());

  188.         if (from == to)
  189.             return;

  191.         Vars<T> removal = (Vars<T>) (_allowsNull ? Vars.ofNullable(_type) : Vars.of(_type));

  193.         List<Var<T>> subList = _variables.subList( from, to );
  194.         for ( Var<T> var : subList ) removal.add(var);
  195.         subList.clear();

  197.         _triggerAction( SequenceChange.REMOVE, from, null, removal );
  198.     }

  200.     private void addAllAt( int index, Vars<T> vars ) {
  201.         if ( !_checkCanAdd(vars) )
  202.             return;

  204.         if ( index < 0 || index > size() )
  205.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size());

  207.         for ( int i = 0; i < vars.size(); i++ ) {
  208.             Var<T> toBeAdded = vars.at(i);
  209.             _checkNullSafetyOf(toBeAdded);
  210.             _variables.add(index + i, toBeAdded);
  211.         }

  213.         _triggerAction( SequenceChange.ADD, index, vars, null );
  214.     }

  216.     private void setAllAt(int index, Vars<T> vars) {
  217.         if ( !_checkCanAdd(vars) )
  218.             return;

  220.         if ( index < 0 || index > size() )
  221.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size());

  223.         int end = index + vars.size();

  225.         if ( end > size() )
  226.             throw new IndexOutOfBoundsException("Index: " + end + ", Size: " + size());

  228.         Vars<T> oldVars = (Vars<T>) (_allowsNull ? Vars.ofNullable(_type) : Vars.of(_type));
  229.         Vars<T> newVars = (Vars<T>) (_allowsNull ? Vars.ofNullable(_type) : Vars.of(_type));

  231.         for ( int i = 0; i < vars.size(); i++ ) {
  232.             Var<T> toBeAdded = vars.at(i);
  233.             _checkNullSafetyOf(toBeAdded);
  234.             Var<T> old = _variables.set(index + i, toBeAdded);
  235.             newVars.add(toBeAdded);
  236.             oldVars.add(old);
  237.         }

  239.         _triggerAction( SequenceChange.SET, index, newVars, oldVars );
  240.     }

  242.     private boolean _checkCanAdd( Vals<T> properties ) {
  243.         if ( properties.allowsNull() != this.allowsNull() )
  244.             throw new IllegalArgumentException(
  245.                     "The null safety of the given property list does not match this list."
  246.                 );

  248.         if ( properties.isEmpty() )
  249.             return false;

  251.         return true;
  252.     }

  254.     private void clear() {
  255.         Vars<T> vars = (Vars<T>) (_allowsNull ? Vars.ofNullable(_type, _variables) : Vars.of(_type, _variables));

  257.         _variables.clear();
  258.         _triggerAction( SequenceChange.CLEAR, 0, null, vars);
  259.     }

  261.     public void sort( Comparator<T> comparator ) {
  262.         _variables.sort( ( a, b ) -> comparator.compare( a.orElseNull(), b.orElseNull() ) );
  263.         _triggerAction( SequenceChange.SORT );
  264.     }

  266.     private void sort() {
  267.         // First we have to check if the type is comparable:
  268.         if (Comparable.class.isAssignableFrom(type())) {
  269.             @SuppressWarnings("unchecked")
  270.             Comparator<T> comparator = (Comparator<T>) Comparator.naturalOrder();
  271.             sort(comparator);
  272.         } else {
  273.             throw new UnsupportedOperationException("Cannot sort a list of non-comparable types.");
  274.         }
  275.     }

  277.     public final void makeDistinct() {
  278.         Set<T> checked = new HashSet<>();
  279.         List<Var<T>> retained = new ArrayList<>();
  280.         for ( Var<T> property : _variables ) {
  281.             T item = property.orElseNull();
  282.             if ( !checked.contains(item) ) {
  283.                 checked.add(item);
  284.                 retained.add(property);
  285.             }
  286.         }
  287.         _variables.clear();
  288.         _variables.addAll(retained);
  289.         _triggerAction( SequenceChange.DISTINCT );
  290.     }

  292.     public void reversed() {
  293.         int size = size();
  294.         for ( int i = 0; i < size / 2; i++ ) {
  295.             Var<T> tmp = at(i);
  296.             _variables.set( i, at(size - i - 1) );
  297.             _variables.set( size - i - 1, tmp );
  298.         }
  299.         _triggerAction( SequenceChange.REVERSE );
  300.     }

  302.     /** {@inheritDoc} */
  303.     @Override
  304.     public Vals<T> onChange( Action<ValsDelegate<T>> action ) {
  305.         _changeListeners.onChange(action);
  306.         return this;
  307.     }

  309.     /** {@inheritDoc} */
  310.     @Override
  311.     public Vals<T> fireChange() {
  312.         _triggerAction( SequenceChange.NONE );
  313.         return this;
  314.     }

  316.     @Override
  317.     public boolean allowsNull() {
  318.         return _allowsNull;
  319.     }

  321.     @Override
  322.     public boolean isMutable() {
  323.         return true;
  324.     }

  326.     @Override
  327.     public boolean isView() {
  328.         return true;
  329.     }

  331.     private void _triggerAction(
  332.             SequenceChange type, int index, @Nullable Var<T> newVal, @Nullable Var<T> oldVal
  333.     ) {
  334.         _changeListeners.fireChange(type, index, newVal, oldVal, this);
  335.     }

  337.     private void _triggerAction(SequenceChange type) {
  338.         _changeListeners.fireChange(type, this);
  339.     }

  341.     private void _triggerAction(
  342.             SequenceChange type, int index, @Nullable Vals<T> newVals, @Nullable Vals<T> oldVals
  343.     ) {
  344.         _changeListeners.fireChange(type, index, newVals, oldVals, this);
  345.     }

  347.     /** {@inheritDoc} */
  348.     @Override
  349.     public java.util.Iterator<T> iterator() {
  350.         return new java.util.Iterator<T>() {
  351.             private int index = 0;
  352.             @Override public boolean hasNext() { return index < size(); }
  353.             @Override public @Nullable T next() { return at(index++).orElseNull(); }
  354.         };
  355.     }

  357.     /** {@inheritDoc} */
  358.     @Override
  359.     public final String toString() {
  360.         String entries = _variables.stream()
  361.                                     .map( o -> o.itemAsString() + ( o.hasID() ? "(" + o.id() + ")" : "" ) )
  362.                                     .collect(Collectors.joining(", "));

  364.         return "Views<" + _type.getSimpleName() + ">[" + entries + "]";
  365.     }

  367.     /** {@inheritDoc} */
  368.     @Override
  369.     public final boolean equals( Object obj ) {
  370.         return this == obj;
  371.     }

  373.     /** {@inheritDoc} */
  374.     @Override
  375.     public final int hashCode() {
  376.         return System.identityHashCode(this);
  377.     }

  379.     private void _checkNullSafety() {
  380.         if ( !_allowsNull )
  381.             for ( Var<T> val : _variables )
  382.                 _checkNullSafetyOf(val);
  383.         else {
  384.             for ( Var<T> val : _variables )
  385.                 if ( !val.allowsNull() )
  386.                     throw new IllegalArgumentException("The null safety of the given property does not match this list.");
  387.         }
  388.     }

  390.     private void _checkNullSafetyOf( Val<T> value ) {
  391.         Objects.requireNonNull(value);
  392.         if ( !_allowsNull && value.allowsNull() )
  393.             throw new IllegalArgumentException("Null values are not allowed in this property list.");
  394.     }

  396.     @Override
  397.     public Observable subscribe( Observer observer ) {
  398.         _changeListeners.onChange(observer);
  399.         return this;
  400.     }

  402.     @Override
  403.     public Observable unsubscribe( Subscriber subscriber ) {
  404.         _changeListeners.unsubscribe(subscriber);
  405.         return this;
  406.     }

  408.     @Override
  409.     public void unsubscribeAll() {
  410.         _changeListeners.unsubscribeAll();
  411.     }
  412. }
Created with JaCoCo 0.8.5.201910111838