Merge branch 'master' of github.com:PolymerLabs/arcs into kt-gen-utils

Author: alxmrs

java/arcs/android/storage/handle/AndroidHandleManager.kt

@@ -3,6 +3,7 @@ package arcs.android.storage.handle
 import android.content.Context
 import androidx.lifecycle.Lifecycle
 import arcs.android.crdt.ParcelableCrdtType
+import arcs.core.common.Referencable
 import arcs.core.crdt.CrdtEntity
 import arcs.core.data.RawEntity
 import arcs.core.storage.EntityActivationFactory
@@ -57,7 +58,7 @@ fun AndroidHandleManager(
          * Create an [ActivationFactory] that will create [ServiceStore] instances that can manage
          * singleton [RawEntities]
          */
-        override fun singletonFactory() = SingletonServiceStoreFactory<RawEntity>(
+        override fun <T : Referencable> singletonFactory() = SingletonServiceStoreFactory<T>(
             context,
             lifecycle,
             ParcelableCrdtType.Singleton,
@@ -69,7 +70,7 @@ fun AndroidHandleManager(
          * Create a ActivationFactory that will create [ServiceStore] instances that can manage
          * sets of [RawEntities]
          */
-        override fun setFactory() = SetServiceStoreFactory<RawEntity>(
+        override fun <T : Referencable> setFactory() = SetServiceStoreFactory<T>(
             context,
             lifecycle,
             ParcelableCrdtType.Set,

java/arcs/android/storage/handle/BUILD

@@ -9,6 +9,7 @@ kt_android_library(
     srcs = glob(["*.kt"]),
     deps = [
         "//java/arcs/android/crdt",
+        "//java/arcs/core/common",
         "//java/arcs/core/crdt",
         "//java/arcs/core/data:rawentity",
         "//java/arcs/core/storage/handle",

java/arcs/core/data/HandleConnectionSpec.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ *
+ * Code distributed by Google as part of this project is also subject to an additional IP rights
+ * grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+package arcs.core.data
+
+import arcs.core.type.Type
+
+data class HandleConnectionSpec(
+    val name: String,
+    val direction: Direction,
+    val type: Type
+) {
+    enum class Direction {
+        READS, WRITES, READS_WRITES
+    }
+}

java/arcs/core/data/ParticleSpec.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ *
+ * Code distributed by Google as part of this project is also subject to an additional IP rights
+ * grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+package arcs.core.data
+
+data class ParticleSpec(
+    val name: String,
+    val connections: List<HandleConnectionSpec>,
+    val location: String
+)

java/arcs/core/data/proto/ParticleSpecProtoDecoder.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ *
+ * Code distributed by Google as part of this project is also subject to an additional IP rights
+ * grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+package arcs.core.data.proto
+
+import arcs.core.data.HandleConnectionSpec
+import arcs.core.data.HandleConnectionSpec.Direction
+import arcs.core.data.ParticleSpec
+
+typealias DirectionProto = HandleConnectionSpecProto.Direction
+
+/** Converts [HandleConnectionSpecProto.Direction] to [HandleConnectionSpec.Direction]. */
+fun DirectionProto.decode() =
+    when (this) {
+        DirectionProto.READS -> Direction.READS
+        DirectionProto.WRITES -> Direction.WRITES
+        DirectionProto.READS_WRITES -> Direction.READS_WRITES
+        DirectionProto.UNRECOGNIZED ->
+            throw IllegalArgumentException("Invalid direction when decoding [HandleConnectionSpec]")
+    }
+
+/** Converts a [HandleConnnectionSpecProto] to the corresponding [HandleConnectionSpec] instance. */
+fun HandleConnectionSpecProto.decode() = HandleConnectionSpec(
+    name = getName(),
+    direction = getDirection().decode(),
+    type = getType().decode()
+)
+
+/** Converts a [ParticleSpecProto] to the corresponding [ParticleSpec] instance. */
+fun ParticleSpecProto.decode() = ParticleSpec(
+    name = getName(),
+    connections = getConnectionsList().map { it.decode() },
+    location = getLocation()
+)

java/arcs/core/data/proto/SchemaProtoDecoder.kt

@@ -17,14 +17,10 @@ import arcs.core.data.Schema
 import arcs.core.data.SchemaFields
 import arcs.core.data.SchemaName
 
-/**
- * Returns the names in the [SchemaProto] as List<SchemaName>.
- */
+/** Returns the names in the [SchemaProto] as List<SchemaName>. */
 fun SchemaProto.decodeNames(): List<SchemaName> = getNamesList().map { SchemaName(it) }
 
-/**
- * Returns the fields in the [SchemaProto] as a Kotlin [SchemaFields] instance.
- */
+/** Returns the fields in the [SchemaProto] as a Kotlin [SchemaFields] instance. */
 fun SchemaProto.decodeFields(): SchemaFields {
     val singletons = mutableMapOf<FieldName, FieldType>()
     val collections = mutableMapOf<FieldName, FieldType>()
@@ -43,8 +39,6 @@ fun SchemaProto.decodeFields(): SchemaFields {
     return SchemaFields(singletons, collections)
 }
 
-/**
- * Converts a [SchemaProto] proto instance into a Kotlin [Schema] instance.
- */
+/** Converts a [SchemaProto] proto instance into a Kotlin [Schema] instance. */
 fun SchemaProto.decode() = Schema(names = decodeNames(), fields = decodeFields(), hash = "")
 // TODO: hash

java/arcs/core/data/proto/TypeProtoDecoders.kt

@@ -16,9 +16,7 @@ import arcs.core.data.FieldType
 import arcs.core.data.PrimitiveType
 import arcs.core.type.Type
 
-/**
- * Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [PrimitiveType] instance.
- */
+/** Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [PrimitiveType] instance. */
 fun PrimitiveTypeProto.decode(): PrimitiveType =
     when (this) {
         PrimitiveTypeProto.TEXT -> PrimitiveType.Text
@@ -28,9 +26,7 @@ fun PrimitiveTypeProto.decode(): PrimitiveType =
             throw IllegalArgumentException("Unknown PrimitiveTypeProto value.")
     }
 
-/**
- * Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [FieldType] instance.
- */
+/** Converts a [PrimitiveTypeProto] protobuf instance into a Kotlin [FieldType] instance. */
 fun PrimitiveTypeProto.decodeAsFieldType(): FieldType.Primitive = FieldType.Primitive(decode())
 
 /**
@@ -50,14 +46,10 @@ fun TypeProto.decodeAsFieldType(): FieldType =
                 "Cannot decode a ${getDataCase().name} type to a [FieldType].")
     }
 
-/**
- * Converts a [EntityTypeProto] protobuf instance into a Kotlin [EntityType] instance.
- */
+/** Converts a [EntityTypeProto] protobuf instance into a Kotlin [EntityType] instance. */
 fun EntityTypeProto.decode() = EntityType(getSchema().decode())
 
-/**
- * Converts a [TypeProto] protobuf instance into a Kotlin [Type] instance.
- */
+/** Converts a [TypeProto] protobuf instance into a Kotlin [Type] instance. */
 fun TypeProto.decode(): Type =
     // TODO: optional, RefinementExpression.
     when (getDataCase()) {
@@ -70,5 +62,5 @@ fun TypeProto.decode(): Type =
             throw IllegalArgumentException("Unknown data field in TypeProto.")
         else ->
             throw IllegalArgumentException(
-                "Cannot decode a ${getDataCase().name} type to a [FieldType].")
+                "Cannot decode a ${getDataCase().name} type to a [Type].")
     }

java/arcs/core/host/EntityHandleManager.kt

@@ -11,12 +11,12 @@ import arcs.core.storage.StorageKey
 import arcs.core.storage.api.Entity
 import arcs.core.storage.api.EntitySpec
 import arcs.core.storage.api.Handle
-import arcs.core.storage.api.ReadWriteCollection
-import arcs.core.storage.api.ReadWriteSingleton
-import arcs.core.storage.api.ReadableCollection
-import arcs.core.storage.api.ReadableSingleton
-import arcs.core.storage.api.WritableCollection
-import arcs.core.storage.api.WritableSingleton
+import arcs.core.storage.api.ReadCollectionHandle
+import arcs.core.storage.api.ReadSingletonHandle
+import arcs.core.storage.api.ReadWriteCollectionHandle
+import arcs.core.storage.api.ReadWriteSingletonHandle
+import arcs.core.storage.api.WriteCollectionHandle
+import arcs.core.storage.api.WriteSingletonHandle
 import arcs.core.storage.handle.CollectionImpl
 import arcs.core.storage.handle.HandleManager
 import arcs.core.storage.handle.SetData
@@ -37,14 +37,16 @@ typealias CollectionSenderCallbackAdapter<E> =
 
 /**
  * Wraps a [HandleManager] and creates [Entity] handles based on [HandleMode], such as
- * [ReadableSingleton] for [HandleMode.Read]. To obtain a [HandleHolder], use
+ * [ReadSingletonHandle] for [HandleMode.Read]. To obtain a [HandleHolder], use
  * `arcs_kt_schema` on a manifest file to generate a `{ParticleName}Handles' class, and
  * invoke its default constructor, or obtain it from the [BaseParticle.handles] field.
+ *
+ * TODO(cromwellian): Add support for creating Singleton/Set handles of [Reference]s.
  */
 class EntityHandleManager(val handleManager: HandleManager) {
     /**
-     * Creates and returns a new [SingletonHandle]. Will also populate the appropriate field inside
-     * the given [HandleHolder].
+     * Creates and returns a new [SingletonHandle] for managing an [Entity]. Will also populate the
+     * appropriate field inside the given [HandleHolder].
      *
      * @property handleHolder contains handle and entitySpec declarations
      * @property handleName name for the handle, must be present in [HandleHolder.entitySpecs]
@@ -65,15 +67,20 @@ class EntityHandleManager(val handleManager: HandleManager) {
     ) = createSdkHandle(
         handleHolder,
         handleName,
-        handleManager.singletonHandle(storageKey, schema, canRead = handleMode != HandleMode.Write),
+        handleManager.rawEntitySingletonHandle(
+            storageKey,
+            schema,
+            name = handleName,
+            canRead = handleMode != HandleMode.Write
+        ),
         handleMode,
         idGenerator,
         sender
     )
 
     /**
-     * Creates and returns a new [SetHandle]. Will also populate the appropriate field inside
-     * the given [HandleHolder].
+     * Creates and returns a new [SetHandle] for a set of [Entity]s. Will also populate the
+     * appropriate field inside the given [HandleHolder].
      *
      * @property handleHolder contains handle and entitySpec declarations
      * @property handleName name for the handle, must be present in [HandleHolder.entitySpecs]
@@ -94,7 +101,12 @@ class EntityHandleManager(val handleManager: HandleManager) {
     ) = createSdkHandle(
         handleHolder,
         handleName,
-        handleManager.setHandle(storageKey, schema, canRead = handleMode != HandleMode.Write),
+        handleManager.rawEntitySetHandle(
+            storageKey,
+            schema,
+            name = handleName,
+            canRead = handleMode != HandleMode.Write
+        ),
         handleMode,
         idGenerator,
         sender
@@ -216,12 +228,12 @@ internal open class HandleEventBase<T, H : Handle> {
     }
 }
 
-internal open class ReadableSingletonHandleImpl<T : Entity>(
+internal open class ReadSingletonHandleImpl<T : Entity>(
     val entitySpec: EntitySpec<T>,
     val handleName: String,
     val storageHandle: SingletonHandle<RawEntity>,
     val sender: Sender
-) : HandleEventBase<T?, ReadableSingleton<T>>(), ReadableSingleton<T> {
+) : HandleEventBase<T?, ReadSingletonHandle<T>>(), ReadSingletonHandle<T> {
     init {
         storageHandle.callback = SingletonSenderCallbackAdapter(
             this::fetch,
@@ -242,11 +254,11 @@ internal open class ReadableSingletonHandleImpl<T : Entity>(
     }
 }
 
-internal class WritableSingletonHandleImpl<T : Entity>(
+internal class WriteSingletonHandleImpl<T : Entity>(
     val handleName: String,
     val storageHandle: SingletonHandle<RawEntity>,
     val idGenerator: Id.Generator
-) : WritableSingleton<T> {
+) : WriteSingletonHandle<T> {
     override val name: String
         get() = handleName
 
@@ -265,24 +277,24 @@ internal class ReadWriteSingletonHandleImpl<T : Entity>(
     storageHandle: SingletonHandle<RawEntity>,
     idGenerator: Id.Generator,
     sender: Sender,
-    private val writableSingleton: WritableSingletonHandleImpl<T> = WritableSingletonHandleImpl(
+    private val writableSingleton: WriteSingletonHandleImpl<T> = WriteSingletonHandleImpl(
         handleName,
         storageHandle,
         idGenerator
     )
-) : ReadWriteSingleton<T>,
-    ReadableSingletonHandleImpl<T>(entitySpec, handleName, storageHandle, sender),
-    WritableSingleton<T> by writableSingleton {
+) : ReadWriteSingletonHandle<T>,
+    ReadSingletonHandleImpl<T>(entitySpec, handleName, storageHandle, sender),
+    WriteSingletonHandle<T> by writableSingleton {
     override val name: String
         get() = writableSingleton.name
 }
 
-internal open class ReadableCollectionHandleImpl<T : Entity>(
+internal open class ReadCollectionHandleImpl<T : Entity>(
     val entitySpec: EntitySpec<T>,
     val handleName: String,
     val storageHandle: SetHandle<RawEntity>,
     val sender: Sender
-) : HandleEventBase<Set<T>, ReadableCollection<T>>(), ReadableCollection<T> {
+) : HandleEventBase<Set<T>, ReadCollectionHandle<T>>(), ReadCollectionHandle<T> {
     init {
         storageHandle.callback = CollectionSenderCallbackAdapter(
             this::fetchAll,
@@ -307,11 +319,11 @@ internal open class ReadableCollectionHandleImpl<T : Entity>(
     }.toSet()
 }
 
-internal class WritableCollectionHandleImpl<T : Entity>(
+internal class WriteCollectionHandleImpl<T : Entity>(
     val handleName: String,
     val storageHandle: CollectionImpl<RawEntity>,
     val idGenerator: Id.Generator
-) : WritableCollection<T> {
+) : WriteCollectionHandle<T> {
     override val name: String
         get() = handleName
 
@@ -336,14 +348,14 @@ internal class ReadWriteCollectionHandleImpl<T : Entity>(
     storageHandle: CollectionImpl<RawEntity>,
     idGenerator: Id.Generator,
     sender: Sender,
-    private val writableCollection: WritableCollectionHandleImpl<T> = WritableCollectionHandleImpl(
+    private val writableCollection: WriteCollectionHandleImpl<T> = WriteCollectionHandleImpl(
         handleName,
         storageHandle,
         idGenerator
     )
-) : ReadWriteCollection<T>,
-    ReadableCollectionHandleImpl<T>(entitySpec, handleName, storageHandle, sender),
-    WritableCollection<T> by writableCollection {
+) : ReadWriteCollectionHandle<T>,
+    ReadCollectionHandleImpl<T>(entitySpec, handleName, storageHandle, sender),
+    WriteCollectionHandle<T> by writableCollection {
     override val name: String
         get() = writableCollection.name
 }
@@ -396,13 +408,13 @@ private fun <T : Entity> createSingletonHandle(
             idGenerator,
             sender
         )
-        HandleMode.Read -> ReadableSingletonHandleImpl<T>(
+        HandleMode.Read -> ReadSingletonHandleImpl<T>(
             entitySpec,
             handleName,
             storageHandle,
             sender
         )
-        HandleMode.Write -> WritableSingletonHandleImpl<T>(
+        HandleMode.Write -> WriteSingletonHandleImpl<T>(
             handleName,
             storageHandle,
             idGenerator
@@ -426,13 +438,13 @@ private fun <T : Entity> createSetHandle(
             idGenerator,
             sender
         )
-        HandleMode.Read -> ReadableCollectionHandleImpl<T>(
+        HandleMode.Read -> ReadCollectionHandleImpl<T>(
             entitySpec,
             handleName,
             storageHandle,
             sender
         )
-        HandleMode.Write -> WritableCollectionHandleImpl<T>(
+        HandleMode.Write -> WriteCollectionHandleImpl<T>(
             handleName,
             storageHandle,
             idGenerator