public static TypedEntity MapTypedEntity(XElement xElement)
        {
            Mandate.ParameterNotNull(xElement, "xElement");

            var attribs = new HashSet<TypedAttribute>();
            var ordinal = 0;
            foreach (var childElement in xElement.Elements().Where(x => !x.HasAttributes))
            {
                var typedAttribute = new TypedAttribute(new AttributeDefinition()
                                                            {
                                                                Alias = childElement.Name.LocalName,
                                                                Name = childElement.Name.LocalName,
                                                                Ordinal = ordinal,
                                                                Id = HiveId.Empty
                                                            }, childElement.Value)
                                         {
                                             Id = HiveId.Empty
                                         };
                attribs.Add(typedAttribute);
                ordinal++;
            }

            var nodeId = (int)xElement.Attribute("id");
            var returnValue = new TypedEntity
            {
                // TODO: Replace provider id with injected value inside UoWFactory
                Id = new HiveId("content", "r-xmlstore-01", new HiveIdValue(nodeId))
            };
            returnValue.Attributes.Reset(attribs);

            return returnValue;
        }

        public CompositeTypedEntity(TypedEntity entity)
        {
            Attributes.Clear();
            entity.Attributes.ForEach(x => Attributes.Add(x));

            RelationProxies.LazyLoadDelegate = entity.RelationProxies.LazyLoadDelegate;
        }

        public void GetIdPath_Returns_In_Correct_Order_For_Entities()
        {
            //mock hive
            IReadonlyEntityRepositoryGroup<IContentStore> readonlyEntitySession;
            IReadonlySchemaRepositoryGroup<IContentStore> readonlySchemaSession;
            IEntityRepositoryGroup<IContentStore> entityRepository;
            ISchemaRepositoryGroup<IContentStore> schemaSession;
            var hive = MockHiveManager.GetManager().MockContentStore(out readonlyEntitySession, out readonlySchemaSession, out entityRepository, out schemaSession);
            var entity = new TypedEntity {Id = new HiveId(100)};
            entityRepository.Get<TypedEntity>(Arg.Any<bool>(), Arg.Any<HiveId[]>()).Returns(new[] {entity});
            entityRepository.GetAncestorRelations(new HiveId(100), FixedRelationTypes.DefaultRelationType)
                .Returns(new[]
                    {
                        new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(99)}, entity),
                        new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(98)}, new TypedEntity{Id = new HiveId(99)}),
                        new Relation(FixedRelationTypes.DefaultRelationType, new TypedEntity{Id = new HiveId(97)}, new TypedEntity{Id = new HiveId(98)}),
                    });

            using (var uow = hive.OpenWriter<IContentStore>())
            {
                var path = uow.Repositories.GetEntityPath<TypedEntity>(new HiveId(100), FixedRelationTypes.DefaultRelationType);
                Assert.AreEqual(new HiveId(97), path.ElementAt(0));
                Assert.AreEqual(new HiveId(98), path.ElementAt(1));
                Assert.AreEqual(new HiveId(99), path.ElementAt(2));                
                Assert.AreEqual(new HiveId(100), path.ElementAt(3));
            }

        }

        /// <summary>
        /// Returns the TooltipContents after proxying through the task system to allow developers to modify the output
        /// </summary>
        /// <param name="ds"></param>
        /// <param name="sender"></param>
        /// <param name="entity"> </param>
        /// <param name="htmlContent"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <returns></returns>
        public static TooltipContents CreateTooltipContentsViaTask(this INodeSelectorDataSource ds, 
                                                                   object sender, 
                                                                   TypedEntity entity,
                                                                   string htmlContent, 
                                                                   int width = -1, 
                                                                   int height = -1)
        {
            var args = new NodeSelectorTooltipEventArgs(entity, htmlContent)
                {
                    Height = height,
                    Width = width
                };

            //launch task to modify the contents
            ds.FrameworkContext.TaskManager
                .ExecuteInContext(
                    NodeSelectorTaskTriggers.GetTooltipContents,
                    sender,
                    new TaskEventArgs(ds.FrameworkContext, args));

            return new TooltipContents(args.HtmlContents)
                {
                    Height = args.Height,
                    Width = args.Width
                };
        }

 public EntityVillager(TypedEntity e)
     : base(e)
 {
     EntityVillager e2 = e as EntityVillager;
     if (e2 != null) {
         _profession = e2._profession;
     }
 }

 public EntityPrimedTnt(TypedEntity e)
     : base(e)
 {
     EntityPrimedTnt e2 = e as EntityPrimedTnt;
     if (e2 != null) {
         _fuse = e2._fuse;
     }
 }

 public EntityFallingSand(TypedEntity e)
     : base(e)
 {
     EntityFallingSand e2 = e as EntityFallingSand;
     if (e2 != null) {
         _tile = e2._tile;
     }
 }

 public EntityCreeper(TypedEntity e)
     : base(e)
 {
     EntityCreeper e2 = e as EntityCreeper;
     if (e2 != null) {
         _powered = e2._powered;
     }
 }

 public EntityMinecart (TypedEntity e)
     : base(e)
 {
     EntityMinecart e2 = e as EntityMinecart;
     if (e2 != null) {
         _type = e2._type;
     }
 }

 public EntityPigZombie(TypedEntity e)
     : base(e)
 {
     EntityPigZombie e2 = e as EntityPigZombie;
     if (e2 != null) {
         _anger = e2._anger;
     }
 }

 public EntityGuardian (TypedEntity e)
     : base(e)
 {
     EntityGuardian e2 = e as EntityGuardian;
     if (e2 != null) {
         _elder = e2._elder;
     }
 }

 public EntityMinecartChest (TypedEntity e)
     : base(e)
 {
     EntityMinecartChest e2 = e as EntityMinecartChest;
     if (e2 != null) {
         _items = e2._items.Copy();
     }
 }

 public EntitySlime(TypedEntity e)
     : base(e)
 {
     EntitySlime e2 = e as EntitySlime;
     if (e2 != null) {
         _size = e2._size;
     }
 }

 public EntityPig(TypedEntity e)
     : base(e)
 {
     EntityPig e2 = e as EntityPig;
     if (e2 != null) {
         _saddle = e2._saddle;
     }
 }

 public EntitySheep (TypedEntity e)
     : base(e)
 {
     EntitySheep e2 = e as EntitySheep;
     if (e2 != null) {
         _sheared = e2._sheared;
         _color = e2._color;
     }
 }

 public EntityArrow(TypedEntity e)
     : base(e)
 {
     EntityArrow e2 = e as EntityArrow;
     if (e2 != null) {
         _inData = e2._inData;
         _player = e2._player;
     }
 }

 public EntityEndermite(TypedEntity e)
     : base(e)
 {
     EntityEndermite e2 = e as EntityEndermite;
     if (e2 != null) {
         _life = e2._life;
         _player = e2._player;
     }
 }

 public EntityAnimal(TypedEntity e)
     : base(e)
 {
     EntityAnimal e2 = e as EntityAnimal;
     if (e2 != null) {
         _age = e2._age;
         _inLove = e2._inLove;
     }
 }

 public EntityChicken (TypedEntity e)
     : base(e)
 {
     EntityChicken e2 = e as EntityChicken;
     if (e2 != null)
     {
         _eggTime = e2._eggTime;
     }
 }

 public EntityBat(TypedEntity e)
     : base(e)
 {
     EntityBat e2 = e as EntityBat;
     if (e2 != null)
     {
         _flag = e2._flag;
     }
 }