polygene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nic...@apache.org
Subject [23/34] zest-java git commit: ZEST-136 - Massive changes to the Runtime, refactoring the Model and Instance relationship.
Date Thu, 14 Apr 2016 06:13:29 GMT
http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerInstance.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerInstance.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerInstance.java
index dec81c1..b515e38 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerInstance.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerInstance.java
@@ -20,16 +20,11 @@ import java.util.stream.Stream;
 import org.apache.zest.api.activation.ActivationEventListener;
 import org.apache.zest.api.activation.ActivationException;
 import org.apache.zest.api.activation.PassivationException;
-import org.apache.zest.api.common.Visibility;
-import org.apache.zest.api.composite.TransientDescriptor;
-import org.apache.zest.api.entity.EntityDescriptor;
-import org.apache.zest.api.object.ObjectDescriptor;
-import org.apache.zest.api.service.ServiceReference;
+import org.apache.zest.api.structure.Application;
 import org.apache.zest.api.structure.Layer;
+import org.apache.zest.api.structure.LayerDescriptor;
 import org.apache.zest.api.structure.Module;
-import org.apache.zest.api.value.ValueDescriptor;
 import org.apache.zest.runtime.activation.ActivationDelegate;
-import org.apache.zest.spi.structure.ModelModule;
 
 /**
  * Instance of a Zest application layer. Contains a list of modules which are managed by this layer.
@@ -41,20 +36,18 @@ public class LayerInstance
     // Constructor parameters
     private final LayerModel layerModel;
     private final ApplicationInstance applicationInstance;
-    private final UsedLayersInstance usedLayersInstance;
+
     // Eager instance objects
     private final ActivationDelegate activation;
     private final List<ModuleInstance> moduleInstances;
 
     public LayerInstance( LayerModel model,
-                          ApplicationInstance applicationInstance,
-                          UsedLayersInstance usedLayersInstance
+                          ApplicationInstance applicationInstance
     )
     {
         // Constructor parameters
         this.layerModel = model;
         this.applicationInstance = applicationInstance;
-        this.usedLayersInstance = usedLayersInstance;
 
         // Eager instance objects
         activation = new ActivationDelegate( this );
@@ -74,6 +67,12 @@ public class LayerInstance
         return layerModel.name();
     }
 
+    @Override
+    public Application application()
+    {
+        return applicationInstance;
+    }
+
     // Implementation of MetaInfoHolder
     @Override
     public <T> T metaInfo( Class<T> infoType )
@@ -114,51 +113,21 @@ public class LayerInstance
         return moduleInstances.stream();
     }
 
-    // Other methods
-    /* package */ void addModule( ModuleInstance module )
-    {
-        module.registerActivationEventListener( activation );
-        moduleInstances.add( module );
-    }
-
-    /* package */ LayerModel model()
+    @Override
+    public LayerDescriptor descriptor()
     {
         return layerModel;
     }
 
-    public ApplicationInstance applicationInstance()
-    {
-        return applicationInstance;
-    }
-
-    /* package */ UsedLayersInstance usedLayersInstance()
+    void addModule( ModuleInstance module )
     {
-        return usedLayersInstance;
-    }
-
-    /* package */ Stream<ModelModule<ObjectDescriptor>> visibleObjects( final Visibility visibility )
-    {
-        return moduleInstances.stream().flatMap( module -> module.visibleObjects( visibility ) );
-    }
-
-    /* package */ Stream<ModelModule<TransientDescriptor>> visibleTransients( final Visibility visibility )
-    {
-        return moduleInstances.stream().flatMap( module -> module.visibleTransients( visibility ) );
-    }
-
-    /* package */ Stream<ModelModule<EntityDescriptor>> visibleEntities( final Visibility visibility )
-    {
-        return moduleInstances.stream().flatMap( module -> module.visibleEntities( visibility ) );
-    }
-
-    /* package */ Stream<ModelModule<ValueDescriptor>> visibleValues( final Visibility visibility )
-    {
-        return moduleInstances.stream().flatMap( module -> module.visibleValues( visibility ) );
+        module.registerActivationEventListener( activation );
+        moduleInstances.add( module );
     }
 
-    /* package */ Stream<ServiceReference<?>> visibleServices( final Visibility visibility )
+    public LayerModel model()
     {
-        return moduleInstances.stream().flatMap( module -> module.visibleServices( visibility ) );
+        return layerModel;
     }
 
     /* package */ ModuleInstance findModule( String moduleName )

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerModel.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerModel.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerModel.java
index 8592122..d883bfe 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerModel.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/LayerModel.java
@@ -16,10 +16,17 @@
 package org.apache.zest.runtime.structure;
 
 import java.util.List;
+import java.util.stream.Stream;
 import org.apache.zest.api.activation.ActivationException;
 import org.apache.zest.api.common.MetaInfo;
+import org.apache.zest.api.common.Visibility;
+import org.apache.zest.api.composite.ModelDescriptor;
+import org.apache.zest.api.composite.TransientDescriptor;
+import org.apache.zest.api.entity.EntityDescriptor;
+import org.apache.zest.api.object.ObjectDescriptor;
 import org.apache.zest.api.structure.Layer;
 import org.apache.zest.api.structure.LayerDescriptor;
+import org.apache.zest.api.value.ValueDescriptor;
 import org.apache.zest.functional.HierarchicalVisitor;
 import org.apache.zest.functional.VisitableHierarchy;
 import org.apache.zest.runtime.activation.ActivatorsInstance;
@@ -37,6 +44,7 @@ public final class LayerModel
     private final UsedLayersModel usedLayersModel;
     private final ActivatorsModel<Layer> activatorsModel;
     private final List<ModuleModel> modules;
+    private LayerInstance layerInstance;
 
     public LayerModel( String name,
                        MetaInfo metaInfo,
@@ -100,20 +108,57 @@ public final class LayerModel
         return modelVisitor.visitLeave( this );
     }
 
-    // Context
-    public LayerInstance newInstance( ApplicationInstance applicationInstance, UsedLayersInstance usedLayerInstance )
+    @Override
+    public Layer instance()
     {
-        LayerInstance layerInstance = new LayerInstance( this, applicationInstance, usedLayerInstance );
+        return layerInstance;
+    }
+
+    public LayerInstance newInstance( ApplicationInstance applicationInstance )
+    {
+        layerInstance = new LayerInstance( this, applicationInstance );
         for( ModuleModel module : modules )
         {
-            ModuleInstance moduleInstance = module.newInstance( layerInstance );
+            ModuleInstance moduleInstance = module.newInstance( this );
             layerInstance.addModule( moduleInstance );
         }
-
         return layerInstance;
     }
 
     @Override
+    public Stream<? extends ObjectDescriptor> visibleObjects( final Visibility visibility )
+    {
+        return modules.stream().flatMap( module -> module.visibleObjects( visibility ) );
+    }
+
+    @Override
+    public Stream<? extends TransientDescriptor> visibleTransients( final Visibility visibility )
+    {
+        return modules.stream().flatMap( module -> module.visibleTransients( visibility ) );
+    }
+
+    @Override
+    public Stream<? extends EntityDescriptor> visibleEntities( final Visibility visibility )
+    {
+        return modules.stream().flatMap( module -> module.visibleEntities( visibility ) );
+    }
+
+    /* package */
+    @Override
+    public Stream<? extends ValueDescriptor> visibleValues( final Visibility visibility )
+    {
+        return modules.stream().flatMap( module -> module.visibleValues( visibility ) );
+    }
+
+    /* package */
+    @Override
+    public Stream<? extends ModelDescriptor> visibleServices( final Visibility visibility )
+    {
+        return modules.stream().flatMap( module -> module.visibleServices( visibility ) );
+    }
+
+
+    @Override
     public String toString()
     {
         return name;

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleClassLoader.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleClassLoader.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleClassLoader.java
new file mode 100644
index 0000000..341dc79
--- /dev/null
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleClassLoader.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+package org.apache.zest.runtime.structure;
+
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+import org.apache.zest.api.common.Visibility;
+import org.apache.zest.api.composite.AmbiguousTypeException;
+import org.apache.zest.api.composite.ModelDescriptor;
+
+import static java.util.stream.Stream.concat;
+import static org.apache.zest.api.common.Visibility.application;
+import static org.apache.zest.api.common.Visibility.module;
+import static org.apache.zest.api.util.Classes.modelTypeSpecification;
+
+// Module ClassLoader
+class ModuleClassLoader
+    extends ClassLoader
+{
+
+    private final ModuleModel moduleModel;
+    private final ConcurrentHashMap<String, Class<?>> classes = new ConcurrentHashMap<>();
+
+    ModuleClassLoader( ModuleModel moduleModel, ClassLoader classLoader )
+    {
+        super( classLoader );
+        this.moduleModel = moduleModel;
+    }
+
+    @Override
+    protected Class<?> findClass( String className )
+        throws ClassNotFoundException
+    {
+        try
+        {
+            Class<?> resultingClass = classes.computeIfAbsent( className, name ->
+            {
+                Predicate<ModelDescriptor> modelTypeSpecification = modelTypeSpecification( name );
+                Stream<? extends ModelDescriptor> moduleModels = concat(
+                    moduleModel.visibleObjects( Visibility.module ),
+                    concat(
+                        moduleModel.visibleEntities( Visibility.module ),
+                        concat(
+                            moduleModel.visibleTransients( Visibility.module ),
+                            moduleModel.visibleValues( Visibility.module )
+                        )
+                    )
+                ).filter( modelTypeSpecification );
+
+                Class<?> clazz = null;
+                Iterator<? extends ModelDescriptor> iterator = moduleModels.iterator();
+                if( iterator.hasNext() )
+                {
+                    clazz = iterator.next().types().findFirst().orElse( null );
+
+                    if( iterator.hasNext() )
+                    {
+                        // Ambiguous exception
+                        new AmbiguousTypeException(
+                            "More than one model matches the classname " + name + ":" + iterator.next()
+                        );
+                    }
+                }
+
+                // Check layer
+                if( clazz == null )
+                {
+                    Stream<? extends ModelDescriptor> modelsInLayer1 = concat(
+                        moduleModel.layer().visibleObjects( Visibility.layer ),
+                        concat(
+                            moduleModel.layer().visibleEntities( Visibility.layer ),
+                            concat(
+                                moduleModel.layer().visibleTransients( Visibility.layer ),
+                                moduleModel.layer().visibleValues( Visibility.layer )
+                            )
+                        )
+                    );
+                    // TODO: What does this actually represents?? Shouldn't 'application' visible models already be handed back from lasyerInstance().visibleXyz() ??
+                    Stream<? extends ModelDescriptor> modelsInLayer2 = concat(
+                        moduleModel.layer().visibleObjects( Visibility.application ),
+                        concat(
+                            moduleModel.layer().visibleEntities( Visibility.application ),
+                            concat(
+                                moduleModel.layer().visibleTransients( Visibility.application ),
+                                moduleModel.layer().visibleValues( Visibility.application )
+                            )
+                        )
+                    );
+                    Stream<? extends ModelDescriptor> layerModels = concat(
+                        modelsInLayer1,
+                        modelsInLayer2
+                    ).filter( modelTypeSpecification );
+
+                    Iterator<? extends ModelDescriptor> layerModelsIter = layerModels.iterator();
+                    if( layerModelsIter.hasNext() )
+                    {
+                        clazz = layerModelsIter.next().types().findFirst().orElse( null );
+
+                        if( layerModelsIter.hasNext() )
+                        {
+                            // Ambiguous exception
+                            new AmbiguousTypeException(
+                                "More than one model matches the classname " + name + ":" + layerModelsIter.next()
+                            );
+                        }
+                    }
+                }
+
+                // Check used layers
+                if( clazz == null )
+                {
+                    Stream<? extends ModelDescriptor> usedLayersModels = concat(
+                        moduleModel.layer()
+                            .usedLayers()
+                            .layers()
+                            .flatMap( layer -> layer.visibleObjects( module ) ),
+                        concat(
+                            moduleModel.layer()
+                                .usedLayers()
+                                .layers()
+                                .flatMap( layer -> layer.visibleEntities( Visibility.layer ) ),
+                            concat(
+                                moduleModel.layer()
+                                    .usedLayers()
+                                    .layers()
+                                    .flatMap( layer -> layer.visibleTransients( application ) ),
+                                moduleModel.layer()
+                                    .usedLayers()
+                                    .layers()
+                                    .flatMap( layer -> layer.visibleValues( application ) )
+                            )
+                        )
+                    ).filter( modelTypeSpecification );
+
+                    Iterator<? extends ModelDescriptor> usedLayersModelsIter = usedLayersModels.iterator();
+                    if( usedLayersModelsIter.hasNext() )
+                    {
+                        clazz = usedLayersModelsIter.next().types().findFirst().orElse( null );
+
+                        if( usedLayersModelsIter.hasNext() )
+                        {
+                            // Ambiguous exception
+                            new AmbiguousTypeException(
+                                "More than one model matches the classname " + name + ":" + usedLayersModelsIter.next()
+                            );
+                        }
+                    }
+                }
+                return clazz;
+            } );
+            if( resultingClass == null )
+            {
+                throw new ClassNotFoundException();
+            }
+            return resultingClass;
+        }
+        catch( AmbiguousTypeException e )
+        {
+            throw new ClassNotFoundException( className, e );
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleInstance.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleInstance.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleInstance.java
index 4bf431f..a24e768 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleInstance.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleInstance.java
@@ -19,28 +19,24 @@ package org.apache.zest.runtime.structure;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.NoSuchElementException;
 import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
+import java.util.stream.Collectors;
 import org.apache.zest.api.activation.Activation;
 import org.apache.zest.api.activation.ActivationEventListener;
 import org.apache.zest.api.activation.ActivationException;
 import org.apache.zest.api.activation.PassivationException;
 import org.apache.zest.api.association.AssociationDescriptor;
 import org.apache.zest.api.common.ConstructionException;
-import org.apache.zest.api.common.Visibility;
-import org.apache.zest.api.composite.AmbiguousTypeException;
 import org.apache.zest.api.composite.Composite;
 import org.apache.zest.api.composite.ModelDescriptor;
 import org.apache.zest.api.composite.NoSuchTransientException;
 import org.apache.zest.api.composite.TransientBuilder;
 import org.apache.zest.api.composite.TransientDescriptor;
-import org.apache.zest.api.entity.EntityDescriptor;
 import org.apache.zest.api.entity.EntityReference;
 import org.apache.zest.api.entity.IdentityGenerator;
 import org.apache.zest.api.metrics.MetricsProvider;
@@ -50,11 +46,12 @@ import org.apache.zest.api.property.Property;
 import org.apache.zest.api.property.PropertyDescriptor;
 import org.apache.zest.api.query.QueryBuilder;
 import org.apache.zest.api.query.QueryBuilderFactory;
-import org.apache.zest.api.service.ImportedServiceDescriptor;
 import org.apache.zest.api.service.NoSuchServiceException;
-import org.apache.zest.api.service.ServiceDescriptor;
 import org.apache.zest.api.service.ServiceReference;
+import org.apache.zest.api.structure.LayerDescriptor;
 import org.apache.zest.api.structure.Module;
+import org.apache.zest.api.structure.ModuleDescriptor;
+import org.apache.zest.api.structure.TypeLookup;
 import org.apache.zest.api.unitofwork.UnitOfWorkException;
 import org.apache.zest.api.unitofwork.UnitOfWorkFactory;
 import org.apache.zest.api.util.NullArgumentException;
@@ -69,12 +66,9 @@ import org.apache.zest.runtime.composite.FunctionStateResolver;
 import org.apache.zest.runtime.composite.StateResolver;
 import org.apache.zest.runtime.composite.TransientBuilderInstance;
 import org.apache.zest.runtime.composite.TransientStateInstance;
-import org.apache.zest.runtime.composite.TransientsModel;
 import org.apache.zest.runtime.composite.UsesInstance;
-import org.apache.zest.runtime.entity.EntitiesModel;
 import org.apache.zest.runtime.injection.InjectionContext;
 import org.apache.zest.runtime.object.ObjectModel;
-import org.apache.zest.runtime.object.ObjectsModel;
 import org.apache.zest.runtime.property.PropertyInstance;
 import org.apache.zest.runtime.property.PropertyModel;
 import org.apache.zest.runtime.query.QueryBuilderFactoryImpl;
@@ -86,17 +80,11 @@ import org.apache.zest.runtime.value.ValueBuilderInstance;
 import org.apache.zest.runtime.value.ValueBuilderWithPrototype;
 import org.apache.zest.runtime.value.ValueBuilderWithState;
 import org.apache.zest.runtime.value.ValueInstance;
-import org.apache.zest.runtime.value.ValuesModel;
 import org.apache.zest.spi.entitystore.EntityStore;
 import org.apache.zest.spi.metrics.MetricsProviderAdapter;
 import org.apache.zest.spi.module.ModuleSpi;
-import org.apache.zest.spi.structure.ModelModule;
-import org.apache.zest.valueserialization.orgjson.OrgJsonValueSerialization;
 
-import static java.util.stream.Stream.concat;
-import static org.apache.zest.api.util.Classes.modelTypeSpecification;
 import static org.apache.zest.functional.Iterables.iterable;
-import static org.apache.zest.runtime.legacy.Specifications.translate;
 
 /**
  * Instance of a Zest Module. Contains the various composites for this Module.
@@ -106,18 +94,13 @@ public class ModuleInstance
 {
     // Constructor parameters
     private final ModuleModel model;
-    private final LayerInstance layer;
-    private final TransientsModel transients;
-    private final ValuesModel values;
-    private final ObjectsModel objects;
-    private final EntitiesModel entities;
+    private final LayerDescriptor layer;
+    private final TypeLookup typeLookup;
     private final ServicesInstance services;
     private final ImportedServicesInstance importedServices;
     // Eager instance objects
     private final ActivationDelegate activation;
-    private final TypeLookupImpl typeLookup;
     private final QueryBuilderFactory queryBuilderFactory;
-    private final ClassLoader classLoader;
     // Lazy assigned on accessors
     private EntityStore store;
     private IdentityGenerator generator;
@@ -126,26 +109,20 @@ public class ModuleInstance
     private UnitOfWorkFactory uowf;
 
     @SuppressWarnings( "LeakingThisInConstructor" )
-    public ModuleInstance( ModuleModel moduleModel, LayerInstance layerInstance, TransientsModel transientsModel,
-                           EntitiesModel entitiesModel, ObjectsModel objectsModel, ValuesModel valuesModel,
+    public ModuleInstance( ModuleModel moduleModel, LayerDescriptor layer, TypeLookup typeLookup,
                            ServicesModel servicesModel, ImportedServicesModel importedServicesModel
     )
     {
         // Constructor parameters
         model = moduleModel;
-        layer = layerInstance;
-        transients = transientsModel;
-        values = valuesModel;
-        entities = entitiesModel;
-        services = servicesModel.newInstance( this );
-        objects = objectsModel;
-        importedServices = importedServicesModel.newInstance( this );
+        this.layer = layer;
+        this.typeLookup = typeLookup;
+        services = servicesModel.newInstance( moduleModel );
+        importedServices = importedServicesModel.newInstance( moduleModel );
 
         // Eager instance objects
         activation = new ActivationDelegate( this );
-        typeLookup = new TypeLookupImpl( this );
         queryBuilderFactory = new QueryBuilderFactoryImpl( this );
-        classLoader = new ModuleClassLoader( this, Thread.currentThread().getContextClassLoader() );
 
         // Activation
         services.registerActivationEventListener( activation );
@@ -158,129 +135,17 @@ public class ModuleInstance
         return model.toString();
     }
 
-    // Implementation of Module
-    @Override
-    public String name()
-    {
-        return model.name();
-    }
-
-    @Override
-    public ClassLoader classLoader()
-    {
-        return classLoader;
-    }
-
-    @Override
-    public EntityDescriptor entityDescriptor( String name )
-    {
-        try
-        {
-            Class<?> type = classLoader().loadClass( name );
-            ModelModule<EntityDescriptor> entityModel = typeLookup.lookupEntityModel( type );
-            if( entityModel == null )
-            {
-                return null;
-            }
-            return entityModel.model();
-        }
-        catch( ClassNotFoundException e )
-        {
-            return null;
-        }
-    }
-
-    @Override
-    public ObjectDescriptor objectDescriptor( String typeName )
-    {
-        try
-        {
-            Class<?> type = classLoader().loadClass( typeName );
-            ModelModule<ObjectDescriptor> objectModel = typeLookup.lookupObjectModel( type );
-            if( objectModel == null )
-            {
-                return null;
-            }
-            return objectModel.model();
-        }
-        catch( ClassNotFoundException e )
-        {
-            return null;
-        }
-    }
-
-    @Override
-    public TransientDescriptor transientDescriptor( String name )
-    {
-        try
-        {
-            Class<?> type = classLoader().loadClass( name );
-            ModelModule<TransientDescriptor> transientModel = typeLookup.lookupTransientModel( type );
-            if( transientModel == null )
-            {
-                return null;
-            }
-            return transientModel.model();
-        }
-        catch( ClassNotFoundException e )
-        {
-            return null;
-        }
-    }
-
     @Override
-    public ValueDescriptor valueDescriptor( String name )
+    public ModuleDescriptor descriptor()
     {
-        try
-        {
-            Class<?> type = classLoader().loadClass( name );
-            ModelModule<ValueDescriptor> valueModel = typeLookup.lookupValueModel( type );
-            if( valueModel == null )
-            {
-                return null;
-            }
-            return valueModel.model();
-        }
-        catch( ClassNotFoundException e )
-        {
-            return null;
-        }
-    }
-
-    @Override
-    public Stream<? extends TransientDescriptor> transientComposites()
-    {
-        return transients.stream();
-    }
-
-    @Override
-    public Stream<? extends ValueDescriptor> valueComposites()
-    {
-        return values.stream();
-    }
-
-    @Override
-    public Stream<? extends ServiceDescriptor> serviceComposites()
-    {
-        return services.stream();
-    }
-
-    @Override
-    public Stream<? extends EntityDescriptor> entityComposites()
-    {
-        return entities.stream();
-    }
-
-    @Override
-    public Stream<? extends ImportedServiceDescriptor> importedServices()
-    {
-        return importedServices.stream();
+        return model;
     }
 
+    // Implementation of Module
     @Override
-    public Stream<? extends ObjectDescriptor> objects()
+    public String name()
     {
-        return objects.stream();
+        return model.name();
     }
 
     // Implementation of MetaInfoHolder
@@ -296,15 +161,15 @@ public class ModuleInstance
         throws NoSuchObjectException
     {
         NullArgumentException.validateNotNull( "mixinType", mixinType );
-        ModelModule<ObjectDescriptor> modelModule = typeLookup.lookupObjectModel( mixinType );
+        ObjectDescriptor model = typeLookup.lookupObjectModel( mixinType );
 
-        if( modelModule == null )
+        if( model == null )
         {
             throw new NoSuchObjectException( mixinType.getName(), name(), typeLookup.allVisibleObjects() );
         }
 
-        InjectionContext injectionContext = new InjectionContext( modelModule.module(), UsesInstance.EMPTY_USES.use( uses ) );
-        return mixinType.cast( ( (ObjectModel) modelModule.model() ).newInstance( injectionContext ) );
+        InjectionContext injectionContext = new InjectionContext( model.module(), UsesInstance.EMPTY_USES.use( uses ) );
+        return mixinType.cast( ( (ObjectModel) model ).newInstance( injectionContext ) );
     }
 
     @Override
@@ -312,15 +177,15 @@ public class ModuleInstance
         throws ConstructionException
     {
         NullArgumentException.validateNotNull( "instance", instance );
-        ModelModule<ObjectDescriptor> modelModule = typeLookup.lookupObjectModel( instance.getClass() );
+        ObjectDescriptor model = typeLookup.lookupObjectModel( instance.getClass() );
 
-        if( modelModule == null )
+        if( model == null )
         {
             throw new NoSuchObjectException( instance.getClass().getName(), name(), typeLookup.allVisibleObjects() );
         }
 
-        InjectionContext injectionContext = new InjectionContext( modelModule.module(), UsesInstance.EMPTY_USES.use( uses ) );
-        ( (ObjectModel) modelModule.model() ).inject( injectionContext, instance );
+        InjectionContext injectionContext = new InjectionContext( model.module(), UsesInstance.EMPTY_USES.use( uses ) );
+        ( (ObjectModel) model ).inject( injectionContext, instance );
     }
 
     // Implementation of TransientBuilderFactory
@@ -329,25 +194,25 @@ public class ModuleInstance
         throws NoSuchTransientException
     {
         NullArgumentException.validateNotNull( "mixinType", mixinType );
-        ModelModule<TransientDescriptor> modelModule = typeLookup.lookupTransientModel( mixinType );
+        TransientDescriptor model = typeLookup.lookupTransientModel( mixinType );
 
-        if( modelModule == null )
+        if( model == null )
         {
             throw new NoSuchTransientException( mixinType.getName(), name() );
         }
 
         Map<AccessibleObject, Property<?>> properties = new HashMap<>();
-        modelModule.model().state().properties().forEach(
+        model.state().properties().forEach(
             propertyModel ->
             {
                 Property<?> property = new PropertyInstance<>( ( (PropertyModel) propertyModel ).getBuilderInfo(),
-                                                               propertyModel.initialValue( modelModule.module() ) );
+                                                               propertyModel.initialValue( model.module() ) );
                 properties.put( propertyModel.accessor(), property );
             } );
 
         TransientStateInstance state = new TransientStateInstance( properties );
 
-        return new TransientBuilderInstance<>( modelModule, state, UsesInstance.EMPTY_USES );
+        return new TransientBuilderInstance<>( model, state, UsesInstance.EMPTY_USES );
     }
 
     @Override
@@ -370,7 +235,7 @@ public class ModuleInstance
         throws NoSuchValueException
     {
         NullArgumentException.validateNotNull( "mixinType", mixinType );
-        ModelModule<ValueDescriptor> compositeModelModule = typeLookup.lookupValueModel( mixinType );
+        ValueDescriptor compositeModelModule = typeLookup.lookupValueModel( mixinType );
 
         if( compositeModelModule == null )
         {
@@ -394,7 +259,7 @@ public class ModuleInstance
         NullArgumentException.validateNotNull( "manyAssociationFunction", manyAssociationFunction );
         NullArgumentException.validateNotNull( "namedAssociationFunction", namedAssociationFunction );
 
-        ModelModule<ValueDescriptor> compositeModelModule = typeLookup.lookupValueModel( mixinType );
+        ValueDescriptor compositeModelModule = typeLookup.lookupValueModel( mixinType );
 
         if( compositeModelModule == null )
         {
@@ -410,9 +275,9 @@ public class ModuleInstance
     private static class InitialStateResolver
         implements StateResolver
     {
-        private final Module module;
+        private final ModuleDescriptor module;
 
-        private InitialStateResolver( Module module )
+        private InitialStateResolver( ModuleDescriptor module )
         {
             this.module = module;
         }
@@ -451,14 +316,14 @@ public class ModuleInstance
         ValueInstance valueInstance = ValueInstance.valueInstanceOf( (ValueComposite) prototype );
         Class<Composite> valueType = (Class<Composite>) valueInstance.types().findFirst().orElse( null );
 
-        ModelModule<ValueDescriptor> modelModule = typeLookup.lookupValueModel( valueType );
+        ValueDescriptor model = typeLookup.lookupValueModel( valueType );
 
-        if( modelModule == null )
+        if( model == null )
         {
             throw new NoSuchValueException( valueType.getName(), name() );
         }
 
-        return new ValueBuilderWithPrototype<>( modelModule, this, prototype );
+        return new ValueBuilderWithPrototype<>( model, this, prototype );
     }
 
     @Override
@@ -466,16 +331,16 @@ public class ModuleInstance
         throws NoSuchValueException, ConstructionException
     {
         NullArgumentException.validateNotNull( "mixinType", mixinType );
-        ModelModule<ValueDescriptor> modelModule = typeLookup.lookupValueModel( mixinType );
+        ValueDescriptor model = typeLookup.lookupValueModel( mixinType );
 
-        if( modelModule == null )
+        if( model == null )
         {
             throw new NoSuchValueException( mixinType.getName(), name() );
         }
 
         try
         {
-            return valueSerialization().deserialize( modelModule.model().valueType(), serializedState );
+            return valueSerialization().deserialize( model.module(), model.valueType(), serializedState );
         }
         catch( ValueSerializationException ex )
         {
@@ -490,29 +355,59 @@ public class ModuleInstance
         return queryBuilderFactory.newQueryBuilder( resultType );
     }
 
-    // Implementation of ServiceFinder
     @Override
     public <T> ServiceReference<T> findService( Class<T> serviceType )
+        throws NoSuchServiceException
     {
-        return typeLookup.lookupServiceReference( serviceType );
+        return findService( (Type) serviceType );
     }
 
     @Override
     public <T> ServiceReference<T> findService( Type serviceType )
     {
-        return typeLookup.lookupServiceReference( serviceType );
+        ModelDescriptor serviceModel = typeLookup.lookupServiceModel( serviceType );
+        if( serviceModel == null )
+        {
+            throw new NoSuchServiceException( serviceType.getTypeName(), name() );
+        }
+        ModuleInstance serviceLocation = (ModuleInstance) serviceModel.module().instance();
+        try
+        {
+            //noinspection unchecked
+            return serviceLocation.services
+                .references()
+                .filter( ref -> ref.hasType( serviceType ) )
+                .map( ref -> (ServiceReference<T>) ref )
+                .findAny().get();
+        }
+        catch( NoSuchElementException e )
+        {
+            throw new NoSuchServiceException( serviceType.getTypeName(), name() );
+        }
     }
 
     @Override
     public <T> Iterable<ServiceReference<T>> findServices( Class<T> serviceType )
     {
-        return typeLookup.lookupServiceReferences( serviceType );
+        return findServices( (Type) serviceType );
     }
 
     @Override
     public <T> Iterable<ServiceReference<T>> findServices( Type serviceType )
     {
-        return typeLookup.lookupServiceReferences( serviceType );
+        List<? extends ModelDescriptor> serviceModels = typeLookup.lookupServiceModels( serviceType );
+        if( serviceModels == null )
+        {
+            return Collections.emptyList();
+        }
+        //noinspection unchecked
+        return serviceModels.stream()
+            .flatMap(
+                model -> ( (ModuleInstance) model.module().instance() ).services.references()
+            )
+            .filter( ref -> ref.hasType( serviceType ) )
+            .map( ref -> (ServiceReference<T>) ref )
+            .collect( Collectors.toList() );
     }
 
     // Implementation of Activation
@@ -544,18 +439,18 @@ public class ModuleInstance
     }
 
     // Other methods
-    /* package */ ModuleModel model()
+    ModuleModel model()
     {
         return model;
     }
 
-    public LayerInstance layerInstance()
+    public LayerDescriptor layer()
     {
         return layer;
     }
 
     @Override
-    public TypeLookupImpl typeLookup()
+    public TypeLookup typeLookup()
     {
         return typeLookup;
     }
@@ -566,16 +461,15 @@ public class ModuleInstance
         {
             if( store == null )
             {
-                ServiceReference<EntityStore> service = null;
                 try
                 {
-                    service = findService( EntityStore.class );
+                    ServiceReference<EntityStore> service = findService( EntityStore.class );
+                    store = service.get();
                 }
                 catch( NoSuchServiceException e )
                 {
                     throw new UnitOfWorkException( "No EntityStore service available in module " + name() );
                 }
-                store = service.get();
             }
         }
         return store;
@@ -587,16 +481,15 @@ public class ModuleInstance
         {
             if( uowf == null )
             {
-                ServiceReference<UnitOfWorkFactory> service = null;
                 try
                 {
-                    service = findService( UnitOfWorkFactory.class );
+                    ServiceReference<UnitOfWorkFactory> service = findService( UnitOfWorkFactory.class );
+                    uowf = service.get();
                 }
                 catch( NoSuchServiceException e )
                 {
                     throw new UnitOfWorkException( "No UnitOfWorkFactory service available in module " + name() );
                 }
-                uowf = service.get();
             }
         }
         return uowf;
@@ -628,7 +521,7 @@ public class ModuleInstance
                 }
                 catch( NoSuchServiceException e )
                 {
-                    valueSerialization = new OrgJsonValueSerialization( layer.applicationInstance(), this, this );
+                    throw new ValueSerializationException( "No ValueSeriaservice available in module " + name() );
                 }
             }
         }
@@ -655,242 +548,24 @@ public class ModuleInstance
         return metrics;
     }
 
-    public Stream<ModelModule<ObjectDescriptor>> visibleObjects( Visibility visibility )
-    {
-        return objects.stream()
-            .filter( new Visibilitypredicate( visibility ) )
-            .map( ModelModule.<ObjectDescriptor>modelModuleFunction( this ) );
-    }
-
-    public Stream<ModelModule<TransientDescriptor>> visibleTransients( Visibility visibility )
-    {
-        return transients.models()
-            .filter( new Visibilitypredicate( visibility ) )
-            .map( ModelModule.<TransientDescriptor>modelModuleFunction( this ) );
-    }
-
-    public Stream<ModelModule<EntityDescriptor>> visibleEntities( Visibility visibility )
-    {
-        return entities.models()
-            .filter( new Visibilitypredicate( visibility ) )
-            .map( ModelModule.<EntityDescriptor>modelModuleFunction( this ) );
-    }
-
-    public Stream<ModelModule<ValueDescriptor>> visibleValues( Visibility visibility )
-    {
-        return values.models()
-            .filter( new Visibilitypredicate( visibility ) )
-            .map( ModelModule.<ValueDescriptor>modelModuleFunction( this ) );
-    }
-
-    public Stream<ServiceReference<?>> visibleServices( Visibility visibility )
-    {
-        return concat( services.visibleServices( visibility ),
-                       importedServices.visibleServices( visibility ) );
-    }
-
-    // Module ClassLoader
-    private static class ModuleClassLoader
-        extends ClassLoader
-    {
-
-        private final ModuleInstance moduleInstance;
-        private final Map<String, Class<?>> classes = new ConcurrentHashMap<>();
-
-        private ModuleClassLoader( ModuleInstance moduleInstance, ClassLoader classLoader )
-        {
-            super( classLoader );
-            this.moduleInstance = moduleInstance;
-        }
-
-        @Override
-        protected Class<?> findClass( String name )
-            throws ClassNotFoundException
-        {
-            Class<?> clazz = classes.get( name );
-            if( clazz == null )
-            {
-                Predicate<ModelDescriptor> modelTypeSpecification = modelTypeSpecification( name );
-                Predicate<ModelModule<? extends ModelDescriptor>> translation = translate( ModelModule.modelFunction(), modelTypeSpecification );
-                Stream<ModelModule<? extends ModelDescriptor>> moduleModels = concat(
-                    moduleInstance.visibleObjects( Visibility.module ),
-                    concat(
-                        moduleInstance.visibleEntities( Visibility.module ),
-                        concat(
-                            moduleInstance.visibleTransients( Visibility.module ),
-                            moduleInstance.visibleValues( Visibility.module )
-                        )
-                    )
-                ).filter( translation );
-
-                Iterator<ModelModule<? extends ModelDescriptor>> moduleModelsIter = moduleModels.iterator();
-                if( moduleModelsIter.hasNext() )
-                {
-                    clazz = moduleModelsIter.next().model().types().findFirst().orElse( null );
-
-                    if( moduleModelsIter.hasNext() )
-                    {
-                        // Ambiguous exception
-                        throw new ClassNotFoundException(
-                            name,
-                            new AmbiguousTypeException(
-                                "More than one model matches the classname " + name + ":" + moduleModelsIter.next()
-                            )
-                        );
-                    }
-                }
-
-                // Check layer
-                if( clazz == null )
-                {
-                    Stream<ModelModule<? extends ModelDescriptor>> modelsInLayer1 = concat(
-                        moduleInstance.layerInstance().visibleObjects( Visibility.layer ),
-                        concat(
-                            moduleInstance.layerInstance().visibleEntities( Visibility.layer ),
-                            concat(
-                                moduleInstance.layerInstance().visibleTransients( Visibility.layer ),
-                                moduleInstance.layerInstance().visibleValues( Visibility.layer )
-                            )
-                        )
-                    );
-                    // TODO: What does this actually represents?? Shouldn't 'application' visible models already be handed back from lasyerInstance().visibleXyz() ??
-                    Stream<ModelModule<? extends ModelDescriptor>> modelsInLayer2 = concat(
-                        moduleInstance.layerInstance().visibleObjects( Visibility.application ),
-                        concat(
-                            moduleInstance.layerInstance().visibleEntities( Visibility.application ),
-                            concat(
-                                moduleInstance.layerInstance().visibleTransients( Visibility.application ),
-                                moduleInstance.layerInstance().visibleValues( Visibility.application )
-                            )
-                        )
-                    );
-                    Stream<ModelModule<? extends ModelDescriptor>> layerModels = concat(
-                        modelsInLayer1,
-                        modelsInLayer2
-                    ).filter( translation );
-
-                    Iterator<ModelModule<? extends ModelDescriptor>> layerModelsIter = layerModels.iterator();
-                    if( layerModelsIter.hasNext() )
-                    {
-                        clazz = layerModelsIter.next().model().types().findFirst().orElse( null );
-
-                        if( layerModelsIter.hasNext() )
-                        {
-                            // Ambiguous exception
-                            throw new ClassNotFoundException(
-                                name,
-                                new AmbiguousTypeException(
-                                    "More than one model matches the classname " + name + ":" + layerModelsIter.next() )
-                            );
-                        }
-                    }
-                }
-
-                // Check used layers
-                if( clazz == null )
-                {
-                    Stream<ModelModule<? extends ModelDescriptor>> usedLayersModels = concat(
-                        moduleInstance.layerInstance().usedLayersInstance().visibleObjects(),
-                        concat(
-                            moduleInstance.layerInstance().usedLayersInstance().visibleEntities(),
-                            concat(
-                                moduleInstance.layerInstance().usedLayersInstance().visibleTransients(),
-                                moduleInstance.layerInstance().usedLayersInstance().visibleValues()
-                            )
-                        )
-                    ).filter( translation );
-
-                    Iterator<ModelModule<? extends ModelDescriptor>> usedLayersModelsIter = usedLayersModels.iterator();
-                    if( usedLayersModelsIter.hasNext() )
-                    {
-                        clazz = usedLayersModelsIter.next().model().types().findFirst().orElse( null );
-
-                        if( usedLayersModelsIter.hasNext() )
-                        {
-                            // Ambiguous exception
-                            throw new ClassNotFoundException(
-                                name,
-                                new AmbiguousTypeException(
-                                    "More than one model matches the classname " + name + ":" + usedLayersModelsIter.next()
-                                )
-                            );
-                        }
-                    }
-                }
-
-                if( clazz == null )
-                {
-                    throw new ClassNotFoundException( name );
-                }
-                classes.put( name, clazz );
-            }
-
-            return clazz;
-        }
-    }
-
-    public Stream<ModelModule<? extends ModelDescriptor>> findVisibleValueTypes()
-    {
-        return concat( visibleValues( Visibility.module ),
-                       concat(
-                           layerInstance().visibleValues( Visibility.layer ),
-                           concat(
-                               layerInstance().visibleValues( Visibility.application ),
-                               layerInstance().usedLayersInstance().visibleValues()
-                           )
-                       )
-        );
-    }
-
-    public Stream<ModelModule<? extends ModelDescriptor>> findVisibleEntityTypes()
-    {
-        return concat( visibleEntities( Visibility.module ),
-                       concat(
-                           layerInstance().visibleEntities( Visibility.layer ),
-                           concat(
-                               layerInstance().visibleEntities( Visibility.application ),
-                               layerInstance().usedLayersInstance().visibleEntities()
-                           )
-                       )
-        );
-    }
-
-    public Stream<ModelModule<? extends ModelDescriptor>> findVisibleTransientTypes()
-    {
-        return concat( visibleTransients( Visibility.module ),
-                       concat(
-                           layerInstance().visibleTransients( Visibility.layer ),
-                           concat(
-                               layerInstance().visibleTransients( Visibility.application ),
-                               layerInstance().usedLayersInstance().visibleTransients()
-                           )
-                       )
-        );
-    }
-
-    public Stream<ServiceReference<?>> findVisibleServiceTypes()
-    {
-        return concat( visibleServices( Visibility.module ),
-                       concat(
-                           layerInstance().visibleServices( Visibility.layer ),
-                           concat(
-                               layerInstance().visibleServices( Visibility.application ),
-                               layerInstance().usedLayersInstance().visibleServices()
-                           )
-                       )
-        );
-    }
-
-    public Stream<ModelModule<? extends ModelDescriptor>> findVisibleObjectTypes()
-    {
-        return concat( visibleObjects( Visibility.module ),
-                       concat(
-                           layerInstance().visibleObjects( Visibility.layer ),
-                           concat(
-                               layerInstance().visibleObjects( Visibility.application ),
-                               layerInstance().usedLayersInstance().visibleObjects()
-                           )
-                       )
-        );
-    }
+//    public Stream<ServiceReference<?>> visibleServices( Visibility visibility )
+//    {
+//        return concat( services.visibleServices( visibility ),
+//                       importedServices.visibleServices( visibility ) );
+//    }
+//
+//
+//
+//    public Stream<ServiceReference<?>> findVisibleServiceTypes()
+//    {
+//        return concat( visibleServices( Visibility.module ),
+//                       concat(
+//                           layer().visibleServices( Visibility.layer ),
+//                           concat(
+//                               layer().visibleServices( Visibility.application ),
+//                               layer().usedLayers().layers().flatMap( layer -> layer.visibleServices(Visibility.application) )
+//                           )
+//                       )
+//        );
+//    }
 }

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleModel.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleModel.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleModel.java
index 49e3670..85fceec 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleModel.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/ModuleModel.java
@@ -15,10 +15,21 @@
  */
 package org.apache.zest.runtime.structure;
 
+import java.util.stream.Stream;
 import org.apache.zest.api.activation.ActivationException;
 import org.apache.zest.api.common.MetaInfo;
+import org.apache.zest.api.common.Visibility;
+import org.apache.zest.api.composite.ModelDescriptor;
+import org.apache.zest.api.composite.TransientDescriptor;
+import org.apache.zest.api.entity.EntityDescriptor;
+import org.apache.zest.api.object.ObjectDescriptor;
+import org.apache.zest.api.service.ImportedServiceDescriptor;
+import org.apache.zest.api.service.ServiceDescriptor;
+import org.apache.zest.api.structure.LayerDescriptor;
 import org.apache.zest.api.structure.Module;
 import org.apache.zest.api.structure.ModuleDescriptor;
+import org.apache.zest.api.structure.TypeLookup;
+import org.apache.zest.api.value.ValueDescriptor;
 import org.apache.zest.functional.HierarchicalVisitor;
 import org.apache.zest.functional.VisitableHierarchy;
 import org.apache.zest.runtime.activation.ActivatorsInstance;
@@ -30,12 +41,18 @@ import org.apache.zest.runtime.service.ImportedServicesModel;
 import org.apache.zest.runtime.service.ServicesModel;
 import org.apache.zest.runtime.value.ValuesModel;
 
+import static java.util.stream.Stream.concat;
+import static org.apache.zest.api.common.Visibility.application;
+import static org.apache.zest.api.common.Visibility.layer;
+import static org.apache.zest.api.common.Visibility.module;
+
 /**
  * JAVADOC
  */
 public class ModuleModel
     implements ModuleDescriptor, VisitableHierarchy<Object, Object>
 {
+    private final LayerDescriptor layerModel;
     private final ActivatorsModel<Module> activatorsModel;
     private final TransientsModel transientsModel;
     private final EntitiesModel entitiesModel;
@@ -43,12 +60,16 @@ public class ModuleModel
     private final ValuesModel valuesModel;
     private final ServicesModel servicesModel;
     private final ImportedServicesModel importedServicesModel;
+    private final TypeLookupImpl typeLookup;
+    private final ClassLoader classLoader;
 
     private final String name;
     private final MetaInfo metaInfo;
+    private ModuleInstance moduleInstance;
 
     public ModuleModel( String name,
                         MetaInfo metaInfo,
+                        LayerDescriptor layerModel,
                         ActivatorsModel<Module> activatorsModel,
                         TransientsModel transientsModel,
                         EntitiesModel entitiesModel,
@@ -60,6 +81,7 @@ public class ModuleModel
     {
         this.name = name;
         this.metaInfo = metaInfo;
+        this.layerModel = layerModel;
         this.activatorsModel = activatorsModel;
         this.transientsModel = transientsModel;
         this.entitiesModel = entitiesModel;
@@ -67,6 +89,8 @@ public class ModuleModel
         this.valuesModel = valuesModel;
         this.servicesModel = servicesModel;
         this.importedServicesModel = importedServicesModel;
+        typeLookup = new TypeLookupImpl( this );
+        classLoader = new ModuleClassLoader( this, Thread.currentThread().getContextClassLoader() );
     }
 
     @Override
@@ -80,6 +104,18 @@ public class ModuleModel
         return metaInfo.get( infoType );
     }
 
+    @Override
+    public LayerDescriptor layer()
+    {
+        return layerModel;
+    }
+
+    @Override
+    public ClassLoader classLoader()
+    {
+        return classLoader;
+    }
+
     public ActivatorsInstance<Module> newActivatorsInstance()
         throws ActivationException
     {
@@ -87,6 +123,237 @@ public class ModuleModel
     }
 
     @Override
+    public EntityDescriptor entityDescriptor( String name )
+    {
+        try
+        {
+            Class<?> type = classLoader().loadClass( name );
+            EntityDescriptor entityModel = typeLookup.lookupEntityModel( type );
+            if( entityModel == null )
+            {
+                return null;
+            }
+            return entityModel;
+        }
+        catch( ClassNotFoundException e )
+        {
+            return null;
+        }
+    }
+
+    @Override
+    public ObjectDescriptor objectDescriptor( String typeName )
+    {
+        try
+        {
+            Class<?> type = classLoader().loadClass( typeName );
+            ObjectDescriptor objectModel = typeLookup.lookupObjectModel( type );
+            if( objectModel == null )
+            {
+                return null;
+            }
+            return objectModel;
+        }
+        catch( ClassNotFoundException e )
+        {
+            return null;
+        }
+    }
+
+    @Override
+    public TransientDescriptor transientDescriptor( String name )
+    {
+        try
+        {
+            Class<?> type = classLoader().loadClass( name );
+            TransientDescriptor transientModel = typeLookup.lookupTransientModel( type );
+            if( transientModel == null )
+            {
+                return null;
+            }
+            return transientModel;
+        }
+        catch( ClassNotFoundException e )
+        {
+            return null;
+        }
+    }
+
+    @Override
+    public ValueDescriptor valueDescriptor( String name )
+    {
+        try
+        {
+            Class<?> type = classLoader().loadClass( name );
+            ValueDescriptor valueModel = typeLookup.lookupValueModel( type );
+            if( valueModel == null )
+            {
+                return null;
+            }
+            return valueModel;
+        }
+        catch( ClassNotFoundException e )
+        {
+            return null;
+        }
+    }
+
+    @Override
+    public Module instance()
+    {
+        return moduleInstance;
+    }
+
+    @Override
+    public TypeLookup typeLookup()
+    {
+        return typeLookup;
+    }
+
+    public ModuleInstance newInstance( LayerDescriptor layerInstance )
+    {
+        moduleInstance = new ModuleInstance( this, layerInstance, typeLookup, servicesModel, importedServicesModel );
+        return moduleInstance;
+    }
+
+    @Override
+    public Stream<? extends TransientDescriptor> transientComposites()
+    {
+        return transientsModel.stream();
+    }
+
+    @Override
+    public Stream<? extends ValueDescriptor> valueComposites()
+    {
+        return valuesModel.stream();
+    }
+
+    @Override
+    public Stream<? extends ServiceDescriptor> serviceComposites()
+    {
+        return servicesModel.models();
+    }
+
+    @Override
+    public Stream<? extends EntityDescriptor> entityComposites()
+    {
+        return entitiesModel.stream();
+    }
+
+    @Override
+    public Stream<? extends ImportedServiceDescriptor> importedServices()
+    {
+        return importedServicesModel.models();
+    }
+
+    @Override
+    public Stream<? extends ObjectDescriptor> objects()
+    {
+        return objectsModel.models();
+    }
+
+    public Stream<? extends ValueDescriptor> findVisibleValueTypes()
+    {
+        return concat( visibleValues( module ),
+                       concat(
+                           layer().visibleValues( layer ),
+                           concat(
+                               layer().visibleValues( application ),
+                               layer().usedLayers().layers().flatMap( layer1 -> layer1.visibleValues( application ) )
+                           )
+                       )
+        );
+    }
+
+    public Stream<? extends EntityDescriptor> findVisibleEntityTypes()
+    {
+        return concat( visibleEntities( module ),
+                       concat(
+                           layer().visibleEntities( layer ),
+                           concat(
+                               layer().visibleEntities( application ),
+                               layer().usedLayers().layers().flatMap( layer1 -> layer1.visibleEntities( application ) )
+                           )
+                       )
+        );
+    }
+
+    public Stream<? extends TransientDescriptor> findVisibleTransientTypes()
+    {
+        return concat( visibleTransients( module ),
+                       concat(
+                           layer().visibleTransients( layer ),
+                           concat(
+                               layer().visibleTransients( application ),
+                               layer().usedLayers()
+                                   .layers()
+                                   .flatMap( layer1 -> layer1.visibleTransients( application ) )
+                           )
+                       )
+        );
+    }
+
+    public Stream<? extends ModelDescriptor> findVisibleServiceTypes()
+    {
+        return concat( visibleServices( module ),
+                       concat(
+                           layer().visibleServices( layer ),
+                           concat(
+                               layer().visibleServices( application ),
+                               layer().usedLayers().layers().flatMap( layer1 -> layer1.visibleServices( application ) )
+                           )
+                       )
+        );
+    }
+
+    public Stream<? extends ObjectDescriptor> findVisibleObjectTypes()
+    {
+        return concat( visibleObjects( module ),
+                       concat(
+                           layer().visibleObjects( layer ),
+                           concat(
+                               layer().visibleObjects( application ),
+                               layer().usedLayers().layers().flatMap( layer -> layer.visibleObjects( application ) )
+                           )
+                       )
+        );
+    }
+
+    public Stream<? extends ObjectDescriptor> visibleObjects( Visibility visibility )
+    {
+        return objectsModel.models()
+            .filter( new Visibilitypredicate( visibility ) );
+    }
+
+    public Stream<? extends TransientDescriptor> visibleTransients( Visibility visibility )
+    {
+        return transientsModel.models()
+            .filter( new Visibilitypredicate( visibility ) );
+    }
+
+    public Stream<? extends EntityDescriptor> visibleEntities( Visibility visibility )
+    {
+        return entitiesModel.models()
+            .filter( new Visibilitypredicate( visibility ) );
+    }
+
+    public Stream<? extends ValueDescriptor> visibleValues( Visibility visibility )
+    {
+        return valuesModel.models()
+            .filter( new Visibilitypredicate( visibility ) );
+    }
+
+    public Stream<? extends ModelDescriptor> visibleServices( Visibility visibility )
+    {
+        return concat(
+            servicesModel.models()
+                .filter( new Visibilitypredicate( visibility ) ),
+            importedServicesModel.models()
+                .filter( new Visibilitypredicate( visibility ) )
+        );
+    }
+
+    @Override
     public <ThrowableType extends Throwable> boolean accept( HierarchicalVisitor<? super Object, ? super Object, ThrowableType> modelVisitor )
         throws ThrowableType
     {
@@ -115,13 +382,6 @@ public class ModuleModel
         return modelVisitor.visitLeave( this );
     }
 
-    // Context
-
-    public ModuleInstance newInstance( LayerInstance layerInstance )
-    {
-        return new ModuleInstance( this, layerInstance, transientsModel, entitiesModel, objectsModel, valuesModel, servicesModel, importedServicesModel );
-    }
-
     @Override
     public String toString()
     {

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/TypeLookupImpl.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/TypeLookupImpl.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/TypeLookupImpl.java
index 7835aaa..0d3c740 100755
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/TypeLookupImpl.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/TypeLookupImpl.java
@@ -22,9 +22,7 @@ package org.apache.zest.runtime.structure;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.WildcardType;
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -35,18 +33,14 @@ import org.apache.zest.api.composite.ModelDescriptor;
 import org.apache.zest.api.composite.TransientDescriptor;
 import org.apache.zest.api.entity.EntityDescriptor;
 import org.apache.zest.api.object.ObjectDescriptor;
-import org.apache.zest.api.service.NoSuchServiceException;
-import org.apache.zest.api.service.ServiceReference;
+import org.apache.zest.api.structure.ModuleDescriptor;
+import org.apache.zest.api.structure.TypeLookup;
 import org.apache.zest.api.type.HasTypes;
 import org.apache.zest.api.value.ValueDescriptor;
-import org.apache.zest.spi.structure.ModelModule;
-import org.apache.zest.spi.structure.TypeLookup;
 
 import static java.util.stream.Stream.concat;
 import static org.apache.zest.api.common.Visibility.application;
 import static org.apache.zest.api.common.Visibility.layer;
-import static org.apache.zest.api.common.Visibility.module;
-import static org.apache.zest.api.util.Classes.RAW_CLASS;
 import static org.apache.zest.api.util.Classes.interfacesOf;
 import static org.apache.zest.functional.Iterables.first;
 
@@ -58,25 +52,26 @@ public class TypeLookupImpl
 {
 
     // Constructor parameters
-    private final ModuleInstance moduleInstance;
+    private final ModuleDescriptor moduleModel;
+
     // Eager instance objects
-    private final Map<Class<?>, ModelModule<ObjectDescriptor>> objectModels;
-    private final Map<Class<?>, ModelModule<TransientDescriptor>> transientModels;
-    private final Map<Class<?>, ModelModule<ValueDescriptor>> valueModels;
-    private final Map<Class<?>, List<ModelModule<EntityDescriptor>>> allEntityModels;
-    private final Map<Class<?>, ModelModule<EntityDescriptor>> unambiguousEntityModels;
-    private final Map<Type, ServiceReference<?>> serviceReferences;
-    private final Map<Type, List<ServiceReference<?>>> servicesReferences;
+    private final ConcurrentHashMap<Class<?>, ObjectDescriptor> objectModels;
+    private final ConcurrentHashMap<Class<?>, TransientDescriptor> transientModels;
+    private final ConcurrentHashMap<Class<?>, ValueDescriptor> valueModels;
+    private final ConcurrentHashMap<Class<?>, List<? extends EntityDescriptor>> allEntityModels;
+    private final ConcurrentHashMap<Class<?>, EntityDescriptor> unambiguousEntityModels;
+    private final ConcurrentHashMap<Type, ModelDescriptor> serviceModels;
+    private final ConcurrentHashMap<Type, List<ModelDescriptor>> servicesReferences;
 
     /**
-     * Create a new TypeLookup bound to the given ModuleInstance.
+     * Create a new TypeLookup bound to the given moduleModel.
      *
-     * @param moduleInstance ModuleInstance bound to this TypeLookup
+     * @param module ModuleModel bound to this TypeLookup
      */
-    TypeLookupImpl( ModuleInstance moduleInstance )
+    TypeLookupImpl( ModuleModel module )
     {
         // Constructor parameters
-        this.moduleInstance = moduleInstance;
+        this.moduleModel = module;
 
         // Eager instance objects
         objectModels = new ConcurrentHashMap<>();
@@ -84,7 +79,7 @@ public class TypeLookupImpl
         valueModels = new ConcurrentHashMap<>();
         allEntityModels = new ConcurrentHashMap<>();
         unambiguousEntityModels = new ConcurrentHashMap<>();
-        serviceReferences = new ConcurrentHashMap<>();
+        serviceModels = new ConcurrentHashMap<>();
         servicesReferences = new ConcurrentHashMap<>();
     }
 
@@ -103,23 +98,19 @@ public class TypeLookupImpl
      *
      * @return First matching Object Model
      */
-    ModelModule<ObjectDescriptor> lookupObjectModel( final Class type )
+    @Override
+    public ObjectDescriptor lookupObjectModel( final Class<?> type )
     {
-        ModelModule<ObjectDescriptor> model = objectModels.get( type );
-        if( model == null )
+        return objectModels.computeIfAbsent( type, key ->
         {
-            List<ModelModule<ObjectDescriptor>> allModels = allObjects().collect( Collectors.toList() );
-            model = ambiguityMatching( type, allModels, new ExactTypeMatching<>( type ) );
+            List<ObjectDescriptor> allModels = allObjects().collect( Collectors.toList() );
+            ObjectDescriptor model = ambiguityMatching( key, allModels, new ExactTypeMatching<>( key ) );
             if( model == null )
             {
-                model = ambiguityMatching( type, allModels, new AssignableFromTypeMatching<>( type ) );
-            }
-            if( model != null )
-            {
-                objectModels.put( type, model );
+                model = ambiguityMatching( key, allModels, new AssignableFromTypeMatching<>( key ) );
             }
-        }
-        return model;
+            return model;
+        } );
     }
 
     /**
@@ -137,23 +128,19 @@ public class TypeLookupImpl
      *
      * @return First matching Transient Model
      */
-    ModelModule<TransientDescriptor> lookupTransientModel( final Class type )
+    @Override
+    public TransientDescriptor lookupTransientModel( final Class<?> type )
     {
-        ModelModule<TransientDescriptor> model = transientModels.get( type );
-        if( model == null )
+        return transientModels.computeIfAbsent( type, key ->
         {
-            List<ModelModule<TransientDescriptor>> allModels = allTransients().collect( Collectors.toList() );
-            model = ambiguityMatching( type, allModels, new ExactTypeMatching<>( type ) );
+            List<TransientDescriptor> allModels = allTransients().collect( Collectors.toList() );
+            TransientDescriptor model = ambiguityMatching( key, allModels, new ExactTypeMatching<>( key ) );
             if( model == null )
             {
-                model = ambiguityMatching( type, allModels, new AssignableFromTypeMatching<>( type ) );
-            }
-            if( model != null )
-            {
-                transientModels.put( type, model );
+                model = ambiguityMatching( key, allModels, new AssignableFromTypeMatching<>( key ) );
             }
-        }
-        return model;
+            return model;
+        } );
     }
 
     /**
@@ -171,23 +158,19 @@ public class TypeLookupImpl
      *
      * @return First matching Value Model
      */
-    public ModelModule<ValueDescriptor> lookupValueModel( final Class type )
+    @Override
+    public ValueDescriptor lookupValueModel( final Class<?> type )
     {
-        ModelModule<ValueDescriptor> model = valueModels.get( type );
-        if( model == null )
+        return valueModels.computeIfAbsent( type, key ->
         {
-            List<ModelModule<ValueDescriptor>> allModels = allValues().collect( Collectors.toList() );
-            model = ambiguityMatching( type, allModels, new ExactTypeMatching<>( type ) );
+            List<ValueDescriptor> allModels = allValues().collect( Collectors.toList() );
+            ValueDescriptor model = ambiguityMatching( key, allModels, new ExactTypeMatching<>( key ) );
             if( model == null )
             {
-                model = ambiguityMatching( type, allModels, new AssignableFromTypeMatching<>( type ) );
-            }
-            if( model != null )
-            {
-                valueModels.put( type, model );
+                model = ambiguityMatching( key, allModels, new AssignableFromTypeMatching<>( key ) );
             }
-        }
-        return model;
+            return model;
+        } );
     }
 
     /**
@@ -209,24 +192,18 @@ public class TypeLookupImpl
      * @return First matching Entity Model
      */
     @Override
-    public ModelModule<EntityDescriptor> lookupEntityModel( final Class type )
+    public EntityDescriptor lookupEntityModel( final Class<?> type )
     {
-        ModelModule<EntityDescriptor> model = unambiguousEntityModels.get( type );
-
-        if( model == null )
+        return unambiguousEntityModels.computeIfAbsent( type, key ->
         {
-            List<ModelModule<EntityDescriptor>> allModels = allEntities().collect( Collectors.toList() );
-            model = ambiguityMatching( type, allModels, new ExactTypeMatching<>( type ) );
+            List<EntityDescriptor> allModels = allEntities().collect( Collectors.toList() );
+            EntityDescriptor model = ambiguityMatching( key, allModels, new ExactTypeMatching<>( key ) );
             if( model == null )
             {
-                model = ambiguityMatching( type, allModels, new AssignableFromTypeMatching<>( type ) );
-            }
-            if( model != null )
-            {
-                unambiguousEntityModels.put( type, model );
+                model = ambiguityMatching( key, allModels, new AssignableFromTypeMatching<>( key ) );
             }
-        }
-        return model;
+            return model;
+        } );
     }
 
     /**
@@ -252,179 +229,161 @@ public class TypeLookupImpl
      * @return All matching Entity Models
      */
     @Override
-    public Iterable<ModelModule<EntityDescriptor>> lookupEntityModels( final Class type )
+    public Iterable<? extends EntityDescriptor> lookupEntityModels( final Class type )
     {
-        List<ModelModule<EntityDescriptor>> result = allEntityModels.get( type );
-        if( result == null )
-        {
-            result = concat(
-                allEntities().filter( ref -> new ExactTypeMatching<>( type ).test( ref.model() ) ),
-                allEntities().filter( ref -> new AssignableFromTypeMatching<>( type ).test( ref.model() ) )
-            ).distinct().collect( Collectors.toList() );
-            allEntityModels.put( type, result );
-        }
-        return result;
+        return allEntityModels.computeIfAbsent( type, key ->
+            concat(
+                allEntities().filter( ref -> new ExactTypeMatching<>( key ).test( ref ) ),
+                allEntities().filter( ref -> new AssignableFromTypeMatching<>( key ).test( ref ) )
+            ).distinct().collect( Collectors.toList() )
+        );
     }
 
-    /**
-     * Lookup first ServiceReference matching the given Type.
-     *
-     * <p>Type lookup is done lazily and cached.</p>
-     *
-     * <p>See {@link #lookupServiceReferences(Type)}.</p>
-     *
-     * @param <T>         Service Type
-     * @param serviceType Looked up Type
-     *
-     * @return First matching ServiceReference
-     */
     @Override
-    public <T> ServiceReference<T> lookupServiceReference( Type serviceType )
+    public ModelDescriptor lookupServiceModel( Type serviceType1 )
     {
-        @SuppressWarnings( "unchecked" )
-        ServiceReference<T> serviceReference = (ServiceReference<T>) serviceReferences.get( serviceType );
-        if( serviceReference == null )
-        {
-            // Lazily resolve ServiceReference
-            serviceReference = first( lookupServiceReferences( serviceType ) );
-            if( serviceReference != null )
-            {
-                serviceReferences.put( serviceType, serviceReference );
-            }
-        }
-
-        if( serviceReference == null )
-        {
-            throw new NoSuchServiceException( RAW_CLASS.apply( serviceType ).getName(), moduleInstance.name() );
-        }
-        return serviceReference;
+        return serviceModels.computeIfAbsent( serviceType1, key -> first( lookupServiceModels( key ) ) );
     }
 
-    /**
-     * Lookup all ServiceReferences matching the given Type.
-     *
-     * <p>Returned Iterable contains, in order, ServiceReferences that: </p>
-     *
-     * <ul>
-     * <li>exactly match the given type, in Visibility then Assembly order ;</li>
-     * <li>match a type assignable to the given type, in Visibility then Assembly order.</li>
-     * </ul>
-     *
-     * <p>Multiple <b>exact</b> matches with the same Visibility are <b>allowed</b> to enable polymorphic lookup/injection.</p>
-     * <p>Multiple <b>assignable</b> matches with the same Visibility are <b>allowed</b> for the very same reason.</p>
-     *
-     * <p>Type lookup is done lazily and cached.</p>
-     *
-     * @param <T>  Service Type
-     * @param type Looked up Type
-     *
-     * @return All matching ServiceReferences
-     */
     @Override
-    public <T> List<ServiceReference<T>> lookupServiceReferences( final Type type )
+    public List<? extends ModelDescriptor> lookupServiceModels( Type type1 )
     {
-        List<ServiceReference<?>> serviceRefs = servicesReferences.get( type );
-        if( serviceRefs == null )
+        return servicesReferences.computeIfAbsent( type1, type ->
         {
-            serviceRefs = concat(
-                allServices()
-                    .filter( new ExactTypeMatching<>( type  ) ),
-                allServices()
-                    .filter( new AssignableFromTypeMatching<>( type )
-                    )
-            ).distinct().collect( Collectors.toList() );
-            servicesReferences.put( type, serviceRefs );
-        }
-        List<ServiceReference<T>> result = new ArrayList<>();
-        //noinspection unchecked
-        serviceRefs.forEach( ref -> result.add( (ServiceReference<T>) ref ) );
-        return result;
+            List<ModelDescriptor> models =
+                allServices().filter(
+                    new ExactTypeMatching<>( type ).or( new AssignableFromTypeMatching<>( type ) )
+                )
+                    .distinct()
+                    .collect( Collectors.toList() );
+
+            // TODO: Needed??
+//            List<T> result = new ArrayList<>();
+//            //noinspection unchecked
+//            serviceRefs.forEach( descriptor -> result.add( (T) descriptor ) );
+
+            return models;
+        } );
     }
 
     @Override
     public Stream<Class<?>> allVisibleObjects()
     {
-        return allObjects().flatMap( model -> model.model().types() );
+        return allObjects().flatMap( HasTypes::types );
     }
 
     @Override
-    public Stream<ModelModule<ObjectDescriptor>> allObjects()
+    public Stream<? extends ObjectDescriptor> allObjects()
     {
-        return concat( moduleInstance.visibleObjects( module ),
+        return concat( moduleModel.objects(),
                        concat(
-                           moduleInstance.layerInstance().visibleObjects( layer ),
                            concat(
-                               moduleInstance.layerInstance().visibleObjects( application ),
-                               moduleInstance.layerInstance().usedLayersInstance().visibleObjects()
-                           )
+                               moduleModel.layer().visibleObjects( layer ),
+                               moduleModel.layer().visibleObjects( application )
+                           ),
+                           moduleModel.layer()
+                               .usedLayers()
+                               .layers()
+                               .flatMap( layer -> layer.visibleObjects( application ) )
                        )
         );
     }
 
     @Override
-    public Stream<ModelModule<TransientDescriptor>> allTransients()
+    public Stream<? extends TransientDescriptor> allTransients()
     {
-        return concat( moduleInstance.visibleTransients( module ),
+        return concat( moduleModel.transientComposites(),
                        concat(
-                           moduleInstance.layerInstance().visibleTransients( layer ),
                            concat(
-                               moduleInstance.layerInstance().visibleTransients( application ),
-                               moduleInstance.layerInstance().usedLayersInstance().visibleTransients()
-                           )
+                               moduleModel.layer().visibleTransients( layer ),
+                               moduleModel.layer().visibleTransients( application )
+                           ),
+                           moduleModel.layer()
+                               .usedLayers()
+                               .layers()
+                               .flatMap( layer -> layer.visibleTransients( application ) )
                        )
         );
     }
 
     @Override
-    public Stream<ModelModule<ValueDescriptor>> allValues()
+    public Stream<? extends ValueDescriptor> allValues()
     {
-        return concat( moduleInstance.visibleValues( module ),
+
+        return concat( moduleModel.valueComposites(),
                        concat(
-                           moduleInstance.layerInstance().visibleValues( layer ),
-                           concat(
-                               moduleInstance.layerInstance().visibleValues( application ),
-                               moduleInstance.layerInstance().usedLayersInstance().visibleValues()
-                           )
+                           concat( moduleModel.layer().visibleValues( layer ),
+                                   moduleModel.layer().visibleValues( application )
+                           ),
+                           moduleModel.layer()
+                               .usedLayers()
+                               .layers()
+                               .flatMap( layer1 -> layer1.visibleValues( application ) )
                        )
         );
     }
 
     @Override
-    public Stream<ModelModule<EntityDescriptor>> allEntities()
+    public Stream<? extends EntityDescriptor> allEntities()
     {
-        return concat( moduleInstance.visibleEntities( module ),
+        return concat( moduleModel.entityComposites(),
                        concat(
-                           moduleInstance.layerInstance().visibleEntities( layer ),
                            concat(
-                               moduleInstance.layerInstance().visibleEntities( application ),
-                               moduleInstance.layerInstance().usedLayersInstance().visibleEntities()
-                           )
+                               moduleModel.layer().visibleEntities( layer ),
+                               moduleModel.layer().visibleEntities( application )
+                           ),
+                           moduleModel.layer()
+                               .usedLayers()
+                               .layers()
+                               .flatMap( layer -> layer.visibleEntities( application ) )
                        )
         );
     }
 
     @Override
-    public Stream<ServiceReference<?>> allServices()
+    public Stream<? extends ModelDescriptor> allServices()
     {
-        return concat( moduleInstance.visibleServices( module ),
-                       concat(
-                           moduleInstance.layerInstance().visibleServices( layer ),
-                           concat(
-                               moduleInstance.layerInstance().visibleServices( application ),
-                               moduleInstance.layerInstance().usedLayersInstance().visibleServices()
-                           )
-                       )
-        );
+        Stream<? extends ModelDescriptor> managedServices =
+            concat( moduleModel.serviceComposites(),
+                    concat(
+                        concat(
+                            moduleModel.layer()
+                                .visibleServices( layer ),
+                            moduleModel.layer()
+                                .visibleServices( application )
+                        ),
+                        moduleModel.layer()
+                            .usedLayers()
+                            .layers()
+                            .flatMap( layer -> layer.visibleServices( application ) )
+                    )
+            );
+        Stream<? extends ModelDescriptor> importedServices =
+            concat( moduleModel.serviceComposites(),
+                    concat(
+                        concat(
+                            moduleModel.layer()
+                                .visibleServices( layer ),
+                            moduleModel.layer()
+                                .visibleServices( application )
+                        ),
+                        moduleModel.layer()
+                            .usedLayers()
+                            .layers()
+                            .flatMap( layer -> layer.visibleServices( application ) )
+                    )
+            );
+        return concat( managedServices, importedServices );
     }
 
-    private <T extends ModelDescriptor> ModelModule<T> ambiguityMatching(
+    private <T extends ModelDescriptor> T ambiguityMatching(
         Class type,
-        List<ModelModule<T>> modelModules,
+        List<T> modelModules,
         TypeMatching<T> matching
     )
     {
-        List<ModelModule<T>> models = modelModules.stream()
-            .filter( ref -> matching.test( ref.model() ) )
+        List<T> models = modelModules.stream()
+            .filter( matching )
             .filter( new SameVisibility<>() )
             .distinct()
             .collect( Collectors.toList() );
@@ -520,19 +479,19 @@ public class TypeLookupImpl
      * This Predicate will filter out all Models that doesn't have the same visisbility as the first one.
      */
     private class SameVisibility<T extends ModelDescriptor>
-        implements Predicate<ModelModule<T>>
+        implements Predicate<T>
     {
         private Visibility current = null;
 
         @Override
-        public boolean test( ModelModule<T> model )
+        public boolean test( T model )
         {
             if( current == null )
             {
-                current = model.model().visibility();
+                current = model.visibility();
                 return true;
             }
-            return current == model.model().visibility();
+            return current == model.visibility();
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersInstance.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersInstance.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersInstance.java
index ebf4b9c..7d1df94 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersInstance.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersInstance.java
@@ -17,50 +17,51 @@ package org.apache.zest.runtime.structure;
 import java.util.List;
 import java.util.stream.Stream;
 import org.apache.zest.api.common.Visibility;
+import org.apache.zest.api.composite.ModelDescriptor;
 import org.apache.zest.api.composite.TransientDescriptor;
 import org.apache.zest.api.entity.EntityDescriptor;
 import org.apache.zest.api.object.ObjectDescriptor;
 import org.apache.zest.api.service.ServiceReference;
+import org.apache.zest.api.structure.LayerDescriptor;
 import org.apache.zest.api.value.ValueDescriptor;
-import org.apache.zest.spi.structure.ModelModule;
 
 /**
  * JAVADOC
  */
 public final class UsedLayersInstance
 {
-    private final List<LayerInstance> usedLayerInstances;
+    private final List<LayerDescriptor> usedLayerInstances;
 
-    public UsedLayersInstance( List<LayerInstance> usedLayerInstances )
+    public UsedLayersInstance( List<LayerDescriptor> usedLayerInstances )
     {
         this.usedLayerInstances = usedLayerInstances;
     }
 
-    /* package */ Stream<ModelModule<ObjectDescriptor>> visibleObjects()
+    Stream<? extends ObjectDescriptor> visibleObjects()
     {
         return usedLayerInstances.stream()
             .flatMap( layerInstance -> layerInstance.visibleObjects( Visibility.application ) );
     }
 
-    /* package */ Stream<ModelModule<TransientDescriptor>> visibleTransients()
+    Stream<? extends TransientDescriptor> visibleTransients()
     {
         return usedLayerInstances.stream()
             .flatMap( layerInstance -> layerInstance.visibleTransients( Visibility.application ) );
     }
 
-    /* package */ Stream<ModelModule<EntityDescriptor>> visibleEntities()
+    Stream<? extends EntityDescriptor> visibleEntities()
     {
         return usedLayerInstances.stream()
             .flatMap( layerInstance -> layerInstance.visibleEntities( Visibility.application ) );
     }
 
-    /* package */ Stream<ModelModule<ValueDescriptor>> visibleValues()
+    Stream<? extends ValueDescriptor> visibleValues()
     {
         return usedLayerInstances.stream()
             .flatMap( layerInstance -> layerInstance.visibleValues( Visibility.application ) );
     }
 
-    /* package */ Stream<ServiceReference<?>> visibleServices()
+    Stream<? extends ModelDescriptor> visibleServices()
     {
         return usedLayerInstances.stream()
             .flatMap( layerInstance -> layerInstance.visibleServices( Visibility.application ) );

http://git-wip-us.apache.org/repos/asf/zest-java/blob/dedb068e/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersModel.java
----------------------------------------------------------------------
diff --git a/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersModel.java b/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersModel.java
index 1f098a9..a00c53e 100644
--- a/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersModel.java
+++ b/core/runtime/src/main/java/org/apache/zest/runtime/structure/UsedLayersModel.java
@@ -15,6 +15,8 @@
 package org.apache.zest.runtime.structure;
 
 import java.util.List;
+import java.util.stream.Stream;
+import org.apache.zest.api.structure.LayerDescriptor;
 import org.apache.zest.api.structure.UsedLayersDescriptor;
 import org.apache.zest.functional.HierarchicalVisitor;
 import org.apache.zest.functional.VisitableHierarchy;
@@ -33,9 +35,9 @@ public final class UsedLayersModel
     }
 
     @Override
-    public Iterable<LayerModel> layers()
+    public Stream<? extends LayerDescriptor> layers()
     {
-        return usedLayers;
+        return usedLayers.stream();
     }
 
     @Override
@@ -56,7 +58,7 @@ public final class UsedLayersModel
         return visitor.visitLeave( this );
     }
 
-    public UsedLayersInstance newInstance( List<LayerInstance> usedLayerInstances )
+    public UsedLayersInstance newInstance( List<LayerDescriptor> usedLayerInstances )
     {
         return new UsedLayersInstance( usedLayerInstances );
     }


Mime
View raw message