Merge pull request #15 from CoderGamester/develop

Release 0.7.0

Author: CoderGamester

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2025-11-03
+
+**New**:
+- Added *Rebind* functionality to all Observable classes (*ObservableField*, *ObservableList*, *ObservableDictionary*) allowing rebinding to new data sources without losing existing observers
+- Added *Rebind* methods to all Observable Resolver classes (*ObservableResolverField*, *ObservableResolverList*, *ObservableResolverDictionary*) to rebind to new origin collections and resolver functions
+- Added new *IObservableResolverField* interface with *Rebind* method for resolver field implementations
+
 ## [0.6.7] - 2025-04-07
 
 **New**:

Runtime/ColorJsonConverter.cs

@@ -0,0 +1,87 @@
+using Newtonsoft.Json;
+using UnityEngine;
+using System;
+
+// ReSharper disable once CheckNamespace
+
+namespace GameLovers
+{
+    /// <summary>
+    /// JSON converter for Unity's Color struct that handles serialization to/from:
+    /// - Hex color strings (e.g. "#FF0000FF" for red)
+    /// - RGBA object format (e.g. {"r":1,"g":0,"b":0,"a":1})
+    /// </summary>
+    /// <remarks>
+    /// This converter enables proper serialization of Unity Color objects with Newtonsoft.Json.
+    /// It's particularly useful for saving color data in JSON configuration files or network payloads.
+    /// </remarks>
+    public class ColorJsonConverter : JsonConverter<Color>
+    {
+        /// <summary>
+        /// Reads JSON data and converts it to a Unity Color object
+        /// </summary>
+        /// <param name="reader">JSON reader providing the input data</param>
+        /// <param name="objectType">Type of object to deserialize (should be Color)</param>
+        /// <param name="existingValue">Existing value of the object being read</param>
+        /// <param name="hasExistingValue">Whether there is an existing value</param>
+        /// <param name="serializer">JSON serializer instance</param>
+        /// <returns>Deserialized Color object</returns>
+        /// <remarks>
+        /// Supports both hex color strings and RGBA object formats:
+        /// - "#RRGGBBAA" or "#RRGGBB" (missing alpha defaults to 1)
+        /// - {"r":1,"g":0,"b":0,"a":1} (missing components default to 0, except alpha which defaults to 1)
+        /// </remarks>
+        public override Color ReadJson(JsonReader reader, Type objectType, Color existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.String)
+            {
+                string colorString = reader.Value.ToString();
+                Color color;
+                if (ColorUtility.TryParseHtmlString(colorString, out color))
+                {
+                    return color;
+                }
+            }
+            else if (reader.TokenType == JsonToken.StartObject)
+            {
+                float r = 0, g = 0, b = 0, a = 1;
+                
+                reader.Read();
+                while (reader.TokenType != JsonToken.EndObject)
+                {
+                    string propertyName = reader.Value.ToString().ToLower();
+                    reader.Read();
+                    
+                    switch (propertyName)
+                    {
+                        case "r": r = Convert.ToSingle(reader.Value); break;
+                        case "g": g = Convert.ToSingle(reader.Value); break;
+                        case "b": b = Convert.ToSingle(reader.Value); break;
+                        case "a": a = Convert.ToSingle(reader.Value); break;
+                    }
+                    
+                    reader.Read();
+                }
+                
+                return new Color(r, g, b, a);
+            }
+            
+            return Color.white;
+        }
+
+        /// <summary>
+        /// Writes a Color object to JSON format
+        /// </summary>
+        /// <param name="writer">JSON writer for output</param>
+        /// <param name="value">Color value to serialize</param>
+        /// <param name="serializer">JSON serializer instance</param>
+        /// <remarks>
+        /// Always serializes to hex string format (e.g. "#FF0000FF" for red)
+        /// This provides a compact and web-friendly representation
+        /// </remarks>
+        public override void WriteJson(JsonWriter writer, Color value, JsonSerializer serializer)
+        {
+            writer.WriteValue("#" + ColorUtility.ToHtmlStringRGBA(value));
+        }
+    }
+}

Runtime/ColorJsonConverter.cs.meta

@@ -176,6 +176,17 @@ public interface IObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueO
 		/// Clear's to the origin dictionary
 		/// </remarks>
 		void ClearOrigin();
+
+		/// <summary>
+		/// Rebinds this dictionary to a new origin dictionary and resolver functions without losing existing observers.
+		/// The internal dictionary will be rebuilt from the new origin dictionary using the new resolvers.
+		/// </summary>
+		/// <param name="dictionary">The new origin dictionary to bind to</param>
+		/// <param name="fromOrignResolver">The new function to convert from origin types to this dictionary's types</param>
+		/// <param name="toOrignResolver">The new function to convert from this dictionary's types to origin types</param>
+		void Rebind(IDictionary<TKeyOrigin, TValueOrigin> dictionary,
+			Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> fromOrignResolver,
+			Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> toOrignResolver);
 	}
 
 	/// <inheritdoc />
@@ -193,7 +204,7 @@ public class ObservableDictionary<TKey, TValue> : IObservableDictionary<TKey, TV
 		/// <inheritdoc />
 		public ReadOnlyDictionary<TKey, TValue> ReadOnlyDictionary => new ReadOnlyDictionary<TKey, TValue>(Dictionary);
 
-		protected virtual IDictionary<TKey, TValue> Dictionary { get; }
+		protected virtual IDictionary<TKey, TValue> Dictionary { get; set; }
 
 		private ObservableDictionary() { }
 
@@ -203,6 +214,15 @@ public ObservableDictionary(IDictionary<TKey, TValue> dictionary)
 			ObservableUpdateFlag = ObservableUpdateFlag.KeyUpdateOnly;
 		}
 
+		/// <summary>
+		/// Rebinds this dictionary to a new dictionary without losing existing observers.
+		/// </summary>
+		/// <param name="dictionary">The new dictionary to bind to</param>
+		public void Rebind(IDictionary<TKey, TValue> dictionary)
+		{
+			Dictionary = dictionary;
+		}
+
 		/// <inheritdoc cref="Dictionary{TKey,TValue}.this" />
 		public TValue this[TKey key]
 		{
@@ -468,14 +488,14 @@ private int AdjustIndex(int index, Action<TKey, TValue, TValue, ObservableUpdate
 		}
 	}
 
-	/// <inheritdoc />
+	/// <inheritdoc cref="IObservableResolverDictionary{TKey, TValue, TKeyOrigin, TValueOrigin}"/>
 	public class ObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueOrigin> : 
 		ObservableDictionary<TKey, TValue>,
 		IObservableResolverDictionary<TKey, TValue, TKeyOrigin, TValueOrigin>
 	{
-		private readonly IDictionary<TKeyOrigin, TValueOrigin> _dictionary;
-		private readonly Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> _toOrignResolver;
-		private readonly Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> _fromOrignResolver;
+		private IDictionary<TKeyOrigin, TValueOrigin> _dictionary;
+		private Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> _toOrignResolver;
+		private Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> _fromOrignResolver;
 
 		/// <inheritdoc />
 		public ReadOnlyDictionary<TKeyOrigin, TValueOrigin> OriginDictionary => new ReadOnlyDictionary<TKeyOrigin, TValueOrigin>(_dictionary);
@@ -495,6 +515,23 @@ public ObservableResolverDictionary(IDictionary<TKeyOrigin, TValueOrigin> dictio
 			}
 		}
 
+		/// <inheritdoc />
+		public void Rebind(IDictionary<TKeyOrigin, TValueOrigin> dictionary,
+			Func<KeyValuePair<TKeyOrigin, TValueOrigin>, KeyValuePair<TKey, TValue>> fromOrignResolver,
+			Func<TKey, TValue, KeyValuePair<TKeyOrigin, TValueOrigin>> toOrignResolver)
+		{
+			_dictionary = dictionary;
+			_toOrignResolver = toOrignResolver;
+			_fromOrignResolver = fromOrignResolver;
+
+			// Rebuild the internal dictionary from the new origin dictionary
+			Dictionary.Clear();
+			foreach (var pair in dictionary)
+			{
+				Dictionary.Add(fromOrignResolver(pair));
+			}
+		}
+
 		/// <inheritdoc />
 		public TValueOrigin GetOriginValue(TKey key)
 		{

Runtime/ObservableDictionary.cs

@@ -50,6 +50,26 @@ public interface IObservableField<T> : IObservableFieldReader<T>
 		/// The field value with possibility to be changed
 		/// </summary>
 		new T Value { get; set; }
+
+		/// <summary>
+		/// Rebinds this field to a new value without losing existing observers.
+		/// </summary>
+		/// <param name="initialValue">The new initial value for the field</param>
+		void Rebind(T initialValue);
+	}
+
+	/// <inheritdoc />
+	/// <remarks>
+	/// A resolver field with the possibility to rebind to new resolver functions
+	/// </remarks>
+	public interface IObservableResolverField<T> : IObservableField<T>
+	{
+		/// <summary>
+		/// Rebinds this field to new resolver functions without losing existing observers
+		/// </summary>
+		/// <param name="fieldResolver">The new getter function for the field</param>
+		/// <param name="fieldSetter">The new setter function for the field</param>
+		void Rebind(Func<T> fieldResolver, Action<T> fieldSetter);
 	}
 
 	/// <inheritdoc />
@@ -84,6 +104,12 @@ public ObservableField(T initialValue)
 
 		public static implicit operator T(ObservableField<T> value) => value.Value;
 
+		/// <inheritdoc />
+		public void Rebind(T initialValue)
+		{
+			_value = initialValue;
+		}
+
 		/// <inheritdoc />
 		public void Observe(Action<T, T> onUpdate)
 		{
@@ -137,11 +163,11 @@ protected void InvokeUpdate(T previousValue)
 		}
 	}
 
-	/// <inheritdoc />
-	public class ObservableResolverField<T> : ObservableField<T>
+	/// <inheritdoc cref="IObservableResolverField{T}"/>
+	public class ObservableResolverField<T> : ObservableField<T>, IObservableResolverField<T>
 	{
-		private readonly Func<T> _fieldResolver;
-		private readonly Action<T> _fieldSetter;
+		private Func<T> _fieldResolver;
+		private Action<T> _fieldSetter;
 
 		/// <inheritdoc cref="IObservableField{T}.Value" />
 		public override T Value
@@ -165,6 +191,17 @@ public ObservableResolverField(Func<T> fieldResolver, Action<T> fieldSetter)
 			_fieldSetter = fieldSetter;
 		}
 
+		/// <summary>
+		/// Rebinds this field to new resolver functions without losing existing observers
+		/// </summary>
+		/// <param name="fieldResolver">The new getter function for the field</param>
+		/// <param name="fieldSetter">The new setter function for the field</param>
+		public void Rebind(Func<T> fieldResolver, Action<T> fieldSetter)
+		{
+			_fieldResolver = fieldResolver;
+			_fieldSetter = fieldSetter;
+		}
+
 		public static implicit operator T(ObservableResolverField<T> value) => value.Value;
 	}
 }

Runtime/ObservableField.cs

@@ -94,7 +94,7 @@ public interface IObservableList<T> : IObservableListReader<T>
 	/// <remarks>
 	/// This interface resolves between 2 lists with different types of values
 	/// </remarks>
-	public interface IObservableResolverListReader<T, TOrigin> : IObservableListReader<T>
+	public interface IObservableResolverListReader<T, out TOrigin> : IObservableListReader<T>
 	{
 		/// <summary>
 		/// The Original List that is being resolved across the entire interface
@@ -134,6 +134,15 @@ public interface IObservableResolverList<T, TOrigin> :
 		/// Clear's to the origin list
 		/// </remarks>
 		void ClearOrigin();
+
+		/// <summary>
+		/// Rebinds this list to a new origin list and resolver functions without losing existing observers.
+		/// The internal list will be rebuilt from the new origin list using the new resolvers.
+		/// </summary>
+		/// <param name="originList">The new origin list to bind to</param>
+		/// <param name="fromOrignResolver">The new function to convert from origin type to this list's type</param>
+		/// <param name="toOrignResolver">The new function to convert from this list's type to origin type</param>
+		void Rebind(IList<TOrigin> originList, Func<TOrigin, T> fromOrignResolver, Func<T, TOrigin> toOrignResolver);
 	}
 
 	/// <inheritdoc />
@@ -160,7 +169,7 @@ public T this[int index]
 		/// <inheritdoc />
 		public IReadOnlyList<T> ReadOnlyList => new List<T>(List);
 
-		protected virtual List<T> List { get; }
+		protected virtual List<T> List { get; set; }
 
 		protected ObservableList() { }
 
@@ -169,6 +178,15 @@ public ObservableList(IList<T> list)
 			List = list as List<T> ?? list.ToList();
 		}
 
+		/// <summary>
+		/// Rebinds this list to a new list without losing existing observers.
+		/// </summary>
+		/// <param name="list">The new list to bind to</param>
+		public void Rebind(IList<T> list)
+		{
+			List = list as List<T> ?? list.ToList();
+		}
+
 		/// <inheritdoc cref="List{T}.GetEnumerator"/>
 		public List<T>.Enumerator GetEnumerator()
 		{
@@ -332,12 +350,15 @@ private int AdjustIndex(int index, Action<int, T, T, ObservableUpdateType> actio
 		}
 	}
 
-	/// <inheritdoc />
+	/// <inheritdoc cref="IObservableResolverList{T, TOrigin}"/>
+	/// <remarks>
+	/// This class resolves between 2 lists with different types of values
+	/// </remarks>
 	public class ObservableResolverList<T, TOrigin> : ObservableList<T>, IObservableResolverList<T, TOrigin>
 	{
-		private readonly IList<TOrigin> _originList;
-		private readonly Func<TOrigin, T> _fromOrignResolver;
-		private readonly Func<T, TOrigin> _toOrignResolver;
+		private IList<TOrigin> _originList;
+		private Func<TOrigin, T> _fromOrignResolver;
+		private Func<T, TOrigin> _toOrignResolver;
 
 		/// <inheritdoc />
 		public IReadOnlyList<TOrigin> OriginList => new List<TOrigin>(_originList);
@@ -357,6 +378,23 @@ public ObservableResolverList(IList<TOrigin> originList,
 			}
 		}
 
+		/// <inheritdoc />
+		public void Rebind(IList<TOrigin> originList, 
+			Func<TOrigin, T> fromOrignResolver, 
+			Func<T, TOrigin> toOrignResolver)
+		{
+			_originList = originList;
+			_fromOrignResolver = fromOrignResolver;
+			_toOrignResolver = toOrignResolver;
+
+			// Rebuild the internal list from the new origin list
+			List.Clear();
+			for (var i = 0; i < originList.Count; i++)
+			{
+				List.Add(fromOrignResolver(originList[i]));
+			}
+		}
+
 		/// <inheritdoc />
 		public override void Add(T data)
 		{