Polish refactor 1

core/Address.cs

@@ -6,7 +6,9 @@ namespace Data
 {
     public struct Address : IEquatable<Address>
     {
-        public FixedString value;
+        private FixedString value;
+
+        public readonly byte Length => value.Length;
 
         public Address(FixedString value)
         {
@@ -126,6 +128,36 @@ public readonly bool EndsWith(USpan<char> other)
             return true;
         }
 
+        public readonly uint IndexOf(char character)
+        {
+            return value.IndexOf(character);
+        }
+
+        public readonly uint LastIndexOf(char character)
+        {
+            return value.LastIndexOf(character);
+        }
+
+        public readonly bool TryIndexOf(char character, out uint index)
+        {
+            return value.TryIndexOf(character, out index);
+        }
+
+        public readonly bool TryLastIndexOf(char character, out uint index)
+        {
+            return value.TryLastIndexOf(character, out index);
+        }
+
+        public readonly Address Slice(uint start, uint length)
+        {
+            return new(value.Slice(start, length));
+        }
+
+        public readonly Address Slice(uint start)
+        {
+            return new(value.Slice(start));
+        }
+
         public readonly bool Matches(string other)
         {
             USpan<char> buffer = stackalloc char[other.Length];
@@ -188,9 +220,9 @@ public static implicit operator Address(string value)
             return new(value);
         }
 
-        public static Address Get<T>() where T : unmanaged, IDataReference
+        public static implicit operator FixedString(Address address)
         {
-            return default(T).Value;
+            return address.value;
         }
     }
 }

core/Components/IsDataRequest.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Unmanaged;
 using Worlds;
 
@@ -7,31 +8,41 @@ namespace Data.Components
     [Component]
     public struct IsDataRequest
     {
-        public Address address;
-        public uint version;
+        public readonly Address address;
+        public RequestStatus status;
+        public TimeSpan timeout;
 
-        public IsDataRequest(USpan<char> address)
+        public IsDataRequest(USpan<char> address, RequestStatus status, TimeSpan timeout)
         {
-            version = default;
             this.address = new(address);
+            this.status = status;
+            this.timeout = timeout;
         }
 
-        public IsDataRequest(Address address)
+        public IsDataRequest(Address address, RequestStatus status, TimeSpan timeout)
         {
-            version = default;
             this.address = address;
+            this.status = status;
+            this.timeout = timeout;
         }
 
-        public IsDataRequest(string address)
+        public IsDataRequest(string address, RequestStatus status, TimeSpan timeout)
         {
-            version = default;
             this.address = new(address);
+            this.status = status;
+            this.timeout = timeout;
         }
 
-        public IsDataRequest(IEnumerable<char> address)
+        public IsDataRequest(IEnumerable<char> address, RequestStatus status, TimeSpan timeout)
         {
-            version = default;
             this.address = new(address);
+            this.status = status;
+            this.timeout = timeout;
+        }
+
+        public readonly IsDataRequest BecomeLoaded()
+        {
+            return new(address, RequestStatus.Loaded, timeout);
         }
     }
 }

core/DataRequest.cs

@@ -2,8 +2,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Threading.Tasks;
-using System.Threading;
 using Unmanaged;
 using Worlds;
 
@@ -12,93 +10,49 @@ namespace Data
     /// <summary>
     /// An entity that will contain data loaded from its address.
     /// </summary>
-    public readonly struct DataRequest : IEntity
+    public readonly partial struct DataRequest : IDataRequest
     {
-        private readonly Entity entity;
+        public readonly Address Address => GetComponent<IsDataRequest>().address;
+        public readonly bool IsLoaded => GetComponent<IsDataRequest>().status == RequestStatus.Loaded;
 
-        /// <summary>
-        /// Address that this data request is looking for.
-        /// </summary>
-        public readonly Address Address
+        public readonly USpan<byte> Bytes
         {
             get
             {
-                ref IsDataRequest component = ref entity.GetComponent<IsDataRequest>();
-                return component.address;
-            }
-        }
-
-        public readonly USpan<byte> Data
-        {
-            get
-            {
-                ThrowIfDataNotAvailable();
-                return entity.GetArray<BinaryData>().As<byte>();
-            }
-        }
+                ThrowIfNotLoaded();
 
-        /// <summary>
-        /// Checks if the data has been loaded.
-        /// </summary>
-        public readonly bool IsLoaded
-        {
-            get
-            {
-                if (entity.TryGetComponent(out IsData data))
-                {
-                    return data.version == entity.GetComponent<IsDataRequest>().version;
-                }
-                else
-                {
-                    return false;
-                }
+                return GetArray<BinaryData>().As<byte>();
             }
         }
 
-        readonly uint IEntity.Value => entity.value;
-        readonly World IEntity.World => entity.world;
-
         readonly void IEntity.Describe(ref Archetype archetype)
         {
             archetype.AddComponentType<IsDataRequest>();
+            archetype.AddArrayType<BinaryData>();
         }
 
-#if NET
-        [Obsolete("Default constructor not supported", true)]
-        public DataRequest()
-        {
-            throw new NotSupportedException();
-        }
-#endif
-
-        public DataRequest(World world, uint existingEntity)
-        {
-            this.entity = new(world, existingEntity);
-        }
-
-        public DataRequest(World world, USpan<char> address)
-        {
-            entity = new Entity<IsDataRequest>(world, new IsDataRequest(address));
-        }
-
-        public DataRequest(World world, Address address)
+        public DataRequest(World world, USpan<char> address, TimeSpan timeout = default)
         {
-            entity = new Entity<IsDataRequest>(world, new IsDataRequest(address));
+            this.world = world;
+            value = world.CreateEntity(new IsDataRequest(address, RequestStatus.Submitted, timeout));
         }
 
-        public DataRequest(World world, string address)
+        public DataRequest(World world, Address address, TimeSpan timeout = default)
         {
-            entity = new Entity<IsDataRequest>(world, new IsDataRequest(address));
+            this.world = world;
+            value = world.CreateEntity(new IsDataRequest(address, RequestStatus.Submitted, timeout));
         }
 
-        public DataRequest(World world, IEnumerable<char> address)
+        public DataRequest(World world, string address, TimeSpan timeout = default)
         {
-            entity = new Entity<IsDataRequest>(world, new IsDataRequest(address));
+            this.world = world;
+            value = world.CreateEntity(new IsDataRequest(address, RequestStatus.Submitted, timeout));
         }
 
-        public readonly void Dispose()
+        public DataRequest(World world, IEnumerable<char> address, TimeSpan timeout = default)
         {
-            entity.Dispose();
+            this.world = world;
+            value = world.CreateEntity(new IsDataRequest(address, RequestStatus.Submitted, timeout));
         }
 
         public readonly override string ToString()
@@ -110,7 +64,7 @@ public readonly bool TryGetData(out USpan<byte> data)
         {
             if (IsLoaded)
             {
-                data = entity.GetArray<BinaryData>().As<byte>();
+                data = Bytes;
                 return true;
             }
             else
@@ -120,46 +74,20 @@ public readonly bool TryGetData(out USpan<byte> data)
             }
         }
 
-        public readonly void SetAddress(Address address)
-        {
-            ref IsDataRequest component = ref entity.GetComponent<IsDataRequest>();
-            component.address = address;
-            component.version++;
-        }
-
-        /// <summary>
-        /// Reads the data as a UTF8 string.
-        /// </summary>
-        /// <returns>Amount of <c>char</c> values copied.</returns>
-        public readonly uint CopyDataAsUTF8To(USpan<char> buffer)
+        public readonly BinaryReader CreateBinaryReader()
         {
-            ThrowIfDataNotAvailable();
+            ThrowIfNotLoaded();
 
-            using BinaryReader reader = new(Data);
-            return reader.ReadUTF8Span(buffer);
-        }
-
-        public async Task UntilLoaded(Update action, CancellationToken cancellation = default)
-        {
-            World world = entity.GetWorld();
-            while (!IsLoaded)
-            {
-                await action(world, cancellation);
-            }
+            return new(Bytes);
         }
 
         [Conditional("DEBUG")]
-        public void ThrowIfDataNotAvailable()
+        private readonly void ThrowIfNotLoaded()
         {
             if (!IsLoaded)
             {
-                throw new InvalidOperationException($"Data not yet available on `{entity.GetEntityValue()}`");
+                throw new InvalidOperationException($"Data entity `{value}` at address `{Address}` has not been loaded");
             }
         }
-
-        public static implicit operator Entity(DataRequest request)
-        {
-            return request.entity;
-        }
     }
-}
+}