void CustomUnboxing(object e, object eMap)
        {
            //IList<Classifications>
            var classifiacationProp = eMap.GetType().GetProperty("Classifications");

            if (classifiacationProp != null && e is IClassifiable)
            {
                var ec = e as IClassifiable;
                var classifications = (IList <string>)classifiacationProp.GetValue(eMap, null);
                foreach (string classification in classifications)
                {
                    _tree.Classify(ec, _tree.GetOrCreatePath(classification));
                }
            }

            //Box<>
            var emapEntriesProp = eMap.GetType().GetProperty("Entries");

            if (emapEntriesProp != null && typeof(IBox).IsAssignableFrom(emapEntriesProp.PropertyType))
            {
                var eEntriesProp = e.GetType().GetProperty("Entries");
                if (eEntriesProp != null)
                {
                    var contverterType = typeof(NHibernateBoxConverter <,>)
                                         .MakeGenericType(
                        eEntriesProp.PropertyType.GetGenericArguments()[0],
                        emapEntriesProp.PropertyType.GetGenericArguments()[0]
                        );
                    var converter = Activator.CreateInstance(contverterType, _repoFinder);
                    var box       = contverterType.GetMethods().Where(m => m.Name == "ToEntity").Skip(1).First()
                                    .Invoke(converter, new[] { emapEntriesProp.GetValue(eMap, null) });
                    eEntriesProp.SetValue(e, box, null);

                    //var transformerType = typeof(NHibernateBoxTransformation<,>)
                    //    .MakeGenericType(
                    //        emapEntriesProp.PropertyType.GetGenericArguments()[0],
                    //        eEntriesProp.PropertyType.GetGenericArguments()[0]);
                    //var transformer = Activator.CreateInstance(transformerType, _context, _repoFinder, _log, _tree, BoxImporterStrategy.RewriteExisting);

                    //transformerType.GetMethod("Transform").Invoke(transformer, new[] { emapEntriesProp.GetValue(eMap, null) });
                    //eEntriesProp.SetValue(e, transformerType.GetProperty("Entries").GetValue(transformer, null), null);
                }
            }

            //SettingsBoxMap
            var settingsProp = eMap.GetType().GetProperty("Settings");

            if (settingsProp != null && e.GetType().GetProperty("Settings") == null && e is IClassifiable)
            {
                var sConverter  = CreateNestedTransformer <SettingsBoxMap, SettingsEntity>(BoxImporterStrategy.UpdateExisting);
                var settingsBox = (SettingsBoxMap)settingsProp.GetValue(eMap, null);
                sConverter.Transform(new Box <SettingsBoxMap>(settingsBox));
                var settings = sConverter.Entries.First();
                foreach (var entry in settings.Entries)
                {
                    entry.Settings = settings;
                }
                _repoFinder.SettingsService.SaveFor((e as IClassifiable), settings);
            }

            //IBox<MetricsBoxMap>
            var metricsProp = eMap.GetType().GetProperty("Metrics");

            if (metricsProp != null && e.GetType().GetProperty("Metrics") == null && e is IClassifiable)
            {
                var mConverter = CreateNestedTransformer <MetricsBoxMap, MetricsEntity>(BoxImporterStrategy.UpdateExisting);
                var metricsBox = ((IBox <MetricsBoxMap>)metricsProp.GetValue(eMap, null));
                mConverter.Transform(metricsBox);
                var metrics = mConverter.Entries;
                foreach (var m in metrics)
                {
                    foreach (var me in m.Entries)
                    {
                        me.Metrics = m;
                    }
                }
                mConverter.Entries.ToList().ForEach(m => _repoFinder.MetricsService.EnsureRelation((e as IClassifiable), m));
                _repoFinder.MetricsService.UpdateMetrics(mConverter.Entries.ToList());
            }
        }