// Finds the node containing the specified object
        // returns true if it found the object
        internal static bool SelectObjectMember(IObjectMember om,
                                                bool createObj)
        {
            ObjectTreeNode node = FindObject(om.Obj, createObj);

            if (node != null)
            {
                node = node.FindMember(om.Member);
                if (node == null)
                {
                    ErrorDialog.Show("You requested to show member "
                                     + om.Member
                                     + " but it cannot be shown because "
                                     + "it is not visible according to the "
                                     + "preferences you have selected "
                                     + "in the object tree.  To show this "
                                     + "member, please modify those "
                                     + "preferences.",
                                     "Member not visible",
                                     MessageBoxIcon.Error);
                    return(false);
                }
                node.PointToNode();
                return(true);
            }
            return(false);
        }
Beispiel #2
0
        public void ShowTarget(Object linkModifier)
        {
            IObjectMember om = (IObjectMember)linkModifier;

            ObjectTreeNode.
            SelectObjectMember(om, ObjectTreeNode.CREATE_OBJ);
        }
        public static TObject MakeObject <TObject>(KvObject keyValueObject, IObjectReflector reflector, IObjectMember objectMember = null)
        {
            Require.NotNull(keyValueObject, nameof(keyValueObject));
            Require.NotNull(reflector, nameof(reflector));

            if (keyValueObject.Value.ValueType == KvValueType.Collection)
            {
                if (IsLookupWithStringKey(typeof(TObject), out var lookupValueType))
                {
                    return((TObject)MakeLookup(lookupValueType, keyValueObject));
                }
                else if (IsDictionary(typeof(TObject)))
                {
                    return((TObject)MakeDictionary(typeof(TObject), keyValueObject));
                }
                else if (IsArray(keyValueObject, out var enumerableValues) && ConstructTypedEnumerable(typeof(TObject), enumerableValues, out var enumerable))
                {
                    return((TObject)enumerable);
                }
                else if (IsConstructibleEnumerableType(typeof(TObject)))
                {
                    throw new InvalidOperationException($"Cannot deserialize a non-array value to type \"{typeof(TObject).Namespace}.{typeof(TObject).Name}\".");
                }

                var typedObject = (TObject)FormatterServices.GetUninitializedObject(typeof(TObject));

                CopyObject(keyValueObject, typedObject, reflector);
                return(typedObject);
            }
            else if (CanConvertValueTo(typeof(TObject)))
            {
                return((TObject)Convert.ChangeType(keyValueObject.Value, typeof(TObject)));
            }
            else if (IsConstructibleEnumerableType(typeof(TObject)))
            {
                Require.NotNull(objectMember, nameof(objectMember));
                if (objectMember?.CollectionType != KvCollectionType.CharSeparated)
                {
                    throw new InvalidOperationException("Cannot deserialise string object values to anything but char separated arrays.");
                }

                // Remove whitespace and split the string
                var str = ((string)Convert.ChangeType(keyValueObject.Value, typeof(string)))
                          .Trim()
                          .Split(objectMember.CollectionTypeSeparator)
                          //.Select(s => s.Trim())
                          .Cast <object>().ToArray();
                if (!ConstructTypedEnumerable(typeof(TObject), str, out var enumerable))
                {
                    throw new InvalidOperationException("Unable to construct enumerable.");
                }

                return((TObject)enumerable);
            }
            else
            {
                throw new NotSupportedException(typeof(TObject).Name);
            }
        }
 public static object MakeObject(KvObject keyValueObject, Type objectType, IObjectReflector reflector, IObjectMember objectMember = null)
 => InvokeGeneric(nameof(MakeObject), objectType, new object[] { keyValueObject, reflector, objectMember });
        private static KvObject FromObjectCore <TObject>(TObject managedObject, string topLevelName, IObjectReflector reflector, HashSet <object> visitedObjects, IObjectMember objectMember = null)
        {
            if (managedObject == null)
            {
                throw new ArgumentNullException(nameof(managedObject));
            }

            Require.NotNull(topLevelName, nameof(topLevelName));
            Require.NotNull(reflector, nameof(reflector));
            Require.NotNull(visitedObjects, nameof(visitedObjects));

            if (!typeof(TObject).IsValueType && typeof(TObject) != typeof(string) && !visitedObjects.Add(managedObject))
            {
                throw new KeyValueException("Serialization failed - circular object reference detected.");
            }

            if (typeof(IConvertible).IsAssignableFrom(typeof(TObject)))
            {
                return(new KvObject(topLevelName, (string)Convert.ChangeType(managedObject, typeof(string))));
            }

            var childObjects = new List <KvObject>();

            if (typeof(IDictionary).IsAssignableFrom(typeof(TObject)))
            {
                var dictionary = (IDictionary)managedObject;
                var enumerator = dictionary.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    var entry = enumerator.Entry;
                    childObjects.Add(new KvObject(entry.Key.ToString(), entry.Value.ToString()));
                }
            }
            else if (typeof(TObject).IsArray || typeof(IEnumerable).IsAssignableFrom(typeof(TObject)))
            {
                var collectionType = objectMember?.CollectionType ?? KvCollectionType.Default;

                switch (collectionType)
                {
                case KvCollectionType.ValueList:
                    var counter = 0;
                    foreach (var child in (IEnumerable)managedObject)
                    {
                        var childKvObject = CopyObject(child, counter.ToString(), reflector, visitedObjects);
                        childObjects.Add(childKvObject);

                        counter++;
                    }
                    break;

                case KvCollectionType.CharSeparated:
                    if (objectMember == null)
                    {
                        throw new InvalidOperationException();
                    }

                    var sb = new StringBuilder();
                    foreach (var child in (IEnumerable)managedObject)
                    {
                        var str = Convert.ChangeType(child, typeof(string));
                        sb.Append(str);
                        sb.Append(objectMember.CollectionTypeSeparator);
                    }

                    return(new KvObject(topLevelName, sb.ToString().TrimEnd(objectMember.CollectionTypeSeparator)));

                default:
                    throw new NotSupportedException("Unsupported KvCollectionType for serialisation.");
                }
            }
            else
            {
                foreach (var member in reflector.GetMembers(managedObject).OrderBy(p => p.Name))
                {
                    if (!member.MemberType.IsValueType && member.Value is null)
                    {
                        continue;
                    }

                    var name = member.Name;
                    if (!member.IsExplicitName && name.Length > 0 && char.IsUpper(name[0]))
                    {
                        name = char.ToLower(name[0]) + name.Substring(1);
                    }

                    childObjects.Add(typeof(IConvertible).IsAssignableFrom(member.MemberType)
                        ? new KvObject(name, (string)Convert.ChangeType(member.Value, typeof(string)))
                        : CopyObject(member.Value, member.Name, reflector, visitedObjects));
                }
            }

            return(new KvObject(topLevelName, childObjects));
        }
		// Finds the node containing the specified object
		// returns true if it found the object
		internal static bool SelectObjectMember(IObjectMember om,
												bool createObj)
		{
			ObjectTreeNode node = FindObject(om.Obj, createObj);
			if (node != null)
			{
				node = node.FindMember(om.Member);
				if (node == null)
				{
					ErrorDialog.Show("You requested to show member "
									+ om.Member
									+ " but it cannot be shown because "
									+ "it is not visible according to the "
									+ "preferences you have selected "
									+ "in the object tree.  To show this "
									+ "member, please modify those "
									+ "preferences.",
									"Member not visible",
									MessageBoxIcon.Error);
					return false;
				}
				node.PointToNode();
				return true;
			}
			return false;
		}