static GenericMixedEntityDescriptor()
{
_nodesToBuild = new INodeBuilder[]
{
new T(),
};
}
public StackNode(Store store, IStackModel stackModel, INodeBuilder builder)
{
m_Store = store;
this.stackModel = stackModel;
m_GraphView = builder.GraphView;
styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "StackNode.uss"));
style.overflow = Overflow.Visible;
var borderItem = this.MandatoryQ("borderItem");
borderItem.style.overflow = Overflow.Visible;
this.AddManipulator(new ContextualMenuManipulator(OnContextualMenuEvent));
RegisterCallback <AttachToPanelEvent>(OnEnterPanel);
RegisterCallback <DetachFromPanelEvent>(OnLeavePanel);
RegisterCallback <CustomStyleResolvedEvent>(OnCustomStyleResolved);
userData = stackModel;
UpdateFromModel();
inputContainer.pickingMode = PickingMode.Ignore;
outputContainer.pickingMode = PickingMode.Ignore;
PopulateStack(m_GraphView, store, stackModel, this);
}
static GenericEntityDescriptor()
{
_nodesToBuild = new INodeBuilder[]
{
new NodeBuilder <T>()
};
}
public StackNode(Store store, IStackModel stackModel, INodeBuilder builder)
{
m_Store = store;
this.stackModel = stackModel;
m_GraphView = builder.GraphView;
styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "StackNode.uss"));
// @TODO: This might need to be reviewed in favor of a better / more scalable approach (non preprocessor based)
// that would ideally bring the same level of backward/forward compatibility and/or removed when a 2013 beta version lands.
#if UNITY_2019_3_OR_NEWER
styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.templatePath + "StackNode.2019.3.uss"));
#endif
style.overflow = Overflow.Visible;
var borderItem = this.MandatoryQ("borderItem");
borderItem.style.overflow = Overflow.Visible;
this.AddManipulator(new ContextualMenuManipulator(OnContextualMenuEvent));
RegisterCallback <AttachToPanelEvent>(OnEnterPanel);
RegisterCallback <DetachFromPanelEvent>(OnLeavePanel);
RegisterCallback <CustomStyleResolvedEvent>(OnCustomStyleResolved);
userData = stackModel;
UpdateFromModel();
inputContainer.pickingMode = PickingMode.Ignore;
outputContainer.pickingMode = PickingMode.Ignore;
PopulateStack(m_GraphView, store, stackModel, this);
}
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;
}
/// <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 CreateObjectContent(INodeBuilder nodeBuilder, object obj, ITypeDescriptor descriptor, bool isPrimitive, bool shouldProcessReference)
{
var reference = nodeBuilder.CreateReferenceForNode(descriptor.Type, obj) as ReferenceEnumerable;
return(new ObjectContent(obj, descriptor, isPrimitive, reference)
{
ShouldProcessReference = shouldProcessReference
});
}
/// <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
});
}
protected override void Initialize(string rootNodeValue)
{
// Initializes the Binary Tree by creating a root node
NodeBuilder = new TextValueNodeBuilder();
RootNode = BuildNode(rootNodeValue);
CurrentNode = RootNode;
}
/// <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 NodePresenterFactory([NotNull] INodeBuilder nodeBuilder, [NotNull] IReadOnlyCollection <INodePresenterCommand> availableCommands, [NotNull] IReadOnlyCollection <INodePresenterUpdater> availableUpdaters)
{
this.nodeBuilder = nodeBuilder;
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
AvailableCommands = availableCommands ?? throw new ArgumentNullException(nameof(availableCommands));
AvailableUpdaters = availableUpdaters ?? throw new ArgumentNullException(nameof(availableUpdaters));
}
public ObjectNode([NotNull] INodeBuilder nodeBuilder, object value, Guid guid, [NotNull] ITypeDescriptor descriptor, IReference reference)
: base(nodeBuilder.SafeArgument(nameof(nodeBuilder)).NodeContainer, guid, descriptor)
{
if (reference is ObjectReference)
{
throw new ArgumentException($"An {nameof(ObjectNode)} cannot contain an {nameof(ObjectReference)}");
}
this.value = value;
ItemReferences = reference as ReferenceEnumerable;
}
/// <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 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;
}
public ModelConsistencyCheckVisitor(INodeBuilder nodeBuilder)
{
if (nodeBuilder == null)
{
throw new ArgumentNullException("nodeBuilder");
}
this.nodeBuilder = nodeBuilder as DefaultModelBuilder;
if (this.nodeBuilder == null)
{
throw new ArgumentException(@"This argument should be a DefaultModelBuilder", "nodeBuilder");
}
}
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;
}
public void AddTopLevelContainer(string aName, INodeBuilder aBuilder)
{
NodeContainer container = new NodeContainer(aName, iNextId, null);
iNextId++;
TopLevelContainer c = new TopLevelContainer();
c.Container = container;
c.Builder = aBuilder;
iTopLevelContainerList.Add(c);
iRoot.Add(container.Name, container);
}
/// <inheritdoc/>
public virtual IObjectNode CreateBoxedNode(INodeBuilder nodeBuilder, Guid guid, object structure, ITypeDescriptor descriptor)
{
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
if (structure == null)
{
throw new ArgumentNullException(nameof(structure));
}
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
return(new BoxedNode(nodeBuilder, structure, guid, descriptor));
}
public IteratorStackNode(Store store, IIteratorStackModel model, INodeBuilder builder)
: base(store, model, builder)
{
// TODO: Move affecting rules in a more generic USS file and share with BlackboardEcsProvider
styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "BlackboardECS.uss"));
// @TODO: This might need to be reviewed in favor of a better / more scalable approach (non preprocessor based)
// that would ideally bring the same level of backward/forward compatibility and/or removed when a 2013 beta version lands.
#if UNITY_2019_3_OR_NEWER
styleSheets.Add(AssetDatabase.LoadAssetAtPath <StyleSheet>(UICreationHelper.TemplatePath + "BlackboardECS.2019.3.uss"));
#endif
var stackNodeHeaderContainer = this.MandatoryQ("stackNodeHeaderContainer");
var stencil = Store.GetState().CurrentGraphModel?.Stencil;
stackNodeHeaderContainer.Add(new CriteriaSubSection(stencil, model, store));
}
public static GraphElement CreateToken(this INodeBuilder builder, Store store, IVariableModel model)
{
var isExposed = model.DeclarationModel?.IsExposed;
Texture2D icon = (isExposed != null && isExposed.Value)
? VisualScriptingIconUtility.LoadIconRequired("GraphView/Nodes/BlackboardFieldExposed.png")
: null;
GetTokenPorts(store, model, out var input, out var output, Orientation.Horizontal);
var token = new Token(model, store, input, output, builder.GraphView, icon);
if (model.DeclarationModel != null && model.DeclarationModel is LoopVariableDeclarationModel loopVariableDeclarationModel)
{
VseUtility.AddTokenIcon(token, loopVariableDeclarationModel.TitleComponentIcon);
}
return(token);
}
public static GraphElement CreateUnaryOperator(this INodeBuilder builder, Store store, UnaryOperatorNodeModel model)
{
return(new Node(model, store, builder.GraphView)
{
CustomSearcherHandler = (node, nStore, pos, _) =>
{
SearcherService.ShowEnumValues("Pick a new operator type", typeof(UnaryOperatorKind), pos, (pickedEnum, __) =>
{
if (pickedEnum != null)
{
((UnaryOperatorNodeModel)node.model).Kind = (UnaryOperatorKind)pickedEnum;
nStore.Dispatch(new RefreshUIAction(UpdateFlags.GraphTopology));
}
});
return true;
}
});
}
/// <inheritdoc/>
public virtual IObjectNode CreateObjectNode(INodeBuilder nodeBuilder, Guid guid, object obj, ITypeDescriptor descriptor)
{
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
var reference = nodeBuilder.CreateReferenceForNode(descriptor.Type, obj, false) as ReferenceEnumerable;
return(new ObjectNode(nodeBuilder, obj, guid, descriptor, reference));
}
/// <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));
}
/// <summary>
/// 加载Update命令生成树的Set节点子节点及其附属的sql参数
/// </summary>
/// <param name="setParameters">属性名及属性值字典</param>
/// <param name="nodeBuilders">Update命令生成树的Set节点子节点集合</param>
/// <param name="sqlParameters">附属的sql参数集合</param>
private void LoadUpdateChildNodesAndParameters(IDictionary <string, object> setParameters, List <INodeBuilder> nodeBuilders, List <IDbDataParameter> sqlParameters)
{
//获取table别名
string tableAlias = this.TableMapper.Header.TableAlias;
//遍历setParameters
foreach (KeyValuePair <string, object> setPair in setParameters)
{
//获取columnMapper
IColumnMapper columnMapper = this.TableMapper.GetColumnMapper(setPair.Key);
//获取参数名
string parameterName = string.Concat("New", columnMapper.Property.Name);
//获取Update Set的子sql表达式节点
INodeBuilder setBuilder = this.CommandTreeFactory.GetUpdateSetChildBuilder(tableAlias, columnMapper.ColumnName, parameterName);
//添加sql表达式节点
nodeBuilders.Add(setBuilder);
//添加sql参数
sqlParameters.Add(this.DbHelper.Parameter(parameterName, setPair.Value));
}
}
public MemberContent([NotNull] INodeBuilder nodeBuilder, Guid guid, [NotNull] IObjectNode parent, [NotNull] IMemberDescriptor memberDescriptor, bool isPrimitive, IReference reference)
: base(guid, nodeBuilder.TypeDescriptorFactory.Find(memberDescriptor.Type), isPrimitive, reference)
{
if (nodeBuilder == null)
{
throw new ArgumentNullException(nameof(nodeBuilder));
}
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
if (memberDescriptor == null)
{
throw new ArgumentNullException(nameof(memberDescriptor));
}
Parent = parent;
MemberDescriptor = memberDescriptor;
Name = memberDescriptor.Name;
nodeContainer = nodeBuilder.NodeContainer;
}
public static GraphElement CreateSetVar(this INodeBuilder builder, Store store, SetVariableNodeModel model)
{
if (model.DeclarationModel.IsObjectReference())
{
return(GraphElementFactoryExtensions.CreateToken(builder, store, model));
}
if (!model.IsGetter)
{
return(new SetVariableNode(model, store, builder.GraphView));
}
GraphElementFactoryExtensions.GetTokenPorts(store, model, out var input, out var output);
if (output != null)
{
output.portName = "";
}
var token = new DotsVariableToken(model, store, input, output, builder.GraphView);
return(token);
}
public OnKeyPressStackNode(Store store, OnKeyPressEcsNodeModel model, INodeBuilder builder)
: base(store, model, builder)
{
void OnKeyCodeChange(ChangeEvent <Enum> e)
{
model.Code = (KeyCode)e.newValue;
store.Dispatch(new RefreshUIAction(UpdateFlags.RequestCompilation));
}
void OnKeyPressTypeChange(ChangeEvent <Enum> e)
{
model.PressType = (OnKeyPressEcsNodeModel.KeyPressType)e.newValue;
store.Dispatch(new RefreshUIAction(UpdateFlags.RequestCompilation));
}
RegisterCallback <AttachToPanelEvent>(evt =>
{
if (m_KeyCodeEnumField == null)
{
title = "On";
m_KeyCodeEnumField = new EnumField(model.Code);
m_KeyCodeEnumField.RegisterValueChangedCallback(OnKeyCodeChange);
TitleElement.Add(m_KeyCodeEnumField);
m_PressTypeEnumField = new EnumField(model.PressType);
m_PressTypeEnumField.RegisterValueChangedCallback(OnKeyPressTypeChange);
TitleElement.Add(m_PressTypeEnumField);
}
});
RegisterCallback <DetachFromPanelEvent>(evt =>
{
m_KeyCodeEnumField.UnregisterValueChangedCallback(OnKeyCodeChange);
m_PressTypeEnumField.UnregisterValueChangedCallback(OnKeyPressTypeChange);
});
}
private void BuildNode(INodeBuilder builder, NodeHandle nodeHandle, NodeHandle activeStateNode)
{
switch (builder.Priority)
{
case BuildPriority.Immediate:
if (builder.Build(nodeHandle, nodeHandle.gameObject, activeStateNode))
{
nodeHandle.builder = builder;
}
break;
default:
pendingBuilds.Enqueue(new BuildInfo()
{
Builder = builder,
NodeHandle = nodeHandle,
Node = nodeHandle.node,
GameObject = nodeHandle.gameObject,
ActiveStateNode = activeStateNode,
});
break;
}
}
/// <summary>
/// 解析查询条件表达式,生成sql条件表达式节点及其附属的sql参数
/// </summary>
/// <param name="parameterExpression">Lambda表达式的参数</param>
/// <param name="bodyExpression">Lambda表达式的主体(或主体的一部分)</param>
/// <param name="parameterNames">记录不允许重复的sql参数名称</param>
/// <returns>sql条件表达式节点及其附属的sql参数</returns>
public override KeyValuePair <INodeBuilder, IDbDataParameter[]> Visit(ParameterExpression parameterExpression, Expression bodyExpression, HashSet <string> parameterNames)
{
//获取二叉树表达式主体
BinaryExpression binaryExpression = bodyExpression as BinaryExpression;
//若该表达式中包含( == null) 或 ( != null),直接返回sql NULL表达式节点及其空的附属参数
if (this.IsContainsNullExpression(binaryExpression))
{
INodeBuilder nodeBuilder = this.GetNullBuilder(parameterExpression, binaryExpression);
return(new KeyValuePair <INodeBuilder, IDbDataParameter[]>(nodeBuilder, new IDbDataParameter[0]));
}
//初始化的参数名及参数值
string parameterName = string.Empty; //初始化参数名
object parameterValue = null; //初始化参数值
//获取sql表达式节点
BinaryBuilder binaryBuilder = new BinaryBuilder()
{
LeftBuilder = base.GetSqlBuilder(parameterExpression, binaryExpression.Left, ref parameterName, ref parameterValue),
NodeType = binaryExpression.NodeType,
RightBuilder = base.GetSqlBuilder(parameterExpression, binaryExpression.Right, ref parameterName, ref parameterValue)
};
//确定二叉树sql表达式节点的sql参数节点
if (binaryBuilder.LeftBuilder == null)
{
binaryBuilder.LeftBuilder = base.GetParameterBuilder(parameterName);
}
if (binaryBuilder.RightBuilder == null)
{
binaryBuilder.RightBuilder = base.GetParameterBuilder(parameterName);
}
//获取其附属参数数组
IDbDataParameter[] sqlParameters = base.GetParameters(parameterNames, parameterName, parameterValue).ToArray();
//返回最终的sql参数表达式及其附属参数
return(new KeyValuePair <INodeBuilder, IDbDataParameter[]>(binaryBuilder, sqlParameters));
}
public INodeBuilderContext SiblingContext(INodeBuilder sibling)
{
var context = new LinkedBuilderContext(parser, this.parent, sibling);
if (this.parent != null)
this.parent.Add(context);
else
this.parser.AddActiveContext(context);
return context;
}
public void TranslateIn(INodeBuilder node)
{
var child = this.ChildContext(node);
this.parser.SetActiveContext((LinkedBuilderContext)child);
}
public BoxedNode([NotNull] INodeBuilder nodeBuilder, object value, Guid guid, [NotNull] ITypeDescriptor descriptor)
: base(nodeBuilder, value, guid, descriptor, null)
{
}
public LinkedBuilderContext(NodeTreeParser parser, LinkedBuilderContext parent, INodeBuilder builder)
{
this.parser = parser;
this.parent = parent;
this.builder = builder;
this.childs = new LinkedList<LinkedBuilderContext>();
this.insertCommand = InsertCommand.Last;
this.contextId = _lastId++;
}
public INodeBuilderContext WrapContext(INodeBuilder wrapper)
{
this.TranslateOut();
var preParent = this.parser.ActiveContext;
var wrapperContext = new LinkedBuilderContext(parser, preParent, wrapper);
preParent.Add(wrapperContext);
return this.SwapParent(wrapperContext);
}
public void TranslateIn(INodeBuilder node)
{
this.parser.ActiveContext.TranslateIn(node);
}
public INodeBuilderContext ChildContext(INodeBuilder child)
{
var context = new LinkedBuilderContext(parser, this, child);
this.parser.SetActiveContext(context);
return this.Add(context);
}
public OverridableMemberContent(INodeBuilder nodeBuilder, IContent container, IMemberDescriptor member, bool isPrimitive, IReference reference)
: base(nodeBuilder, container, member, isPrimitive, reference)
{
Override = container.Value.GetOverride(member);
}
public ModelConsistencyCheckVisitor(INodeBuilder nodeBuilder)
{
if (nodeBuilder == null) throw new ArgumentNullException(nameof(nodeBuilder));
this.nodeBuilder = nodeBuilder as DefaultNodeBuilder;
if (this.nodeBuilder == null) throw new ArgumentException(@"This argument should be a DefaultNodeBuilder", nameof(nodeBuilder));
}
/// <inheritdoc/>
public virtual IContent CreateObjectContent(INodeBuilder nodeBuilder, object obj, ITypeDescriptor descriptor, bool isPrimitive)
{
var reference = nodeBuilder.CreateReferenceForNode(descriptor.Type, obj) as ReferenceEnumerable;
return new ObjectContent(obj, descriptor, isPrimitive, reference);
}
public AssetBoxedNode([NotNull] INodeBuilder nodeBuilder, object value, Guid guid, [NotNull] ITypeDescriptor descriptor)
: base(nodeBuilder, value, guid, descriptor)
{
ex = new AssetObjectNodeExtended(this);
ItemChanged += (sender, e) => ex.OnItemChanged(sender, e);
}
/// <inheritdoc/>
public virtual IContent CreateBoxedContent(INodeBuilder nodeBuilder, object structure, ITypeDescriptor descriptor, bool isPrimitive)
{
return new BoxedContent(structure, descriptor, isPrimitive);
}
public LinkedBuilderContext(NodeTreeParser parser, INodeBuilder builder)
: this(parser, null, builder)
{
}
public AssetNodePresenterFactory([NotNull] INodeBuilder nodeBuilder, [NotNull] IReadOnlyCollection <INodePresenterCommand> availableCommands, [NotNull] IReadOnlyCollection <INodePresenterUpdater> availableUpdaters)
: base(nodeBuilder, availableCommands, availableUpdaters)
{
}
