public object Parse(Type type, XObject config, bool isAssignableTypeAllowed, XmlLocation childLocation, IContext context)
 {
     var xel = config as XElement;
     if (xel == null)
         throw new TestLibsException($"Couldn't cast following config to XElement:\n{config}");
     return xel;
 }

 public int? GetNodeCount(XObject xml, string xpath)
 {
     if(xml == null)
     {
         return null;
     }
     if(xml.Document == null)
     {
         return null;
     }
     if(xml.Document.Root == null)
     {
         return null;
     }
     try
     {
         var namespaceResolver = new SimpleXmlNamespaceResolver(xml.Document);
         var results = (IEnumerable)xml.Document.XPathEvaluate(xpath, namespaceResolver);
         return results.OfType<XObject>().Count();
     }
     catch(Exception)
     {
         return null;
     }
 }

        public ISerializer Select(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
        {
            if (target.NodeType != XmlNodeType.Element)
                return null;

            return _serializer;
        }

        public static void AreEqual(XObject expected, XObject actual)
        {
            if (expected is XDocument)
            {
                expected = ((XDocument)expected).Root;
            }
            if (actual is XDocument)
            {
                actual = ((XDocument)actual).Root;
            }

            if (expected == null && actual == null)
            {
                return;
            }
            if (expected == null)
            {
                RaiseAssertFailure(null, actual);
                return;
            }
            if (actual == null)
            {
                RaiseAssertFailure(expected, null);
                return;
            }
            if (expected.GetType() != actual.GetType())
            {
                RaiseAssertFailure(expected, actual);
                return;
            }

            AssertEqualValues(expected, actual);
        }

 public ParseDefinitionFileException(string message, XObject source) 
     : base(GetMessage(message, source))
 {
     _source = source;
     Line = (source as IXmlLineInfo).LineNumber;
     Position = (source as IXmlLineInfo).LinePosition;
 }

        public void Deserialize(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
        {
            if (source == null)
                return;

            if (source.NodeType != XmlNodeType.Element)
                throw new ArgumentException("Parameter must be an XML element.", "source");

            if (_log.IsDebugEnabled)
                _log.Debug("Deserializing " + source.ToFriendlyName() + " into " + target + ".");

            var elem = (XElement)source;

            Type targetType = _typeConverter.GetActualType(source, target, adviceRequester);
            if (targetType == null)
                throw new ArgumentException("Unable to get target type for target '" + target + "'.");

            IObjectContext targetObject = _objectContextFactory.CreateForDeserialization(target, targetType, adviceRequester);
            if (targetObject == null)
                throw new ArgumentException("Unable to create target object for target '" + target + "'.");

            target.SetValue(targetObject);

            List<IMapping<XObject, IMemberContext>> mappings = _mapper.MapForDeserialization(elem, target, adviceRequester)
                .ToList();
            if (mappings == null)
                throw new ArgumentException("Unable to map source '" + source + "' and target '" + target + "'.");

            DeserializeRecursively(mappings, adviceRequester);

            target.CommitChanges();
        }

 public EventsHelper(XObject x)
 {
     _root = x;
     _root.Changing += new EventHandler<XObjectChangeEventArgs>(Changing);
     _root.Changed += new EventHandler<XObjectChangeEventArgs>(Changed);
     _events = new Queue<EventItem>();
 }

        public override void AddSubcomponent(string name, XObject sub)
        {
			if (this.Levels == null)
				this.Levels = new List<XLevelInfo>();
            
			this.Levels.Add((XLevelInfo)sub);
		}

        protected virtual IDeserializer Select(XObject source, IMemberContext target, Type type, IAdviceRequester adviceRequester)
        {
            var typeCode = Type.GetTypeCode(type);

            switch (typeCode)
            {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return null;
                case TypeCode.Object:
                    if (target.ContractType == typeof(TimeSpan))
                        break;
                    if (target.ContractType == typeof(string))
                        break;
                    if (target.ContractType.IsNullable())
                        break;

                    return null;
            }

            if (source == null)
                return GetDeserializer(type);

            if (source.NodeType == XmlNodeType.Element && !((XElement)source).HasElements)
                return GetDeserializer(type);

            if (source.NodeType == XmlNodeType.Attribute)
                return GetDeserializer(type);

            return null;
        }

 private XObject FindObject(string id, XObject root)
 {
     var o = root.FindLocal(id);
     if (o == null)
         throw new InvalidOperationException(string.Format("Iterator '{0}' could not find obect id: '{1}'", this.Id, id));
     return o;
 }

 public IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
 {
     return Selectors
             .Select(s => s.Select(source, target, adviceRequester))
             .Where(d => d != null)
             .FirstOrDefault();
 }

 /// <summary>
 /// Initializes a new instance.
 /// </summary>
 /// <param name="xml"></param>
 /// <param name="context"></param>
 /// <param name="xpath"></param>
 internal Binding(XObject xml, EvaluationContext context, string xpath)
     : this(xml, context, context.CompileXPath(xml, xpath))
 {
     Contract.Requires<ArgumentNullException>(xml != null);
     Contract.Requires<ArgumentNullException>(context != null);
     Contract.Requires<ArgumentNullException>(xpath != null);
 }

 private void setRoot(XObject root)
 {
     if (root is XDocument)
         _current = ((XDocument)root).Root;
     else
         _current = root;
 }

 public Type GetActualType(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
 {
     return Converters
             .Select(c => c.GetActualType(source, target, adviceRequester))
             .Where(t => t != null)
             .FirstOrDefault();
 }

		public void CopyAttributes(XObject src, XObject dest)
		{
			dest.Id = src.Id;
			//dest.Class = src.Class;
			
			dest.Enabled = src.Enabled;
			
			// Element
			var srcElement = src as XElement;
			if (srcElement != null)
			{
				var destElement = (XElement)dest;
				
				destElement.Bounds = srcElement.Bounds;
				
				if (srcElement.backColor.HasValue)
					destElement.BackColor = srcElement.BackColor;

				if (srcElement.Rotation != 0)
					destElement.Rotation = srcElement.Rotation;
			}
			
			// IHasPoints
			var srcHasPoints = src as IHasPoints;
			if (srcHasPoints != null && srcHasPoints.Points != 0)
			{
				((IHasPoints)dest).Points = srcHasPoints.Points;
			}
			
			var srcEnemy = src as XEnemy;
			if (srcEnemy != null && srcEnemy.DamageSpecified)
			{
				((XEnemy)dest).Damage = srcEnemy.Damage;
			}
		}

        public static bool BindLiteralOrReference(ParserContext context, XObject xmlObject, string xmlValue, PropertyInfo boundProperty)
        {
            object convertedLiteralValue;

            if (LiteralTypeConverter.TryConvert(boundProperty.PropertyType, xmlValue, out convertedLiteralValue))
            {
                if (BindExpression(context, xmlObject, xmlValue, boundProperty))
                {
                    return true;
                }
             
                BindFinalValue(boundProperty, context.FrameworkItem, convertedLiteralValue, xmlObject, true);
                return true;
            }

            if (xmlObject is XAttribute)
            {
                if (BindExpression(context, xmlObject, xmlValue, boundProperty))
                {
                    return true;
                }

                DelayedBind(context, xmlObject, xmlValue, boundProperty);
                return true;
            }

            return false;
        }

		public XObject CreateInstance(XObject placeholder)
		{
			var instance = TemplateObject.Copy();
			CopyAttributes(placeholder, instance);
			
			// move subcomponents from the placeholder to the new instance
			while(placeholder.Subcomponents != null && placeholder.Subcomponents.Count > 0)
			{
				var subcomponent = placeholder.Subcomponents[0];
				placeholder.Subcomponents.RemoveAt(0);
				
				instance.Subcomponents.Add(subcomponent);
			}

			var parent = placeholder.Parent;
			
			// replace the placeholder with the new instance
			int instanceIndex = parent.Subcomponents.IndexOf(placeholder);
			parent.Subcomponents.RemoveAt(instanceIndex);
			parent.Subcomponents.Insert(instanceIndex, instance);
			
			ReplaceParameters(instance, placeholder.ClassParams);
			
			return instance;
		}

        public static DateTimeOffset? InstantOrNull(XObject elem)
        {
            string value = StringValueOrNull(elem);

            return String.IsNullOrEmpty(value) ? (DateTimeOffset?)null : 
                PrimitiveTypeConverter.ConvertTo<DateTimeOffset>(value);
        }

        public bool Serialize(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (target.NodeType != XmlNodeType.Element)
                throw new ArgumentException("Parameter must be an XML element.", "target");

            var elem = (XElement)target;

            IObjectContext sourceObject = source.GetValue();

            if (sourceObject == null || sourceObject.GetObject() == null)
            {
                if (_isNullableStrategy.IsNullable(source, elem, adviceRequester))
                {
                    elem.Add(Constants.XsiNilAttribute);
                    return true;
                }

                return false;
            }

            List<IMapping<IMemberContext, XObject>> mappings = _mapper.MapForSerialization(source, elem, adviceRequester)
                .ToList();
            if (mappings == null)
                throw new ArgumentException("Unable to map source '" + source + "' and target '" + target + "'.");

            SerializeRecursively(elem, mappings, adviceRequester);

            return true;
        }

 internal Tuple<bool, bool> CanExecute(
     XObject selectedElement, object docView, object singleViewModelSelection, object propertiesCompartment, bool isSingleSelection)
 {
     return _canExecute == null
                ? new Tuple<bool, bool>(true, true)
                : _canExecute(selectedElement, docView, singleViewModelSelection, propertiesCompartment, isSingleSelection);
 }