public OpenEnergyMonitorParserRule(String rule) throws OpenEnergyMonitorException {
try {
String[] parts = rule.split(":");
if (parts.length != 2) {
throw new OpenEnergyMonitorException("Invalid parser rule '" + rule + "'");
}
// Address
this.address = Byte.parseByte(parts[0]);
// Data type
Matcher matcher = EXTRACT_DATA_TYPE_PATTERN.matcher(parts[1]);
if (!matcher.matches()) {
throw new OpenEnergyMonitorException(
"Invalid parser rule '"
+ rule
+ "', given data type '"
+ parts[1]
+ "' does not follow the expected pattern '<DataType>(<pattern>)'");
}
matcher.reset();
matcher.find();
String dataType = matcher.group(1);
try {
this.dataType = DataType.valueOf(dataType);
} catch (IllegalArgumentException e) {
throw new OpenEnergyMonitorException(
"Invalid parser rule '" + rule + "', unknown data type");
}
// Byte indexes
String[] b = matcher.group(2).split("\\|");
if (b.length > 8) {
throw new OpenEnergyMonitorException("Invalid parser rule '" + rule + "', too many bytes");
}
bytesIndex = new int[b.length];
for (int i = 0; i < b.length; i++) {
bytesIndex[i] = Integer.parseInt(b[i]);
}
} catch (Exception e) {
throw new OpenEnergyMonitorException("Invalid parser rule", e);
}
}
public DataType getDataType(Message message) {
final String dataTypeHeader = Headers.get(message, Headers.DATATYPE);
final String typeHeader = Headers.get(message, Headers.TYPE);
// we have two possible header sets here
// legacy: there is Headers.DATATYPE .Headers.TYPE
// contains either the string "mms" or an integer which is the internal type of the sms
// current: there IS a Headers.DATATYPE containing a string representation of Headers.DataType
// Headers.TYPE then contains the type of the sms, mms or calllog entry
// The current header set was introduced in version 1.2.00
if (dataTypeHeader == null) {
return MmsConsts.LEGACY_HEADER.equalsIgnoreCase(typeHeader) ? DataType.MMS : DataType.SMS;
} else {
try {
return DataType.valueOf(dataTypeHeader.toUpperCase(Locale.ENGLISH));
} catch (IllegalArgumentException e) {
return DataType.SMS; // whateva
}
}
}
/** Set the configuration information for this field=value line. */
private static void readField(DatabaseFieldConfig config, String field, String value) {
if (field.equals(FIELD_NAME_FIELD_NAME)) {
config.setFieldName(value);
} else if (field.equals(FIELD_NAME_COLUMN_NAME)) {
config.setColumnName(value);
} else if (field.equals(FIELD_NAME_DATA_PERSISTER)) {
config.setDataPersister(DataType.valueOf(value).getDataPersister());
} else if (field.equals(FIELD_NAME_DEFAULT_VALUE)) {
config.setDefaultValue(value);
} else if (field.equals(FIELD_NAME_WIDTH)) {
config.setWidth(Integer.parseInt(value));
} else if (field.equals(FIELD_NAME_CAN_BE_NULL)) {
config.setCanBeNull(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_ID)) {
config.setId(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_GENERATED_ID)) {
config.setGeneratedId(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_GENERATED_ID_SEQUENCE)) {
config.setGeneratedIdSequence(value);
} else if (field.equals(FIELD_NAME_FOREIGN)) {
config.setForeign(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_USE_GET_SET)) {
config.setUseGetSet(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_UNKNOWN_ENUM_VALUE)) {
String[] parts = value.split("#", -2);
if (parts.length != 2) {
throw new IllegalArgumentException(
"Invalid value for unknownEnumValue which should be in class#name format: " + value);
}
Class<?> enumClass;
try {
enumClass = Class.forName(parts[0]);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException(
"Unknown class specified for unknownEnumValue: " + value);
}
Object[] consts = enumClass.getEnumConstants();
if (consts == null) {
throw new IllegalArgumentException(
"Invalid class is not an Enum for unknownEnumValue: " + value);
}
@SuppressWarnings("rawtypes")
Enum[] enumConstants = (Enum[]) consts;
boolean found = false;
for (Enum<?> enumInstance : enumConstants) {
if (enumInstance.name().equals(parts[1])) {
config.setUnknownEnumValue(enumInstance);
found = true;
}
}
if (!found) {
throw new IllegalArgumentException(
"Invalid enum value name for unknownEnumvalue: " + value);
}
} else if (field.equals(FIELD_NAME_THROW_IF_NULL)) {
config.setThrowIfNull(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_FORMAT)) {
config.setFormat(value);
} else if (field.equals(FIELD_NAME_UNIQUE)) {
config.setUnique(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_UNIQUE_COMBO)) {
config.setUniqueCombo(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_INDEX)) {
config.setIndex(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_INDEX_NAME)) {
config.setIndex(true);
config.setIndexName(value);
} else if (field.equals(FIELD_NAME_UNIQUE_INDEX)) {
config.setUniqueIndex(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_UNIQUE_INDEX_NAME)) {
config.setUniqueIndex(true);
config.setUniqueIndexName(value);
} else if (field.equals(FIELD_NAME_FOREIGN_AUTO_REFRESH)) {
config.setForeignAutoRefresh(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_MAX_FOREIGN_AUTO_REFRESH_LEVEL)) {
config.setMaxForeignAutoRefreshLevel(Integer.parseInt(value));
} else if (field.equals(FIELD_NAME_PERSISTER_CLASS)) {
try {
@SuppressWarnings("unchecked")
Class<? extends DataPersister> clazz =
(Class<? extends DataPersister>) Class.forName(value);
config.setPersisterClass(clazz);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Could not find persisterClass: " + value);
}
} else if (field.equals(FIELD_NAME_ALLOW_GENERATED_ID_INSERT)) {
config.setAllowGeneratedIdInsert(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_COLUMN_DEFINITION)) {
config.setColumnDefinition(value);
} else if (field.equals(FIELD_NAME_FOREIGN_AUTO_CREATE)) {
config.setForeignAutoCreate(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_VERSION)) {
config.setVersion(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_FOREIGN_COLUMN_NAME)) {
config.setForeignColumnName(value);
} else if (field.equals(FIELD_NAME_READ_ONLY)) {
config.setReadOnly(Boolean.parseBoolean(value));
}
/** foreign collection field information */
else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION)) {
config.setForeignCollection(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_EAGER)) {
config.setForeignCollectionEager(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_MAX_EAGER_FOREIGN_COLLECTION_LEVEL_OLD)) {
config.setForeignCollectionMaxEagerLevel(Integer.parseInt(value));
} else if (field.equals(FIELD_NAME_MAX_EAGER_FOREIGN_COLLECTION_LEVEL)) {
config.setForeignCollectionMaxEagerLevel(Integer.parseInt(value));
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_COLUMN_NAME)) {
config.setForeignCollectionColumnName(value);
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_ORDER_COLUMN_NAME_OLD)) {
config.setForeignCollectionOrderColumnName(value);
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_ORDER_COLUMN_NAME)) {
config.setForeignCollectionOrderColumnName(value);
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_ORDER_ASCENDING)) {
config.setForeignCollectionOrderAscending(Boolean.parseBoolean(value));
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_FOREIGN_FIELD_NAME_OLD)) {
config.setForeignCollectionForeignFieldName(value);
} else if (field.equals(FIELD_NAME_FOREIGN_COLLECTION_FOREIGN_FIELD_NAME)) {
config.setForeignCollectionForeignFieldName(value);
}
}
public void setType(String type) {
this.type = DataType.valueOf(type.trim().toUpperCase());
}
public DataType readFrom(RESPReader reader) {
return DataType.valueOf(reader.readString().toUpperCase());
}
