/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (CurrentPath.Match(MemberPath))
VisitAssetMember(value, member.TypeDescriptor);
else
base.VisitObjectMember(container, containerDescriptor, member, value);
}
public override void WriteMemberValue(ref ObjectContext objectContext, IMemberDescriptor memberDescriptor, object memberValue, Type memberType)
{
var memberObjectContext = new ObjectContext(objectContext.SerializerContext, memberValue, objectContext.SerializerContext.FindTypeDescriptor(memberType));
bool nonIdentifiableItems;
// We allow compact style only for collection with non-identifiable items
var allowCompactStyle = objectContext.SerializerContext.Properties.TryGetValue(CollectionWithIdsSerializerBase.NonIdentifiableCollectionItemsKey, out nonIdentifiableItems) && nonIdentifiableItems;
var member = memberDescriptor as MemberDescriptorBase;
if (member != null && objectContext.Settings.Attributes.GetAttribute<NonIdentifiableCollectionItemsAttribute>(member.MemberInfo) != null)
{
memberObjectContext.Properties.Add(CollectionWithIdsSerializerBase.NonIdentifiableCollectionItemsKey, true);
allowCompactStyle = true;
}
if (allowCompactStyle)
{
memberObjectContext.Style = memberDescriptor.Style;
}
var path = GetCurrentPath(ref objectContext, true);
path.PushMember(memberDescriptor.Name);
SetCurrentPath(ref memberObjectContext, path);
WriteYaml(ref memberObjectContext);
}
/// <summary>
/// Gets the override for the specified member.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="memberDescriptor">The member descriptor.</param>
/// <returns>OverrideType.</returns>
/// <exception cref="System.ArgumentNullException">
/// instance
/// or
/// memberDescriptor
/// </exception>
public static OverrideType GetOverride(this object instance, IMemberDescriptor memberDescriptor)
{
if (instance == null) throw new ArgumentNullException("instance");
if (memberDescriptor == null) throw new ArgumentNullException("memberDescriptor");
OverrideType overrideType;
return instance.TryGetDynamicProperty(memberDescriptor, OverrideKey, out overrideType) ? overrideType : OverrideType.Base;
}
/// <inheritdoc/>
public virtual IContent CreateMemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, object value, bool shouldProcessReference)
{
var reference = nodeBuilder.CreateReferenceForNode(member.Type, value);
return new MemberContent(nodeBuilder, container, member, isPrimitive, reference)
{
ShouldProcessReference = shouldProcessReference
};
}
public MemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, IReference reference)
: base(nodeBuilder.TypeDescriptorFactory.Find(member.Type), isPrimitive, reference)
{
if (container == null) throw new ArgumentNullException(nameof(container));
Member = member;
Container = container;
nodeContainer = nodeBuilder.NodeContainer;
}
/// <inheritdoc/>
public virtual IContent CreateMemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, object value, bool shouldProcessReference)
{
var reference = nodeBuilder.CreateReferenceForNode(member.Type, value);
// TODO: OverridableMemberContent should not be in the DefaultContentFactory but in an asset-specific factory.
return new OverridableMemberContent(nodeBuilder, container, member, isPrimitive, reference)
{
ShouldProcessReference = shouldProcessReference
};
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (!AcceptMember(member))
{
return;
}
var node = stackItems.Peek();
var newNode = new DataVisitMember(value, member);
AddMember(node, newNode);
stackItems.Push(newNode);
base.VisitObjectMember(container, containerDescriptor, member, value);
stackItems.Pop();
}
/// <summary>
/// Initialize the tests.
/// </summary>
public virtual void Initialize()
{
TypeFactory = new TypeDescriptorFactory();
var myClassDesc = TypeFactory.Find(typeof(MyClass));
var myStructDesc = TypeFactory.Find(typeof(MyStruct));
ListClassDesc = (CollectionDescriptor)TypeFactory.Find(typeof(List<MyClass>));
MapClassDesc = (DictionaryDescriptor)TypeFactory.Find(typeof(Dictionary<string, MyClass>));
MemberValue = myClassDesc.Members.FirstOrDefault(member => member.Name == "Value");
MemberSub = myClassDesc.Members.FirstOrDefault(member => member.Name == "Sub");
MemberStruct = myClassDesc.Members.FirstOrDefault(member => member.Name == "Struct");
MemberSubs = myClassDesc.Members.FirstOrDefault(member => member.Name == "Subs");
MemberMaps = myClassDesc.Members.FirstOrDefault(member => member.Name == "Maps");
MemberX = myStructDesc.Members.FirstOrDefault(member => member.Name == "X");
MemberClass = myStructDesc.Members.FirstOrDefault(member => member.Name == "Class");
}
public override object ReadMemberValue(ref ObjectContext objectContext, IMemberDescriptor memberDescriptor, object memberValue, Type memberType)
{
var memberObjectContext = new ObjectContext(objectContext.SerializerContext, memberValue, objectContext.SerializerContext.FindTypeDescriptor(memberType));
var member = memberDescriptor as MemberDescriptorBase;
if (member != null && objectContext.Settings.Attributes.GetAttribute<NonIdentifiableCollectionItemsAttribute>(member.MemberInfo) != null)
{
memberObjectContext.Properties.Add(CollectionWithIdsSerializerBase.NonIdentifiableCollectionItemsKey, true);
}
var path = GetCurrentPath(ref objectContext, true);
path.PushMember(memberDescriptor.Name);
SetCurrentPath(ref memberObjectContext, path);
var result = ReadYaml(ref memberObjectContext);
return result;
}
public override void Initialize()
{
base.Initialize();
TypeFactory = new TypeDescriptorFactory();
var assetDesc = TypeFactory.Find(typeof(TestAssetUpdate));
memberMyClass = assetDesc.Members.FirstOrDefault(member => member.Name == "MyClass");
if (session != null)
{
session.Dispose();
dependencyManager.Dispose();
}
package = new Package();
session = new PackageSession(package);
dependencyManager = new AssetDependencyManager(session);
assetUpdater = new AssetUpdater(dependencyManager);
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (sourceFiles != null)
{
if (member.Type == typeof(UFile) && value != null)
{
var file = (UFile)value;
if (!string.IsNullOrWhiteSpace(file.ToString()))
{
var attribute = member.GetCustomAttributes<SourceFileMemberAttribute>(true).SingleOrDefault();
if (attribute != null)
{
if (!sourceFiles.ContainsKey(file))
{
sourceFiles.Add(file, attribute.UpdateAssetIfChanged);
}
else if (attribute.UpdateAssetIfChanged)
{
// If the file has already been collected, just update whether it should update the asset when changed
sourceFiles[file] = true;
}
}
}
}
}
if (sourceMembers != null)
{
if (member.Type == typeof(UFile))
{
var attribute = member.GetCustomAttributes<SourceFileMemberAttribute>(true).SingleOrDefault();
if (attribute != null)
{
sourceMembers[CurrentPath.Clone()] = value as UFile;
}
}
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
protected virtual void WriteMemberName(ref ObjectContext objectContext, IMemberDescriptor member, string name)
{
objectContext.ObjectSerializerBackend.WriteMemberName(ref objectContext, member, name);
}
/// <inheritdoc/>
public virtual IMemberNode CreateMemberNode(INodeBuilder nodeBuilder, Guid guid, IObjectNode parent, IMemberDescriptor member, object value)
{
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
var reference = nodeBuilder.CreateReferenceForNode(member.Type, value, true);
return(new MemberNode(nodeBuilder, guid, parent, member, reference));
}
private void AddMemberTo(Dictionary <string, IMemberDescriptor> members, string name, IMemberDescriptor desc)
{
IOverloadableMemberDescriptor odesc = desc as IOverloadableMemberDescriptor;
if (odesc != null)
{
if (members.ContainsKey(name))
{
OverloadedMethodMemberDescriptor overloads = members[name] as OverloadedMethodMemberDescriptor;
if (overloads != null)
{
overloads.AddOverload(odesc);
}
else
{
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
}
else
{
members.Add(name, new OverloadedMethodMemberDescriptor(name, this.Type, odesc));
}
}
else
{
if (members.ContainsKey(name))
{
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
else
{
members.Add(name, desc);
}
}
}
/// <summary>
/// Gets the getter of the member as a DynValue containing a callback
/// </summary>
/// <param name="desc">The descriptor instance.</param>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <returns></returns>
public static DynValue GetGetterCallbackAsDynValue(this IMemberDescriptor desc, Script script, object obj)
{
return(DynValue.NewCallback((p1, p2) => desc.GetValue(script, obj)));
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// Don't visit base parts as they are visited at the top level.
if (typeof(Asset).IsAssignableFrom(member.DeclaringType) && (member.Name == Asset.BasePartsProperty))
{
return;
}
if (sourceFiles != null)
{
if (member.Type == typeof(UFile) && value != null)
{
var file = (UFile)value;
if (!string.IsNullOrWhiteSpace(file.ToString()))
{
var attribute = member.GetCustomAttributes <SourceFileMemberAttribute>(true).SingleOrDefault();
if (attribute != null)
{
if (!sourceFiles.ContainsKey(file))
{
sourceFiles.Add(file, attribute.UpdateAssetIfChanged);
}
else if (attribute.UpdateAssetIfChanged)
{
// If the file has already been collected, just update whether it should update the asset when changed
sourceFiles[file] = true;
}
}
}
}
}
if (sourceMembers != null)
{
if (member.Type == typeof(UFile))
{
var attribute = member.GetCustomAttributes <SourceFileMemberAttribute>(true).SingleOrDefault();
if (attribute != null)
{
sourceMembers[CurrentPath.Clone()] = value as UFile;
}
}
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
public virtual void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
Visit(value, member.TypeDescriptor);
}
public virtual void WriteMemberValue(ref ObjectContext objectContext, IMemberDescriptor member, object memberValue,
Type memberType)
{
// Push the style of the current member
objectContext.SerializerContext.WriteYaml(memberValue, memberType, member.Style);
}
public static IMemberDescriptor FindDescriptor(this IMemberDescriptor descriptor, string memberName)
{
return(Extensions.FindDescriptor(descriptor, memberName));
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
bool shouldProcessReference;
if (!NotifyNodeConstructing(containerDescriptor, member, out shouldProcessReference))
return;
// If this member should contains a reference, create it now.
GraphNode containerNode = GetContextNode();
IContent content = ContentFactory.CreateMemberContent(this, containerNode.Content, member, IsPrimitiveType(member.Type), value, shouldProcessReference);
var node = (GraphNode)NodeFactory(member.Name, content, Guid.NewGuid());
containerNode.AddChild(node);
if (content.IsReference)
referenceContents.Add(content);
PushContextNode(node);
if (!(content.Reference is ObjectReference))
{
// For enumerable references, we visit the member to allow VisitCollection or VisitDictionary to enrich correctly the node.
Visit(content.Value);
}
PopContextNode();
AvailableCommands.Where(x => x.CanAttach(node.Content.Descriptor, (MemberDescriptorBase)member)).ForEach(node.AddCommand);
NotifyNodeConstructed(content);
node.Seal();
}
/// <summary>
/// Raises the <see cref="NodeConstructing"/> event.
/// </summary>
/// <param name="containerDescriptor">The descriptor of the container of the member being constructed, or of the object itself it is a root object.</param>
/// <param name="member">The member descriptor of the member being constructed.</param>
/// <param name="shouldProcessReference">Indicates whether the reference that will be created in the node should be processed or not.</param>
/// <returns><c>true</c> if the node should be constructed, <c>false</c> if it should be discarded.</returns>
/// <remarks>This method is internal so it can be used by the <see cref="ModelConsistencyCheckVisitor"/>.</remarks>
internal bool NotifyNodeConstructing(ObjectDescriptor containerDescriptor, IMemberDescriptor member, out bool shouldProcessReference)
{
var handler = NodeConstructing;
if (handler != null)
{
var args = new NodeConstructingArgs(containerDescriptor, (MemberDescriptorBase)member);
handler(this, args);
shouldProcessReference = !args.Discard && args.ShouldProcessReference;
return !args.Discard;
}
shouldProcessReference = true;
return true;
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// AssetCompositeSerializer.ReadMemberValue/WriteMemberValue is not run with CustomDataVisitor, so we need to Enter/Leave memebers ourselves
// TODO: Unify IDataCustomVisitor and AssetVisitorBase?
var removeLastEnteredNode = AssetCompositeSerializer.LocalContext.Value?.EnterNode(member) ?? false;
try
{
base.VisitObjectMember(container, containerDescriptor, member, value);
}
finally
{
AssetCompositeSerializer.LocalContext.Value?.LeaveNode(removeLastEnteredNode);
}
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// If this member should contains a reference, create it now.
var containerNode = (IInitializingObjectNode)GetContextNode();
var guid = Guid.NewGuid();
var content = (MemberContent)ContentFactory.CreateMemberContent(this, guid, containerNode, member, IsPrimitiveType(member.Type), value);
containerNode.AddMember(content);
if (content.IsReference)
{
referenceContents.Add(content);
}
PushContextNode(content);
if (content.TargetReference == null)
{
// For enumerable references, we visit the member to allow VisitCollection or VisitDictionary to enrich correctly the node.
Visit(content.Value);
}
PopContextNode();
AvailableCommands.Where(x => x.CanAttach(content.Descriptor, (MemberDescriptorBase)member)).ForEach(content.AddCommand);
content.Seal();
}
private void AddMemberTo(Dictionary<string, IMemberDescriptor> members, string name, IMemberDescriptor desc)
{
IOverloadableMemberDescriptor odesc = desc as IOverloadableMemberDescriptor;
if (odesc != null)
{
if (members.ContainsKey(name))
{
OverloadedMethodMemberDescriptor overloads = members[name] as OverloadedMethodMemberDescriptor;
if (overloads != null)
overloads.AddOverload(odesc);
else
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
else
{
members.Add(name, new OverloadedMethodMemberDescriptor(name, this.Type, odesc));
}
}
else
{
if (members.ContainsKey(name))
{
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
else
{
members.Add(name, desc);
}
}
}
/// <summary>
/// Adds a property to the member list
/// </summary>
/// <param name="name">The name.</param>
/// <param name="desc">The descriptor.</param>
/// <exception cref="System.ArgumentException">
/// Thrown if a name conflict is detected and one of the conflicting members does not support overloads.
/// </exception>
public void AddMember(string name, IMemberDescriptor desc)
{
if (desc != null)
AddMemberTo(m_Members, name, desc);
}
/// <summary>
/// Sets the override for the specified member.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="memberDescriptor">The member descriptor.</param>
/// <param name="overrideType">Type of the override.</param>
/// <exception cref="System.ArgumentNullException">
/// instance
/// or
/// memberDescriptor
/// </exception>
public static void SetOverride(this object instance, IMemberDescriptor memberDescriptor, OverrideType overrideType)
{
if (instance == null) throw new ArgumentNullException("instance");
if (memberDescriptor == null) throw new ArgumentNullException("memberDescriptor");
instance.SetDynamicProperty(memberDescriptor, OverrideKey, overrideType);
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// If this member should contains a reference, create it now.
var containerNode = (IInitializingObjectNode)GetContextNode();
var guid = Guid.NewGuid();
var content = (MemberNode)NodeFactory.CreateMemberNode(this, guid, containerNode, member, value);
containerNode.AddMember(content);
if (content.IsReference)
{
referenceContents.Add(content);
}
PushContextNode(content);
if (content.TargetReference == null)
{
// For enumerable references, we visit the member to allow VisitCollection or VisitDictionary to enrich correctly the node.
Visit(content.Retrieve());
}
PopContextNode();
content.Seal();
}
private static bool AcceptMember(IMemberDescriptor member)
{
if (!typeof(Asset).IsAssignableFrom(member.DeclaringType))
return true;
// Skip some properties that are not using when visiting
return member.Name != SourceHashesHelper.MemberName && member.Name != Asset.BaseProperty && member.Name != Asset.BasePartsProperty && member.Name != "Id";
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
base.VisitObjectMember(container, containerDescriptor, member, value);
var assetReference = value as AssetReference;
var assetBase = value as AssetBase;
var attachedReference = value != null?AttachedReferenceManager.GetAttachedReference(value) : null;
if (assetReference != null)
{
AddLink(assetReference,
(guid, location) =>
{
var newValue = AssetReference.New(member.Type, guid.HasValue ? guid.Value : assetReference.Id, location);
member.Set(container, newValue);
return(newValue);
});
}
else if (assetBase != null)
{
AddLink(assetBase,
(guid, location) =>
{
var newValue = new AssetBase(location, assetBase.Asset);
member.Set(container, newValue);
return(newValue);
});
}
else if (attachedReference != null)
{
AddLink(new AttachedContentReference(attachedReference),
(guid, location) =>
{
object newValue = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateSerializableVersion(member.Type, guid.Value, location) : null;
member.Set(container, newValue);
return(newValue);
});
}
else if (value is UFile)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UFile(location);
member.Set(container, newValue);
return(newValue);
});
}
else if (value is UDirectory)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UDirectory(location);
member.Set(container, newValue);
return(newValue);
});
}
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// Don't visit base parts as they are visited at the top level.
if (typeof(Asset).IsAssignableFrom(member.DeclaringType) && (member.Name == "~BaseParts"))
{
return;
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
public OverridableMemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, IReference reference)
: base(nodeBuilder, container, member, isPrimitive, reference)
{
Override = container.Value.GetOverride(member);
}
/// <inheritdoc/>
public virtual IContentNode CreateMemberContent(INodeBuilder nodeBuilder, Guid guid, IObjectNode parent, IMemberDescriptor member, bool isPrimitive, object value)
{
var reference = nodeBuilder.CreateReferenceForNode(member.Type, value);
return(new MemberContent(nodeBuilder, guid, parent, member, isPrimitive, reference));
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (CurrentPath.Match(MemberPath))
{
VisitAssetMember(value, member.TypeDescriptor);
}
else
{
base.VisitObjectMember(container, containerDescriptor, member, value);
}
}
public virtual object ReadMemberValue(ref ObjectContext objectContext, IMemberDescriptor memberDescriptor, object memberValue,
Type memberType)
{
return objectContext.SerializerContext.ReadYaml(memberValue, memberType);
}
/// <summary>
/// Creates a ScriptRuntimeException with a predefined error message specifying that
/// an attempt to access a non-static member from a static userdata was made
/// </summary>
/// <param name="typeDescr">The type descriptor.</param>
/// <param name="desc">The member descriptor.</param>
/// <returns></returns>
public static ScriptRuntimeException AccessInstanceMemberOnStatics(IUserDataDescriptor typeDescr, IMemberDescriptor desc)
{
return(new ScriptRuntimeException("attempt to access instance member {0}.{1} from a static userdata", typeDescr.Name, desc.Name));
}
public virtual void WriteMemberName(ref ObjectContext objectContext, IMemberDescriptor member, string name)
{
// Emit the key name
objectContext.Writer.Emit(new ScalarEventInfo(name, typeof(string))
{
RenderedValue = name,
IsPlainImplicit = true,
Style = ScalarStyle.Plain
});
}
protected virtual object ReadMemberValue(ref ObjectContext objectContext, IMemberDescriptor member,
object memberValue,
Type memberType)
{
return(objectContext.ObjectSerializerBackend.ReadMemberValue(ref objectContext, member, memberValue, memberType));
}
public virtual void WriteMemberValue(ref ObjectContext objectContext, IMemberDescriptor member, object memberValue,
Type memberType)
{
// Push the style of the current member
objectContext.SerializerContext.WriteYaml(memberValue, memberType, member.Style);
}
protected virtual void WriteMemberValue(ref ObjectContext objectContext, IMemberDescriptor member, object memberValue,
Type memberType)
{
objectContext.ObjectSerializerBackend.WriteMemberValue(ref objectContext, member, memberValue, memberType);
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (ProcessObject(value, member.TypeDescriptor.Type))
{
return;
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
/// <summary>
/// Executes the specified indexer method.
/// </summary>
/// <param name="mdesc">The method descriptor</param>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <param name="index">The indexer parameter</param>
/// <param name="value">The dynvalue to set on a setter, or null.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
protected virtual DynValue ExecuteIndexer(IMemberDescriptor mdesc, Script script, object obj, DynValue index, DynValue value)
{
IList<DynValue> values;
if (index.Type == DataType.Tuple)
{
if (value == null)
{
values = index.Tuple;
}
else
{
values = new List<DynValue>(index.Tuple);
values.Add(value);
}
}
else
{
if (value == null)
{
values = new DynValue[] { index };
}
else
{
values = new DynValue[] { index, value };
}
}
CallbackArguments args = new CallbackArguments(values, false);
ScriptExecutionContext execCtx = script.CreateDynamicExecutionContext();
DynValue v = mdesc.GetValue(script, obj);
if (v.Type != DataType.ClrFunction)
throw new ScriptRuntimeException("a clr callback was expected in member {0}, while a {1} was found", mdesc.Name, v.Type);
return v.Callback.ClrCallback(execCtx, args);
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
bool shouldProcessReference;
if (!nodeBuilder.NotifyNodeConstructing(containerDescriptor, member, out shouldProcessReference))
{
return;
}
var node = GetContextNode();
ModelNode child;
try
{
child = (ModelNode)node.Children.Single(x => x.Name == member.Name);
}
catch (InvalidOperationException)
{
throw new QuantumConsistencyException("A single child node [{0}]", member.Name, "No child or multiple children [{0}]", member.Name, node);
}
if (!IsPrimitiveType(child.Content.Type))
{
PushContextNode(child);
Visit(value);
PopContextNode();
}
}
public AssetMemberNode([NotNull] INodeBuilder nodeBuilder, Guid guid, [NotNull] IObjectNode parent, [NotNull] IMemberDescriptor memberDescriptor, IReference reference)
: base(nodeBuilder, guid, parent, memberDescriptor, reference)
{
ValueChanged += ContentChanged;
IsNonIdentifiableCollectionContent = MemberDescriptor.GetCustomAttributes <NonIdentifiableCollectionItemsAttribute>(true)?.Any() ?? false;
CanOverride = MemberDescriptor.GetCustomAttributes <NonOverridableAttribute>(true)?.Any() != true;
}
/// <summary>
/// Determines whether a member is readonly.
/// </summary>
/// <param name="memberDescriptor">The member descriptor.</param>
/// <returns><c>true</c> if a member is readonly; otherwise, <c>false</c>.</returns>
public static bool IsReadOnly(this IMemberDescriptor memberDescriptor)
{
return(memberDescriptor.Mode == DataMemberMode.ReadOnly);
}
public override object ReadMemberValue(ref ObjectContext objectContext, IMemberDescriptor memberDescriptor, object memberValue, Type memberType)
{
return LoadAssetIfRequired(memberType, base.ReadMemberValue(ref objectContext, memberDescriptor, memberValue, memberType));
}
/// <inheritdoc />
public virtual void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
Visit(value, member.TypeDescriptor);
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (!AcceptMember(member))
{
return;
}
var node = stackItems.Peek();
var newNode = new DataVisitMember(value, member);
AddMember(node, newNode);
stackItems.Push(newNode);
base.VisitObjectMember(container, containerDescriptor, member, value);
stackItems.Pop();
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
bool shouldProcessReference;
if (!nodeBuilder.NotifyNodeConstructing(containerDescriptor, member, out shouldProcessReference))
return;
var node = GetContextNode();
GraphNode child;
try
{
child = (GraphNode)node.Children.Single(x => x.Name == member.Name);
}
catch (InvalidOperationException)
{
throw new QuantumConsistencyException("A single child node [{0}]", member.Name, "No child or multiple children [{0}]", member.Name, node);
}
if (!IsPrimitiveType(child.Content.Type))
{
PushContextNode(child);
Visit(value);
PopContextNode();
}
}
/// <inheritdoc/>
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
bool shouldProcessReference;
if (ShouldDiscardMember(member as MemberDescriptorBase))
{
return;
}
NotifyNodeConstructing(containerDescriptor, member, out shouldProcessReference);
// If this member should contains a reference, create it now.
GraphNode containerNode = GetContextNode();
IContent content = ContentFactory.CreateMemberContent(this, containerNode.Content, member, IsPrimitiveType(member.Type), value, shouldProcessReference);
var node = (GraphNode)currentNodeFactory(member.Name, content, Guid.NewGuid());
containerNode.AddChild(node);
if (content.IsReference)
{
referenceContents.Add(content);
}
PushContextNode(node);
if (!(content.Reference is ObjectReference))
{
// For enumerable references, we visit the member to allow VisitCollection or VisitDictionary to enrich correctly the node.
Visit(content.Value);
}
PopContextNode();
AvailableCommands.Where(x => x.CanAttach(node.Content.Descriptor, (MemberDescriptorBase)member)).ForEach(node.AddCommand);
node.Seal();
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (ProcessObject(value, member.TypeDescriptor.Type)) return;
base.VisitObjectMember(container, containerDescriptor, member, value);
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
base.VisitObjectMember(container, containerDescriptor, member, value);
var assetReference = value as AssetReference;
var assetBase = value as AssetBase;
var attachedReference = value != null ? AttachedReferenceManager.GetAttachedReference(value) : null;
if (assetReference != null)
{
AddLink(assetReference,
(guid, location) =>
{
var newValue = AssetReference.New(member.Type, guid.HasValue ? guid.Value : assetReference.Id, location);
member.Set(container, newValue);
return newValue;
});
}
else if (assetBase != null)
{
AddLink(assetBase,
(guid, location) =>
{
var newValue = new AssetBase(location, assetBase.Asset);
member.Set(container, newValue);
return newValue;
});
}
else if (attachedReference != null)
{
AddLink(attachedReference,
(guid, location) =>
{
object newValue = guid.HasValue && guid.Value != Guid.Empty ? AttachedReferenceManager.CreateSerializableVersion(member.Type, guid.Value, location) : null;
member.Set(container, newValue);
return newValue;
});
}
else if (value is UFile)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UFile(location);
member.Set(container, newValue);
return newValue;
});
}
else if (value is UDirectory)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UDirectory(location);
member.Set(container, newValue);
return newValue;
});
}
}
public MemberNode([NotNull] INodeBuilder nodeBuilder, Guid guid, [NotNull] IObjectNode parent, [NotNull] IMemberDescriptor memberDescriptor, IReference reference)
: base(nodeBuilder.SafeArgument(nameof(nodeBuilder)).NodeContainer, guid, nodeBuilder.TypeDescriptorFactory.Find(memberDescriptor.Type))
{
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
Parent = parent ?? throw new ArgumentNullException(nameof(parent));
MemberDescriptor = memberDescriptor ?? throw new ArgumentNullException(nameof(memberDescriptor));
Name = memberDescriptor.Name;
TargetReference = reference as ObjectReference;
}
/// <summary>
/// Determines whether this instance can be written to
/// </summary>
/// <param name="desc">The descriptor instance.</param>
/// <returns></returns>
public static bool CanWrite(this IMemberDescriptor desc)
{
return(desc.MemberAccess.HasAllFlags(MemberDescriptorAccess.CanWrite));
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
base.VisitObjectMember(container, containerDescriptor, member, value);
var assetReference = value as AssetReference;
var attachedReference = AttachedReferenceManager.GetAttachedReference(value);
if (assetReference != null)
{
AddLink(assetReference,
(guid, location) =>
{
var newValue = AssetReference.New(guid ?? assetReference.Id, location);
member.Set(container, newValue);
return(newValue);
});
}
else if (attachedReference != null)
{
AddLink(attachedReference,
(guid, location) =>
{
object newValue = guid.HasValue && guid.Value != AssetId.Empty ? AttachedReferenceManager.CreateProxyObject(member.Type, guid.Value, location) : null;
member.Set(container, newValue);
return(newValue);
});
}
else if (value is UFile)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UFile(location);
member.Set(container, newValue);
return(newValue);
});
}
else if (value is UDirectory)
{
AddLink(value,
(guid, location) =>
{
var newValue = new UDirectory(location);
member.Set(container, newValue);
return(newValue);
});
}
}
private static bool AcceptMember(IMemberDescriptor member)
{
// Skip some properties that are not using when visiting
if ((typeof(AssetImport).IsAssignableFrom(member.DeclaringType) && (member.Name == "ImporterId" || member.Name == "SourceHash"))
|| typeof(Asset).IsAssignableFrom(member.DeclaringType) && (member.Name.StartsWith("~Base") || member.Name == "Id"))
{
return false;
}
return true;
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
if (member.GetCustomAttributes <NonIdentifiableCollectionItemsAttribute>(true).Any())
{
// Value types (collection that are struct) will automatically be considered as non-identifiable.
if (value?.GetType().IsValueType == false)
{
nonIdentifiableCollection = nonIdentifiableCollection ?? new HashSet <object>();
nonIdentifiableCollection.Add(value);
}
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
public int GetDescriptorIndex(IMemberDescriptor descriptor)
{
return(GetUtf8Index(descriptor.Serialize()));
}
public virtual object ReadMemberValue(ref ObjectContext objectContext, IMemberDescriptor memberDescriptor, object memberValue,
Type memberType)
{
return(objectContext.SerializerContext.ReadYaml(memberValue, memberType));
}
/// <summary>
/// Creates a ScriptRuntimeException with a predefined error message specifying that
/// an attempt to access a non-static member from a static userdata was made
/// </summary>
/// <param name="typeDescr">The type descriptor.</param>
/// <param name="desc">The member descriptor.</param>
/// <returns></returns>
public static ScriptRuntimeException AccessInstanceMemberOnStatics(IUserDataDescriptor typeDescr, IMemberDescriptor desc)
{
return new ScriptRuntimeException("attempt to access instance member {0}.{1} from a static userdata", typeDescr.Name, desc.Name);
}
public override void VisitObjectMember(object container, ObjectDescriptor containerDescriptor, IMemberDescriptor member, object value)
{
// Don't visit base parts as they are visited at the top level.
if (typeof(Asset).IsAssignableFrom(member.DeclaringType) && (member.Name == Asset.BasePartsProperty))
{
return;
}
base.VisitObjectMember(container, containerDescriptor, member, value);
}
