Attachment #123270 for bug #216833

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 216833
Collapse All | Expand All

Lines 1-3 Link Here

(-)a/.hgmail-web-main (+1 lines)
1	[usersubs]	1	[usersubs]
2	commits@php.netbeans.org=php/,hudson.php/,languages.ini/,languages.neon/,languages.apacheconf/	2	commits@php.netbeans.org=php/,hudson.php/,languages.ini/,languages.neon/,languages.apacheconf/
3	dkonecny@netbeans.org=web/,j2ee/,maven.j2ee/,coherence/,cloud./,extbrowser,javaee/,core.browser/,netserver	3	dkonecny@netbeans.org=web/,j2ee/,maven.j2ee/,coherence/,cloud./,extbrowser,javaee/,core.browser/,netserver
		4	mentlicher@netbeans.org=web.webkit.debugging/,web.javascript.debugger/




public class JPQLValidation extends JPAClassRule implements CancelListener{
    
    private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required
    private JPQLQueryHelper helper;
    /** Creates a new instance of NonFinalClass */
    public JPQLValidation() {
        setClassContraints(Arrays.asList(ClassConstraints.ENTITY,

                }
            }
        }
        helper = new JPQLQueryHelper();
        Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
        List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
        mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData(), jpaCtx.getCompilationInfo().getElements());
        for(int index=0;index<values.size() && !ctx.isCancelled();index++){
            String value = values.get(index);
            String qName = names.get(index);

        }
        jpaCtx.removeCancelListener(this);
        mtp = null;
        helper = null;
        return ret;
    }
    

    @Override
    public void cancelled() {
        if(mtp != null)mtp.invalidate();
        if(helper != null)helper.dispose();
    }
}

Lines 138-144 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/editor/completion/ETCompletionContextResolver.java (-2 / +2 lines)
138	JPQLQueryHelper helper = new JPQLQueryHelper();	138	JPQLQueryHelper helper = new JPQLQueryHelper();
139		139
140	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	140	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
141	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings())));	141	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings(), ctx.getController().getElements())));
142	int offset = ctx.getCompletionOffset() - nnattr.getValueOffset() - (nnattr.isValueQuoted() ? 1 : 0);	142	int offset = ctx.getCompletionOffset() - nnattr.getValueOffset() - (nnattr.isValueQuoted() ? 1 : 0);
143	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);	143	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);
144		144
Lines 168-174 Link Here
168	completedValue = org.netbeans.modules.j2ee.persistence.editor.completion.Utils.unquote(completedValue);	168	completedValue = org.netbeans.modules.j2ee.persistence.editor.completion.Utils.unquote(completedValue);
169		169
170	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	170	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
171	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings())));	171	helper.setQuery(new Query(null, completedValue, new ManagedTypeProvider(project, ctx.getEntityMappings(), ctx.getController().getElements())));
172	int offset = ctx.getCompletionOffset() - method.getValueOffset() - (method.isWithQ() ? 1 : 0);	172	int offset = ctx.getCompletionOffset() - method.getValueOffset() - (method.isWithQ() ? 1 : 0);
173	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);	173	ContentAssistProposals buildContentAssistProposals = helper.buildContentAssistProposals(offset);
174		174




import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.lang.model.util.Elements;
import org.eclipse.persistence.jpa.jpql.spi.IEntity;
import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
import org.eclipse.persistence.jpa.jpql.spi.IManagedType;

    private ITypeRepository typeRepository;
    private final EntityMappings mappings;
    private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way
    private final Elements elements;

    public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData, Elements elements) {
        this.project = project;
        this.mappings = metaData.getRoot();
        this.elements = elements;
    }
    
    public ManagedTypeProvider(Project project, EntityMappings mappings, Elements elements) {
        this.project = project;
        this.mappings = mappings;
        this.elements = elements;
    }
    
    @Override

    @Override
    public ITypeRepository getTypeRepository() {
        if (typeRepository == null) {
            typeRepository = new TypeRepository(project, this, elements);
        }
        return typeRepository;
    }

    public void invalidate() {
        valid = false;
        //TODO: may have sense to clean stored data
        ((TypeRepository)typeRepository).invalidate();
    }

    private void initializeManagedTypes() {




 */
package org.netbeans.modules.j2ee.persistence.spi.jpql;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import org.eclipse.persistence.jpa.jpql.TypeHelper;
import org.eclipse.persistence.jpa.jpql.spi.IType;
import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.java.source.ClasspathInfo;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
import org.openide.filesystems.FileObject;

/**
 *

public class TypeRepository implements ITypeRepository {
    private final Project project;
    private final Map<String, IType[]> types;
    private final Map<String, Boolean> packages;
    private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
    private final ManagedTypeProvider mtp;
    private final Elements elements;


    TypeRepository(Project project, ManagedTypeProvider mtp, Elements elements) {
        this.project = project;
        this.mtp = mtp;
        this.elements = elements;
        types = new HashMap<String, IType[]>();
        packages = new HashMap<String, Boolean>();
    }
    
    @Override

            if(mainPart != null){
                IType[] mainType = types.get(mainPart);
                if(mainType == null){
                    //first check packages
                    int mainFirstPoint = mainPart.indexOf('.');
                    int mainLastPoint = mainPart.lastIndexOf('.');
                    
                    if(mainFirstPoint != mainLastPoint && mainFirstPoint>-1){
                        //we have at least 2 points and at least one for package (we may have nested enums)
                        for(int packagePartIndex = mainFirstPoint;packagePartIndex<mainLastPoint && packagePartIndex>-1;packagePartIndex = mainPart.indexOf('.', packagePartIndex+1)){
                            String packageStr = mainPart.substring(0,packagePartIndex);
                            Boolean exist = packages.get(packageStr);
                            if(exist == null){
                                packages.put(packageStr, elements.getPackageElement(packageStr)!=null);
                                exist = packages.get(packageStr);
                            }
                            if(Boolean.FALSE.equals(exist)){
                                mainType = new Type[]{null};
                                types.put(mainPart, mainType);
                                break;
                            }
                        }
                    }
                    //
                    if(mainType == null){
                        fillTypeElement(mainPart);
                    }
                }
                mainType = types.get(mainPart);
                if(mainType[0] != null){

            }
            ret = types.get(fqn);
        }
        return ret!=null ? ret[0] : null;
    }

    @Override

    private void fillTypeElement(final String fqn){
        types.put(fqn, new Type[]{null});
        if(isValid()){ 
            if(isValid()) {
                TypeElement te = elements.getTypeElement(fqn);
                if(te!=null) {
                    types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});

                        @Override
                        public Void call() throws Exception {
                                if(isValid()) {//model will be filled with nulls  after provider invalidation and with values only if valid provider
                                    TypeElement te = amh.getCompilationController().getElements().getTypeElement(fqn);
                                    if(te!=null) {
                                        PersistentObject po = new PersistentObject(amh, te) {};
                                        types.put(fqn, new Type[]{new Type(TypeRepository.this, po)});
                                    }
                                }
                                return null;
                        }
                    });
                } catch (IOException ex) {
                    //TODO: any logging?
                }
            }
        }

    private void fillTypeElement(Class<?> type){
        types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
    }
   
    AnnotationModelHelper getAnnotationModelHelper() {
        if(amh == null) {
                Sources sources=ProjectUtils.getSources(project);
                SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
                if(groups != null && groups.length>0){
                    SourceGroup firstGroup=groups[0];
                    FileObject fo=firstGroup.getRootFolder();
                    ClasspathInfo classpathInfo = ClasspathInfo.create(fo);
                    amh = AnnotationModelHelper.create(classpathInfo);
                }            
        }
        return amh;
    }
    
    boolean isValid(){
        return mtp.isValid();
    }

    void invalidate() {
        
    }
}

Return to bug 216833

Lines 1-3 Link Here

(-)a/.hgmail-web-main (+1 lines)
1	[usersubs]	1	[usersubs]
2	commits@php.netbeans.org=php/,hudson.php/,languages.ini/,languages.neon/,languages.apacheconf/	2	commits@php.netbeans.org=php/,hudson.php/,languages.ini/,languages.neon/,languages.apacheconf/
3	dkonecny@netbeans.org=web/,j2ee/,maven.j2ee/,coherence/,cloud./,extbrowser,javaee/,core.browser/,netserver	3	dkonecny@netbeans.org=web/,j2ee/,maven.j2ee/,coherence/,cloud./,extbrowser,javaee/,core.browser/,netserver
		4	mentlicher@netbeans.org=web.webkit.debugging/,web.javascript.debugger/

Lines 84-90 Link Here

(-)a/j2ee.jpa.verification/src/org/netbeans/modules/j2ee/jpa/verification/rules/entity/JPQLValidation.java (-3 / +5 lines)
84	public class JPQLValidation extends JPAClassRule implements CancelListener{	84	public class JPQLValidation extends JPAClassRule implements CancelListener{
85		85
86	private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required	86	private ManagedTypeProvider mtp;//need to store as jpql validation may be too long and need to be cancelled if required
87		87	private JPQLQueryHelper helper;
88	/** Creates a new instance of NonFinalClass */	88	/** Creates a new instance of NonFinalClass */
89	public JPQLValidation() {	89	public JPQLValidation() {
90	setClassContraints(Arrays.asList(ClassConstraints.ENTITY,	90	setClassContraints(Arrays.asList(ClassConstraints.ENTITY,
Lines 132-141 Link Here
132	}	132	}
133	}	133	}
134	}	134	}
135	JPQLQueryHelper helper = new JPQLQueryHelper();	135	helper = new JPQLQueryHelper();
136	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());	136	Project project = FileOwnerQuery.getOwner(ctx.getFileObject());
137	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();	137	List<JPQLQueryProblem> problems = new ArrayList<JPQLQueryProblem>();
138	mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData());	138	mtp = new ManagedTypeProvider(project, jpaCtx.getMetaData(), jpaCtx.getCompilationInfo().getElements());
139	for(int index=0;index<values.size() && !ctx.isCancelled();index++){	139	for(int index=0;index<values.size() && !ctx.isCancelled();index++){
140	String value = values.get(index);	140	String value = values.get(index);
141	String qName = names.get(index);	141	String qName = names.get(index);
Lines 178-183 Link Here
178	}	178	}
179	jpaCtx.removeCancelListener(this);	179	jpaCtx.removeCancelListener(this);
180	mtp = null;	180	mtp = null;
		181	helper = null;
181	return ret;	182	return ret;
182	}	183	}
183		184
Lines 190-194 Link Here
190	@Override	191	@Override
191	public void cancelled() {	192	public void cancelled() {
192	if(mtp != null)mtp.invalidate();	193	if(mtp != null)mtp.invalidate();
		194	if(helper != null)helper.dispose();
193	}	195	}
194	}	196	}

Lines 45-50 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/ManagedTypeProvider.java (-3 / +8 lines)
45	import java.util.Collections;	45	import java.util.Collections;
46	import java.util.HashMap;	46	import java.util.HashMap;
47	import java.util.Map;	47	import java.util.Map;
		48	import javax.lang.model.util.Elements;
48	import org.eclipse.persistence.jpa.jpql.spi.IEntity;	49	import org.eclipse.persistence.jpa.jpql.spi.IEntity;
49	import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;	50	import org.eclipse.persistence.jpa.jpql.spi.IJPAVersion;
50	import org.eclipse.persistence.jpa.jpql.spi.IManagedType;	51	import org.eclipse.persistence.jpa.jpql.spi.IManagedType;
Lines 68-82 Link Here
68	private ITypeRepository typeRepository;	69	private ITypeRepository typeRepository;
69	private final EntityMappings mappings;	70	private final EntityMappings mappings;
70	private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way	71	private boolean valid = true;//used to conrol long tasks, if not valid long tasks should be either terminated or goes short way
		72	private final Elements elements;
71		73
72	public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData) {	74	public ManagedTypeProvider(Project project, EntityMappingsMetadata metaData, Elements elements) {
73	this.project = project;	75	this.project = project;
74	this.mappings = metaData.getRoot();	76	this.mappings = metaData.getRoot();
		77	this.elements = elements;
75	}	78	}
76		79
77	public ManagedTypeProvider(Project project, EntityMappings mappings) {	80	public ManagedTypeProvider(Project project, EntityMappings mappings, Elements elements) {
78	this.project = project;	81	this.project = project;
79	this.mappings = mappings;	82	this.mappings = mappings;
		83	this.elements = elements;
80	}	84	}
81		85
82	@Override	86	@Override
Lines 116-122 Link Here
116	@Override	120	@Override
117	public ITypeRepository getTypeRepository() {	121	public ITypeRepository getTypeRepository() {
118	if (typeRepository == null) {	122	if (typeRepository == null) {
119	typeRepository = new TypeRepository(project, this);	123	typeRepository = new TypeRepository(project, this, elements);
120	}	124	}
121	return typeRepository;	125	return typeRepository;
122	}	126	}
Lines 145-150 Link Here
145	public void invalidate() {	149	public void invalidate() {
146	valid = false;	150	valid = false;
147	//TODO: may have sense to clean stored data	151	//TODO: may have sense to clean stored data
		152	((TypeRepository)typeRepository).invalidate();
148	}	153	}
149		154
150	private void initializeManagedTypes() {	155	private void initializeManagedTypes() {

Lines 41-66 Link Here

(-)a/j2ee.persistence/src/org/netbeans/modules/j2ee/persistence/spi/jpql/TypeRepository.java (-47 / +40 lines)
41	*/	41	*/
42	package org.netbeans.modules.j2ee.persistence.spi.jpql;	42	package org.netbeans.modules.j2ee.persistence.spi.jpql;
43		43
44	import java.io.IOException;
45	import java.util.HashMap;	44	import java.util.HashMap;
46	import java.util.List;	45	import java.util.List;
47	import java.util.Map;	46	import java.util.Map;
48	import java.util.concurrent.Callable;
49	import javax.lang.model.element.TypeElement;	47	import javax.lang.model.element.TypeElement;
		48	import javax.lang.model.util.Elements;
50	import org.eclipse.persistence.jpa.jpql.TypeHelper;	49	import org.eclipse.persistence.jpa.jpql.TypeHelper;
51	import org.eclipse.persistence.jpa.jpql.spi.IType;	50	import org.eclipse.persistence.jpa.jpql.spi.IType;
52	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;	51	import org.eclipse.persistence.jpa.jpql.spi.ITypeRepository;
53	import org.netbeans.api.java.project.JavaProjectConstants;
54	import org.netbeans.api.java.source.ClasspathInfo;
55	import org.netbeans.api.project.Project;	52	import org.netbeans.api.project.Project;
56	import org.netbeans.api.project.ProjectUtils;
57	import org.netbeans.api.project.SourceGroup;
58	import org.netbeans.api.project.Sources;
59	import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.AnnotationModelHelper;
60	import org.netbeans.modules.j2ee.metadata.model.api.support.annotation.PersistentObject;
61	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;	53	import org.netbeans.modules.j2ee.persistence.api.metadata.orm.EntityMappingsMetadata;
62	import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;	54	import org.netbeans.modules.j2ee.persistence.util.MetadataModelReadHelper;
63	import org.openide.filesystems.FileObject;
64		55
65	/**	56	/**
66	*	57	*
Lines 69-83 Link Here
69	public class TypeRepository implements ITypeRepository {	60	public class TypeRepository implements ITypeRepository {
70	private final Project project;	61	private final Project project;
71	private final Map<String, IType[]> types;	62	private final Map<String, IType[]> types;
		63	private final Map<String, Boolean> packages;
72	private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;	64	private MetadataModelReadHelper<EntityMappingsMetadata, List<org.netbeans.modules.j2ee.persistence.api.metadata.orm.Entity>> readHelper;
73	private final ManagedTypeProvider mtp;	65	private final ManagedTypeProvider mtp;
74	private AnnotationModelHelper amh;	66	private final Elements elements;
75		67
76		68
77	TypeRepository(Project project, ManagedTypeProvider mtp) {	69	TypeRepository(Project project, ManagedTypeProvider mtp, Elements elements) {
78	this.project = project;	70	this.project = project;
79	this.mtp = mtp;	71	this.mtp = mtp;
		72	this.elements = elements;
80	types = new HashMap<String, IType[]>();	73	types = new HashMap<String, IType[]>();
		74	packages = new HashMap<String, Boolean>();
81	}	75	}
82		76
83	@Override	77	@Override
Lines 90-96 Link Here
90	if(mainPart != null){	84	if(mainPart != null){
91	IType[] mainType = types.get(mainPart);	85	IType[] mainType = types.get(mainPart);
92	if(mainType == null){	86	if(mainType == null){
93	fillTypeElement(mainPart);	87	//first check packages
		88	int mainFirstPoint = mainPart.indexOf('.');
		89	int mainLastPoint = mainPart.lastIndexOf('.');
		90
		91	if(mainFirstPoint != mainLastPoint && mainFirstPoint>-1){
		92	//we have at least 2 points and at least one for package (we may have nested enums)
		93	for(int packagePartIndex = mainFirstPoint;packagePartIndex<mainLastPoint && packagePartIndex>-1;packagePartIndex = mainPart.indexOf('.', packagePartIndex+1)){
		94	String packageStr = mainPart.substring(0,packagePartIndex);
		95	Boolean exist = packages.get(packageStr);
		96	if(exist == null){
		97	packages.put(packageStr, elements.getPackageElement(packageStr)!=null);
		98	exist = packages.get(packageStr);
		99	}
		100	if(Boolean.FALSE.equals(exist)){
		101	mainType = new Type[]{null};
		102	types.put(mainPart, mainType);
		103	break;
		104	}
		105	}
		106	}
		107	//
		108	if(mainType == null){
		109	fillTypeElement(mainPart);
		110	}
94	}	111	}
95	mainType = types.get(mainPart);	112	mainType = types.get(mainPart);
96	if(mainType[0] != null){	113	if(mainType[0] != null){
Lines 137-143 Link Here
137	}	154	}
138	ret = types.get(fqn);	155	ret = types.get(fqn);
139	}	156	}
140	return ret[0];	157	return ret!=null ? ret[0] : null;
141	}	158	}
142		159
143	@Override	160	@Override
Lines 148-172 Link Here
148	private void fillTypeElement(final String fqn){	165	private void fillTypeElement(final String fqn){
149	types.put(fqn, new Type[]{null});	166	types.put(fqn, new Type[]{null});
150	if(isValid()){	167	if(isValid()){
151	getAnnotationModelHelper();	168	if(isValid()) {
152	if(amh != null && isValid()) {	169	TypeElement te = elements.getTypeElement(fqn);
153	try {	170	if(te!=null) {
154	amh.runJavaSourceTask(new Callable<Void>() {	171	types.put(fqn, new Type[]{new Type(TypeRepository.this, te)});
155
156	@Override
157	public Void call() throws Exception {
158	if(isValid()) {//model will be filled with nulls after provider invalidation and with values only if valid provider
159	TypeElement te = amh.getCompilationController().getElements().getTypeElement(fqn);
160	if(te!=null) {
161	PersistentObject po = new PersistentObject(amh, te) {};
162	types.put(fqn, new Type[]{new Type(TypeRepository.this, po)});
163	}
164	}
165	return null;
166	}
167	});
168	} catch (IOException ex) {
169	//TODO: any logging?
170	}	172	}
171	}	173	}
172	}	174	}
Lines 174-195 Link Here
174	private void fillTypeElement(Class<?> type){	176	private void fillTypeElement(Class<?> type){
175	types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});	177	types.put(type.getName(), new Type[]{new Type(TypeRepository.this, type)});
176	}	178	}
177		179
178	AnnotationModelHelper getAnnotationModelHelper() {
179	if(amh == null) {
180	Sources sources=ProjectUtils.getSources(project);
181	SourceGroup groups[]=sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
182	if(groups != null && groups.length>0){
183	SourceGroup firstGroup=groups[0];
184	FileObject fo=firstGroup.getRootFolder();
185	ClasspathInfo classpathInfo = ClasspathInfo.create(fo);
186	amh = AnnotationModelHelper.create(classpathInfo);
187	}
188	}
189	return amh;
190	}
191		180
192	boolean isValid(){	181	boolean isValid(){
193	return mtp.isValid();	182	return mtp.isValid();
194	}	183	}
		184
		185	void invalidate() {
		186
		187	}
195	}	188	}