001    /*
002     * Copyright 2010-2013 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.psi.*;
020    import com.intellij.psi.impl.light.AbstractLightClass;
021    import com.intellij.psi.impl.light.LightEmptyImplementsList;
022    import com.intellij.psi.impl.light.LightModifierList;
023    import com.intellij.psi.javadoc.PsiDocComment;
024    import org.jetbrains.annotations.NonNls;
025    import org.jetbrains.annotations.NotNull;
026    import org.jetbrains.annotations.Nullable;
027    import org.jetbrains.jet.plugin.JetLanguage;
028    
029    /**
030     * This class contains method that are straightforward, and only would pollute the actual implementation
031     */
032    public abstract class KotlinLightClassForPackageBase extends AbstractLightClass {
033    
034        private final PsiModifierList modifierList;
035        private final LightEmptyImplementsList implementsList;
036    
037        public KotlinLightClassForPackageBase(PsiManager manager) {
038            super(manager, JetLanguage.INSTANCE);
039            this.modifierList = new LightModifierList(manager, JetLanguage.INSTANCE, PsiModifier.PUBLIC, PsiModifier.FINAL);
040            this.implementsList = new LightEmptyImplementsList(manager);
041        }
042    
043        @Nullable
044        @Override
045        public PsiModifierList getModifierList() {
046            return modifierList;
047        }
048    
049        @Override
050        public boolean hasModifierProperty(@NonNls @NotNull String name) {
051            return modifierList.hasModifierProperty(name);
052        }
053    
054        @Override
055        public boolean isDeprecated() {
056            return false;
057        }
058    
059        @Override
060        public boolean isInterface() {
061            return false;
062        }
063    
064        @Override
065        public boolean isAnnotationType() {
066            return false;
067        }
068    
069        @Override
070        public boolean isEnum() {
071            return false;
072        }
073    
074        @Nullable
075        @Override
076        public PsiClass getContainingClass() {
077            return null;
078        }
079    
080        @Override
081        public boolean hasTypeParameters() {
082            return false;
083        }
084    
085        @NotNull
086        @Override
087        public PsiTypeParameter[] getTypeParameters() {
088            return PsiTypeParameter.EMPTY_ARRAY;
089        }
090    
091        @Nullable
092        @Override
093        public PsiTypeParameterList getTypeParameterList() {
094            return null;
095        }
096    
097        @Nullable
098        @Override
099        public PsiDocComment getDocComment() {
100            return null;
101        }
102    
103        @Nullable
104        @Override
105        public PsiReferenceList getImplementsList() {
106            return implementsList;
107        }
108    
109        @NotNull
110        @Override
111        public PsiClassType[] getImplementsListTypes() {
112            return PsiClassType.EMPTY_ARRAY;
113        }
114    
115        @Nullable
116        @Override
117        public PsiReferenceList getExtendsList() {
118            // TODO: Find a way to return just Object
119            return super.getExtendsList();
120        }
121    
122        @NotNull
123        @Override
124        public PsiClassType[] getExtendsListTypes() {
125            // TODO see getExtendsList()
126            return super.getExtendsListTypes();
127        }
128    
129        @Nullable
130        @Override
131        public PsiClass getSuperClass() {
132            // TODO see getExtendsList()
133            return super.getSuperClass();
134        }
135    
136        @NotNull
137        @Override
138        public PsiClass[] getSupers() {
139            // TODO see getExtendsList()
140            return super.getSupers();
141        }
142    
143        @NotNull
144        @Override
145        public PsiClassType[] getSuperTypes() {
146            // TODO see getExtendsList()
147            return super.getSuperTypes();
148        }
149    
150        @Override
151        public PsiClass[] getInterfaces() {
152            return PsiClass.EMPTY_ARRAY;
153        }
154    
155        @NotNull
156        @Override
157        public PsiClass[] getInnerClasses() {
158            return PsiClass.EMPTY_ARRAY;
159        }
160    
161        @NotNull
162        @Override
163        public PsiClassInitializer[] getInitializers() {
164            return PsiClassInitializer.EMPTY_ARRAY;
165        }
166    
167        @NotNull
168        @Override
169        public PsiClass[] getAllInnerClasses() {
170            return PsiClass.EMPTY_ARRAY;
171        }
172    
173        @Nullable
174        @Override
175        public PsiClass findInnerClassByName(@NonNls String name, boolean checkBases) {
176            return null;
177        }
178    }