@Override public RouteOptions roles(String... roles) { Coll.assign(this.roles, roles); return this; }
public static <K, V> ConcurrentMap<K, V> concurrentMap(K key1, V value1, K key2, V value2) { ConcurrentMap<K, V> map = concurrentMap(key1, value1); map.put(key2, value2); return map; }
public static <K1, K2, V> Map<K1, Map<K2, List<V>>> mapOfMapOfLists() { return autoExpandingMap(src -> mapOfLists()); }
public static <K1, K2, V> Map<K1, Map<K2, Set<V>>> mapOfMapOfSets() { return autoExpandingMap(src -> mapOfSets()); }
public static <K1, K2, V> Map<K1, Map<K2, V>> mapOfMaps() { return autoExpandingMap(src -> synchronizedMap()); }
@Override public void assign(Screen src) { home(src.home()); brand(src.brand()); title(src.title()); content(src.content()); menu(Coll.deepCopyOf(src.menu())); embedded(src.embedded()); search(src.search()); navbar(src.navbar()); fluid(src.fluid()); cdn(src.cdn()); Coll.assign(js, src.js()); Coll.assign(css, src.css()); }
@Override public boolean cond(String name) { Object val = get(name); return val != null && !Boolean.FALSE.equals(val) && !"".equals(val) && (!Coll.isCollection(val) || !U.isEmpty((Collection<?>) val)) && (!Coll.isMap(val) || !U.isEmpty((Map<?, ?>) val)); }
@SuppressWarnings("unchecked") public static <T> T newInstance(Class<T> clazz) { Err.argMust(clazz != AutoExpandingMap.class, "Cannot instantiate AutoExpandingMap!"); if (clazz == List.class) { return (T) U.list(); } else if (clazz == Set.class) { return (T) U.set(); } else if (clazz == Map.class) { return (T) U.map(); } else if (clazz == ConcurrentMap.class) { return (T) Coll.concurrentMap(); } else if (clazz.getName().equals("java.util.Collections$SynchronizedSet")) { return (T) Coll.synchronizedSet(); } else if (clazz.getName().equals("java.util.Collections$SynchronizedList")) { return (T) Coll.synchronizedList(); } else if (clazz.getName().equals("java.util.Collections$SynchronizedMap")) { return (T) Coll.synchronizedMap(); } else if (clazz == Var.class) { return (T) Vars.var("<new>", null); } else if (clazz == Object.class) { return (T) new Object(); } return newBeanInstance(clazz); }
public RouteMeta copy() { RouteMeta copy = new RouteMeta(); copy.id = this.id; copy.summary = this.summary; copy.description = this.description; copy.publish = this.publish; copy.tags = Coll.copyOf(U.safe(this.tags)); copy.inputSchema = this.inputSchema; copy.outputSchema = this.outputSchema; copy.responses = Coll.deepCopyOf(U.safe(this.responses)); return copy; }
private void reloadAndProcessChanges() { mustBeRoot(); Set<ConfigChangeListener> listeners = U.set(base.configChangesListeners); if (listeners.isEmpty()) return; ConfigImpl previousConfig = new ConfigImpl(Coll.deepCopyOf(toMap())); // reload the configuration invalidate(); makeSureIsInitialized(); // notify listeners for (ConfigChangeListener listener : listeners) { notifyChangeListener(listener, previousConfig); } }
Map<String, List<Upload>> autoFiles = Coll.mapOfLists(); parseMultiParts(src, body, data, dataContentTypes, autoFiles, multipartBoundary, helper); files.putAll(autoFiles);
public static <K1, K2, K3, V> Map<K1, Map<K2, Map<K3, V>>> mapOfMapOfMaps() { return autoExpandingMap(src -> mapOfMaps()); }
public static <K, V> Map<K, List<V>> mapOfLists() { return autoExpandingMap(src -> synchronizedList()); }
public static <K, V> Map<K, Set<V>> mapOfSets() { return autoExpandingMap(src -> synchronizedSet()); }
@Override public Map<String, Serializable> session() { if (session == null) { synchronized (this) { if (session == null) { session = Coll.trackChanges(loadSession(), sessionChanged); } } } return session; }
public static <T> List<T> page(Iterable<T> items, int page, int pageSize) { return Coll.range(items, (page - 1) * pageSize, page * pageSize); }
@Override public <K, V> Map<K, V> autoExpandingInjectingMap(final Class<V> clazz) { return Coll.autoExpandingMap(src -> inject(Cls.newInstance(clazz))); }
@SuppressWarnings("unchecked") public static Set<String> getRolesFor(String username) { if (U.isEmpty(username)) { return U.set(); } Config user = Conf.USERS.sub(username); if (user.isEmpty()) { return U.set(); } Object roles = user.entry("roles").getOrNull(); if (Coll.isCollection(roles)) { Set<String> roleSet = U.set(); for (String role : (Collection<String>) roles) { roleSet.add(role.toLowerCase()); } return roleSet; } else if (roles instanceof String) { Set<String> roleSet = U.set(); for (String role : ((String) roles).toLowerCase().split("\\s*\\,\\s*")) { role = role.trim(); if (U.notEmpty(role)) { roleSet.add(role); } } return roleSet; } else { return Collections.emptySet(); } }
private void crawl() { for (Iterable<? extends Expiring> coll : Coll.copyOf(collections)) { long now = U.time(); for (Expiring target : coll) { try { long expiresAt = target.getExpiresAt(); if (expiresAt > 0 && expiresAt < now) { target.expire(); target.setExpiresAt(0); } } catch (Exception e) { Log.error("Error on expiration!", e); } } } }
@SuppressWarnings("unchecked") public static Object copyOf(Object source, Mapper<Object, ?> transformation) { Err.argMust(source != null, "source cannot be null!"); if (Coll.isCollection(source)) { return copyOf((Collection<?>) source, transformation); } else if (Coll.isMap(source)) { return copyOf((Map<?, ?>) source, transformation); } else if (source instanceof Object[]) { // FIXME support primitive arrays return copyOf((Object[]) source, transformation); } else { try { return transformation != null ? transformation.map(source) : source; } catch (Exception e) { throw new RuntimeException("Transformation error!", e); } } }