Changeset 5525 for jomc-modlet


Ignore:
Timestamp:
Apr 3, 2020, 4:47:22 AM (2 years ago)
Author:
Christian Schulte
Message:

o Updated to try to preserve the readability of the streams by extracting

larger lambdas.

See #75,#130,#132,#134

Location:
jomc-modlet/trunk/src/main/java/org/jomc/modlet
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • jomc-modlet/trunk/src/main/java/org/jomc/modlet/DefaultModelContext.java

    r5524 r5525  
    6161import java.util.concurrent.CopyOnWriteArraySet;
    6262import java.util.function.Function;
     63import java.util.function.Predicate;
    6364import java.util.jar.Attributes;
    6465import java.util.jar.Manifest;
     
    681682            }
    682683
     684            final Function<ModelValidator, Optional<ModelValidationReport>> toOptionalModelValidationReport =
     685                modelValidator  ->
     686            {
     687                try
     688                {
     689                    if ( isLoggable( Level.FINER ) )
     690                    {
     691                        log( Level.FINER, getMessage( "validatingModel", model.getIdentifier(),
     692                                                      modelValidator.toString() ), null );
     693
     694                    }
     695
     696                    return Objects.requireNonNull( modelValidator.validateModel( DefaultModelContext.this, cloned ),
     697                                                   modelValidator.toString() );
     698
     699                }
     700                catch ( final ModelException e )
     701                {
     702                    throw new ValidateModelFailure( e );
     703                }
     704            };
     705
    683706            try
    684707            {
    685                 resultReport.getDetails().addAll( st0.map( modelValidator  ->
    686                 {
    687                     try
    688                     {
    689                         if ( isLoggable( Level.FINER ) )
    690                         {
    691                             log( Level.FINER, getMessage( "validatingModel", model.getIdentifier(),
    692                                                           modelValidator.toString() ), null );
    693 
    694                         }
    695 
    696                         return Objects.requireNonNull( modelValidator.validateModel( DefaultModelContext.this, cloned ),
    697                                                        modelValidator.toString() );
    698 
    699                     }
    700                     catch ( final ModelException e )
    701                     {
    702                         throw new ValidateModelFailure( e );
    703                     }
    704                 } ).filter( r  -> r.isPresent() ).
    705                     flatMap( r  -> r.get().getDetails().parallelStream().unordered() ).
    706                     collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
    707                                        {
    708                                            l1.addAll( l2 );
    709                                            return l1;
    710                                        }, Collector.Characteristics.CONCURRENT,
    711                                            Collector.Characteristics.UNORDERED ) ) );
    712 
     708                resultReport.getDetails().addAll(
     709                    st0.map( toOptionalModelValidationReport ).
     710                        filter( r  -> r.isPresent() ).
     711                        flatMap( r  -> r.get().getDetails().parallelStream().unordered() ).
     712                        collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
     713                                           {
     714                                               l1.addAll( l2 );
     715                                               return l1;
     716                                           }, Collector.Characteristics.CONCURRENT,
     717                                               Collector.Characteristics.UNORDERED ) )
     718                );
    713719            }
    714720            catch ( final ValidateModelFailure f )
     
    16511657                    }
    16521658
     1659                    final Function<Map.Entry<Object, Object>, CreateModletServiceObjectResult<T>> toResult = e  ->
     1660                    {
     1661                        try
     1662                        {
     1663                            final CreateModletServiceObjectResult<T> r = new CreateModletServiceObjectResult<>();
     1664                            final String configuration = e.getValue().toString();
     1665
     1666                            if ( isLoggable( Level.FINEST ) )
     1667                            {
     1668                                log( Level.FINEST, getMessage( "serviceInfo", platformServices.getAbsolutePath(),
     1669                                                               serviceClass.getName(), configuration ), null );
     1670
     1671                            }
     1672
     1673                            r.serviceKey = e.getKey().toString();
     1674                            r.serviceObject = this.createModletServiceObject( serviceClass, configuration );
     1675                            return r;
     1676                        }
     1677                        catch ( final ModelException ex )
     1678                        {
     1679                            throw new CreateModletServiceObjectFailure( ex );
     1680                        }
     1681                    };
     1682
    16531683                    try
    16541684                    {
    16551685                        sortedPlatformServices.putAll(
    16561686                            st0.filter( e  -> e.getKey().toString().startsWith( serviceNamePrefix ) ).
    1657                                 map( e  ->
    1658                                 {
    1659                                     try
    1660                                     {
    1661                                         final CreateModletServiceObjectResult<T> r =
    1662                                             new CreateModletServiceObjectResult<>();
    1663 
    1664                                         final String configuration = e.getValue().toString();
    1665 
    1666                                         if ( isLoggable( Level.FINEST ) )
    1667                                         {
    1668                                             log( Level.FINEST,
    1669                                                  getMessage( "serviceInfo", platformServices.getAbsolutePath(),
    1670                                                              serviceClass.getName(), configuration ), null );
    1671 
    1672                                         }
    1673 
    1674                                         r.serviceKey = e.getKey().toString();
    1675                                         r.serviceObject = this.createModletServiceObject( serviceClass, configuration );
    1676                                         return r;
    1677                                     }
    1678                                     catch ( final ModelException ex )
    1679                                     {
    1680                                         throw new CreateModletServiceObjectFailure( ex );
    1681                                     }
    1682                                 } ).collect( Collectors.toMap( r  -> r.serviceKey, r  -> r.serviceObject ) ) );
     1687                                map( toResult ).
     1688                                collect( Collectors.toMap( r  -> r.serviceKey, r  -> r.serviceObject ) )
     1689                        );
    16831690                    }
    16841691                    catch ( final CreateModletServiceObjectFailure f )
     
    17351742                    }
    17361743
     1744                    final Function<String, T> toModletServiceObject = line  ->
     1745                    {
     1746                        try
     1747                        {
     1748                            if ( isLoggable( Level.FINEST ) )
     1749                            {
     1750                                log( Level.FINEST, getMessage( "serviceInfo", url.toExternalForm(),
     1751                                                               serviceClass.getName(), line ), null );
     1752
     1753                            }
     1754
     1755                            return createModletServiceObject( serviceClass, line );
     1756                        }
     1757                        catch ( final ModelException e )
     1758                        {
     1759                            throw new CreateModletServiceObjectFailure( e );
     1760                        }
     1761                    };
     1762
    17371763                    try
    17381764                    {
    17391765                        sortedClasspathServices.addAll(
    17401766                            st0.filter( l  -> !l.contains( "#" ) ).
    1741                                 map( l  ->
    1742                                 {
    1743                                     try
    1744                                     {
    1745                                         if ( isLoggable( Level.FINEST ) )
    1746                                         {
    1747                                             log( Level.FINEST, getMessage( "serviceInfo", url.toExternalForm(),
    1748                                                                            serviceClass.getName(), l ), null );
    1749 
    1750                                         }
    1751 
    1752                                         return this.createModletServiceObject( serviceClass, l );
    1753                                     }
    1754                                     catch ( final ModelException e )
    1755                                     {
    1756                                         throw new CreateModletServiceObjectFailure( e );
    1757                                     }
    1758                                 } ).collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
    1759                                                        {
    1760                                                            l1.addAll( l2 );
    1761                                                            return l1;
    1762                                                        }, Collector.Characteristics.CONCURRENT,
    1763                                                            Collector.Characteristics.UNORDERED ) ) );
     1767                                map( toModletServiceObject ).
     1768                                collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
     1769                                                   {
     1770                                                       l1.addAll( l2 );
     1771                                                       return l1;
     1772                                                   }, Collector.Characteristics.CONCURRENT,
     1773                                                       Collector.Characteristics.UNORDERED ) )
     1774                        );
    17641775
    17651776                        Collections.sort( sortedClasspathServices, ( o1, o2 )  -> ordinalOf( o1 ) - ordinalOf( o2 ) );
     
    19151926                    } );
    19161927
     1928                    final Predicate<Map.Entry<String, Attributes>> schemaExtension = entry  ->
     1929                    {
     1930                        try ( final Stream<String> st1 =
     1931                            Arrays.asList( SCHEMA_EXTENSIONS ).parallelStream().unordered() )
     1932                        {
     1933                            final boolean found = st1.filter( ext  -> parallelToLowerCase.apply( entry.getKey() ).
     1934                                endsWith( '.' + parallelToLowerCase.apply( ext ) ) ).findAny().isPresent();
     1935
     1936                            if ( found && isLoggable( Level.FINEST ) )
     1937                            {
     1938                                log( Level.FINEST, getMessage( "foundSchemaCandidate", entry.getKey() ), null );
     1939                            }
     1940
     1941                            return found;
     1942                        }
     1943                    };
     1944
     1945                    final Function<Map.Entry<String, Attributes>, URI> toUri = entry  ->
     1946                    {
     1947                        try
     1948                        {
     1949                            return new URL( baseUrl + entry.getKey() ).toURI();
     1950                        }
     1951                        catch ( final MalformedURLException | URISyntaxException ex )
     1952                        {
     1953                            throw new CreateUriFailure( ex );
     1954                        }
     1955                    };
     1956
    19171957                    try
    19181958                    {
    1919                         st0.filter( entry  ->
    1920                         {
    1921                             try ( final Stream<String> st2 =
    1922                                 Arrays.asList( SCHEMA_EXTENSIONS ).parallelStream().unordered() )
    1923                             {
    1924                                 final boolean found = st2.filter( ext  -> parallelToLowerCase.apply( entry.getKey() ).
    1925                                     endsWith( '.' + parallelToLowerCase.apply( ext ) ) ).findAny().isPresent();
    1926 
    1927                                 if ( found && isLoggable( Level.FINEST ) )
    1928                                 {
    1929                                     log( Level.FINEST, getMessage( "foundSchemaCandidate", entry.getKey() ), null );
    1930                                 }
    1931 
    1932                                 return found;
    1933                             }
    1934                         } ).map( entry  ->
    1935                         {
    1936                             try
    1937                             {
    1938                                 return new URL( baseUrl + entry.getKey() ).toURI();
    1939                             }
    1940                             catch ( final MalformedURLException | URISyntaxException ex )
    1941                             {
    1942                                 throw new CreateUriFailure( ex );
    1943                             }
    1944                         } ).collect( Collector.of( CopyOnWriteArraySet::new, Set::add, ( s1, s2 )  ->
    1945                                                {
    1946                                                    s1.addAll( s2 );
    1947                                                    return s2;
    1948                                                }, Collector.Characteristics.CONCURRENT,
    1949                                                    Collector.Characteristics.UNORDERED ) );
    1950 
     1959                        resources.addAll(
     1960                            st0.filter( schemaExtension ).
     1961                                map( toUri ).
     1962                                collect( Collector.of( CopyOnWriteArraySet::new, Set::add, ( s1, s2 )  ->
     1963                                                   {
     1964                                                       s1.addAll( s2 );
     1965                                                       return s2;
     1966                                                   }, Collector.Characteristics.CONCURRENT,
     1967                                                       Collector.Characteristics.UNORDERED ) )
     1968                        );
    19511969                    }
    19521970                    catch ( final CreateUriFailure f )
  • jomc-modlet/trunk/src/main/java/org/jomc/modlet/DefaultModletProcessor.java

    r5524 r5525  
    463463            }
    464464
     465            final Function<URL, Transformer> toTransformer = url  ->
     466            {
     467                try
     468                {
     469                    TransformerFactory transformerFactory = threadLocalTransformerFactory.get();
     470                    if ( transformerFactory == null )
     471                    {
     472                        transformerFactory = TransformerFactory.newInstance();
     473                        transformerFactory.setErrorListener( errorListener );
     474                        threadLocalTransformerFactory.set( transformerFactory );
     475                    }
     476
     477                    if ( context.isLoggable( Level.FINEST ) )
     478                    {
     479                        context.log( Level.FINEST, getMessage( "processing", url.toExternalForm() ), null );
     480                    }
     481
     482                    final Transformer transformer =
     483                        transformerFactory.newTransformer( new StreamSource( url.toURI().toASCIIString() ) );
     484
     485                    transformer.setErrorListener( errorListener );
     486
     487                    parameters.entrySet().forEach( e  ->
     488                    {
     489                        transformer.setParameter( e.getKey().toString(), e.getValue() );
     490                    } );
     491
     492                    return transformer;
     493                }
     494                catch ( final TransformerConfigurationException | URISyntaxException e )
     495                {
     496                    throw new CreateTransformerFailure( e );
     497                }
     498            };
     499
    465500            try
    466501            {
    467502                transformers.addAll(
    468                     st0.map( url  ->
    469                     {
    470                         try
    471                         {
    472                             TransformerFactory transformerFactory = threadLocalTransformerFactory.get();
    473                             if ( transformerFactory == null )
    474                             {
    475                                 transformerFactory = TransformerFactory.newInstance();
    476                                 transformerFactory.setErrorListener( errorListener );
    477                                 threadLocalTransformerFactory.set( transformerFactory );
    478                             }
    479 
    480                             if ( context.isLoggable( Level.FINEST ) )
    481                             {
    482                                 context.log( Level.FINEST, getMessage( "processing", url.toExternalForm() ), null );
    483                             }
    484 
    485                             final Transformer transformer =
    486                                 transformerFactory.newTransformer( new StreamSource( url.toURI().toASCIIString() ) );
    487 
    488                             transformer.setErrorListener( errorListener );
    489 
    490                             parameters.entrySet().forEach( e  ->
    491                             {
    492                                 transformer.setParameter( e.getKey().toString(), e.getValue() );
    493                             } );
    494 
    495                             return transformer;
    496                         }
    497                         catch ( final TransformerConfigurationException | URISyntaxException e )
    498                         {
    499                             throw new CreateTransformerFailure( e );
    500                         }
    501                     } ).collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
     503                    st0.map( toTransformer ).
     504                        collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
    502505                                           {
    503506                                               l1.addAll( l2 );
    504507                                               return l1;
    505508                                           }, Collector.Characteristics.CONCURRENT,
    506                                                Collector.Characteristics.UNORDERED ) ) );
    507 
     509                                               Collector.Characteristics.UNORDERED ) )
     510                );
    508511            }
    509512            catch ( final CreateTransformerFailure f )
  • jomc-modlet/trunk/src/main/java/org/jomc/modlet/DefaultModletProvider.java

    r5524 r5525  
    571571            }
    572572
     573            final Function<URL, Modlets> toModlets = url  ->
     574            {
     575                try
     576                {
     577                    final Modlets result = new Modlets();
     578
     579                    Unmarshaller unmarshaller = threadLocalUnmarshaller.get();
     580                    if ( unmarshaller == null )
     581                    {
     582                        unmarshaller = ctx.createUnmarshaller();
     583                        unmarshaller.setSchema( schema );
     584
     585                        threadLocalUnmarshaller.set( unmarshaller );
     586                    }
     587
     588                    Object content = unmarshaller.unmarshal( url );
     589
     590                    if ( content instanceof JAXBElement<?> )
     591                    {
     592                        content = ( (JAXBElement<?>) content ).getValue();
     593                    }
     594
     595                    if ( content instanceof Modlet )
     596                    {
     597                        result.getModlet().add( (Modlet) content );
     598                    }
     599                    else if ( content instanceof Modlets )
     600                    {
     601                        result.getModlet().addAll( ( (Modlets) content ).getModlet() );
     602                    }
     603
     604                    return result;
     605                }
     606                catch ( final JAXBException e )
     607                {
     608                    throw new UnmarshalFailure( url, e );
     609                }
     610            };
     611
    573612            try
    574613            {
    575                 modlets.getModlet().addAll( st0.map( url  ->
    576                 {
    577                     try
    578                     {
    579                         final Modlets result = new Modlets();
    580 
    581                         Unmarshaller unmarshaller = threadLocalUnmarshaller.get();
    582                         if ( unmarshaller == null )
    583                         {
    584                             unmarshaller = ctx.createUnmarshaller();
    585                             unmarshaller.setSchema( schema );
    586 
    587                             threadLocalUnmarshaller.set( unmarshaller );
    588                         }
    589 
    590                         Object content = unmarshaller.unmarshal( url );
    591 
    592                         if ( content instanceof JAXBElement<?> )
    593                         {
    594                             content = ( (JAXBElement<?>) content ).getValue();
    595                         }
    596 
    597                         if ( content instanceof Modlet )
    598                         {
    599                             result.getModlet().add( (Modlet) content );
    600                         }
    601                         else if ( content instanceof Modlets )
    602                         {
    603                             result.getModlet().addAll( ( (Modlets) content ).getModlet() );
    604                         }
    605 
    606                         return result;
    607                     }
    608                     catch ( final JAXBException e )
    609                     {
    610                         throw new UnmarshalFailure( url, e );
    611                     }
    612                 } ).flatMap( m  -> m.getModlet().parallelStream().unordered() ).
    613                     collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
    614                                        {
    615                                            l1.addAll( l2 );
    616                                            return l1;
    617                                        }, Collector.Characteristics.CONCURRENT,
    618                                            Collector.Characteristics.UNORDERED ) ) );
    619 
     614                modlets.getModlet().addAll(
     615                    st0.map( toModlets ).
     616                        flatMap( m  -> m.getModlet().parallelStream().unordered() ).
     617                        collect( Collector.of( CopyOnWriteArrayList::new, List::add, ( l1, l2 )  ->
     618                                           {
     619                                               l1.addAll( l2 );
     620                                               return l1;
     621                                           }, Collector.Characteristics.CONCURRENT,
     622                                               Collector.Characteristics.UNORDERED ) )
     623                );
    620624            }
    621625            catch ( final UnmarshalFailure f )
Note: See TracChangeset for help on using the changeset viewer.