Sitecore Glass Mapper Data Handler for a Link List field

<links>
  <link linktype="internal" url="/Home" querystring="" target="" id="{110D559F-DEA5-42EA-9C1C-8A5DF7E70EF9}" />
  <link text="Google Link" linktype="external" url="http://www.google.com" anchor="" target="_blank" />
  <link linktype="media" url="/System/Simulator Backgrounds/Feature Phone" target="" id="{E6BA438D-B112-4BEF-AE3C-4F0C046868D6}" />
</links>

namespace Hedgehog.GlassMapper.Handlers
{
    /// Glass Data Handler for the LinkList custom field, from the Monoco Shared Source package.
    /// When fields are mapped to IList<Link> Glass will parse the field value using this class.
    public class LinkListDataHandler : Glass.Mapper.Sc.DataMappers.AbstractSitecoreFieldMapper
    {
        SitecoreFieldLinkMapper _linkMapper = new SitecoreFieldLinkMapper();
 
        public LinkListDataHandler()
            : base(typeof(IList<Link>))
        {
        }
 
        public override string SetFieldValue(object value, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
        {
            var links = value as IEnumerable<Link>;
            if (links == null)
            {
                return String.Empty;
            }
 
            StringBuilder sb = new StringBuilder();
            sb.Append("<links>");
 
            try
            {
                // in order to utilize the linkMapper, we need this link to be a field on an item, so we 
                // create a fake item with a fake field, and parse it that way.
                var fakeItem = Glass.Mapper.Sc.Utilities.CreateFakeItem(new HashDictionary<Guid, string>(),
                                                            ID.NewID,
                                                            context.Service.Database);
                using (new SecurityDisabler())
                {
                    var field = new Field(new ID(Guid.Empty), fakeItem);
 
                    fakeItem.Editing.BeginEdit();
 
                    foreach (var link in links)
                    {
                        _linkMapper.SetField(field, link, config, context);
                        sb.Append(field.Value);
                    }
 
                    fakeItem.Editing.CancelEdit();
                }
            }
            catch (Exception ex)
            {
                Log.Error("Parsing of LinkList field failed.", ex);
            }
 
            sb.Append("</links>");
            return sb.ToString();
        }
 
        public override object GetFieldValue(string fieldValue, SitecoreFieldConfiguration config, SitecoreDataMappingContext context)
        {
            var links = new List<Link>();
            if (String.IsNullOrWhiteSpace(fieldValue))
            {
                return links;
            }
 
            try
            {
                // parse the links from the xml.
                var xDocument = new XmlDocument();
                xDocument.LoadXml(fieldValue);
 
                var xmlLinks = xDocument.SelectNodes("/links/link");
 
                // in order to utilize the linkMapper, we need this link to be a field on an item, so we 
                // create a fake item with a fake field, and parse it that way.
                var fakeItem = Glass.Mapper.Sc.Utilities.CreateFakeItem(new HashDictionary<Guid, string>(),
                                                            ID.NewID,
                                                            context.Service.Database);
 
                using (new SecurityDisabler())
                {
                    Field field = new Field(new ID(Guid.Empty), fakeItem);
                    fakeItem.Editing.BeginEdit();
 
                    foreach (XmlNode xmlLink in xmlLinks)
                    {
                        field.Value = xmlLink.OuterXml;
 
                        var link = _linkMapper.GetField(field, config, context) as Link;
                        if (link != null)
                        {
                            links.Add(link);
                        }
                    }
 
                    fakeItem.Editing.CancelEdit();
                }
            }
            catch (Exception ex)
            {
                Log.Error("Parsing of LinkList field failed.", ex);
            }
 
            return links;
        }
 
        public override void Setup(Glass.Mapper.Pipelines.DataMapperResolver.DataMapperResolverArgs args)
        {
            _linkMapper.Setup(args);
            base.Setup(args);
        }
    }

        public static void CastleConfig(IWindsorContainer container)
        {
            var config = new Config();
            container.Register(Component.For<AbstractDataMapper>().ImplementedBy<LinkListDataHandler>().LifestyleTransient());
            container.Install(new SitecoreInstaller(config));
        }

namespace Hedgehog.Extensions
{
    public static class LinkExtensions
    {
        /// Render a Glass Link property on it's own. (Mainly used on individual Links 
        /// in the LinkList field type).
        public static string RenderLink(this Link link, NameValueCollection attributes = null, string contents = null)
        {
            StringBuilder sb = new StringBuilder();
            using (TextWriter writer = new StringWriter(sb))
            {
                var result = GlassHtml.BeginRenderLink(link, attributes, contents, writer);
                result.Dispose();
            }
            return sb.ToString();
        }
    }
}

<%@ Import Namespace="Hedgehog.Extensions"  %>
<%@ Import Namespace="Glass.Mapper.Sc.Fields"  %>
 
<% if (Model.Links != null && Model.Links.Any())
   { %>
        <ul>
            <% foreach (Link link in Model.Links) 
               { %>
                    <li>
                        <%= link.RenderLink() %>    
                    </li>
            <% } %>
        </ul>
<% } %>