001 /*
002 * Copyright 2010-2014 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.jet.asJava;
018
019 import com.intellij.lang.Language;
020 import com.intellij.psi.PsiClass;
021 import com.intellij.psi.PsiField;
022 import com.intellij.psi.PsiManager;
023 import com.intellij.psi.PsiMethod;
024 import com.intellij.psi.impl.PsiClassImplUtil;
025 import com.intellij.psi.impl.light.AbstractLightClass;
026 import com.intellij.psi.impl.light.LightField;
027 import org.jetbrains.jet.asJava.light.KotlinLightField;
028 import com.intellij.psi.impl.light.LightMethod;
029 import com.intellij.psi.impl.source.ClassInnerStuffCache;
030 import com.intellij.psi.impl.source.PsiExtensibleClass;
031 import com.intellij.util.Function;
032 import com.intellij.util.containers.ContainerUtil;
033 import org.jetbrains.annotations.NotNull;
034 import org.jetbrains.jet.lang.psi.JetDeclaration;
035 import org.jetbrains.jet.lang.psi.JetProperty;
036
037 import java.util.List;
038
039 public abstract class KotlinWrappingLightClass extends AbstractLightClass implements KotlinLightClass, PsiExtensibleClass {
040 private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this);
041
042 protected KotlinWrappingLightClass(PsiManager manager, Language language) {
043 super(manager, language);
044 }
045
046 @NotNull
047 @Override
048 public abstract PsiClass getDelegate();
049
050 @Override
051 @NotNull
052 public PsiField[] getFields() {
053 return myInnersCache.getFields();
054 }
055
056 @Override
057 @NotNull
058 public PsiMethod[] getMethods() {
059 return myInnersCache.getMethods();
060 }
061
062 @Override
063 @NotNull
064 public PsiMethod[] getConstructors() {
065 return myInnersCache.getConstructors();
066 }
067
068 @Override
069 @NotNull
070 public PsiClass[] getInnerClasses() {
071 return myInnersCache.getInnerClasses();
072 }
073
074 @Override
075 @NotNull
076 public PsiField[] getAllFields() {
077 return PsiClassImplUtil.getAllFields(this);
078 }
079
080 @Override
081 @NotNull
082 public PsiMethod[] getAllMethods() {
083 return PsiClassImplUtil.getAllMethods(this);
084 }
085
086 @Override
087 @NotNull
088 public PsiClass[] getAllInnerClasses() {
089 return PsiClassImplUtil.getAllInnerClasses(this);
090 }
091
092 @Override
093 public PsiField findFieldByName(String name, boolean checkBases) {
094 return myInnersCache.findFieldByName(name, checkBases);
095 }
096
097 @Override
098 @NotNull
099 public PsiMethod[] findMethodsByName(String name, boolean checkBases) {
100 return myInnersCache.findMethodsByName(name, checkBases);
101 }
102
103 @Override
104 public PsiClass findInnerClassByName(String name, boolean checkBases) {
105 return myInnersCache.findInnerClassByName(name, checkBases);
106 }
107
108 @NotNull
109 @Override
110 public List<PsiField> getOwnFields() {
111 return ContainerUtil.map(getDelegate().getFields(), new Function<PsiField, PsiField>() {
112 @Override
113 public PsiField fun(PsiField field) {
114 JetDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(field);
115 return declaration instanceof JetProperty
116 ? new KotlinLightField(myManager, (JetProperty) declaration, field, KotlinWrappingLightClass.this)
117 : new LightField(myManager, field, KotlinWrappingLightClass.this);
118 }
119 });
120 }
121
122 @NotNull
123 @Override
124 public List<PsiMethod> getOwnMethods() {
125 return ContainerUtil.map(getDelegate().getMethods(), new Function<PsiMethod, PsiMethod>() {
126 @Override
127 public PsiMethod fun(PsiMethod method) {
128 JetDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(method);
129 return declaration != null
130 ? new KotlinLightMethodForDeclaration(myManager, method, declaration, KotlinWrappingLightClass.this)
131 : new LightMethod(myManager, method, KotlinWrappingLightClass.this);
132 }
133 });
134 }
135 }