DataContainer is completely sufficient, require just that.
JIRA: MDSAL-805
Change-Id: Iff55143f2c3bcc8a4b678649285f170f0353db5c
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.io.File;
import java.io.IOException;
-import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
@MetaInfServices(value = BindingDOMCodecServices.class)
public final class BindingCodecContext extends AbstractBindingNormalizedNodeSerializer
- implements BindingDOMCodecServices, Immutable, CodecContextFactory, DataObjectSerializerRegistry {
+ implements BindingDOMCodecServices, Immutable, CodecContextFactory, DataContainerSerializerRegistry {
private static final Logger LOG = LoggerFactory.getLogger(BindingCodecContext.class);
private static final @NonNull NodeIdentifier FAKE_NODEID = new NodeIdentifier(QName.create("fake", "fake"));
private static final File BYTECODE_DIRECTORY;
BYTECODE_DIRECTORY = Strings.isNullOrEmpty(dir) ? null : new File(dir);
}
- private final LoadingCache<Class<?>, DataObjectStreamer<?>> streamers = CacheBuilder.newBuilder().build(
- new CacheLoader<Class<?>, DataObjectStreamer<?>>() {
+ private final LoadingCache<Class<?>, DataContainerStreamer<?>> streamers = CacheBuilder.newBuilder().build(
+ new CacheLoader<>() {
@Override
- public DataObjectStreamer<?> load(final Class<?> key) throws ReflectiveOperationException {
- final Class<?> streamer = DataObjectStreamerGenerator.generateStreamer(loader, BindingCodecContext.this,
+ public DataContainerStreamer<?> load(final Class<?> key) throws ReflectiveOperationException {
+ final var streamer = DataContainerStreamerGenerator.generateStreamer(loader, BindingCodecContext.this,
key);
- final Field instance = streamer.getDeclaredField(DataObjectStreamerGenerator.INSTANCE_FIELD);
- return (DataObjectStreamer<?>) instance.get(null);
+ final var instance = streamer.getDeclaredField(DataContainerStreamerGenerator.INSTANCE_FIELD);
+ return (DataContainerStreamer<?>) instance.get(null);
}
});
- private final LoadingCache<Class<?>, DataObjectSerializer> serializers = CacheBuilder.newBuilder().build(
- new CacheLoader<Class<?>, DataObjectSerializer>() {
+ private final LoadingCache<Class<?>, DataContainerSerializer> serializers = CacheBuilder.newBuilder().build(
+ new CacheLoader<>() {
@Override
- public DataObjectSerializer load(final Class<?> key) throws ExecutionException {
- return new DataObjectSerializer(BindingCodecContext.this, streamers.get(key));
+ public DataContainerSerializer load(final Class<?> key) throws ExecutionException {
+ return new DataContainerSerializer(BindingCodecContext.this, streamers.get(key));
}
});
}
@Override
- public DataObjectSerializer getEventStreamSerializer(final Class<?> type) {
+ public DataContainerSerializer getEventStreamSerializer(final Class<?> type) {
return serializers.getUnchecked(type);
}
@Override
- public DataObjectStreamer<?> getDataObjectSerializer(final Class<?> type) {
+ public DataContainerStreamer<?> getDataContainerStreamer(final Class<?> type) {
return streamers.getUnchecked(type);
}
@Override
- public DataObjectSerializer getSerializer(final Class<? extends DataObject> type) {
+ public DataContainerSerializer getSerializer(final Class<? extends DataContainer> type) {
return serializers.getUnchecked(type);
}
* This serializer implements {@link BindingStreamEventWriter} along with {@link BindingSerializer}.
*
* <p>
- * {@link BindingSerializer} interface is used by generated implementations of {@link DataObjectSerializer} to provide
- * Binding object for inspection and to prevent streaming of already serialized object.
+ * {@link BindingSerializer} interface is used by generated implementations of {@link DataContainerSerializer} to
+ * provide Binding object for inspection and to prevent streaming of already serialized object.
*/
final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEventWriter
implements BindingSerializer<Object, DataObject> {
*
* <p>
* Note that this optional is serialization of child node invoked from
- * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataObjectSerializer}, which may opt-out from
+ * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataContainerSerializer}, which may opt-out from
* streaming of data when non-null result is returned.
*/
@Override
}
return null;
}
-}
\ No newline at end of file
+}
*/
@NonNull BindingClassLoader getLoader();
- @NonNull DataObjectStreamer<?> getDataObjectSerializer(Class<?> type);
+ @NonNull DataContainerStreamer<?> getDataContainerStreamer(Class<?> type);
- DataObjectSerializer getEventStreamSerializer(Class<?> type);
+ DataContainerSerializer getEventStreamSerializer(Class<?> type);
}
static {
try {
EVENT_STREAM_SERIALIZER = MethodHandles.lookup().findVarHandle(DataContainerCodecContext.class,
- "eventStreamSerializer", DataObjectSerializer.class);
+ "eventStreamSerializer", DataContainerSerializer.class);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new ExceptionInInitializerError(e);
}
// Accessed via a VarHandle
@SuppressWarnings("unused")
- private volatile DataObjectSerializer eventStreamSerializer;
+ private volatile DataContainerSerializer eventStreamSerializer;
DataContainerCodecContext(final DataContainerCodecPrototype<T> prototype) {
this.prototype = requireNonNull(prototype);
return new IncorrectNestingException(message, args);
}
- final DataObjectSerializer eventStreamSerializer() {
- final DataObjectSerializer existing = (DataObjectSerializer) EVENT_STREAM_SERIALIZER.getAcquire(this);
+ final DataContainerSerializer eventStreamSerializer() {
+ final DataContainerSerializer existing = (DataContainerSerializer) EVENT_STREAM_SERIALIZER.getAcquire(this);
return existing != null ? existing : loadEventStreamSerializer();
}
// Split out to aid inlining
- private DataObjectSerializer loadEventStreamSerializer() {
- final DataObjectSerializer loaded = factory().getEventStreamSerializer(getBindingClass());
+ private DataContainerSerializer loadEventStreamSerializer() {
+ final DataContainerSerializer loaded = factory().getEventStreamSerializer(getBindingClass());
final Object witness = EVENT_STREAM_SERIALIZER.compareAndExchangeRelease(this, null, loaded);
- return witness == null ? loaded : (DataObjectSerializer) witness;
+ return witness == null ? loaded : (DataContainerSerializer) witness;
}
final @NonNull NormalizedNode serializeImpl(final @NonNull D data) {
import java.io.IOException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
-import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
/**
* A serializer which writes DataObject to supplied stream event writer.
*/
-final class DataObjectSerializer {
- private final @NonNull DataObjectSerializerRegistry registry;
- private final @NonNull DataObjectStreamer<?> delegate;
+public final class DataContainerSerializer {
+ private final @NonNull DataContainerSerializerRegistry registry;
+ private final @NonNull DataContainerStreamer<?> delegate;
- DataObjectSerializer(final DataObjectSerializerRegistry registry, final DataObjectStreamer<?> delegate) {
+ DataContainerSerializer(final DataContainerSerializerRegistry registry, final DataContainerStreamer<?> delegate) {
this.registry = requireNonNull(registry);
this.delegate = requireNonNull(delegate);
}
* @param obj Source of stream events
* @param stream Stream to which events should be written.
*/
- void serialize(final DataObject obj, final BindingStreamEventWriter stream) throws IOException {
+ void serialize(final DataContainer obj, final BindingStreamEventWriter stream) throws IOException {
delegate.serialize(registry, obj, stream);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.dom.codec.impl;
+
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+
+/**
+ * SPI-level contract for registry of {@link DataContainerSerializer}. The contract is kept between implementation of
+ * {@link DataContainerSerializer}, Registry provides lookup for serializers to support recursive serialization of
+ * nested {@link DataContainer}s.
+ */
+// FIXME: this interface should not be necessary
+public interface DataContainerSerializerRegistry {
+
+ DataContainerSerializer getSerializer(Class<? extends DataContainer> binding);
+
+}
* Base superclass for all concrete streamers, that is objects which are able to turn a concrete DataObject into a
* stream of events.
*
- * @param <T> DataObject type
+ * @param <T> DataContainer type
*/
@Beta
-public abstract class DataObjectStreamer<T extends DataObject> {
- private static final Logger LOG = LoggerFactory.getLogger(DataObjectStreamer.class);
+public abstract class DataContainerStreamer<T extends DataContainer> {
+ private static final Logger LOG = LoggerFactory.getLogger(DataContainerStreamer.class);
- protected DataObjectStreamer() {
+ protected DataContainerStreamer() {
}
* DataObjectSerializerRegistry may be used to lookup serializers for other generated classes in order to support
* writing their events.
*/
- protected abstract void serialize(DataObjectSerializerRegistry reg, DataObject obj, BindingStreamEventWriter stream)
- throws IOException;
+ protected abstract void serialize(DataContainerSerializerRegistry reg, DataContainer obj,
+ BindingStreamEventWriter stream) throws IOException;
protected static final void streamAnydata(final BindingStreamEventWriter writer, final String localName,
final Object value) throws IOException {
- if (value != null && writer instanceof AnydataBindingStreamWriter) {
+ if (value != null && writer instanceof AnydataBindingStreamWriter anydataWriter) {
verify(value instanceof OpaqueObject, "Unexpected data %s", value);
- ((AnydataBindingStreamWriter) writer).anydataNode(localName, (OpaqueObject<?>) value);
+ anydataWriter.anydataNode(localName, (OpaqueObject<?>) value);
}
}
}
}
- protected static final void streamAugmentations(final DataObjectSerializerRegistry registry,
+ protected static final void streamAugmentations(final DataContainerSerializerRegistry registry,
final BindingStreamEventWriter writer, final Augmentable<?> obj) throws IOException {
for (final var aug : obj.augmentations().entrySet()) {
emitAugmentation(aug.getKey(), aug.getValue(), writer, registry);
}
protected static final <C extends DataContainer> void streamChoice(final Class<C> choiceClass,
- final DataObjectSerializerRegistry registry, final BindingStreamEventWriter writer, final C value)
+ final DataContainerSerializerRegistry registry, final BindingStreamEventWriter writer, final C value)
throws IOException {
if (value != null) {
final Class<? extends DataContainer> caseClass = value.implementedInterface();
writer.startChoiceNode(choiceClass, BindingStreamEventWriter.UNKNOWN_SIZE);
- final DataObjectSerializer caseStreamer = registry.getSerializer(caseClass.asSubclass(DataObject.class));
+ final DataContainerSerializer caseStreamer = registry.getSerializer(caseClass.asSubclass(DataObject.class));
if (caseStreamer != null) {
if (tryCache(writer, (DataObject) value)) {
caseStreamer.serialize((DataObject) value, writer);
}
}
- protected static final <C extends DataObject> void streamContainer(final DataObjectStreamer<C> childStreamer,
- final DataObjectSerializerRegistry registry, final BindingStreamEventWriter writer, final C value)
+ protected static final <C extends DataObject> void streamContainer(final DataContainerStreamer<C> childStreamer,
+ final DataContainerSerializerRegistry registry, final BindingStreamEventWriter writer, final C value)
throws IOException {
if (value != null && tryCache(writer, value)) {
childStreamer.serialize(registry, value, writer);
}
protected static final <E extends DataObject> void streamList(final Class<E> childClass,
- final DataObjectStreamer<E> childStreamer, final DataObjectSerializerRegistry registry,
+ final DataContainerStreamer<E> childStreamer, final DataContainerSerializerRegistry registry,
final BindingStreamEventWriter writer, final List<? extends E> value) throws IOException {
final int size = nullSize(value);
if (size != 0) {
}
protected static final <E extends DataObject & KeyAware<?>> void streamMap(final Class<E> childClass,
- final DataObjectStreamer<E> childStreamer, final DataObjectSerializerRegistry registry,
+ final DataContainerStreamer<E> childStreamer, final DataContainerSerializerRegistry registry,
final BindingStreamEventWriter writer, final Map<?, ? extends E> value) throws IOException {
final int size = nullSize(value);
if (size != 0) {
}
protected static final <E extends DataObject & KeyAware<?>> void streamOrderedMap(final Class<E> childClass,
- final DataObjectStreamer<E> childStreamer, final DataObjectSerializerRegistry registry,
+ final DataContainerStreamer<E> childStreamer, final DataContainerSerializerRegistry registry,
final BindingStreamEventWriter writer, final List<? extends E> value) throws IOException {
final int size = nullSize(value);
if (size != 0) {
}
}
- private static <E extends DataObject> void commonStreamList(final DataObjectSerializerRegistry registry,
- final BindingStreamEventWriter writer, final DataObjectStreamer<E> childStreamer,
+ private static <E extends DataObject> void commonStreamList(final DataContainerSerializerRegistry registry,
+ final BindingStreamEventWriter writer, final DataContainerStreamer<E> childStreamer,
final Collection<? extends E> value) throws IOException {
for (E entry : value) {
}
private static void emitAugmentation(final Class<? extends Augmentation<?>> type, final Augmentation<?> value,
- final BindingStreamEventWriter writer, final DataObjectSerializerRegistry registry) throws IOException {
+ final BindingStreamEventWriter writer, final DataContainerSerializerRegistry registry) throws IOException {
/*
* Binding Specification allowed to insert augmentation with null for value, which effectively could be used to
* remove augmentation from builder / DTO.
*/
if (value != null) {
- final DataObjectSerializer serializer = registry.getSerializer(type);
+ final DataContainerSerializer serializer = registry.getSerializer(type);
if (serializer != null) {
serializer.serialize(value, writer);
} else {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class DataObjectStreamerGenerator<T extends DataObjectStreamer<?>> implements ClassGenerator<T> {
+final class DataContainerStreamerGenerator<T extends DataContainerStreamer<?>> implements ClassGenerator<T> {
static final String INSTANCE_FIELD = "INSTANCE";
- private static final Logger LOG = LoggerFactory.getLogger(DataObjectStreamerGenerator.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DataContainerStreamerGenerator.class);
private static final Generic BB_VOID = TypeDefinition.Sort.describe(void.class);
- private static final Generic BB_DATAOBJECT = TypeDefinition.Sort.describe(DataObject.class);
- private static final Generic BB_DOSR = TypeDefinition.Sort.describe(DataObjectSerializerRegistry.class);
+ private static final Generic BB_DATA_CONTAINER = TypeDefinition.Sort.describe(DataContainer.class);
+ private static final Generic BB_DOSR = TypeDefinition.Sort.describe(DataContainerSerializerRegistry.class);
private static final Generic BB_BESV = TypeDefinition.Sort.describe(BindingStreamEventWriter.class);
private static final Generic BB_IOX = TypeDefinition.Sort.describe(IOException.class);
- private static final Builder<?> TEMPLATE = new ByteBuddy().subclass(DataObjectStreamer.class)
+ private static final Builder<?> TEMPLATE = new ByteBuddy().subclass(DataContainerStreamer.class)
.modifiers(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC);
private static final StackManipulation REG = MethodVariableAccess.REFERENCE.loadFrom(1);
UNKNOWN_SIZE,
invokeMethod(BindingStreamEventWriter.class, "startUnkeyedListItem", int.class));
- private static final StackManipulation STREAM_ANYDATA = invokeMethod(DataObjectStreamer.class,
+ private static final StackManipulation STREAM_ANYDATA = invokeMethod(DataContainerStreamer.class,
"streamAnydata", BindingStreamEventWriter.class, String.class, Object.class);
- private static final StackManipulation STREAM_ANYXML = invokeMethod(DataObjectStreamer.class,
+ private static final StackManipulation STREAM_ANYXML = invokeMethod(DataContainerStreamer.class,
"streamAnyxml", BindingStreamEventWriter.class, String.class, Object.class);
- private static final StackManipulation STREAM_CHOICE = invokeMethod(DataObjectStreamer.class,
- "streamChoice", Class.class, DataObjectSerializerRegistry.class, BindingStreamEventWriter.class,
+ private static final StackManipulation STREAM_CHOICE = invokeMethod(DataContainerStreamer.class,
+ "streamChoice", Class.class, DataContainerSerializerRegistry.class, BindingStreamEventWriter.class,
DataContainer.class);
- private static final StackManipulation STREAM_CONTAINER = invokeMethod(DataObjectStreamer.class,
- "streamContainer", DataObjectStreamer.class, DataObjectSerializerRegistry.class, BindingStreamEventWriter.class,
- DataObject.class);
- private static final StackManipulation STREAM_LEAF = invokeMethod(DataObjectStreamer.class,
+ private static final StackManipulation STREAM_CONTAINER = invokeMethod(DataContainerStreamer.class,
+ "streamContainer", DataContainerStreamer.class, DataContainerSerializerRegistry.class,
+ BindingStreamEventWriter.class, DataObject.class);
+ private static final StackManipulation STREAM_LEAF = invokeMethod(DataContainerStreamer.class,
"streamLeaf", BindingStreamEventWriter.class, String.class, Object.class);
- private static final StackManipulation STREAM_LEAF_LIST = invokeMethod(DataObjectStreamer.class,
+ private static final StackManipulation STREAM_LEAF_LIST = invokeMethod(DataContainerStreamer.class,
"streamLeafList",
BindingStreamEventWriter.class, String.class, Set.class);
- private static final StackManipulation STREAM_ORDERED_LEAF_LIST = invokeMethod(DataObjectStreamer.class,
+ private static final StackManipulation STREAM_ORDERED_LEAF_LIST = invokeMethod(DataContainerStreamer.class,
"streamOrderedLeafList", BindingStreamEventWriter.class, String.class, List.class);
- private static final StackManipulation STREAM_LIST = invokeMethod(DataObjectStreamer.class,
- "streamList", Class.class, DataObjectStreamer.class, DataObjectSerializerRegistry.class,
+ private static final StackManipulation STREAM_LIST = invokeMethod(DataContainerStreamer.class,
+ "streamList", Class.class, DataContainerStreamer.class, DataContainerSerializerRegistry.class,
BindingStreamEventWriter.class, List.class);
- private static final StackManipulation STREAM_MAP = invokeMethod(DataObjectStreamer.class,
- "streamMap", Class.class, DataObjectStreamer.class, DataObjectSerializerRegistry.class,
+ private static final StackManipulation STREAM_MAP = invokeMethod(DataContainerStreamer.class,
+ "streamMap", Class.class, DataContainerStreamer.class, DataContainerSerializerRegistry.class,
BindingStreamEventWriter.class, Map.class);
- private static final StackManipulation STREAM_ORDERED_MAP = invokeMethod(DataObjectStreamer.class,
- "streamOrderedMap", Class.class, DataObjectStreamer.class, DataObjectSerializerRegistry.class,
+ private static final StackManipulation STREAM_ORDERED_MAP = invokeMethod(DataContainerStreamer.class,
+ "streamOrderedMap", Class.class, DataContainerStreamer.class, DataContainerSerializerRegistry.class,
BindingStreamEventWriter.class, List.class);
// streamAugmentations(reg, stream, obj)
REG,
STREAM,
OBJ,
- invokeMethod(DataObjectStreamer.class, "streamAugmentations", DataObjectSerializerRegistry.class,
+ invokeMethod(DataContainerStreamer.class, "streamAugmentations", DataContainerSerializerRegistry.class,
BindingStreamEventWriter.class, Augmentable.class));
private final CodecContextFactory registry;
private final Class<?> type;
private final GeneratedType genType;
- private DataObjectStreamerGenerator(final CodecContextFactory registry, final GeneratedType genType,
+ private DataContainerStreamerGenerator(final CodecContextFactory registry, final GeneratedType genType,
final DataNodeContainer schema, final Class<?> type, final StackManipulation startEvent) {
this.registry = requireNonNull(registry);
this.genType = requireNonNull(genType);
this.startEvent = requireNonNull(startEvent);
}
- static Class<? extends DataObjectStreamer<?>> generateStreamer(final BindingClassLoader loader,
+ static Class<? extends DataContainerStreamer<?>> generateStreamer(final BindingClassLoader loader,
final CodecContextFactory registry, final Class<?> type) {
final var typeAndSchema = registry.getRuntimeContext().getTypeWithSchema(type);
return CodecPackage.STREAMER.generateClass(loader, type,
// FIXME: cast to GeneratedType: we really should adjust getTypeWithSchema()
- new DataObjectStreamerGenerator<>(registry, (GeneratedType) typeAndSchema.javaType(),
+ new DataContainerStreamerGenerator<>(registry, (GeneratedType) typeAndSchema.javaType(),
(DataNodeContainer) schema, type, startEvent));
}
final GeneratorResult<T> result = GeneratorResult.of(builder
.defineMethod("serialize", BB_VOID, Opcodes.ACC_PROTECTED | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC)
- .withParameters(BB_DOSR, BB_DATAOBJECT, BB_BESV)
+ .withParameters(BB_DOSR, BB_DATA_CONTAINER, BB_BESV)
.throwing(BB_IOX)
.intercept(new SerializeImplementation(bindingInterface, startEvent, children)).make(), depBuilder.build());
private ChildStream containerChildStream(final Method getter) {
final Class<? extends DataObject> itemClass = getter.getReturnType().asSubclass(DataObject.class);
- final DataObjectStreamer<?> streamer = registry.getDataObjectSerializer(itemClass);
+ final DataContainerStreamer<?> streamer = registry.getDataContainerStreamer(itemClass);
// streamContainer(FooStreamer.INSTANCE, reg, stream, obj.getFoo())
return new ChildStream(streamer,
private ChildStream listChildStream(final Method getter, final Class<? extends DataObject> itemClass,
final ListSchemaNode childSchema) {
- final DataObjectStreamer<?> streamer = registry.getDataObjectSerializer(itemClass);
+ final DataContainerStreamer<?> streamer = registry.getDataContainerStreamer(itemClass);
final StackManipulation method;
if (childSchema.getKeyDefinition().isEmpty()) {
method = STREAM_LIST;
method);
}
- private static StackManipulation streamerInstance(final DataObjectStreamer<?> streamer) {
+ private static StackManipulation streamerInstance(final DataContainerStreamer<?> streamer) {
try {
return getField(streamer.getClass().getDeclaredField(INSTANCE_FIELD));
} catch (NoSuchFieldException e) {
dependency = null;
}
- ChildStream(final DataObjectStreamer<?> streamer, final StackManipulation... stackManipulation) {
+ ChildStream(final DataContainerStreamer<?> streamer, final StackManipulation... stackManipulation) {
super(stackManipulation);
dependency = streamer.getClass();
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.binding.dom.codec.impl;
-
-import org.opendaylight.yangtools.yang.binding.DataObject;
-
-/**
- * SPI-level contract for registry of {@link DataObjectSerializer}. The contract is kept between implementation of
- * {@link DataObjectSerializer}, Registry provides lookup for serializers to support recursive serialization of nested
- * {@link DataObject}s.
- */
-// FIXME: this interface should not be necessary
-public interface DataObjectSerializerRegistry {
-
- DataObjectSerializer getSerializer(Class<? extends DataObject> binding);
-
-}
Code Review / mdsal.git / commitdiff