Java UtilXml.checkBoolean方法代码示例

import org.ofbiz.base.util.UtilXml; //导入方法依赖的package包/类
protected void populateBasicInfo(Element entityElement) {
    this.entityName = UtilXml.checkEmpty(entityElement.getAttribute("entity-name")).intern();
    this.tableName = UtilXml.checkEmpty(entityElement.getAttribute("table-name"), ModelUtil.javaNameToDbName(this.entityName)).intern();
    this.packageName = UtilXml.checkEmpty(entityElement.getAttribute("package-name")).intern();
    this.dependentOn = UtilXml.checkEmpty(entityElement.getAttribute("dependent-on")).intern();
    this.doLock = UtilXml.checkBoolean(entityElement.getAttribute("enable-lock"), false);
    this.noAutoStamp = UtilXml.checkBoolean(entityElement.getAttribute("no-auto-stamp"), false);
    this.neverCache = UtilXml.checkBoolean(entityElement.getAttribute("never-cache"), false);
    this.neverCheck = UtilXml.checkBoolean(entityElement.getAttribute("never-check"), false);
    this.autoClearCache = UtilXml.checkBoolean(entityElement.getAttribute("auto-clear-cache"), true);

    String sequenceBankSizeStr = UtilXml.checkEmpty(entityElement.getAttribute("sequence-bank-size"));
    if (UtilValidate.isNotEmpty(sequenceBankSizeStr)) {
        try {
            this.sequenceBankSize = Integer.valueOf(sequenceBankSizeStr);
        } catch (NumberFormatException e) {
            Debug.logError("Error parsing sequence-bank-size value [" + sequenceBankSizeStr + "] for entity [" + this.entityName + "]", module);
        }
    }
}
 

import org.ofbiz.base.util.UtilXml; //导入方法依赖的package包/类
private void createImplDefs(Element baseElement, ModelService service) {
    for (Element implement: UtilXml.childElementList(baseElement, "implements")) {
        String serviceName = UtilXml.checkEmpty(implement.getAttribute("service")).intern();
        boolean optional = UtilXml.checkBoolean(implement.getAttribute("optional"), false);
        if (serviceName.length() > 0)
            service.implServices.add(new ModelServiceIface(serviceName, optional));
            //service.implServices.add(serviceName);
    }
}
 

import org.ofbiz.base.util.UtilXml; //导入方法依赖的package包/类
public void addExtendEntity(ModelReader reader, Element extendEntityElement) {
    if (extendEntityElement.hasAttribute("enable-lock")) {
        this.doLock = UtilXml.checkBoolean(extendEntityElement.getAttribute("enable-lock"), false);
    }
    
    if (extendEntityElement.hasAttribute("no-auto-stamp")) {
        this.noAutoStamp = UtilXml.checkBoolean(extendEntityElement.getAttribute("no-auto-stamp"), false);
    }
    
    if (extendEntityElement.hasAttribute("auto-clear-cache")) {
        this.autoClearCache = UtilXml.checkBoolean(extendEntityElement.getAttribute("auto-clear-cache"), false);
    }
    
    if (extendEntityElement.hasAttribute("never-cache")) {
        this.neverCache = UtilXml.checkBoolean(extendEntityElement.getAttribute("never-cache"), false);
    }
    
    if (extendEntityElement.hasAttribute("sequence-bank-size")) {
        String sequenceBankSizeStr = UtilXml.checkEmpty(extendEntityElement.getAttribute("sequence-bank-size"));
        if (UtilValidate.isNotEmpty(sequenceBankSizeStr)) {
            try {
                this.sequenceBankSize = Integer.valueOf(sequenceBankSizeStr);
            } catch (NumberFormatException e) {
                Debug.logError("Error parsing sequence-bank-size value [" + sequenceBankSizeStr + "] for entity [" + this.entityName + "]", module);
            }
        }
    }
    
    for (Element fieldElement : UtilXml.childElementList(extendEntityElement, "field")) {
        ModelField newField = ModelField.create(this, fieldElement, false);
        ModelField existingField = this.getField(newField.getName());
        if (existingField != null) {
            // override the existing field's attributes
            // TODO: only overrides of type, colName, description and enable-audit-log are currently supported
            String type = existingField.getType();
            if (!newField.getType().isEmpty()) {
                type = newField.getType();
            }
            String colName = existingField.getColName();
            if (!newField.getColName().isEmpty()) {
                colName = newField.getColName();
            }
            String description = existingField.getDescription();
            if (!newField.getDescription().isEmpty()) {
                description = newField.getDescription();
            }
            boolean enableAuditLog = existingField.getEnableAuditLog();
            if (UtilValidate.isNotEmpty(fieldElement.getAttribute("enable-audit-log"))) {
                enableAuditLog = "true".equals(fieldElement.getAttribute("enable-audit-log"));
            }
            newField = ModelField.create(this, description, existingField.getName(), type, colName, existingField.getColValue(), existingField.getFieldSet(),
                    existingField.getIsNotNull(), existingField.getIsPk(), existingField.getEncryptMethod(), existingField.getIsAutoCreatedInternal(),
                    enableAuditLog, existingField.getValidators());
        }
        // add to the entity as a new field
        synchronized (fieldsLock) {
            if (existingField != null) {
                this.fieldsList.remove(existingField);
            }
            this.fieldsList.add(newField);
            this.fieldsMap.put(newField.getName(), newField);
            if (!newField.getIsPk()) {
                if (existingField != null) {
                    this.nopks.remove(existingField);
                }
                this.nopks.add(newField);
            } else {
                if (existingField != null) {
                    this.pks.remove(existingField);
                }
                this.pks.add(newField);
            }
        }
    }
    this.modelInfo = ModelInfo.createFromAttributes(this.modelInfo, extendEntityElement);
    this.populateRelated(reader, extendEntityElement);
    this.populateIndexes(extendEntityElement);
    this.dependentOn = UtilXml.checkEmpty(extendEntityElement.getAttribute("dependent-on")).intern();
}