private IModelNode TransformVertexRecursive(IModelNode vertex, TransformRule[] transforms)
		{
			var newName = transforms.Aggregate(
				vertex.DisplayName, 
				(name, rule) => GetTransform(rule.Pattern).Replace(name, rule.Name ?? string.Empty));
			var type = vertex.Type;
			var linesOfCode = vertex.LinesOfCode;
			var maintainabilityIndex = vertex.MaintainabilityIndex;
			var cyclomaticComplexity = vertex.CyclomaticComplexity;
			var quality = vertex.Quality;
			var children = vertex.Children.Select(x => TransformVertexRecursive(x, transforms));
			return vertex is StaticModelNode
					   ? new StaticModelNode(
							 newName, 
							 type, 
							 quality, 
							 linesOfCode, 
							 maintainabilityIndex, 
							 cyclomaticComplexity, 
							 children.ToList())
					   : new ModelNode(
							 newName, 
							 type, 
							 quality, 
							 linesOfCode, 
							 maintainabilityIndex, 
							 cyclomaticComplexity, 
							 children.ToList());
		}

 private static void PrintHierarchyInternal(IModelNode node, int indentation, StringBuilder builder)
 {
     PrintIndentation(indentation, builder);
     builder.Append(node.Guid + " ");
     PrintIndentation(indentation, builder);
     builder.Append(node.Name ?? "<untitled>");
     builder.Append(": [");
     builder.Append(node.Content.GetType().Name);
     builder.Append("] = ");
     if (node.Content.IsReference)
     {
         if (node.Content.Value != null)
         {
             builder.Append(node.Content.Value.ToString().Replace(Environment.NewLine, " "));
             builder.Append(" > ");
         }
         builder.Append("Reference -> ");
         builder.Append(node.Content.Reference);
     }
     else if (node.Content.Value == null)
     {
         builder.Append("(null)");
     }
     else
     {
         builder.Append(node.Content.Value.ToString().Replace(Environment.NewLine, " "));
     }
     builder.AppendLine();
     foreach (var child in node.Children)
     {
         PrintHierarchyInternal(child, indentation + 4, builder);
     }
 }

		private static ComparisonResult Compare(IModelNode vertex, IModelNode pattern)
		{
			if (vertex.QualifiedName.EndsWith(pattern.QualifiedName))
			{
				var node = (IModelNode)vertex;
				var patternNode = (IModelNode)pattern;
				if (!node.Children.Any() && !patternNode.Children.Any())
				{
					return new ComparisonResult(ComparisonResultKind.Same, pattern, vertex);
				}

				if (!patternNode.Children.Any())
				{
					return new ComparisonResult(ComparisonResultKind.Partial, pattern, vertex);
				}

				var childComparisons = node.Children.Zip(patternNode.Children, Compare).AsArray();
				return childComparisons.All(x => x.Kind == ComparisonResultKind.Same)
						   ? new ComparisonResult(ComparisonResultKind.Same, pattern, vertex)
						   : childComparisons.All(x => x.Kind != ComparisonResultKind.Different)
								 ? new ComparisonResult(ComparisonResultKind.Partial, pattern, vertex)
								 : new ComparisonResult(ComparisonResultKind.Different, pattern, null);
			}

			return new ComparisonResult(ComparisonResultKind.Different, pattern, null);
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ObservableModelNode"/> class.
        /// </summary>
        /// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="ObservableModelNode"/>.</param>
        /// <param name="baseName">The base name of this node. Can be null if <see cref="index"/> is not. If so a name will be automatically generated from the index.</param>
        /// <param name="isPrimitive">Indicate whether this node should be considered as a primitive node.</param>
        /// <param name="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
        /// <param name="modelNodePath">The <see cref="ModelNodePath"/> corresponding to the given <see cref="modelNode"/>.</param>
        /// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
        protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IModelNode modelNode, ModelNodePath modelNodePath, object index = null)
            : base(ownerViewModel, baseName, index)
        {
            if (modelNode == null) throw new ArgumentNullException(nameof(modelNode));
            if (baseName == null && index == null)
                throw new ArgumentException("baseName and index can't be both null.");

            this.isPrimitive = isPrimitive;
            SourceNode = modelNode;
            // By default we will always combine items of list of primitive items.
            CombineMode = index != null && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
            targetNode = GetTargetNode(modelNode, index);
            SourceNodePath = modelNodePath;

            // Override display name if available
            var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase;
            if (memberDescriptor != null)
            {
                if (index == null)
                {
                    var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute<DisplayAttribute>(memberDescriptor.MemberInfo);
                    if (!string.IsNullOrEmpty(displayAttribute?.Name))
                    {
                        DisplayName = displayAttribute.Name;
                    }
                    IsReadOnly = !memberDescriptor.HasSet;
                }
            }
        }

 public override bool IsVisible(IModelNode node, string propertyName) {
     var typesInfo = node.Application.GetTypesInfo();
     var typeToTypeInfo = typesInfo.FindTypeInfo(typeof(GridListEditorVisibilityCalculatorHelper));
     var typeInfo = ReflectionHelper.FindTypeDescendants(typeToTypeInfo).Single();
     var calculatorHelper = (GridListEditorVisibilityCalculatorHelper)Activator.CreateInstance(typeInfo.Type);
     return calculatorHelper.IsVisible(node, propertyName);
 }

        public override object LayoutControls(IModelNode layoutInfo, ViewItemsCollection detailViewItems) {
            var splitLayout = layoutInfo as IModelSplitLayout;
            if (IsMasterDetail(layoutInfo, detailViewItems, splitLayout)) {
                _detailViewItems = detailViewItems;

                var gridView = (Control)detailViewItems[0].Control as ASPxGridView;
                if (gridView != null) {
                    var detailControl = (Control)detailViewItems[1].Control;
                    SetupViewItems(gridView);
                    ASPxSplitter splitter = LayoutMasterDetail(detailControl, gridView, splitLayout);
                    var viewItem = detailViewItems[0] as ListEditorViewItem;

                    if (viewItem != null) {
                        var listEditor = viewItem.ListEditor as XpandASPxGridListEditor;
                        if (listEditor != null) {
                            listEditor.ViewControlsCreated += (s, e) => SetSplitterInitClientEvent(splitter, e.IsRoot);
                        }
                    }

                    RaiseMasterDetailLayout(new MasterDetailLayoutEventArgs {
                        MasterViewItem = detailViewItems[0],
                        DetailViewItem = detailViewItems[1],
                        SplitterControl = splitter
                    });

                    return splitter;
                }
                throw new NotImplementedException(detailViewItems[0].Control.ToString());
            }
            return base.LayoutControls(layoutInfo, detailViewItems);
        }

 /// <summary>
 /// Initializes a new instance of the QuantumConsistencyException class.
 /// </summary>
 /// <param name="expected">A string representing the expected result.</param>
 /// <param name="observed">A string representing the observed result.</param>
 /// <param name="node">The node that is related to this error.</param>
 public QuantumConsistencyException(string expected, string observed, IModelNode node)
     : base(GetMessage(expected, observed))
 {
     Expected = expected ?? "(NullMessage)";
     Observed = observed ?? "(NullMessage)";
     Node = node;
 }

 public override bool IsVisible(IModelNode node, string propertyName) {
     Type editorType = EditorType(node);
     if (editorType == typeof(GridListEditor))
         return true;
     if (typeof(XpandGridListEditor).IsAssignableFrom(editorType) && !typeof(AdvBandedListEditor).IsAssignableFrom(editorType))
         return true;
     return false;
 }

 public bool IsVisible(IModelNode node, string propertyName){
     var modelLogicRule = (IModelLogicRule)node;
     if (modelLogicRule.ModelClass != null){
         var names = modelLogicRule.ModelClass.TypeInfo.Members.Select(info => info.Name);
         return modelLogicRule.ModelLogicWrapper.ObjectChangedExecutionContextGroup.SelectMany(contexts => contexts).Any(context => context.PropertyNames.Split(';').Any(names.Contains));
     }
     return false;
 }

		public Task<IEnumerable<IValidationResult>> Validate(IModelNode modelTree)
		{
			return Task.Factory.StartNew(
				() =>
				{
					var result = Contains(modelTree, _pattern);
					return new IValidationResult[] { new BranchResult(result.Kind == ComparisonResultKind.Same, _pattern) }.AsEnumerable();
				});
		}

        /// <inheritdoc/>
        // TODO: Remove the type argument here
        public IModelNode Build(IModelNode referencer, object obj, Type type, Guid guid)
        {
            Reset();
            rootGuid = guid;
            var typeDescriptor = TypeDescriptorFactory.Find(obj != null ? obj.GetType() : type);
            VisitObject(obj, typeDescriptor as ObjectDescriptor, true);

            return rootNode;
        }

 protected Type EditorType(IModelNode node) {
     var modelListView = node as IModelListView;
     if (modelListView != null)
         return modelListView.EditorType;
     var modelColumn = node as IModelColumn;
     if (modelColumn != null)
         return ((IModelListView)modelColumn.ParentView).EditorType;
     throw new NotImplementedException(node.GetType().ToString());
 }

 public static void ReadFromModel(this ModelXmlReader modelXmlReader, IModelNode modelNode,
                                   IModelNode readFrom, Func<string, bool> aspectNamePredicate) {
     var modelApplication = ((ModelApplicationBase) readFrom.Application);
     for (int i = 0; i < modelApplication.AspectCount; i++) {
         string aspect = modelApplication.GetAspect(i);
         string xml = new ModelXmlWriter().WriteToString(readFrom, i);
         if (!(string.IsNullOrEmpty(xml)))
             new ModelXmlReader().ReadFromString(modelNode, aspect, xml);
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ObservableViewModel"/> class.
 /// </summary>
 /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param>
 /// <param name="modelContainer">A <see cref="ModelContainer"/> to use to build view model nodes.</param>
 /// <param name="modelNode">The root model node of the view model to generate.</param>
 /// <param name="dirtiables">The list of <see cref="IDirtiableViewModel"/> objects linked to this view model.</param>
 public ObservableViewModel(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IModelNode modelNode, IEnumerable<IDirtiableViewModel> dirtiables)
     : this(serviceProvider, modelContainer, dirtiables.SafeArgument("dirtiables").ToList())
 {
     if (modelNode == null) throw new ArgumentNullException("modelNode");
     var node = observableViewModelService.ObservableNodeFactory(this, "Root", modelNode.Content.IsPrimitive, modelNode, new ModelNodePath(modelNode), modelNode.Content.Type, null);
     Identifier = new ObservableViewModelIdentifier(node.ModelGuid);
     node.Initialize();
     RootNode = node;
     node.CheckConsistency();
 }

		public Task<IEnumerable<IValidationResult>> Validate(IModelNode modelTree)
		{
			return
				Task.Factory.StartNew(
					() => modelTree.Children.SelectMany(x => x.Flatten())
							  .Where(x => x.Type == NodeKind.Class)
							  .Where(x => x.CyclomaticComplexity > _cyclomaticComplexity || x.MaintainabilityIndex < _maintainabilityIndex || x.LinesOfCode > _linesOfCode)
							  .Select(x => new KpiResult(false, x))
							  .Cast<IValidationResult>()
							  .AsArray()
							  .AsEnumerable());
		}

 public override object LayoutControls(IModelNode layoutInfo, ViewItemsCollection detailViewItems) {
     var splitLayout = layoutInfo as IModelSplitLayout;
     if (IsMasterDetail(layoutInfo, detailViewItems, splitLayout)) {
         _detailViewItems = detailViewItems;
         var gridView = (Control)detailViewItems[0].Control as ASPxGridView;
         if (gridView != null) {
             var detailControl = (Control)detailViewItems[1].Control;
             SetupViewItems(detailControl, gridView);
             return LayoutControls(detailControl, gridView, splitLayout);
         }
         throw new NotImplementedException(detailViewItems[0].Control.ToString());
     }
     return base.LayoutControls(layoutInfo, detailViewItems);
 }

		private static ComparisonResult Contains(IModelNode tree, IModelNode pattern)
		{
			var deepComparison = tree.Flatten().Select(x => Compare(x, pattern)).AsArray();
			if (deepComparison.Any(x => x.Kind == ComparisonResultKind.Same))
			{
				return new ComparisonResult(ComparisonResultKind.Same, pattern, deepComparison.Where(x => x.Kind == ComparisonResultKind.Same).SelectMany(x => x.Matches).Distinct());
			}

			if (deepComparison.Any(x => x.Kind == ComparisonResultKind.Partial))
			{
				return new ComparisonResult(ComparisonResultKind.Partial, pattern, deepComparison.Where(x => x.Kind == ComparisonResultKind.Partial).SelectMany(x => x.Matches).Distinct());
			}

			return new ComparisonResult(ComparisonResultKind.Different, pattern, null);
		}

        public static void PrintModelContainerContent(ModelContainer container, IModelNode rootNode = null)
        {
            Console.WriteLine(@"Container content:");
            Console.WriteLine(@"------------------");
            // Print the root node first, if specified
            if (rootNode != null)
                Console.WriteLine(rootNode.PrintHierarchy());

            // Print other nodes next
            // TODO: FIXME
            //foreach (var node in container.Guids.Select(container.GetModelNode).Where(x => x != rootNode))
            //{
            //    Console.WriteLine(node.PrintHierarchy());
            //}
            Console.WriteLine(@"------------------");
        }

 public bool IsVisible(IModelNode node, string propertyName){
     return ((IModelOptionsWin) node.Application.Options).FormStyle == RibbonFormStyle.Standard;
 }

 public bool IsVisible(IModelNode node, string propertyName) {
     return !(node is IModelRuntimeOrphanedColection) || propertyName != "Type";
 }