Java Code Examples for org.osgl.util.S#eq()

public static void main(String[] args) {
    int warmUp = WARM_UP;
    int iteration = ITERATION;
    String singletonStr = conf("singleton");
    boolean singleton = S.notBlank(singletonStr) && Boolean.parseBoolean(singletonStr);
    String s = conf("warmup");
    if (S.notBlank(s)) {
        warmUp = Integer.parseInt(s);
    }
    s = conf("iteration");
    if (S.notBlank(s)) {
        iteration = Integer.parseInt(s);
    }
    s = conf("type");
    if (S.eq(s, "runtime")) {
        new RuntimeBenchmark().run(warmUp, iteration, singleton);
    }
    if (S.eq(s, "startup")) {
        new StartupBenchmark().run(warmUp, iteration);
    }
    if (S.eq(s, "split_startup")) {
        new SplitStartupBenchmark().run(iteration);
    }
}
 

private String evaluateExpression(String expression, Class<? extends Annotation> annoClass) {
    String prefix = annoClass.getSimpleName();
    if (S.eq(FixedDelay.class.getName(), prefix)) {
        prefix = "fixed-delay";
    } else {
        prefix = prefix.toLowerCase();
    }
    String ret = expression.trim();
    if (ret.startsWith(prefix)) {
        ret = (String) app().config().get(expression);
        if (S.blank(ret)) {
            throw E.invalidConfiguration("Expression configuration not found: %s", expression);
        }
    }
    return ret;
}
 

public static SourceInfo loadSourceInfo(StackTraceElement[] stackTraceElements, Class<? extends ActError> errClz) {
    E.illegalStateIf(Act.isProd());
    DevModeClassLoader cl = (DevModeClassLoader) App.instance().classLoader();
    String errClzName = errClz.getName();
    for (StackTraceElement stackTraceElement : stackTraceElements) {
        int line = stackTraceElement.getLineNumber();
        if (line <= 0) {
            continue;
        }
        String className = stackTraceElement.getClassName();
        if (S.eq(className, errClzName)) {
            continue;
        }
        Source source = cl.source(className);
        if (null == source) {
            continue;
        }
        return new SourceInfoImpl(source, line);
    }
    return null;
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();

    if (S.eq("hashCode", methodName)) {
        return hashCode();
    } else if (S.eq("equals", methodName)) {
        return equals(args[0]);
    } else if (S.eq("annotationType", methodName)) {
        return type;
    } else if (S.eq("toString", methodName)) {
        return toString();
    }

    Object result = memberValues.get(methodName);
    if (null != result) {
        return result;
    }

    result = method.getDefaultValue();

    if (result == null) {
        throw new IncompleteAnnotationException(type, methodName);
    }

    return result;
}
 

@Override
public boolean equals(Object obj) {
    if (obj == this) {
        return true;
    }
    if (obj instanceof NamedPort) {
        NamedPort that = (NamedPort) obj;
        return S.eq(that.name, name);
    }
    return false;
}
 

@GetAction("person/{name};{attributes}/{key}")
public String test2(String name, Map<String, Integer> attributes, String key) {
    if (S.eq("name", key)) {
        return name;
    }
    return S.string(attributes.get(key));
}
 

public ActionMethodMetaInfo action(String name) {
    if (null == actionLookup) {
        for (ActionMethodMetaInfo act : actions) {
            if (S.eq(name, act.name())) {
                return act;
            }
        }
        return null;
    }
    return actionLookup.get(name);
}
 

public MailerConfig(String id, Map<String, String> properties, App app) {
    super(app);
    E.illegalArgumentIf(S.blank(id), "mailer config id expected");
    this.id = id;
    this.isDefault = "default".equals(id);
    this.from = getFromConfig(properties);
    this.contentType = getContentTypeConfig(properties);
    this.locale = getLocaleConfig(properties);
    this.subject = getProperty(SUBJECT, properties);
    this.host = getProperty(SMTP_HOST, properties);
    if ("gmail".equals(this.host)) {
        this.host = "smtp.gmail.com";
    }
    this.username = getProperty(SMTP_USERNAME, properties);
    if (null == host) {
        if (S.notBlank(this.username) && this.username.endsWith("gmail.com")) {
            this.host = "smtp.gmail.com";
        } else {
            info("smtp host configuration not found, will use mock smtp to send email");
            mock = true;
        }
    }
    if (!mock) {
        this.useTls = getBooleanConfig(SMTP_TLS, properties) || S.eq("smtp.gmail.com", this.host) || S.eq("smtp-mail.outlook.com", this.host);
        this.useSsl = !this.useTls && getBooleanConfig(SMTP_SSL, properties);
        this.port = getPortConfig(properties);
        this.password = getProperty(SMTP_PASSWORD, properties);
        if (null == username || null == password) {
            warn("Either smtp.username or smtp.password is not configured for mailer[%s]", id);
        }
    }
    this.toList = getEmailListConfig(TO, properties);
    this.ccList = getEmailListConfig(CC, properties);
    this.bccList = getEmailListConfig(BCC, properties);
}
 

public SenderMethodMetaInfo sender(String name) {
    if (null == mailerLookup) {
        for (SenderMethodMetaInfo act : senders) {
            if (S.eq(name, act.name())) {
                return act;
            }
        }
        return null;
    }
    return mailerLookup.get(name);
}
 

private static boolean isTemplateBounded(String templatePath, String methodPath) {
    int pos = templatePath.indexOf('/');
    if (pos < 0) {
        // must be a free template without package hierarchies
        return false;
    }
    int pos2 = methodPath.indexOf('.');
    if (pos2 != pos) {
        // must be a free template as the first package path doesn't match
        return false;
    }
    String templatePathStartPkg = templatePath.substring(0, pos);
    String methodPathStartPkg = methodPath.substring(0, pos2);
    return S.eq(templatePathStartPkg, methodPathStartPkg);
}
 

@Override
public final boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj instanceof SysEventListener) {
        SysEventListener that = (SysEventListener) obj;
        return S.eq(that.id(), this.id());
    }
    return false;
}
 

@Override
public void visitEnd() {
    int arrayValueSize = arrayValue.size();
    if (arrayValueSize > 0) {
        if (S.eq(desc, DESC_REQUIRE_PROFILE) || S.eq(desc, DESC_PROFILE)) {
            matched = Env.profileMatches(arrayValue.toArray(new String[arrayValueSize]));
        } else if (S.eq(desc, DESC_REQUIRE_GROUP) || S.eq(desc, DESC_GROUP)) {
            matched = Env.groupMatches(arrayValue.toArray(new String[arrayValueSize]));
        }
    }
    matched = except ^ matched;
    super.visitEnd();
}
 

@Override
public void visit(String name, Object value) {
    if ("value".equals(name)) {
        String s = S.string(value);
        if (S.eq(desc, DESC_REQUIRE_MODE) || S.eq(desc, DESC_MODE)) {
            matched = Env.modeMatches(s);
        }
    } else if ("except".equals(name)) {
        except = (Boolean) value;
    }
    super.visit(name, value);
}
 

public boolean verifySignature(String message, String signature) {
    if (!rotationEnabled) {
        return S.eq(signature, super.sign(message));
    }
    return S.eq(signature, cur().sign(message))
            || S.eq(signature, prev().sign(message))
            || S.eq(signature, next().sign(message));
}
 

public static boolean groupMatches(String[] groups) {
    final String actGroup = Act.nodeGroup();
    for (String group : groups) {
        if (S.eq(group, actGroup, S.IGNORECASE)) {
            return true;
        }
    }
    return false;
}
 

public boolean verifyArgo(String algoName) {
    Algorithm algorithm = algoLookup.get(algoName);
    return null != algorithm && S.eq(this.algoName, algorithm.jwtName());
}
 

String varName() {
    return (null == varName || S.eq(ProvidesImplicitTemplateVariable.DEFAULT, varName)) ? methodName : varName;
}
 

private boolean verifyIssuer(JSONObject payloads) {
    return S.eq(issuer, payloads.getString("iss"));
}
 

public boolean matches(String s) {
    return isPattern() ? this.s.startsWith(S.concat(s, "\\.")) || p.matcher(s).matches() : S.eq(s(), s);
}
 

private static boolean isAnnotation(Class<? extends Annotation> annoType, String desc) {
    return S.eq(annoType.getName(), Type.getType(desc).getClassName());
}