@Override protected List<DataSourceField> addDataSourceFields() { List<DataSourceField> fields = super.addDataSourceFields(); DataSourceField idDataField = new DataSourceIntegerField("id", MSG.common_title_id(), 50); idDataField.setPrimaryKey(true); idDataField.setCanEdit(false); fields.add(idDataField); DataSourceTextField nameDataField = new DataSourceTextField(NAME.propertyName(), NAME.title(), 200); nameDataField.setCanEdit(false); fields.add(nameDataField); DataSourceTextField descriptionDataField = new DataSourceTextField(DESCRIPTION.propertyName(), DESCRIPTION.title()); descriptionDataField.setCanEdit(false); fields.add(descriptionDataField); DataSourceTextField typeNameDataField = new DataSourceTextField(TYPE.propertyName(), TYPE.title()); fields.add(typeNameDataField); DataSourceTextField pluginNameDataField = new DataSourceTextField(PLUGIN.propertyName(), PLUGIN.title()); fields.add(pluginNameDataField); DataSourceTextField categoryDataField = new DataSourceTextField(CATEGORY.propertyName(), CATEGORY.title()); fields.add(categoryDataField); return fields; }
@Override @SideOnly(Side.CLIENT) public void registerIcons(IIconRegister iconRegister) { for (TYPE type : TYPE.VALUES) { type.registerIcon(iconRegister); } }
@Override public String randomValueAsString(Field<TYPE> field) { TYPE randomValue = randomValue(field); String stringValue = randomValue.toString(); if (field.getPadding() != null) { long maxLength = field.getMaxLength() != 0 ? field.getMaxLength() : field.getFixedLength(); stringValue = paddedRandomValue(field.getPadding(), randomValue, maxLength); } return stringValue; }
/** * Creates the given item. * * @param database * @param table table name * @param item item model * @return returns true on success. */ public boolean createNew(TYPE item) { item.clearValue(AbstractModel.ID_PROPERTY); long newRow = database.insert(table.name, AbstractModel.ID_PROPERTY.name, item.getMergedValues()); boolean result = newRow >= 0; if (result) { item.setId(newRow); onModelUpdated(item); item.markSaved(); } return result; }
/** * Save the given object to the database. Creates a new object if model id property has not been * set * * @return true on success. */ public boolean persist(TYPE item) { if (item.getId() == AbstractModel.NO_ID) { return createNew(item); } else { ContentValues values = item.getSetValues(); if (values.size() == 0) // nothing changed return true; return saveExisting(item); } }
/** {@inheritDoc} */ @Override public TYPE createFromParcel(Parcel source) { TYPE model; try { model = cls.newInstance(); } catch (IllegalAccessException | InstantiationException e) { throw new RuntimeException(e); } model.setValues = source.readParcelable(ContentValues.class.getClassLoader()); model.values = source.readParcelable(ContentValues.class.getClassLoader()); return model; }
@Override protected Void doInBackground(Void... voids) { if (TYPE.equalsIgnoreCase("ALERT") || TYPE.equalsIgnoreCase("ALERTS")) { fetchALertData(); } else if (TYPE.equalsIgnoreCase("HOMEWORK")) { fetchHomeWorkData(); } else { fetchNoticeData(TYPE); } return null; }
/** * Saves the given item. Will not create a new item! * * @param database * @param table table name * @param item item model * @return returns true on success. */ public boolean saveExisting(TYPE item) { ContentValues values = item.getSetValues(); if (values == null || values.size() == 0) // nothing changed return true; boolean result = database.update( table.name, values, AbstractModel.ID_PROPERTY.eq(item.getId()).toString(), null) > 0; if (result) { onModelUpdated(item); item.markSaved(); } return result; }
@Override public String asText() { switch (type) { case ADDED: return type.name().toCharArray()[0] + "\t" + TextValueSerializer.asString(Optional.fromNullable((Object) newGeometry.orNull())); case REMOVED: return type.name().toCharArray()[0] + "\t" + TextValueSerializer.asString(Optional.fromNullable((Object) oldGeometry.orNull())); case MODIFIED: default: return type.name().toCharArray()[0] + "\t" + diff.asText(); } }
@Override public ListGridRecord copyValues(ResourceGroupComposite from) { ListGridRecord record = new ListGridRecord(); record.setAttribute("group", from); record.setAttribute("id", from.getResourceGroup().getId()); record.setAttribute(NAME.propertyName(), from.getResourceGroup().getName()); record.setAttribute(DESCRIPTION.propertyName(), from.getResourceGroup().getDescription()); record.setAttribute(CATEGORY.propertyName(), from.getResourceGroup().getGroupCategory().name()); record.setAttribute("explicitCount", String.valueOf(from.getExplicitCount())); record.setAttribute("explicitDown", String.valueOf(from.getExplicitDown())); record.setAttribute("explicitDisabled", String.valueOf(from.getExplicitDisabled())); record.setAttribute("implicitCount", String.valueOf(from.getImplicitCount())); record.setAttribute("implicitDown", String.valueOf(from.getImplicitDown())); record.setAttribute("implicitDisabled", String.valueOf(from.getImplicitDisabled())); record.setAttribute(AVAIL_CHILDREN.propertyName(), getExplicitFormatted(from)); record.setAttribute(AVAIL_DESCENDANTS.propertyName(), getImplicitFormatted(from)); if (from.getResourceGroup().getResourceType() != null) { record.setAttribute("resourceType", from.getResourceGroup().getResourceType()); record.setAttribute(TYPE.propertyName(), from.getResourceGroup().getResourceType().getName()); record.setAttribute( PLUGIN.propertyName(), from.getResourceGroup().getResourceType().getPlugin()); } return record; }
public <TYPE extends BaseMessage> TYPE getReply() { Class msgClass = this.getClass(); while (!msgClass.getSimpleName().endsWith("Type")) { msgClass = msgClass.getSuperclass(); } TYPE reply = null; String replyType = msgClass.getName().replaceAll("Type", "") + "ResponseType"; try { Class responseClass = ClassLoader.getSystemClassLoader().loadClass(replyType); reply = (TYPE) responseClass.newInstance(); reply.correlationId = this.correlationId; } catch (Exception e) { Logger.getLogger(BaseMessage.class).debug(e, e); throw new TypeNotPresentException(this.correlationId, e); } return reply; }
// ============================================================= // PUBLIC METHODS // ============================================================ public String getString() { StringBuilder builder = new StringBuilder("\n[" + mType.name() + "]"); if (!TextUtils.isEmpty(getAction())) builder.append("\nAction:[" + getAction() + "]"); if (!TextUtils.isEmpty(getPointer())) builder.append("\nPointer:[" + getPointer() + "]"); for (int i = 0; i < mAttribute.size(); i++) if (!TextUtils.isEmpty(mAttribute.get(i).getString())) builder.append("\nAttr:[" + (mAttribute.get(i).getString()) + "]"); return builder.toString(); }
/** * This method is used to apply padding to a random value to make it the required length * * @param padding the value to be padded * @param value the generated random value * @param maxLength the maximum length of the random value * @return the padded random value as String */ private String paddedRandomValue(String padding, TYPE value, long maxLength) { long paddingLength = maxLength - value.toString().length(); String formattedValue = value.toString(); if (paddingLength <= 0) { return formattedValue; } StringBuilder valueWithPadding = new StringBuilder(padding); while (valueWithPadding.length() < paddingLength) { valueWithPadding.append(padding); } valueWithPadding.append(value.toString()); if (valueWithPadding.length() > maxLength) { formattedValue = valueWithPadding.substring(0, (int) maxLength); } else { formattedValue = valueWithPadding.toString(); } return formattedValue; }
@Override public void setProperties(LibProperties properties) { type = TYPE.valueOf(properties.getString(LibProperties.COLOR_HISTOGRAMS_TYPE)); binX = properties.getInteger(LibProperties.COLOR_HISTOGRAMS_BINS_X); binY = properties.getInteger(LibProperties.COLOR_HISTOGRAMS_BINS_Y); binZ = properties.getInteger(LibProperties.COLOR_HISTOGRAMS_BINS_Z); checkNotNull(type, "type must not be null"); checkArgument(binX > 0, "bin x must be >0 but was " + binX); checkArgument(binY > 0, "bin y must be >0 but was " + binY); checkArgument(binZ > 0, "bin z must be >0 but was " + binZ); }
/** * Check whether the user has changed this property value and it should be stored for saving in * the database */ protected synchronized <TYPE> boolean shouldSaveValue(Property<TYPE> property, TYPE newValue) { // we've already decided to save it, so overwrite old value if (setValues.containsKey(property.getColumnName())) { return true; } // values contains this key, we should check it out if (values != null && values.containsKey(property.getColumnName())) { TYPE value = getValue(property); if (value == null) { if (newValue == null) { return false; } } else if (value.equals(newValue)) { return false; } } // otherwise, good to save return true; }
/** * Constructs a new {@code EnumParam}, initialized to the default value. Limit the set of options * with the supplied {@code EnumSet}. * * @param name of the {@code Param} (max 72 chars) * @param info {@code String} for use in tooltips; a {@code null} value will be set to an empty * {@code String} (max 256 chars) * @param defaultValue of the {@code Param} * @param options a subset of the option type * @throws IllegalArgumentException if {@code name} is an empty string, {@code options} is empty, * or the {@code defaultValue} is not included in {@code options} */ DefaultEnumParam(String name, String info, E defaultValue, Set<E> options) { super(name, info, defaultValue); checkNotNull(options); checkArgument(!options.isEmpty(), "Options is empty"); checkArgument(options.contains(defaultValue), "Default missing from options"); this.options = Sets.immutableEnumSet(options); // init state state.addProperty(TYPE.toString(), ENUM.toString()); JsonArray stateOptions = new JsonArray(); for (E option : options) { stateOptions.add(new JsonPrimitive(option.name())); } state.add(OPTIONS.toString(), stateOptions); }
/** * Helper that reads entries from legacy database and row-by-row creates new models and saves * them. * * @param context * @param legacyTable * @param propertyMap * @param model * @param dao */ @SuppressWarnings("nls") private static final <TYPE extends AbstractModel> void upgradeTable( Context context, String legacyTable, HashMap<String, Property<?>> propertyMap, TYPE model, DatabaseDao<TYPE> dao) { if (!checkIfDatabaseExists(context, legacyTable)) return; SQLiteDatabase upgradeDb = new Astrid2UpgradeHelper(context, legacyTable, null, 1).getReadableDatabase(); Cursor cursor = upgradeDb.rawQuery("SELECT * FROM " + legacyTable, null); UpgradeVisitorContainer<TYPE> container = new UpgradeVisitorContainer<TYPE>(); container.cursor = cursor; container.model = model; ColumnUpgradeVisitor visitor = new ColumnUpgradeVisitor(); for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { model.clear(); for (Entry<String, Property<?>> entry : propertyMap.entrySet()) { container.columnIndex = cursor.getColumnIndex(entry.getKey()); entry.getValue().accept(visitor, container); } // special tweak for adding upgrade notes to tasks if (container.upgradeNotes != null) { if (container.model.getValue(Task.NOTES).length() == 0) container.model.setValue(Task.NOTES, container.upgradeNotes.toString()); else { container.model.setValue( Task.NOTES, container.model.getValue(Task.NOTES) + "\n\n" + container.upgradeNotes); } container.upgradeNotes = null; } dao.createNew(container.model); } cursor.close(); upgradeDb.close(); }
@Override public ResourceGroupComposite copyValues(Record from) { Integer idAttrib = from.getAttributeAsInt("id"); String nameAttrib = from.getAttribute(NAME.propertyName()); String descriptionAttrib = from.getAttribute(DESCRIPTION.propertyName()); String typeNameAttrib = from.getAttribute(TYPE.propertyName()); ResourceGroup rg = new ResourceGroup(nameAttrib); rg.setId(idAttrib); rg.setDescription(descriptionAttrib); if (typeNameAttrib != null) { ResourceType rt = new ResourceType(); rt.setName(typeNameAttrib); String pluginNameAttrib = from.getAttribute(PLUGIN.propertyName()); rt.setPlugin(pluginNameAttrib); rg.setResourceType(rt); } Long explicitCount = Long.valueOf(from.getAttribute("explicitCount")); Long explicitDown = Long.valueOf(from.getAttribute("explicitDown")); Long explicitUnknown = Long.valueOf(from.getAttribute("explicitUnknown")); Long explicitDisabled = Long.valueOf(from.getAttribute("explicitDisabled")); Long implicitCount = Long.valueOf(from.getAttribute("implicitCount")); Long implicitDown = Long.valueOf(from.getAttribute("implicitDown")); Long implicitUnknown = Long.valueOf(from.getAttribute("implicitUnknown")); Long implicitDisabled = Long.valueOf(from.getAttribute("implicitDisabled")); ResourceGroupComposite composite = new ResourceGroupComposite( explicitCount, explicitDown, explicitUnknown, explicitDisabled, implicitCount, implicitDown, implicitUnknown, implicitDisabled, rg); return composite; }
public static boolean isType(String type, String format) { return TYPE.equals(type) && FORMAT.equals(format); }
/** * Create the object of {@link AbstractIdentifiableEntity} type * * @param object the object to create * @return <code>TYPE</code> that was created */ public default Optional<TYPE> create(final TYPE object) { this.getDAO().create(object); return this.getDAO().getById(object.getId()); }
/** * Update all matching a clause to have the values set on template object. * * <p>Example (updates "joe" => "bob" in metadata value1): {code} Metadata item = new Metadata(); * item.setValue(Metadata.VALUE1, "bob"); update(item, Metadata.VALUE1.eq("joe")); {code} * * @param where sql criteria * @param template set fields on this object in order to set them in the db. * @return # of updated items */ public int update(Criterion where, TYPE template) { return database.update(table.name, template.getSetValues(), where.toString(), null); }
public boolean add(final TYPE e) { underlying.add(e.name()); return super.add(e); }
protected void onModelUpdated(TYPE model) { TYPE modelCopy = (TYPE) model.clone(); for (ModelUpdateListener<TYPE> listener : listeners) { listener.onModelUpdated(modelCopy); } }