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 org.jetbrains.jet.asJava.light.LightField;
027 import com.intellij.psi.impl.light.LightMethod;
028 import com.intellij.psi.impl.source.ClassInnerStuffCache;
029 import com.intellij.psi.impl.source.PsiExtensibleClass;
030 import com.intellij.util.Function;
031 import com.intellij.util.containers.ContainerUtil;
032 import org.jetbrains.annotations.NotNull;
033 import org.jetbrains.jet.lang.psi.JetDeclaration;
034
035 import java.util.List;
036
037 public abstract class KotlinWrappingLightClass extends AbstractLightClass implements KotlinLightClass, PsiExtensibleClass {
038 private final ClassInnerStuffCache myInnersCache = new ClassInnerStuffCache(this);
039
040 protected KotlinWrappingLightClass(PsiManager manager, Language language) {
041 super(manager, language);
042 }
043
044 @NotNull
045 @Override
046 public abstract PsiClass getDelegate();
047
048 @Override
049 @NotNull
050 public PsiField[] getFields() {
051 return myInnersCache.getFields();
052 }
053
054 @Override
055 @NotNull
056 public PsiMethod[] getMethods() {
057 return myInnersCache.getMethods();
058 }
059
060 @Override
061 @NotNull
062 public PsiMethod[] getConstructors() {
063 return myInnersCache.getConstructors();
064 }
065
066 @Override
067 @NotNull
068 public PsiClass[] getInnerClasses() {
069 return myInnersCache.getInnerClasses();
070 }
071
072 @Override
073 @NotNull
074 public PsiField[] getAllFields() {
075 return PsiClassImplUtil.getAllFields(this);
076 }
077
078 @Override
079 @NotNull
080 public PsiMethod[] getAllMethods() {
081 return PsiClassImplUtil.getAllMethods(this);
082 }
083
084 @Override
085 @NotNull
086 public PsiClass[] getAllInnerClasses() {
087 return PsiClassImplUtil.getAllInnerClasses(this);
088 }
089
090 @Override
091 public PsiField findFieldByName(String name, boolean checkBases) {
092 return myInnersCache.findFieldByName(name, checkBases);
093 }
094
095 @Override
096 @NotNull
097 public PsiMethod[] findMethodsByName(String name, boolean checkBases) {
098 return myInnersCache.findMethodsByName(name, checkBases);
099 }
100
101 @Override
102 public PsiClass findInnerClassByName(String name, boolean checkBases) {
103 return myInnersCache.findInnerClassByName(name, checkBases);
104 }
105
106 @NotNull
107 @Override
108 public List<PsiField> getOwnFields() {
109 return ContainerUtil.map(getDelegate().getFields(), new Function<PsiField, PsiField>() {
110 @Override
111 public PsiField fun(PsiField field) {
112 return new LightField(myManager, field, KotlinWrappingLightClass.this);
113 }
114 });
115 }
116
117 @NotNull
118 @Override
119 public List<PsiMethod> getOwnMethods() {
120 return ContainerUtil.map(getDelegate().getMethods(), new Function<PsiMethod, PsiMethod>() {
121 @Override
122 public PsiMethod fun(PsiMethod method) {
123 JetDeclaration declaration = ClsWrapperStubPsiFactory.getOriginalDeclaration(method);
124 return declaration != null
125 ? new KotlinLightMethodForDeclaration(myManager, method, declaration, KotlinWrappingLightClass.this)
126 : new LightMethod(myManager, method, KotlinWrappingLightClass.this);
127 }
128 });
129 }
130 }