/** * {@inheritDoc} */ @Override public boolean saveLabel(AbstractStorageLabel<?> label) { if (label.getStorageLabelType().isValueReusable()) { List<?> exampleFind = loadAll(label.getClass()); if (!exampleFind.contains(label)) { AbstractStorageLabelType<?> labelType = label.getStorageLabelType(); if (null == labelType) { return false; } if ((labelType.getId() == 0) && !labelType.isMultiType()) { return false; } entityManager.persist(label); return true; } } return false; }
/** * {@inheritDoc} */ @Override public int compareTo(AbstractStorageLabelType<?> other) { if (!AbstractCustomStorageLabelType.class.isAssignableFrom(other.getClass())) { return super.compareTo(other); } else { AbstractCustomStorageLabelType<?> abstractCustomStorageLabelType = (AbstractCustomStorageLabelType<?>) other; return name.compareTo(abstractCustomStorageLabelType.getName()); } }
/** * {@inheritDoc} */ @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } AbstractStorageLabel<?> other = (AbstractStorageLabel<?>) obj; if (storageLabelType == null) { if (other.storageLabelType != null) { return false; } } else if (!storageLabelType.equals(other.storageLabelType)) { return false; } return true; }
if (label.getStorageLabelType().isOnePerStorage()) { boolean exists = false; for (AbstractStorageLabel<?> existingLabel : labelList) { if (label.getStorageLabelType().equals(existingLabel.getStorageLabelType())) { exists = true; if (doOverwrite) {
/** * {@inheritDoc} */ @Override public void removeLabel(AbstractStorageLabel<?> label) { if (label.getStorageLabelType().isValueReusable()) { JpaUtil.delete(entityManager, label); } }
AbstractStorageLabelType<Object> labelType = mock(AbstractStorageLabelType.class); when(storageLabel.getStorageLabelType()).thenReturn(labelType); when(labelType.isOnePerStorage()).thenReturn(false); assertThat(storageData.isLabelPresent(labelType), is(false)); when(labelType.isOnePerStorage()).thenReturn(true); AbstractStorageLabel<Object> storageLabel2 = mock(AbstractStorageLabel.class); when(storageLabel2.getStorageLabelType()).thenReturn(labelType);
/** * {@inheritDoc} */ @Override public int hashCode() { final int prime = 31; int result = 1; result = (prime * result) + ((storageLabelType == null) ? 0 : storageLabelType.hashCode()); return result; }
/** * Returns the class type of the label type. * * @param labelType * Label type to get name for. * @return Returns the class type of the label type. */ public static String getLabelValueType(AbstractStorageLabelType<?> labelType) { if (null == labelType) { return "null"; } else if (Boolean.class.equals(labelType.getValueClass())) { return "Yes/No"; } else if (Date.class.equals(labelType.getValueClass())) { return "Date"; } else if (Number.class.equals(labelType.getValueClass())) { return "Number"; } else if (String.class.equals(labelType.getValueClass())) { return "Text"; } else { return "Unknown Label Type"; } }
/** * {@inheritDoc} */ @Override protected boolean canEdit(Object element) { AbstractStorageLabel<?> label = (AbstractStorageLabel<?>) element; return label.getStorageLabelType().isEditable(); }
/** * {@inheritDoc} */ @Override public void saveLabelType(AbstractStorageLabelType<?> labelType) { if (labelType.isMultiType()) { entityManager.persist(labelType); } else { List<?> findByClass = loadAll(labelType.getClass()); if (findByClass.isEmpty()) { entityManager.persist(labelType); } } }
if (labelType.isGroupingEnabled()) { groupByLabelMenu.add( new LabelOrderAction(TextFormatter.getLabelName(labelType), ImageFormatter.getImageDescriptorForLabel(labelType), labelType, ObjectUtils.equals(labelType, orderingLabelType)));
if (!Objects.equals(label, editingLabel)) { if (label.getStorageLabelType().isValueReusable() && (cmrRepositoryDefinition.getOnlineStatus() != OnlineStatus.OFFLINE)) { suggestionLabelList.clear(); suggestionLabelList.addAll(cmrRepositoryDefinition.getStorageService().getLabelSuggestions(label.getStorageLabelType()));
/** * {@inheritDoc} */ @Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = (prime * result) + ((imageKey == null) ? 0 : imageKey.hashCode()); result = (prime * result) + ((name == null) ? 0 : name.hashCode()); result = (prime * result) + (onePerStorage ? 1231 : 1237); return result; }
if (index >= 0) { AbstractStorageLabel<Object> label = (AbstractStorageLabel<Object>) element; if (label.getStorageLabelType().getValueClass().equals(Boolean.class)) { Boolean newValue = Boolean.valueOf(0 == index); changeValue(label, newValue);
/** * Manages the label type selection. */ private void manageLabelTypeSlection() { if (!labelTypeTableViewer.getSelection().isEmpty()) { AbstractStorageLabelType<?> labelType = (AbstractStorageLabelType<?>) ((StructuredSelection) labelTypeTableViewer.getSelection()).getFirstElement(); List<AbstractStorageLabel<?>> inputForLabelTable = new ArrayList<>(); for (AbstractStorageLabel<?> label : labelList) { if (ObjectUtils.equals(label.getStorageLabelType(), labelType)) { inputForLabelTable.add(label); } } if (labelType.isValueReusable()) { createLabel.setEnabled(true); labelsTableViewer.getTable().setEnabled(true); } else { createLabel.setEnabled(false); labelsTableViewer.getTable().setEnabled(false); } removeLabelType.setEnabled(AbstractCustomStorageLabelType.class.isAssignableFrom(labelType.getClass())); labelsTableViewer.setInput(inputForLabelTable); labelsTableViewer.refresh(); } else { removeLabelType.setEnabled(false); createLabel.setEnabled(true); labelsTableViewer.getTable().setEnabled(true); labelsTableViewer.setInput(null); labelsTableViewer.refresh(); } }
/** * {@inheritDoc} */ @Override public int compareTo(AbstractStorageLabel<?> other) { int typeCompare = storageLabelType.compareTo(other.getStorageLabelType()); if (0 != typeCompare) { return typeCompare; } else { if (!BooleanStorageLabel.class.isAssignableFrom(other.getClass())) { return super.compareTo(other); } else { BooleanStorageLabel otherLabel = (BooleanStorageLabel) other; return booleanValue.compareTo(otherLabel.booleanValue); } } }
/** * Return if the label of provided type is present in the label list. * * @param labelType * Type to search for. * @return True if one of more labels of desired type is present, false otherwise. */ public boolean isLabelPresent(AbstractStorageLabelType<?> labelType) { for (AbstractStorageLabel<?> label : labelList) { if (label.getStorageLabelType().equals(labelType)) { return true; } } return false; }
/** * {@inheritDoc} */ @Override public int compareTo(AbstractStorageLabel<?> other) { int typeCompare = storageLabelType.compareTo(other.getStorageLabelType()); if (0 != typeCompare) { return typeCompare; } else { if (!StringStorageLabel.class.isAssignableFrom(other.getClass())) { return super.compareTo(other); } else { StringStorageLabel otherLabel = (StringStorageLabel) other; return stringValue.compareToIgnoreCase(otherLabel.stringValue); } } }
/** * Return all labels of these storage that are of a given type. * * @param <T> * Type * @param labelType * Searched label type. * @return List of labels. */ @SuppressWarnings("unchecked") public <T> List<AbstractStorageLabel<T>> getLabels(AbstractStorageLabelType<T> labelType) { List<AbstractStorageLabel<T>> labels = new ArrayList<>(); for (AbstractStorageLabel<?> label : labelList) { if (label.getStorageLabelType().equals(labelType)) { labels.add((AbstractStorageLabel<T>) label); } } return labels; }
/** * {@inheritDoc} */ @Override public int compareTo(AbstractStorageLabel<?> other) { int typeCompare = storageLabelType.compareTo(other.getStorageLabelType()); if (0 != typeCompare) { return typeCompare; } else { if (!DateStorageLabel.class.isAssignableFrom(other.getClass())) { return super.compareTo(other); } else { DateStorageLabel otherLabel = (DateStorageLabel) other; return dateValue.compareTo(otherLabel.dateValue); } } }