@Override public Tuple<User, Organization> apply(User user) { return tuple(user, org); } });
@Override protected Tuple<A, Object> change() { synchronized (lock) { if (!stable) change += 1; return tuple(a, (Object) change); } }
@Override public Tuple<A, B> apply(B b) { return tuple(a, b); } };
/** Create a list of tuples (K, V) from a map. */ public static <K, V> List<Tuple<K, V>> toList(Map<K, V> map) { List<Tuple<K, V>> list = new ArrayList<>(); for (Entry<K, V> entry : map.entrySet()) { list.add(Tuple.tuple(entry.getKey(), entry.getValue())); } return list; }
@Override public <B, M extends Iterable<B>> ListMonadic<Tuple<A, B>> zip(M m) { final List<Tuple<A, B>> target = newListBuilder(); final Iterator<B> mi = m.iterator(); while (as.hasNext() && mi.hasNext()) { target.add(tuple(as.next(), mi.next())); } return mlist(target); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(B[] bs) { final List<Tuple<A, B>> target = newListBuilder(bs.length); int i = 0; while (as.hasNext() && i < bs.length) { target.add(tuple(as.next(), bs[i++])); } return mlist(target); }
@Override public <B, M extends Iterable<B>> ListMonadic<Tuple<A, B>> zip(M m) { final List<Tuple<A, B>> target = newListBuilder(); final Iterator<A> asi = as.iterator(); final Iterator<B> mi = m.iterator(); while (asi.hasNext() && mi.hasNext()) { target.add(tuple(asi.next(), mi.next())); } return mlist(target); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(Iterator<B> bs) { final List<Tuple<A, B>> target = newListBuilder(as.length); int i = 0; while (i < as.length && bs.hasNext()) { target.add(tuple(as[i++], bs.next())); } return mlist(target); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(Iterator<B> bs) { final List<Tuple<A, B>> target = newListBuilder(as.size()); final Iterator<A> asi = as.iterator(); while (asi.hasNext() && bs.hasNext()) { target.add(tuple(asi.next(), bs.next())); } return mlist(target); }
@Override public <B, M extends Iterable<B>> ListMonadic<Tuple<A, B>> zip(M m) { final List<Tuple<A, B>> target = newListBuilder(); int i = 0; final Iterator<B> mi = m.iterator(); while (i < as.length && mi.hasNext()) { target.add(tuple(as[i++], mi.next())); } return mlist(target); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(Iterator<B> bs) { final List<Tuple<A, B>> target = newListBuilder(); while (as.hasNext() && bs.hasNext()) { target.add(tuple(as.next(), bs.next())); } return mlist(target); }
@Override protected Tuple<A, Object> change() { synchronized (lock) { return tuple(calc(), change); } } }
/** * Record a failure incident for a given job. * * @see #record(org.opencastproject.job.api.Job, org.opencastproject.job.api.Incident.Severity, int, java.util.Map, * java.util.List) * @see org.opencastproject.job.api.Incident */ public void recordFailure(Job job, int code, Throwable t, Map<String, String> params, List<Tuple<String, String>> details) { List<Tuple<String, String>> detailList = new ArrayList<>(details); detailList.add(tuple("stack-trace", ExceptionUtils.getStackTrace(t))); record(job, Severity.FAILURE, code, params, detailList); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(B[] bs) { final List<Tuple<A, B>> target = newListBuilder(min(as.size(), bs.length)); int i = 0; final Iterator<A> asi = as.iterator(); while (asi.hasNext() && i < bs.length) { target.add(tuple(asi.next(), bs[i++])); } return mlist(target); }
@Override public <B> ListMonadic<Tuple<A, B>> zip(B[] bs) { final List<Tuple<A, B>> target = newListBuilder(min(as.length, bs.length)); int i = 0; while (i < as.length && i < bs.length) { target.add(tuple(as[i], bs[i])); i++; } return mlist(target); }
public void updateService(ServiceRegistration registration) { if (!registration.isActive()) { services.remove(Tuple.tuple(registration.getHost(), registration.getServiceType())); logger.trace("Removing inactive service '{}'", registration); } else { services.put(Tuple.tuple(registration.getHost(), registration.getServiceType()), registration.getServiceState()); } sendNotification(JmxUtil.createUpdateNotification(this, sequenceNumber++, "Service updated")); }
/** @see org.opencastproject.job.api.Incident#getDetails() */ public List<Tuple<String, String>> getTechnicalInformation() { final List<Tuple<String, String>> list = new ArrayList<Tuple<String, String>>(); JsonObj messageJson = JsonObj.jsonObj(details); for (Object k : messageJson.keySet()) { String title = JsonVal.asJsonVal.apply(k).as(asString); String content = messageJson.val(title).as(asString); list.add(tuple(title, content)); } return list; }
public <B> Option<Tuple<A, B>> and(Option<B> b) { if (isSome() && b.isSome()) { return some(tuple(get(), b.get())); } else { return none(); } }
@Override protected A calc() { final Tuple<B, Object> mChangeB = masterB.change(); final Tuple<C, Object> mChangeC = masterC.change(); final Tuple<Object, Object> mChange = tuple(mChangeB.getB(), mChangeC.getB()); if (ne(mChange, change)) { a = f.apply(mChangeB.getA(), mChangeC.getA()); change = mChange; } return a; } };