private static String title(JsonObject o, String defaults) { String s = Strings.firstNotEmpty(o.getString(TITLE), o.getString("x-" + TITLE)); if(Strings.isEmpty(s)) { s = Strings.firstNotEmpty(o.getString(SUMMARY), o.getString("x-" + SUMMARY)); } if(Strings.isEmpty(s)) { s = defaults; } return s; }
public static void parse(MetaSecurity security, String expr) { expr = Strings.trim(expr); if(Strings.isEmpty(expr)) { return; } String[] rules = Strings.split(expr, '|'); if(rules.length > 2) { throw new IllegalStateException("Invalid security expr '" + expr + "'"); } for(String rule : rules) { parseRule(security, rule); } }
protected BeanDefinition findBeanDefinition(Set<BeanDefinitionBase> beanDefinitions,String name){ for(BeanDefinitionBase bd : beanDefinitions){ if(Strings.equals(bd.name, name)){ return bd; } } return null; }
protected String[] parseProducesOrConsumes(String expr) { return Strings.splitWhitespaces(Strings.replace(expr, ",", " ")); } }
protected String removePrefixAndSuffix(String expr) { if (expr.startsWith("#{")) { return Strings.removeEnd(Strings.removeStart(expr, "#{"), "}"); } else { return expr; } } }
public FieldMappingBuilder trySetFieldName(String fieldName){ if(Strings.isEmpty(this.fieldName)){ this.fieldName = fieldName; } return this; }
public static <T> T get(Properties properties,String key,Class<T> targetType, T defaultValue) { if(null == properties || null == key){ return defaultValue; } String value = properties.getProperty(key); if(null == value || Strings.isEmpty((value = Strings.trim(value)))){ return defaultValue; } return Converts.convert(value, targetType); }
protected List<String> parseWords(String words){ List<String> list = new ArrayList<String>(); if(!Strings.isEmpty(words)){ String[] lines = Strings.splitMultiLines(words); for(String line : lines){ for(String word : Strings.split(line,',')){ list.add(word); } } } return list; }
public static int parseFlags(String flags){ String[] flagNames = Strings.split(flags,"|"); int flag = 0; for(String name : flagNames){ Integer value = Patterns.flags.get(name); if(null == value){ throw new IllegalStateException("Invalid pattern flag '" + name + "'"); } flag = flag | value; } return flag; }
private void configureNested(Object bean, String keyPrefix, ReflectValued member, Configurable.Nested nested) { String nestedPrefix = nested.prefix(); if(Strings.isEmpty(nestedPrefix)) { nestedPrefix = Strings.lowerUnderscore(member.getName()); if(nestedPrefix.endsWith("_config")) { nestedPrefix = Strings.removeEnd(nestedPrefix, "_config"); } } String fullKeyPrefix = keyPrefix(keyPrefix + nestedPrefix); Object nestedBean = member.getValue(bean); BeanType nestedType; if(null == nestedBean) { nestedType = BeanType.of(member.getType()); nestedBean = nestedType.newInstance(); member.setValue(bean, nestedBean); }else{ nestedType = BeanType.of(nestedBean.getClass()); } configure(nestedBean, nestedType, fullKeyPrefix); }
protected boolean matchProfile(String profile, XmlReader element) { String profileName = element.getAttribute(IF_PROFILE_ATTRIBUTE); if(!Strings.isEmpty(profileName)){ return Strings.equalsIgnoreCase(profile, profileName); }else{ return true; } } }
protected ValueDefinition readRefElement(LoaderContext context, XmlReader reader) { String refId = reader.resolveAttribute(ID_ATTRIBUTE); String refType = reader.resolveAttribute(TYPE_ATTRIBUTE); String refName = reader.resolveAttribute(NAME_ATTRIBUTE); if (Strings.isAllEmpty(refId, refType, refName)) { throw new BeanDefinitionException("Invalid bean reference in '" + reader.getCurrentLocation() + "'"); } if (Strings.isNotEmpty(refName) && Strings.isEmpty(refType)) { throw new BeanDefinitionException("The referenced type must be exists in '" + reader.getCurrentLocation() + "'"); } return tryCreateBeanReference(context, reader, refId, refType, refName); }
protected void addReplacedText(SqlStatementBuilder stm,Params params, Object p) throws IOException { Object value = eval(stm,params); String string = Converts.toString(value); if(!Strings.isEmpty(string)){ Scope scope = getScope(); if(scope == Scope.STRING){ string = Strings.replace(string, "'", "''"); } stm.append(string); } }
@Override public int[] executeBatchUpdate(String... sqls) throws NestedSQLException { if(null == sqls || sqls.length == 0) { return Arrays2.EMPTY_INT_ARRAY; } SqlExecutionContext.setup(SqlExcutionType.Write, Strings.join(sqls, ";")); return executeWithResult((conn) -> { Statement stmt = conn.createStatement(); for(String sql : sqls) { if(Strings.isEmpty(sql)) { throw new IllegalArgumentException("Sql content must not be empty in the sql array"); } stmt.addBatch(sql); } return stmt.executeBatch(); }); }
protected void parseTags(String expr) { if(Strings.isNotEmpty(expr)){ String[] tags = Strings.split(expr,","); for(String tag : tags){ if(Strings.isNotEmpty(tag)){ op.addTag(tag.trim()); } } } }
protected BeanDefinitionBase findBeanDefinition(BeanReference br){ if(Strings.isNotEmpty(br.getTargetId())){ return findBeanDefinition(br.getTargetId()); } if(Strings.isEmpty(br.getBeanName())) { return findPrimaryBeanDefinition(br.getBeanType()); }else{ return findBeanOrAliasDefinition(br.getBeanType(),br.getBeanName()); } }
public String[] getProfiled(String[] templates) { String[] array = new String[templates.length]; for(int i=0;i<array.length;i++) { array[i] = Strings.replace(templates[i], "{profile}", profile); } return array; }
public String toSql() { StringBuilder sb = new StringBuilder(); for(int i=0;i<nodes.length;i++){ nodes[i].toSql(sb); } return Strings.trim(sb.toString()); }
protected void parseTag(String expr) { if(Strings.isNotEmpty(expr)){ op.addTag(expr); } }