feat (core): Introduce ThingIO

java/dev/enola/cli/CommandWithModel.java

@@ -87,6 +87,9 @@ public final void run() throws Exception {
         // TODO Move elsewhere for continuous ("shell") mode, as this is "expensive".
         ServiceProvider grpc = null;
         if (group.load != null) {
+            // TODO Use (new) ThingIO / ResourceIntoThingConverters infra here! (With TLC.open(),
+            // similar to how it's done in RdfResourceIntoThingConverterTest; but needs more
+            // thought.)
             // TODO Replace DatatypeRepository with store itself, once a Datatype is a Thing
             DatatypeRepository dtr = new DatatypeRepositoryBuilder().build();
             ThingMemoryRepositoryROBuilder store = new ThingMemoryRepositoryROBuilder();

java/dev/enola/thing/io/Loader.java

@@ -33,6 +33,8 @@
 public class Loader<T extends Thing>
         implements ConverterInto<Stream<ReadableResource>, Store<?, T>> {
 
+    // TODO This must simply use the (new) ResourceIntoThingConverters !
+
     // TODO Do this multi-threaded, in parallel...
 
     private static final Logger LOG = LoggerFactory.getLogger(Loader.class);
@@ -59,6 +61,7 @@ private void load(ReadableResource resource, Store<?, T> store) {
             things.get()
                     .forEach(
                             thingBuilder -> {
+                                // TODO Move this into ResourceIntoThingConverters
                                 thingBuilder.set(KIRI.E.ORIGIN, resource.uri());
                                 var thing = thingBuilder.build();
                                 store.merge(thing);

java/dev/enola/thing/io/ResourceIntoThingConverters.java

@@ -32,6 +32,10 @@
 public class ResourceIntoThingConverters<T extends Thing>
         implements Converter<ReadableResource, List<Thing.Builder<T>>> {
 
+    // TODO Reconsider use of generics here -VS- in ThingIO
+
+    // TODO Support a more "streaming" API...
+
     private final ImmutableList<ResourceIntoThingConverter<T>> converters;
 
     public ResourceIntoThingConverters(Iterable<ResourceIntoThingConverter<T>> converters) {

java/dev/enola/thing/io/ThingIO.java

@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Copyright 2024 The Enola <https://enola.dev> Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dev.enola.thing.io;
+
+import dev.enola.common.io.resource.ResourceProvider;
+import dev.enola.thing.Thing;
+
+import java.net.URI;
+
+public class ThingIO {
+
+    // TODO Support a more "streaming" API...
+
+    private final ResourceProvider rp = null; // TODO NOT new ResourceProviders();
+
+    private final ResourceIntoThingConverters<Thing> converter =
+            new ResourceIntoThingConverters<>();
+
+    public Iterable<Thing> read(URI uri) {
+        return read(uri, Thing.class);
+    }
+
+    public <T extends Thing> Iterable<T> read(URI uri, Class<T> klass) {
+        var resource = rp.getReadableResource(uri);
+        return null; // TODO converter.convert(resource);
+    }
+
+    public void write(Iterable<Thing> things, URI uri) {}
+}