@Override public HashMap<K, V> filter(Predicate<? super Tuple2<K, V>> predicate) { return fromStream(stream().filter(predicate)); }
public void assureModule(Module module) { if (!modulePort.containsKey(module.getContext())) { HashMap<String, ModuleBean> builder = HashMap.empty(); builder = builder.putAll(modulePort); builder = builder.put(module.getContext(), ModuleBean.builder().host(getHost(module)).port(getPort(module)).build()); modulePort = builder; } }
/** * Use classifier function to group elements in this Sequence into a Map * * <pre> * {@code * HashMap<Integer, Vector<Integer>> map1 = of(1, 2, 3, 4).groupBy(i -> i % 2); * assertEquals(Vector.of(2, 4), map1.getOrElse(0,Vector.empty())); * assertEquals(Vector.of(1, 3), map1.getOrElse(1,Vector.empty())); * assertEquals(2, map1.size()); * * } * * </pre> */ @Override default <K> HashMap<K, Vector<T>> groupBy(final Function<? super T, ? extends K> classifier) { return this.foldLeft(HashMap.<K, Vector<T>>empty(), (a, b) -> { K k = classifier.apply(b); Vector<T> s = a.getOrElse(k, Vector.empty()); return a.put(k, s.plus(b)); }); }
@Test public void testGroupByEager() { HashMap<Integer, Vector<Integer>> map1 =of(1, 2, 3, 4).groupBy(i -> i % 2); assertThat(map1.getOrElse(0,Vector.empty()),hasItem(2)); assertThat(map1.getOrElse(0,Vector.empty()),hasItem(4)); assertThat(map1.getOrElse(1,Vector.empty()),hasItem(1)); assertThat(map1.getOrElse(1,Vector.empty()),hasItem(3)); assertEquals(2, map1.size()); }
public MicroserverEnvironment(Properties propertyFactory) { modulePort = HashMap.empty(); this.properties = propertyFactory; }
/** * <pre> * {@code * PersistentMap<Integer,String> q = Reducers.toPersistentMap() .foldMap(Stream.of(Arrays.asList("hello",1),Arrays.asList("world",2))); * * } * </pre> * @return Reducer for PersistentMap */ public static <K, V> Reducer<PersistentMap<K, V>,Tuple2<K,V>> toPersistentMap() { return Reducer.of(HashMap.empty(), (final PersistentMap<K, V> a) -> b -> a.putAll(b), (in) -> { Tuple2<K, V> w = in; return HashMap.of((K) w._1(), (V) w._2()); }); }
public MicroserverEnvironment(Properties propertyFactory, Collection<ModuleBean> modules) { modulePort = HashMap.fromStream(modules.stream().map(m-> tuple(m.getModule().getContext(),m))); this.properties = propertyFactory; }
/** * Topic will maintain a queue for each Subscribing Stream * If a Stream is finished with a Topic it is good practice to disconnect from the Topic * so messages will no longer be stored for that Stream * * @param stream */ @Synchronized("lock") public void disconnect(final ReactiveSeq<T> stream) { Option<Queue<T>> o = streamToQueue.get(stream); distributor.removeQueue(streamToQueue.getOrElse(stream, new Queue<>())); this.streamToQueue = streamToQueue.remove(stream); this.index--; }
@Override public boolean containsValue(final T e) { return map.get(e).isPresent(); }
@Synchronized("lock") private <R> ReactiveSeq<R> connect(final Function<Queue<T>, ReactiveSeq<R>> streamCreator) { final Queue<T> queue = this.getNextQueue(); final ReactiveSeq<R> stream = streamCreator.apply(queue); this.streamToQueue = streamToQueue.put(stream, queue); return stream; }
public Config buildConfig(Class class1) { Microserver microserver = (Microserver) class1.getAnnotation(Microserver.class); if (microserver == null){ microserver = Microserver.Instance.class.getAnnotation(Microserver.class); } String[] basePackages=microserver.basePackages(); if(basePackages.length==0){ String[] basePackagesFromClass ={class1.getPackage().getName()}; basePackages = basePackagesFromClass; } List<Class> classes = buildClasses(class1, microserver); Map<String, String> properties = buildProperties(microserver); return Config.instance().withBasePackages(basePackages).withEntityScan(microserver.entityScan()).withClasses(cyclops.data.HashSet.fromIterable(classes)) .withPropertiesName(microserver.propertiesName()).withInstancePropertiesName(microserver.instancePropertiesName()) .withServiceTypePropertiesName(microserver.serviceTypePropertiesName()) .withAllowCircularReferences(microserver.allowCircularDependencies()).withProperties(HashMap.fromMap(properties)).set(); }
@Override public boolean isEmpty() { return size()==0; }
@Override protected <K, V> ImmutableMap<K, V> of(K k1, V v1, K k2, V v2) { return HashMap.of(k1,v1,k2,v2); }
@Override public HashMap<K, V> removeAll(K... keys) { HAMT.Node<K,V> cur = map; for(K key : keys){ cur = cur.minus(0,key.hashCode(),key); } return new HashMap<>(cur); }