return store.appendAllValues(bean, valuesToAdd); store.addAllValues(bean.withPosition(index), valuesToAdd); return index; return store.appendAllReferences(bean, referencesToAdd); store.addAllReferences(bean.withPosition(index), referencesToAdd); return index;
@Test void testAddReference() { assertRecorded(() -> store.addReference(mock(ManyFeatureBean.class), mock(Id.class)), "addReference", CALLS_COUNT); }
@Test void testAddValue() { assertRecorded(() -> store.addValue(mock(ManyFeatureBean.class), mock(Object.class)), "addValue", CALLS_COUNT); }
Stream<Object> stream; if (!feature.isMany()) { stream = store.valueOf(bean) .map(Stream::of) .orElseGet(Stream::empty); stream = store.allValuesOf(bean); Stream<Id> stream; if (!feature.isMany()) { stream = store.referenceOf(bean) .map(Stream::of) .orElseGet(Stream::empty); stream = store.allReferencesOf(bean);
@Override public final boolean contains(InternalEObject internalObject, EStructuralFeature feature, @Nullable Object value) { checkNotNull(internalObject, "internalObject"); checkNotNull(feature, "feature"); checkState(feature.isMany(), "Cannot compute contains() of a single-valued feature"); if (isNull(value)) { return false; } PersistentEObject object = PersistentEObject.from(internalObject); refresh(object); SingleFeatureBean bean = SingleFeatureBean.from(object, feature); if (EFeatures.isAttribute(feature)) { return store.allValuesOf(bean).anyMatch(attrConverter.convert(value, EFeatures.asAttribute(feature))::equals); } else { return store.allReferencesOf(bean).anyMatch(refConverter.convert(PersistentEObject.from(value))::equals); } }
@Override public final void add(InternalEObject internalObject, EStructuralFeature feature, int index, Object value) { checkNotNull(internalObject, "internalObject"); checkNotNull(feature, "feature"); checkNotNull(value, "value"); checkState(feature.isMany(), "Cannot compute add() of a single-valued feature"); PersistentEObject object = PersistentEObject.from(internalObject); updateInstanceOf(object); SingleFeatureBean bean = SingleFeatureBean.from(object, feature); if (EFeatures.isAttribute(feature)) { if (index == EStore.NO_INDEX) { store.appendValue(bean, attrConverter.convert(value, EFeatures.asAttribute(feature))); } else { store.addValue(bean.withPosition(index), attrConverter.convert(value, EFeatures.asAttribute(feature))); } } else { PersistentEObject referencedObject = PersistentEObject.from(value); updateInstanceOf(referencedObject); if (index == EStore.NO_INDEX) { store.appendReference(bean, refConverter.convert(referencedObject)); } else { store.addReference(bean.withPosition(index), refConverter.convert(referencedObject)); } } }
@Test void testAppendValue() { assertRecorded(() -> store.appendValue(mock(SingleFeatureBean.class), mock(Object.class)), "appendValue", CALLS_COUNT); }
@Test @SuppressWarnings("unchecked") void testAppendAllReferences() { assertRecorded(() -> store.appendAllReferences(mock(SingleFeatureBean.class), mock(List.class)), "appendAllReferences", CALLS_COUNT); }
@Test void testAddAllValues() { assertRecorded(() -> store.addAllValues(mock(ManyFeatureBean.class), Collections.emptyList()), "addAllValues", CALLS_COUNT); }
@Test @SuppressWarnings("unchecked") void testAddAllReferences() { assertRecorded(() -> store.addAllReferences(mock(ManyFeatureBean.class), mock(List.class)), "addAllReferences", CALLS_COUNT); }
@Test void testAllValuesOf() { assertRecorded(() -> store.allValuesOf(mock(SingleFeatureBean.class)), "allValuesOf", CALLS_COUNT); }
@Test void testAllReferencesOf() { assertRecorded(() -> store.allReferencesOf(mock(SingleFeatureBean.class)), "allReferencesOf", CALLS_COUNT); }
@Test void testAppendReference() { assertRecorded(() -> store.appendReference(mock(SingleFeatureBean.class), mock(Id.class)), "appendReference", CALLS_COUNT); }
@Test void testAppendAllValues() { assertRecorded(() -> store.appendAllValues(mock(SingleFeatureBean.class), Collections.emptyList()), "appendAllValues", CALLS_COUNT); }
@Override public final int lastIndexOf(InternalEObject internalObject, EStructuralFeature feature, @Nullable Object value) { checkNotNull(internalObject, "internalObject"); checkNotNull(feature, "feature"); checkState(feature.isMany(), "Cannot compute lastIndexOf() of a single-valued feature"); if (isNull(value)) { return EStore.NO_INDEX; } PersistentEObject object = PersistentEObject.from(internalObject); refresh(object); SingleFeatureBean bean = SingleFeatureBean.from(object, feature); Optional<Integer> index; if (EFeatures.isAttribute(feature)) { index = MoreStreams.lastIndexOf(store.allValuesOf(bean), attrConverter.convert(value, EFeatures.asAttribute(feature))); } else { index = MoreStreams.lastIndexOf(store.allReferencesOf(bean), refConverter.convert(PersistentEObject.from(value))); } return index.orElse(EStore.NO_INDEX); }
@Test void testAppendValue() { assertThat( catchThrowable(() -> store.appendValue(mock(SingleFeatureBean.class), mock(Object.class))) ).isExactlyInstanceOf(CLOSED_EXCEPTION_TYPE); }
@Test @SuppressWarnings("unchecked") void testAppendAllReferences() { assertThat( catchThrowable(() -> store.appendAllReferences(mock(SingleFeatureBean.class), mock(List.class))) ).isExactlyInstanceOf(READONLY_EXCEPTION_TYPE); }
@Test void testAddAllValues() { assertThat( catchThrowable(() -> store.addAllValues(mock(ManyFeatureBean.class), Collections.emptyList())) ).isExactlyInstanceOf(CLOSED_EXCEPTION_TYPE); }
@Test @SuppressWarnings("unchecked") void testAddAllReferences() { assertThat( catchThrowable(() -> store.addAllReferences(mock(ManyFeatureBean.class), mock(List.class))) ).isExactlyInstanceOf(CLOSED_EXCEPTION_TYPE); }
@Test void testAllValuesOf() { assertThat( catchThrowable(() -> store.allValuesOf(mock(SingleFeatureBean.class))) ).isNull(); }