Java Code Examples for org.rapidoid.u.U#eq()

public static boolean contains(Object arrOrColl, Object value) {
	if (arrOrColl instanceof Object[]) {
		Object[] arr = (Object[]) arrOrColl;
		return Arr.indexOf(arr, value) >= 0;

	} else if (arrOrColl instanceof Collection<?>) {
		Collection<?> coll = (Collection<?>) arrOrColl;
		return coll.contains(value);

	} else if (arrOrColl == null) {
		return false;

	} else {
		return U.eq(arrOrColl, value);
	}
}
 

public static boolean login(String username, String password) {
	if (U.isEmpty(username) || password == null) {
		return false;
	}

	if (!Conf.USERS.has(username)) {
		return false;
	}

	Config user = Conf.USERS.sub(username);

	if (user.isEmpty()) {
		return false;
	}

	String pass = user.entry("password").str().getOrNull();
	String hash = user.entry("hash").str().getOrNull();

	return (pass != null && U.eq(password, pass)) || (hash != null && Crypto.passwordMatches(password, hash));
}
 

public boolean clicked() {
	if (command != null) {
		IReqInfo req = ReqInfo.get();

		if (!req.isGetReq()) {
			String event = GUI.getCommand();

			if (U.notEmpty(event) && U.eq(event, command)) {
				Object[] args = new Object[cmdArgs.length];

				for (int i = 0; i < args.length; i++) {
					args[i] = U.or(req.data().get("_" + i), "");
				}

				return Arrays.equals(args, cmdArgs);
			}
		}
	}

	return false;
}
 

private static boolean isMainMethod(MethodInfo method) {
	int flags = method.getAccessFlags();

	return method.getName().equals("main")
		&& Modifier.isPublic(flags)
		&& Modifier.isStatic(flags)
		&& U.eq(method.getDescriptor(), "([Ljava/lang/String;)V"); // TODO find more elegant solution
}
 

@Override
protected Object render() {
	U.notNull(options, "options");
	List<Object> radios = U.list();

	for (Object opt : options) {
		boolean checked = initial != null && U.eq(initial, opt);
		radios.add(GUI.radio().name(_name()).value(opt).checked(checked).label(str(opt)));
	}

	return radios;
}
 

@Override
protected Object render() {
	U.notNull(options, "options");
	SelectTag select = GUI.select().name(_name()).class_("form-control select2");

	for (Object opt : options) {
		boolean initial = this.initial != null && U.eq(this.initial, opt);
		OptionTag op = GUI.option(opt).value(str(opt)).selected(picked(opt, initial));
		select = select.append(op);
	}

	return select;
}
 

public int fieldIndex(String fieldName) {
	for (int i = 0; i < fields.size(); i++) {
		if (U.eq(fields.get(i).name, fieldName)) {
			return i;
		}
	}

	throw U.rte("Cannot find field '%s'!", fieldName);
}
 

public static byte[] responseToBytes(Req req, Object result, MediaType contentType, HttpResponseRenderer responseRenderer) {
	if (U.eq(contentType, MediaType.JSON) || U.eq(contentType, MediaType.XML_UTF_8)) {
		ByteArrayOutputStream out = new ByteArrayOutputStream();

		try {
			responseRenderer.render(req, result, out);
		} catch (Exception e) {
			throw U.rte(e);
		}

		return out.toByteArray();
	} else {
		return Msc.toBytes(result);
	}
}
 

private static void close(Stack<XNode> stack, String text) {
	U.must(!stack.isEmpty(), "Empty stack!");

	XNode x = stack.pop();
	U.must(x.op != XNode.OP.OP_ROOT, "Cannot close a tag that wasn't open: %s", text);

	if (!U.eq(x.text, text)) {
		throw U.rte("Expected block: %s, but found: %s", x.text, text);
	}

	stack.peek().children.add(x);
}
 

public static Class<?> getCallingMainClass() {
	StackTraceElement[] trace = Thread.currentThread().getStackTrace();

	// skip the first 2 elements:
	// [0] java.lang.Thread.getStackTrace
	// [1] THIS METHOD

	for (int i = 2; i < trace.length; i++) {
		String cls = trace[i].getClassName();

		if (couldBeCaller(cls) && U.eq(trace[i].getMethodName(), "main")) {
			Class<?> clazz = Cls.getClassIfExists(cls);

			if (clazz != null) {
				Method main = Cls.findMethod(clazz, "main", String[].class);
				if (main != null && main.getReturnType() == void.class
					&& !main.isVarArgs() && main.getDeclaringClass().equals(clazz)) {
					int modif = main.getModifiers();
					if (Modifier.isStatic(modif) && Modifier.isPublic(modif)) {
						return clazz;
					}
				}
			}
		}
	}

	return null;
}
 

protected MapEntry<K, V> findEntry(K key, SimpleBucket<MapEntry<K, V>> bucket) {
	for (int i = 0; i < bucket.size(); i++) {
		MapEntry<K, V> entry = bucket.get(i);

		if (entry != null && U.eq(entry.key, key)) {
			return entry;
		}
	}

	return null;
}
 

public E find(String id) {
	U.notNull(id, "id");

	for (E item : items) {
		if (U.eq(id, item.id())) return item;
	}

	return null;
}
 

private static Manageable findById(List<? extends Manageable> items, String id) {
	U.notNull(id, "id");

	for (Manageable item : items) {
		if (U.eq(id, item.id())) return item;
	}

	return null;
}
 

public static int indexOf(Object[] arr, Object value) {
	for (int i = 0; i < arr.length; i++) {
		if (U.eq(arr[i], value)) {
			return i;
		}
	}
	return -1;
}
 

public static boolean isEvent() {
	IReqInfo req = req();
	return U.eq(req.params().get("__event__"), "true");
}
 

void setActiveUri(String uri) {
	active = U.eq(uri, target);
}
 

private static boolean shouldScanJAR(String jar) {
	String filename = new File(jar).getName();
	return !filename.equalsIgnoreCase("rapidoid.jar") && (!ClasspathUtil.hasAppJar() || U.eq(jar, ClasspathUtil.appJar()));
}
 

public static boolean eq(Object a, Object b) {
	return U.eq(a, b);
}