Type -> DfId

Add descriptor to MetaConverter

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 ### Added
+- Obligatory `type: KType` and `descriptor` property for `MetaConverters`
 - Added separate `Meta`, `SealedMeta` and `ObservableMutableMeta` builders.
 
 ### Changed

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/Plugin.kt

@@ -3,8 +3,8 @@ package space.kscience.dataforge.context
 import space.kscience.dataforge.context.Plugin.Companion.TARGET
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.MetaRepr
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.misc.Named
-import space.kscience.dataforge.misc.Type
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.parseAsName
 import space.kscience.dataforge.provider.Provider
@@ -18,7 +18,7 @@ import space.kscience.dataforge.provider.Provider
  *
  * create - configure - attach - detach - destroy
  */
-@Type(TARGET)
+@DfId(TARGET)
 public interface Plugin : Named, ContextAware, Provider, MetaRepr {
 
     /**

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/PluginFactory.kt

@@ -1,9 +1,9 @@
 package space.kscience.dataforge.context
 
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 
-@Type(PluginFactory.TYPE)
+@DfId(PluginFactory.TYPE)
 public interface PluginFactory<T : Plugin> : Factory<T> {
     public val tag: PluginTag
 

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/provider/dfType.kt

@@ -4,29 +4,29 @@ import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.context.PluginBuilder
 import space.kscience.dataforge.context.gather
 import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.misc.Named
-import space.kscience.dataforge.misc.Type
 import space.kscience.dataforge.names.Name
 import kotlin.reflect.KClass
 import kotlin.reflect.full.findAnnotation
 
 
 @DFExperimental
-public val KClass<*>.dfType: String
+public val KClass<*>.dfId: String
-    get() = findAnnotation<Type>()?.id ?: simpleName ?: ""
+    get() = findAnnotation<DfId>()?.id ?: simpleName ?: ""
 
 /**
- * Provide an object with given name inferring target from its type using [Type] annotation
+ * Provide an object with given name inferring target from its type using [DfId] annotation
  */
 @DFExperimental
 public inline fun <reified T : Any> Provider.provideByType(name: String): T? {
-    val target = T::class.dfType
+    val target = T::class.dfId
     return provide(target, name)
 }
 
 @DFExperimental
 public inline fun <reified T : Any> Provider.top(): Map<Name, T> {
-    val target = T::class.dfType
+    val target = T::class.dfId
     return top(target)
 }
 
@@ -35,15 +35,15 @@ public inline fun <reified T : Any> Provider.top(): Map<Name, T> {
  */
 @DFExperimental
 public inline fun <reified T : Any> Context.gather(inherit: Boolean = true): Map<Name, T> =
-    gather<T>(T::class.dfType, inherit)
+    gather<T>(T::class.dfId, inherit)
 
 
 @DFExperimental
 public inline fun <reified T : Any> PluginBuilder.provides(items: Map<Name, T>) {
-    provides(T::class.dfType, items)
+    provides(T::class.dfId, items)
 }
 
 @DFExperimental
 public inline fun <reified T : Any> PluginBuilder.provides(vararg items: Named) {
-    provides(T::class.dfType, *items)
+    provides(T::class.dfId, *items)
 }

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/Data.kt

@@ -5,7 +5,7 @@ import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.MetaRepr
 import space.kscience.dataforge.meta.isEmpty
 import space.kscience.dataforge.misc.DFInternal
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.reflect.KType
@@ -14,7 +14,7 @@ import kotlin.reflect.typeOf
 /**
  * A data element characterized by its meta
  */
-@Type(Data.TYPE)
+@DfId(Data.TYPE)
 public interface Data<out T> : Goal<T>, MetaRepr {
     /**
      * Type marker for the data. The type is known before the calculation takes place so it could be checked.

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/DataTree.kt

@@ -2,7 +2,7 @@ package space.kscience.dataforge.data
 
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.misc.DFInternal
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.names.*
 import kotlin.collections.component1
 import kotlin.collections.component2
@@ -31,7 +31,7 @@ public val <T : Any> DataTreeItem<T>.type: KType
 /**
  * A tree-like [DataSet] grouped into the node. All data inside the node must inherit its type
  */
-@Type(DataTree.TYPE)
+@DfId(DataTree.TYPE)
 public interface DataTree<out T : Any> : DataSet<T> {
 
     /**

dataforge-io/src/commonMain/kotlin/space/kscience/dataforge/io/EnvelopeFormat.kt

@@ -4,7 +4,7 @@ import kotlinx.io.Source
 import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.io.EnvelopeFormatFactory.Companion.ENVELOPE_FORMAT_TYPE
 import space.kscience.dataforge.meta.Meta
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.asName
 import kotlin.reflect.KType
@@ -17,7 +17,7 @@ public interface EnvelopeFormat : IOFormat<Envelope> {
 
 public fun EnvelopeFormat.read(input: Source): Envelope = readFrom(input)
 
-@Type(ENVELOPE_FORMAT_TYPE)
+@DfId(ENVELOPE_FORMAT_TYPE)
 public interface EnvelopeFormatFactory : IOFormatFactory<Envelope>, EnvelopeFormat {
     override val type: KType get() = typeOf<Envelope>()
 

dataforge-io/src/commonMain/kotlin/space/kscience/dataforge/io/IOFormat.kt

@@ -7,8 +7,8 @@ import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.context.Factory
 import space.kscience.dataforge.io.IOFormatFactory.Companion.IO_FORMAT_TYPE
 import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.misc.Named
-import space.kscience.dataforge.misc.Type
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.asName
 import kotlin.reflect.KType
@@ -72,7 +72,7 @@ public fun <T : Any> Sink.writeWith(format: IOWriter<T>, obj: T): Unit =
     format.writeTo(this, obj)
 
 
-@Type(IO_FORMAT_TYPE)
+@DfId(IO_FORMAT_TYPE)
 public interface IOFormatFactory<T : Any> : Factory<IOFormat<T>>, Named {
     /**
      * Explicit type for dynamic type checks

dataforge-io/src/commonMain/kotlin/space/kscience/dataforge/io/MetaFormat.kt

@@ -9,7 +9,7 @@ import space.kscience.dataforge.context.Global
 import space.kscience.dataforge.io.MetaFormatFactory.Companion.META_FORMAT_TYPE
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.descriptors.MetaDescriptor
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.asName
 import space.kscience.dataforge.names.plus
@@ -38,7 +38,7 @@ public interface MetaFormat : IOFormat<Meta> {
     public fun readMeta(source: Source, descriptor: MetaDescriptor? = null): Meta
 }
 
-@Type(META_FORMAT_TYPE)
+@DfId(META_FORMAT_TYPE)
 public interface MetaFormatFactory : IOFormatFactory<Meta>, MetaFormat {
     public val shortName: String
 

dataforge-meta/src/commonMain/kotlin/space/kscience/dataforge/meta/Meta.kt

@@ -2,7 +2,7 @@ package space.kscience.dataforge.meta
 
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.misc.unsafeCast
 import space.kscience.dataforge.names.*
 import kotlin.jvm.JvmName
@@ -31,7 +31,7 @@ public fun interface MetaProvider : ValueProvider {
  * TODO add documentation
  * Same name siblings are supported via elements with the same [Name] but different indices.
  */
-@Type(Meta.TYPE)
+@DfId(Meta.TYPE)
 @Serializable(MetaSerializer::class)
 public interface Meta : MetaRepr, MetaProvider {
     public val value: Value?

dataforge-meta/src/commonMain/kotlin/space/kscience/dataforge/meta/descriptors/MetaDescriptor.kt

@@ -7,7 +7,7 @@ import space.kscience.dataforge.names.*
 /**
  * Restrictions on value in the node
  */
-public enum class ValueRequirement {
+public enum class ValueRestriction {
     /**
      * No restrictions
      */
@@ -26,26 +26,25 @@ public enum class ValueRequirement {
 
 /**
  * The descriptor for a meta
- * @param info description text
+ * @param description description text
  * @param children child descriptors for this node
  * @param multiple True if same name siblings with this name are allowed
- * @param valueRequirement The requirements for node content
+ * @param valueRestriction The requirements for node content
  * @param valueTypes list of allowed types for [Meta.value], null if all values are allowed.
  *  Empty list means that no value should be present in this node.
  * @param indexKey An index field by which this node is identified in case of same name siblings construct
  * @param defaultValue the default [Meta.value] for the node
- * @param attributes additional attributes of this descriptor. For example validation and widget parameters
+ * @param attributes additional attributes of this descriptor. For example, validation and widget parameters
  */
 @Serializable
 public data class MetaDescriptor(
-    public val info: String? = null,
+    public val description: String? = null,
     public val children: Map<String, MetaDescriptor> = emptyMap(),
     public val multiple: Boolean = false,
-    public val valueRequirement: ValueRequirement = ValueRequirement.NONE,
+    public val valueRestriction: ValueRestriction = ValueRestriction.NONE,
     public val valueTypes: List<ValueType>? = null,
     public val indexKey: String = Meta.INDEX_KEY,
     public val defaultValue: Value? = null,
-    public val readOnly: Boolean = false,
     public val attributes: Meta = Meta.EMPTY,
 ) {
     /**
@@ -63,11 +62,12 @@ public data class MetaDescriptor(
     }
 
     public companion object {
+        public val EMPTY: MetaDescriptor = MetaDescriptor("Generic meta tree")
         internal const val ALLOWED_VALUES_KEY = "allowedValues"
     }
 }
 
-public val MetaDescriptor.required: Boolean get() = valueRequirement == ValueRequirement.REQUIRED || children.values.any { required }
+public val MetaDescriptor.required: Boolean get() = valueRestriction == ValueRestriction.REQUIRED || children.values.any { required }
 
 public val MetaDescriptor.allowedValues: List<Value>? get() = attributes[MetaDescriptor.ALLOWED_VALUES_KEY]?.value?.list
 
@@ -80,9 +80,9 @@ public operator fun MetaDescriptor.get(name: Name): MetaDescriptor? = when (name
 public operator fun MetaDescriptor.get(name: String): MetaDescriptor? = get(name.parseAsName(true))
 
 public fun MetaDescriptor.validate(value: Value?): Boolean = if (value == null) {
-    valueRequirement != ValueRequirement.REQUIRED
+    valueRestriction != ValueRestriction.REQUIRED
 } else {
-    if (valueRequirement == ValueRequirement.ABSENT) false
+    if (valueRestriction == ValueRestriction.ABSENT) false
     else {
         (valueTypes == null || value.type in valueTypes) && (allowedValues?.let { value in it } ?: true)
     }

dataforge-meta/src/commonMain/kotlin/space/kscience/dataforge/meta/descriptors/MetaDescriptorBuilder.kt

@@ -8,20 +8,26 @@ import space.kscience.dataforge.names.first
 import space.kscience.dataforge.names.length
 import kotlin.collections.set
 
-public class MetaDescriptorBuilder  @PublishedApi internal constructor() {
+public class MetaDescriptorBuilder @PublishedApi internal constructor() {
     public var info: String? = null
     public var children: MutableMap<String, MetaDescriptorBuilder> = linkedMapOf()
     public var multiple: Boolean = false
-    public var valueRequirement: ValueRequirement = ValueRequirement.NONE
+    public var valueRestriction: ValueRestriction = ValueRestriction.NONE
-    public var readOnly: Boolean = false
 
-    public var type: List<ValueType>? = null
+    public var valueTypes: List<ValueType>? = null
 
-    public fun type(primaryType: ValueType, vararg otherTypes: ValueType) {
+    public fun valueType(primaryType: ValueType, vararg otherTypes: ValueType) {
-        type = listOf(primaryType, *otherTypes)
+        valueTypes = listOf(primaryType, *otherTypes)
     }
 
+    /**
+     * A key for indexing values. Should be changed in case of the name clash.
+     */
     public var indexKey: String = Meta.INDEX_KEY
+
+    /**
+     * The default value
+     */
     public var default: Value? = null
 
     public fun default(value: Any?) {
@@ -42,6 +48,7 @@ public class MetaDescriptorBuilder  @PublishedApi internal constructor() {
                 children[name.first().body] = target
                 target
             }
+
             else -> {
                 children.getOrPut(name.first().body) { MetaDescriptorBuilder() }.item(name.cutFirst(), block)
             }
@@ -51,16 +58,17 @@ public class MetaDescriptorBuilder  @PublishedApi internal constructor() {
     public fun node(
         name: Name,
         descriptor: MetaDescriptor,
-        block: MetaDescriptorBuilder.() -> Unit = {}
+        block: MetaDescriptorBuilder.() -> Unit = {},
     ): MetaDescriptorBuilder = when (name.length) {
         0 -> error("Can't set descriptor to root")
         1 -> {
             val item = descriptor.toBuilder().apply {
-                valueRequirement = ValueRequirement.ABSENT
+                valueRestriction = ValueRestriction.ABSENT
             }.apply(block)
             children[name.first().body] = item
             item
         }
+
         else -> children.getOrPut(name.first().body) {
             MetaDescriptorBuilder()
         }.node(name.cutFirst(), descriptor, block)
@@ -79,14 +87,13 @@ public class MetaDescriptorBuilder  @PublishedApi internal constructor() {
 
     @PublishedApi
     internal fun build(): MetaDescriptor = MetaDescriptor(
-        info = info,
+        description = info,
         children = children.mapValues { it.value.build() },
         multiple = multiple,
-        valueRequirement = valueRequirement,
+        valueRestriction = valueRestriction,
-        valueTypes = type,
+        valueTypes = valueTypes,
         indexKey = indexKey,
         defaultValue = default,
-        readOnly = readOnly,
         attributes = attributes
     )
 }
@@ -104,9 +111,9 @@ public fun MetaDescriptorBuilder.value(
     name: Name,
     type: ValueType,
     vararg additionalTypes: ValueType,
-    block: MetaDescriptorBuilder.() -> Unit = {}
+    block: MetaDescriptorBuilder.() -> Unit = {},
 ): MetaDescriptorBuilder = item(name) {
-    type(type, *additionalTypes)
+    valueType(type, *additionalTypes)
     block()
 }
 
@@ -114,16 +121,16 @@ public fun MetaDescriptorBuilder.value(
     name: String,
     type: ValueType,
     vararg additionalTypes: ValueType,
-    block: MetaDescriptorBuilder.() -> Unit = {}
+    block: MetaDescriptorBuilder.() -> Unit = {},
 ): MetaDescriptorBuilder = value(Name.parse(name), type, additionalTypes = additionalTypes, block)
 
 /**
  * Create and configure child value descriptor
  */
 public fun MetaDescriptorBuilder.node(
-    name: Name, block: MetaDescriptorBuilder.() -> Unit
+    name: Name, block: MetaDescriptorBuilder.() -> Unit,
 ): MetaDescriptorBuilder = item(name) {
-    valueRequirement = ValueRequirement.ABSENT
+    valueRestriction = ValueRestriction.ABSENT
     block()
 }
 
@@ -142,7 +149,7 @@ public fun MetaDescriptorBuilder.node(
 }
 
 public fun MetaDescriptorBuilder.required() {
-    valueRequirement = ValueRequirement.REQUIRED
+    valueRestriction = ValueRestriction.REQUIRED
 }
 
 public inline fun <reified E : Enum<E>> MetaDescriptorBuilder.enum(
@@ -158,11 +165,11 @@ public inline fun <reified E : Enum<E>> MetaDescriptorBuilder.enum(
 }
 
 private fun MetaDescriptor.toBuilder(): MetaDescriptorBuilder = MetaDescriptorBuilder().apply {
-    info = this@toBuilder.info
+    info = this@toBuilder.description
     children = this@toBuilder.children.mapValuesTo(LinkedHashMap()) { it.value.toBuilder() }
     multiple = this@toBuilder.multiple
-    valueRequirement = this@toBuilder.valueRequirement
+    valueRestriction = this@toBuilder.valueRestriction
-    type = this@toBuilder.valueTypes
+    valueTypes = this@toBuilder.valueTypes
     indexKey = this@toBuilder.indexKey
     default = defaultValue
     attributes = this@toBuilder.attributes.toMutableMeta()

dataforge-meta/src/commonMain/kotlin/space/kscience/dataforge/meta/transformations/MetaConverter.kt

@@ -1,12 +1,25 @@
 package space.kscience.dataforge.meta.transformations
 
 import space.kscience.dataforge.meta.*
+import space.kscience.dataforge.meta.descriptors.MetaDescriptor
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
 
 /**
  * A converter of generic object to and from [Meta]
  */
 public interface MetaConverter<T> {
 
+    /**
+     * Runtime type of [T]
+     */
+    public val type: KType
+
+    /**
+     * A descriptor for resulting meta
+     */
+    public val descriptor: MetaDescriptor get() = MetaDescriptor.EMPTY
+
     /**
      * Attempt conversion of [meta] to an object or return null if conversion failed
      */
@@ -20,51 +33,105 @@ public interface MetaConverter<T> {
     public companion object {
 
         public val meta: MetaConverter<Meta> = object : MetaConverter<Meta> {
+            override val type: KType = typeOf<Meta>()
+
             override fun metaToObjectOrNull(meta: Meta): Meta = meta
             override fun objectToMeta(obj: Meta): Meta = obj
         }
 
         public val value: MetaConverter<Value> = object : MetaConverter<Value> {
+            override val type: KType = typeOf<Value>()
+
             override fun metaToObjectOrNull(meta: Meta): Value? = meta.value
             override fun objectToMeta(obj: Value): Meta = Meta(obj)
         }
 
         public val string: MetaConverter<String> = object : MetaConverter<String> {
+            override val type: KType = typeOf<String>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.STRING)
+            }
+
+
             override fun metaToObjectOrNull(meta: Meta): String? = meta.string
             override fun objectToMeta(obj: String): Meta = Meta(obj.asValue())
         }
 
         public val boolean: MetaConverter<Boolean> = object : MetaConverter<Boolean> {
+            override val type: KType = typeOf<Boolean>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.BOOLEAN)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Boolean? = meta.boolean
             override fun objectToMeta(obj: Boolean): Meta = Meta(obj.asValue())
         }
 
         public val number: MetaConverter<Number> = object : MetaConverter<Number> {
+            override val type: KType = typeOf<Number>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.NUMBER)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Number? = meta.number
             override fun objectToMeta(obj: Number): Meta = Meta(obj.asValue())
         }
 
         public val double: MetaConverter<Double> = object : MetaConverter<Double> {
+            override val type: KType = typeOf<Double>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.NUMBER)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Double? = meta.double
             override fun objectToMeta(obj: Double): Meta = Meta(obj.asValue())
         }
 
         public val float: MetaConverter<Float> = object : MetaConverter<Float> {
+            override val type: KType = typeOf<Float>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.NUMBER)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Float? = meta.float
             override fun objectToMeta(obj: Float): Meta = Meta(obj.asValue())
         }
 
         public val int: MetaConverter<Int> = object : MetaConverter<Int> {
+            override val type: KType = typeOf<Int>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.NUMBER)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Int? = meta.int
             override fun objectToMeta(obj: Int): Meta = Meta(obj.asValue())
         }
 
         public val long: MetaConverter<Long> = object : MetaConverter<Long> {
+            override val type: KType = typeOf<Long>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.NUMBER)
+            }
+
             override fun metaToObjectOrNull(meta: Meta): Long? = meta.long
             override fun objectToMeta(obj: Long): Meta = Meta(obj.asValue())
         }
 
         public inline fun <reified E : Enum<E>> enum(): MetaConverter<E> = object : MetaConverter<E> {
+            override val type: KType = typeOf<E>()
+
+            override val descriptor: MetaDescriptor = MetaDescriptor {
+                valueType(ValueType.STRING)
+                allowedValues(enumValues<E>())
+            }
+
             @Suppress("USELESS_CAST")
             override fun metaToObjectOrNull(meta: Meta): E = meta.enum<E>() as? E ?: error("The Item is not a Enum")
 
@@ -76,6 +143,12 @@ public interface MetaConverter<T> {
             reader: (Value) -> T,
         ): MetaConverter<List<T>> =
             object : MetaConverter<List<T>> {
+                override val type: KType = typeOf<List<T>>()
+
+                override val descriptor: MetaDescriptor = MetaDescriptor {
+                    valueType(ValueType.LIST)
+                }
+
                 override fun metaToObjectOrNull(meta: Meta): List<T>? = meta.value?.list?.map(reader)
 
                 override fun objectToMeta(obj: List<T>): Meta = Meta(obj.map(writer).asValue())

dataforge-workspace/src/commonMain/kotlin/space/kscience/dataforge/workspace/Task.kt

@@ -9,7 +9,7 @@ import space.kscience.dataforge.meta.MetaRepr
 import space.kscience.dataforge.meta.Specification
 import space.kscience.dataforge.meta.descriptors.Described
 import space.kscience.dataforge.meta.descriptors.MetaDescriptor
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.workspace.Task.Companion.TYPE
 import kotlin.reflect.KType
@@ -19,7 +19,7 @@ import kotlin.reflect.typeOf
  * A configurable task that could be executed on a workspace. The [TaskResult] represents a lazy result of the task.
  * In general no computations should be made until the result is called.
  */
-@Type(TYPE)
+@DfId(TYPE)
 public interface Task<out T : Any> : Described {
 
     /**

dataforge-workspace/src/commonMain/kotlin/space/kscience/dataforge/workspace/Workspace.kt

@@ -6,7 +6,7 @@ import space.kscience.dataforge.data.DataSet
 import space.kscience.dataforge.data.asSequence
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.MutableMeta
-import space.kscience.dataforge.misc.Type
+import space.kscience.dataforge.misc.DfId
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.provider.Provider
 
@@ -18,7 +18,7 @@ public interface DataSelector<T: Any>{
 /**
  * An environment for pull-mode computation
  */
-@Type(Workspace.TYPE)
+@DfId(Workspace.TYPE)
 public interface Workspace : ContextAware, Provider {
     /**
      * The whole data node for current workspace