001    // SECTION-START[License Header]
002    // <editor-fold defaultstate="collapsed" desc=" Generated License ">
003    /*
004     *   jDTAUS
005     *   Copyright (C) Christian Schulte, 2012-039
006     *
007     *   This program is free software: you can redistribute it and/or modify
008     *   it under the terms of the GNU Lesser General Public License as published
009     *   by the Free Software Foundation, either version 2.1 of the License, or
010     *   (at your option) any later version.
011     *
012     *   This program is distributed in the hope that it will be useful,
013     *   but WITHOUT ANY WARRANTY; without even the implied warranty of
014     *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
015     *   GNU General Public License for more details.
016     *
017     *   You should have received a copy of the GNU Lesser General Public License
018     *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
019     *
020     *   $JDTAUS: ModelModelProvider.java 8518 2012-04-02 20:55:41Z schulte2005 $
021     *
022     */
023    // </editor-fold>
024    // SECTION-END
025    package org.jdtaus.core.container.ri.jomc;
026    
027    import java.util.HashSet;
028    import java.util.Locale;
029    import java.util.Set;
030    import org.jomc.model.Argument;
031    import org.jomc.model.ArgumentType;
032    import org.jomc.model.Arguments;
033    import org.jomc.model.Dependencies;
034    import org.jomc.model.Dependency;
035    import org.jomc.model.Implementation;
036    import org.jomc.model.ImplementationReference;
037    import org.jomc.model.Implementations;
038    import org.jomc.model.InheritanceModel;
039    import org.jomc.model.Message;
040    import org.jomc.model.MessageReference;
041    import org.jomc.model.Messages;
042    import org.jomc.model.Module;
043    import org.jomc.model.Modules;
044    import org.jomc.model.Multiplicity;
045    import org.jomc.model.Properties;
046    import org.jomc.model.Property;
047    import org.jomc.model.Specification;
048    import org.jomc.model.SpecificationReference;
049    import org.jomc.model.Specifications;
050    import org.jomc.model.Text;
051    import org.jomc.model.Texts;
052    import org.jomc.model.modlet.ModelHelper;
053    import org.jomc.modlet.Model;
054    import org.jomc.modlet.ModelContext;
055    import org.jomc.modlet.ModelException;
056    
057    // SECTION-START[Documentation]
058    // <editor-fold defaultstate="collapsed" desc=" Generated Documentation ">
059    /**
060     * JOMC {@code ModelProvider} providing the jDTAUS {@code Model}.
061     *
062     * <dl>
063     *   <dt><b>Identifier:</b></dt><dd>jDTAUS Core JOMC Container :: Model ModelProvider</dd>
064     *   <dt><b>Name:</b></dt><dd>jDTAUS Core JOMC Container :: Model ModelProvider</dd>
065     *   <dt><b>Specifications:</b></dt>
066     *     <dd>org.jomc.modlet.ModelProvider</dd>
067     *   <dt><b>Abstract:</b></dt><dd>No</dd>
068     *   <dt><b>Final:</b></dt><dd>No</dd>
069     *   <dt><b>Stateless:</b></dt><dd>No</dd>
070     * </dl>
071     *
072     * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 1.0
073     * @version 1.11
074     */
075    // </editor-fold>
076    // SECTION-END
077    // SECTION-START[Annotations]
078    // <editor-fold defaultstate="collapsed" desc=" Generated Annotations ">
079    @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.3", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.3" )
080    // </editor-fold>
081    // SECTION-END
082    public class ModelModelProvider
083        implements
084        org.jomc.modlet.ModelProvider
085    {
086        // SECTION-START[ModelProvider]
087    
088        /** Name of the system property controlling the use of the context class loader. */
089        private static final String CONTEXT_CLASSLOADER_PROPERTY_NAME =
090            "org.jdtaus.core.container.ClassLoaderFactory.enableContextClassloader";
091    
092        @Override
093        public Model findModel( final ModelContext context, final Model model ) throws NullPointerException, ModelException
094        {
095            Model provided = null;
096            final String sys = System.getProperty( CONTEXT_CLASSLOADER_PROPERTY_NAME );
097            final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
098    
099            try
100            {
101                System.setProperty( CONTEXT_CLASSLOADER_PROPERTY_NAME, Boolean.TRUE.toString() );
102                Thread.currentThread().setContextClassLoader( context.getClassLoader() );
103    
104                final Modules modules = transformModules( org.jdtaus.core.container.ModelFactory.getModel().getModules() );
105    
106                if ( modules != null )
107                {
108                    applyInheritanceAttributes( modules );
109                    provided = model.clone();
110                    ModelHelper.addModules( provided, modules );
111                }
112    
113                return provided;
114            }
115            finally
116            {
117                Thread.currentThread().setContextClassLoader( classLoader );
118    
119                if ( sys != null )
120                {
121                    System.setProperty( CONTEXT_CLASSLOADER_PROPERTY_NAME, sys );
122                }
123                else
124                {
125                    System.clearProperty( CONTEXT_CLASSLOADER_PROPERTY_NAME );
126                }
127            }
128        }
129    
130        // SECTION-END
131        // SECTION-START[ModelModelProvider]
132        private static Modules transformModules( final org.jdtaus.core.container.Modules jdtausModules )
133        {
134            Modules modules = null;
135    
136            if ( jdtausModules != null )
137            {
138                modules = new Modules();
139    
140                for ( int i = 0, s0 = jdtausModules.size(); i < s0; i++ )
141                {
142                    final org.jdtaus.core.container.Module jdtausModule = jdtausModules.getModule( i );
143    
144                    if ( !org.jdtaus.core.container.Model.class.getName().equals( jdtausModule.getName() ) )
145                    { // Skip platform module.
146                        modules.getModule().add( transformModule( jdtausModule ) );
147                    }
148                }
149            }
150    
151            return modules;
152        }
153    
154        private static Module transformModule( final org.jdtaus.core.container.Module jdtausModule )
155        {
156            Module module = null;
157    
158            if ( jdtausModule != null )
159            {
160                module = new Module();
161                module.setDocumentation( transformText( jdtausModule.getDocumentation() ) );
162                module.setName( jdtausModule.getName() );
163                module.setVersion( jdtausModule.getVersion() );
164                module.setSpecifications( transformSpecifications( jdtausModule.getSpecifications() ) );
165                module.setImplementations( transformImplementations( jdtausModule.getImplementations() ) );
166            }
167    
168            return module;
169        }
170    
171        private static Implementations transformImplementations(
172            final org.jdtaus.core.container.Implementations jdtausImplementations )
173        {
174            Implementations implementations = null;
175    
176            if ( jdtausImplementations != null )
177            {
178                implementations = new Implementations();
179                implementations.setDocumentation( transformText( jdtausImplementations.getDocumentation() ) );
180    
181                for ( int i = 0, s0 = jdtausImplementations.size(); i < s0; i++ )
182                {
183                    implementations.getImplementation().add( transformImplementation(
184                        jdtausImplementations.getImplementation( i ) ) );
185    
186                }
187            }
188    
189            return implementations;
190        }
191    
192        private static Implementation transformImplementation(
193            final org.jdtaus.core.container.Implementation jdtausImplementation )
194        {
195            final Implementation implementation = new Implementation();
196            implementation.setIdentifier( jdtausImplementation.getIdentifier() );
197            implementation.setClazz( jdtausImplementation.getIdentifier() );
198            implementation.setClassDeclaration( Boolean.TRUE );
199            implementation.setFinal( jdtausImplementation.isFinal() );
200            implementation.setName( jdtausImplementation.getName() );
201            implementation.setVendor( jdtausImplementation.getVendor() );
202            implementation.setVersion( jdtausImplementation.getVersion() );
203            implementation.setDocumentation( transformText( jdtausImplementation.getDocumentation() ) );
204            implementation.setProperties( transformProperties( jdtausImplementation.getDeclaredProperties() ) );
205            implementation.setMessages( transformMessages( jdtausImplementation.getDeclaredMessages() ) );
206            implementation.setDependencies( transformDependencies( jdtausImplementation.getDeclaredDependencies() ) );
207            implementation.setSpecifications( transformSpecificationReferences(
208                jdtausImplementation.getImplementedSpecifications() ) );
209    
210            // The jDTAUS Container has no support for synchronising object accesses. This ensures the state management of
211            // the JOMC ObjectManager is in effect.
212            implementation.setStateless( Boolean.FALSE );
213    
214            if ( jdtausImplementation.getParent() != null )
215            {
216                final Implementations references = new Implementations();
217                implementation.setImplementations( references );
218    
219                final ImplementationReference reference = new ImplementationReference();
220                references.getReference().add( reference );
221    
222                reference.setIdentifier( jdtausImplementation.getParent().getIdentifier() );
223                reference.setVersion( jdtausImplementation.getParent().getVersion() );
224            }
225    
226            return implementation;
227        }
228    
229        private static Specifications transformSpecifications(
230            final org.jdtaus.core.container.Specifications jdtausSpecifications )
231        {
232            Specifications specifications = null;
233    
234            if ( jdtausSpecifications != null )
235            {
236                specifications = new Specifications();
237                specifications.setDocumentation( transformText( jdtausSpecifications.getDocumentation() ) );
238    
239                for ( int i = 0, s0 = jdtausSpecifications.size(); i < s0; i++ )
240                {
241                    specifications.getSpecification().add( transformSpecification(
242                        jdtausSpecifications.getSpecification( i ) ) );
243    
244                }
245            }
246    
247            return specifications;
248        }
249    
250        private static Specifications transformSpecificationReferences(
251            final org.jdtaus.core.container.Specifications jdtausSpecifications )
252        {
253            Specifications specifications = null;
254    
255            if ( jdtausSpecifications != null )
256            {
257                specifications = new Specifications();
258                specifications.setDocumentation( transformText( jdtausSpecifications.getDocumentation() ) );
259    
260                for ( int i = 0, s0 = jdtausSpecifications.size(); i < s0; i++ )
261                {
262                    final SpecificationReference specificationReference = new SpecificationReference();
263                    specificationReference.setIdentifier( jdtausSpecifications.getSpecification( i ).getIdentifier() );
264                    specificationReference.setVersion( jdtausSpecifications.getSpecification( i ).getVersion() );
265                    specifications.getReference().add( specificationReference );
266                }
267            }
268    
269            return specifications;
270        }
271    
272        private static Specification transformSpecification(
273            final org.jdtaus.core.container.Specification jdtausSpecification )
274        {
275            final Specification specification = new Specification();
276            specification.setClassDeclaration( Boolean.TRUE );
277            specification.setClazz( jdtausSpecification.getIdentifier() );
278            specification.setIdentifier( jdtausSpecification.getIdentifier() );
279            specification.setVendor( jdtausSpecification.getVendor() );
280            specification.setVersion( jdtausSpecification.getVersion() );
281            specification.setDocumentation( transformText( jdtausSpecification.getDocumentation() ) );
282    
283            switch ( jdtausSpecification.getMultiplicity() )
284            {
285                case org.jdtaus.core.container.Specification.MULTIPLICITY_MANY:
286                    specification.setMultiplicity( Multiplicity.MANY );
287                    break;
288                case org.jdtaus.core.container.Specification.MULTIPLICITY_ONE:
289                    specification.setMultiplicity( Multiplicity.ONE );
290                    break;
291                default:
292    
293            }
294    
295            switch ( jdtausSpecification.getScope() )
296            {
297                case org.jdtaus.core.container.Specification.SCOPE_CONTEXT:
298                    specification.setScope( "jDTAUS Context" );
299                    break;
300    
301                case org.jdtaus.core.container.Specification.SCOPE_SINGLETON:
302                    specification.setScope( "Singleton" );
303                    break;
304                default:
305    
306            }
307    
308            specification.setProperties( transformProperties( jdtausSpecification.getProperties() ) );
309            return specification;
310        }
311    
312        private static Texts transformText( final org.jdtaus.core.container.Text jdtausText )
313        {
314            Texts texts = null;
315    
316            if ( jdtausText != null )
317            {
318                texts = new Texts();
319    
320                for ( final Locale locale : jdtausText.getLocales() )
321                {
322                    final Text text = new Text();
323                    text.setLanguage( locale.getLanguage() );
324                    text.setValue( jdtausText.getValue( locale ) );
325                    texts.getText().add( text );
326    
327                    if ( text.getValue().equals( jdtausText.getValue() ) )
328                    {
329                        texts.setDefaultLanguage( locale.getLanguage() );
330                    }
331                }
332    
333                if ( texts.getText().isEmpty() )
334                {
335                    texts = null;
336                }
337            }
338    
339            return texts;
340        }
341    
342        private static Properties transformProperties( final org.jdtaus.core.container.Properties jdtausProperties )
343        {
344            Properties properties = null;
345    
346            if ( jdtausProperties != null )
347            {
348                properties = new Properties();
349                properties.setDocumentation( transformText( jdtausProperties.getDocumentation() ) );
350    
351                for ( int i = 0, s0 = jdtausProperties.size(); i < s0; i++ )
352                {
353                    properties.getProperty().add( transformProperty( jdtausProperties.getProperty( i ) ) );
354                }
355            }
356    
357            return properties;
358        }
359    
360        private static Property transformProperty( final org.jdtaus.core.container.Property jdtausProperty )
361        {
362            Property property = null;
363    
364            if ( jdtausProperty != null )
365            {
366                property = new Property();
367                property.setDocumentation( transformText( jdtausProperty.getDocumentation() ) );
368                property.setName( jdtausProperty.getName() );
369                property.setFinal( Boolean.FALSE );
370                property.setOverride( Boolean.FALSE );
371                property.setType( jdtausProperty.getType().getName() );
372    
373                if ( jdtausProperty.getValue() != null )
374                {
375                    property.setValue( jdtausProperty.getValue().toString() );
376                }
377                else if ( jdtausProperty.isApi() )
378                {
379                    if ( Byte.TYPE.equals( jdtausProperty.getType() )
380                         || Short.TYPE.equals( jdtausProperty.getType() )
381                         || Integer.TYPE.equals( jdtausProperty.getType() )
382                         || Long.TYPE.equals( jdtausProperty.getType() )
383                         || Float.TYPE.equals( jdtausProperty.getType() )
384                         || Double.TYPE.equals( jdtausProperty.getType() ) )
385                    {
386                        property.setValue( "0" );
387                    }
388                    else
389                    {
390                        property.setValue( "" );
391                    }
392                }
393            }
394    
395            return property;
396        }
397    
398        private static Messages transformMessages( final org.jdtaus.core.container.Messages jdtausMessages )
399        {
400            Messages messages = null;
401    
402            if ( jdtausMessages != null )
403            {
404                messages = new Messages();
405                messages.setDocumentation( transformText( jdtausMessages.getDocumentation() ) );
406    
407                for ( int i = 0, s0 = jdtausMessages.size(); i < s0; i++ )
408                {
409                    messages.getMessage().add( transformMessage( jdtausMessages.getMessage( i ) ) );
410                }
411            }
412    
413            return messages;
414        }
415    
416        private static Message transformMessage( final org.jdtaus.core.container.Message jdtausMessage )
417        {
418            Message message = null;
419    
420            if ( jdtausMessage != null )
421            {
422                message = new Message();
423                message.setDocumentation( transformText( jdtausMessage.getDocumentation() ) );
424                message.setName( jdtausMessage.getName() );
425                message.setFinal( Boolean.FALSE );
426                message.setOverride( Boolean.FALSE );
427                message.setTemplate( transformText( jdtausMessage.getTemplate() ) );
428                message.setArguments( transformArguments( jdtausMessage.getArguments() ) );
429            }
430    
431            return message;
432        }
433    
434        private static Arguments transformArguments( final org.jdtaus.core.container.Arguments jdtausArguments )
435        {
436            Arguments arguments = null;
437    
438            if ( jdtausArguments != null )
439            {
440                arguments = new Arguments();
441                arguments.setDocumentation( transformText( jdtausArguments.getDocumentation() ) );
442    
443                for ( int i = 0, s0 = jdtausArguments.size(); i < s0; i++ )
444                {
445                    arguments.getArgument().add( transformArgument( jdtausArguments.getArgument( i ) ) );
446                }
447            }
448    
449            return arguments;
450        }
451    
452        private static Argument transformArgument( final org.jdtaus.core.container.Argument jdtausArgument )
453        {
454            Argument argument = null;
455    
456            if ( jdtausArgument != null )
457            {
458                argument = new Argument();
459                argument.setDocumentation( transformText( jdtausArgument.getDocumentation() ) );
460                argument.setIndex( jdtausArgument.getIndex() );
461                argument.setName( jdtausArgument.getName() );
462    
463                switch ( jdtausArgument.getType() )
464                {
465                    case org.jdtaus.core.container.Argument.TYPE_DATE:
466                        argument.setType( ArgumentType.DATE );
467                        break;
468    
469                    case org.jdtaus.core.container.Argument.TYPE_NUMBER:
470                        argument.setType( ArgumentType.NUMBER );
471                        break;
472    
473                    case org.jdtaus.core.container.Argument.TYPE_TEXT:
474                        argument.setType( ArgumentType.TEXT );
475                        break;
476                    case org.jdtaus.core.container.Argument.TYPE_TIME:
477                        argument.setType( ArgumentType.TIME );
478                        break;
479                    default:
480    
481                }
482            }
483    
484            return argument;
485        }
486    
487        private static Dependencies transformDependencies( final org.jdtaus.core.container.Dependencies jdtausDependencies )
488        {
489            Dependencies dependencies = null;
490    
491            if ( jdtausDependencies != null )
492            {
493                dependencies = new Dependencies();
494                dependencies.setDocumentation( transformText( jdtausDependencies.getDocumentation() ) );
495    
496                for ( int i = 0, s0 = jdtausDependencies.size(); i < s0; i++ )
497                {
498                    dependencies.getDependency().add( transformDependency( jdtausDependencies.getDependency( i ) ) );
499                }
500            }
501    
502            return dependencies;
503        }
504    
505        private static Dependency transformDependency( final org.jdtaus.core.container.Dependency jdtausDependency )
506        {
507            Dependency dependency = null;
508    
509            if ( jdtausDependency != null )
510            {
511                dependency = new Dependency();
512                dependency.setDocumentation( transformText( jdtausDependency.getDocumentation() ) );
513                dependency.setName( jdtausDependency.getName() );
514                dependency.setFinal( Boolean.FALSE );
515                dependency.setOverride( Boolean.FALSE );
516                dependency.setBound( jdtausDependency.isBound() );
517                dependency.setIdentifier( jdtausDependency.getSpecification().getIdentifier() );
518                dependency.setVersion( jdtausDependency.getSpecification().getVersion() );
519    
520                if ( jdtausDependency.getImplementation() != null )
521                {
522                    dependency.setImplementationName( jdtausDependency.getImplementation().getName() );
523                }
524    
525                // Cannot set to optional since the JOMC ObjectManager returns null if no implementations are found and
526                // jDTAUS implementations expect an empty array.
527                dependency.setOptional( Boolean.FALSE );
528                dependency.setProperties( transformProperties( jdtausDependency.getDeclaredProperties() ) );
529            }
530    
531            return dependency;
532        }
533    
534        private static void applyInheritanceAttributes( final Modules modules )
535        {
536            final InheritanceModel imodel = new InheritanceModel( modules );
537    
538            if ( modules.getImplementations() != null )
539            {
540                for ( int i = 0, s0 = modules.getImplementations().getImplementation().size(); i < s0; i++ )
541                {
542                    applyInheritanceAttributes(
543                        modules, imodel, modules.getImplementations().getImplementation().get( i ) );
544    
545                }
546            }
547        }
548    
549        private static void applyInheritanceAttributes( final Modules modules, final InheritanceModel imodel,
550                                                        final Implementation implementation )
551        {
552            final Set<String> dependencyNames = imodel.getDependencyNames( implementation.getIdentifier() );
553            final Set<String> messageNames = imodel.getMessageNames( implementation.getIdentifier() );
554            final Set<String> propertyNames = imodel.getPropertyNames( implementation.getIdentifier() );
555    
556            for ( final String dependencyName : dependencyNames )
557            {
558                final Set<InheritanceModel.Node<Dependency>> effDependency =
559                    imodel.getDependencyNodes( implementation.getIdentifier(), dependencyName );
560    
561                for ( final InheritanceModel.Node<Dependency> d : effDependency )
562                {
563                    if ( d.getImplementation().getIdentifier().equals( implementation.getIdentifier() )
564                         && !d.getOverriddenNodes().isEmpty() )
565                    {
566                        implementation.getDependencies().getDependency( dependencyName ).setOverride( true );
567                    }
568                }
569            }
570    
571            for ( final String messageName : messageNames )
572            {
573                final Set<InheritanceModel.Node<Message>> effMessage =
574                    imodel.getMessageNodes( implementation.getIdentifier(), messageName );
575    
576                for ( final InheritanceModel.Node<Message> m : effMessage )
577                {
578                    if ( m.getImplementation().getIdentifier().equals( implementation.getIdentifier() )
579                         && !m.getOverriddenNodes().isEmpty() )
580                    {
581                        final Message msg = implementation.getMessages().getMessage( messageName );
582                        final MessageReference ref = implementation.getMessages().getReference( messageName );
583    
584                        if ( msg != null )
585                        {
586                            msg.setOverride( true );
587                        }
588                        if ( ref != null )
589                        {
590                            ref.setOverride( true );
591                        }
592                    }
593                }
594            }
595    
596            for ( final String propertyName : propertyNames )
597            {
598                final Set<InheritanceModel.Node<Property>> effProperty =
599                    imodel.getPropertyNodes( implementation.getIdentifier(), propertyName );
600    
601                for ( final InheritanceModel.Node<Property> p : effProperty )
602                {
603                    if ( p.getImplementation().getIdentifier().equals( implementation.getIdentifier() )
604                         && !p.getOverriddenNodes().isEmpty() )
605                    {
606                        implementation.getProperties().getProperty( propertyName ).setOverride( true );
607                    }
608                }
609            }
610    
611            if ( implementation.getDependencies() != null )
612            {
613                for ( int i = 0, s0 = implementation.getDependencies().getDependency().size(); i < s0; i++ )
614                {
615                    applyInheritanceAttributes(
616                        modules, imodel, implementation.getDependencies().getDependency().get( i ) );
617    
618                }
619            }
620        }
621    
622        private static void applyInheritanceAttributes( final Modules modules, final InheritanceModel imodel,
623                                                        final Dependency dependency )
624        {
625            final Set<Implementation> implementations = new HashSet<Implementation>();
626    
627            if ( dependency.getImplementationName() != null )
628            {
629                final Implementation i = modules.getImplementation( dependency.getIdentifier(),
630                                                                    dependency.getImplementationName() );
631    
632                if ( i != null )
633                {
634                    implementations.add( i );
635                }
636            }
637            else
638            {
639                final Implementations i = modules.getImplementations( dependency.getIdentifier() );
640                if ( i != null )
641                {
642                    implementations.addAll( i.getImplementation() );
643                }
644            }
645    
646            if ( dependency.getDependencies() != null )
647            {
648                for ( int i = 0, s0 = dependency.getDependencies().getDependency().size(); i < s0; i++ )
649                {
650                    final Dependency d = dependency.getDependencies().getDependency().get( i );
651    
652                    for ( final Implementation impl : implementations )
653                    {
654                        final Set<InheritanceModel.Node<Dependency>> effDependencies =
655                            imodel.getDependencyNodes( impl.getIdentifier(), d.getName() );
656    
657                        if ( !d.isOverride() && !effDependencies.isEmpty() )
658                        {
659                            d.setOverride( true );
660                        }
661                    }
662    
663                    applyInheritanceAttributes( modules, imodel, d );
664                }
665            }
666            if ( dependency.getMessages() != null )
667            {
668                for ( int i = 0, s0 = dependency.getMessages().getMessage().size(); i < s0; i++ )
669                {
670                    final Message m = dependency.getMessages().getMessage().get( i );
671    
672                    for ( final Implementation impl : implementations )
673                    {
674                        final Set<InheritanceModel.Node<Message>> effMessages =
675                            imodel.getMessageNodes( impl.getIdentifier(), m.getName() );
676    
677                        if ( !m.isOverride() && !effMessages.isEmpty() )
678                        {
679                            m.setOverride( true );
680                        }
681                    }
682                }
683            }
684            if ( dependency.getProperties() != null )
685            {
686                for ( int i = 0, s0 = dependency.getProperties().getProperty().size(); i < s0; i++ )
687                {
688                    final Property p = dependency.getProperties().getProperty().get( i );
689    
690                    for ( final Implementation impl : implementations )
691                    {
692                        final Set<InheritanceModel.Node<Property>> effProperties =
693                            imodel.getPropertyNodes( impl.getIdentifier(), p.getName() );
694    
695                        if ( !p.isOverride() && !effProperties.isEmpty() )
696                        {
697                            p.setOverride( true );
698                        }
699                    }
700                }
701            }
702        }
703    
704        // SECTION-END
705        // SECTION-START[Constructors]
706        // <editor-fold defaultstate="collapsed" desc=" Generated Constructors ">
707        /** Creates a new {@code ModelModelProvider} instance. */
708        @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.3", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.3" )
709        public ModelModelProvider()
710        {
711            // SECTION-START[Default Constructor]
712            super();
713            // SECTION-END
714        }
715        // </editor-fold>
716        // SECTION-END
717        // SECTION-START[Dependencies]
718        // SECTION-END
719        // SECTION-START[Properties]
720        // SECTION-END
721        // SECTION-START[Messages]
722        // SECTION-END
723    }