How to use com.ochafik.util.listenable

Best Java code snippets using com.ochafik.util.listenable (Showing top 20 results out of 315)

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 LocalDateTime l =new LocalDateTime()
LocalDateTime.now()
DateTimeFormatter formatter;String text;formatter.parseLocalDateTime(text)
Smart code suggestions by Codota
}

@Override
public ListenableCollection<V> values() {
  return ListenableCollections.unmodifiableCollection(listenableMap.values());
}
@Override

@Override
public ListenableSet<Entry<K, V>> entrySet() {
  synchronized (mutex) {
    return new SynchronizedListenableSet<Entry<K,V>>(super.entrySet(), mutex);
  }
}
@Override

public Object getSelectedItem() {
  if (selectedItem != null && !getList().contains(selectedItem))
    selectedItem = null;
  return selectedItem;
}
@SuppressWarnings("unchecked")

void propagateRemoved(Collection<Map.Entry<K, V>> entries) {
  if (keySet != null)
    keySet.collectionSupport.fireRemoved(keySet, new AdaptedCollection<Map.Entry<K,V>, K>(entries, entryToKeyAdapter));
  
  if (entrySet != null) {
    entrySet.collectionSupport.fireRemoved(entrySet, entries);
  }
    
  if (values != null) {
    valuesSupport.fireRemoved(values, new AdaptedCollection<Map.Entry<K,V>, V>(entries, entryToValueAdapter));
  }
}

public ListenableCollection<V> values() {
  if (values == null) {
    valuesSupport = new ListenableSupport<V>();
    values = ListenableCollections.unmodifiableCollection(new DefaultListenableCollection<V>(map.values(), valuesSupport));
   }
      return values;
}

@Override
public ListenableSet<K> listenableKeySet() {
  return new UnmodifiableListenableSet<K>(listenableMap.keySet());
}
@Override

@Override
public ListenableCollection<V> values() {
  synchronized (mutex) {
    return new SynchronizedListenableCollection<V>(super.values());
  }
}

@Override
public ListenableSet<Entry<K, V>> entrySet() {
  return ListenableCollections.unmodifiableSet(listenableMap.entrySet());
}
@Override

@Override
public ListenableSet<K> keySet() {
  synchronized (mutex) {
    return new SynchronizedListenableSet<K>(super.keySet());
  }
}
@Override

  public void removeCollectionListener(CollectionListener<V> l) {
    if (collectionSupport == null)
      return;
    
    collectionSupport.removeCollectionListener(l);
  }
}

public boolean remove(Object o) {
  int i = indexOf(o);
  return i >= 0 && remove(i) != null;
}
public void clear() {

@Override
public V remove(Object key) {
  synchronized (mutex) {
    return super.remove(key);
  }
}
@Override

@Override
public boolean isEmpty() {
  synchronized (mutex) {
    return super.isEmpty();
  }
}

@Override
public void clear() {
  synchronized (mutex) {
    super.clear();
  }
}
@Override

@Override
public boolean isEmpty() {
  synchronized (mutex) {
    return super.isEmpty();
  }
}

@Override
public Iterator<T> iterator() {
  synchronized (mutex) {
    return new SynchronizedListenableIterator();//super.iterator());
  }
}
@Override

@Override
public String toString() {
  synchronized (mutex) {
    return super.toString();
  }
}

public MapResult(Threads threads, ListenableList<V> out, ListenableList<Pair<U,Throwable>> errorsOut) {
  this.values = ListenableCollections.unmodifiableList(out);
  this.threads = threads;
  this.errors = ListenableCollections.unmodifiableList(errorsOut);
}

  @SuppressWarnings("unchecked")
  //@Override
  public void setSelectedItem(Object anItem) {
    if (getList().contains(anItem))
      selectedItem = (T)anItem;
    else
      selectedItem = null;
  }
}

@Override
public ListenableSet<K> keySet() {
  return new UnmodifiableListenableSet<K>(listenableMap.keySet());
  //return Collections.unmodifiableSet(listenableMap.keySet());
}
@Override