jdk8-mips64-public/langtools: test/tools/javac/lambdaShapes/org/openjdk/tests/shapegen/ClassCase.java@b12ffdfa1341 (annotated)

test/tools/javac/lambdaShapes/org/openjdk/tests/shapegen/ClassCase.java@b12ffdfa1341 (annotated)

test/tools/javac/lambdaShapes/org/openjdk/tests/shapegen/ClassCase.java

Mon, 21 Jan 2013 20:15:16 +0000

author: mcimadamore
date: Mon, 21 Jan 2013 20:15:16 +0000
changeset 1512: b12ffdfa1341
parent 0: 959103a6100f
permissions: -rw-r--r--

8005851: Remove support for synchronized interface methods
Summary: Synchronized default methods are no longer supported
Reviewed-by: jjg

 /*
  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package org.openjdk.tests.shapegen;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 /**
  *
  * @author Robert Field
  */
 public class ClassCase {
     public enum Kind {
         IVAC        (true,  "v"),
         IPRESENT    (true,  "p"),
         IDEFAULT    (true,  "d"),
         CNONE       (false, "n"),
         CABSTRACT   (false, "a"),
         CCONCRETE   (false, "c");
         private final String prefix;
         public final boolean isInterface;
         Kind(boolean isInterface, String prefix) {
             this.isInterface = isInterface;
             this.prefix = prefix;
         }
         public String getPrefix() { return prefix; }
     }
     public final Kind kind;
     private final ClassCase superclass;
     private final List<ClassCase> supertypes;
     private String name;
     private boolean _OK;
     private boolean _HasClassMethod;
     private Set<ClassCase> _mprov;
     private boolean _IsConcrete;
     private boolean _HasDefault;
     private ClassCase _mres;
     private ClassCase _mdefend;
     private Set<RuleGroup> executed = new HashSet<RuleGroup>();
     public ClassCase(Kind kind, ClassCase superclass, List<ClassCase> interfaces) {
         this.kind = kind;
         this.superclass = superclass;
         // Set supertypes from superclass (if any) and interfaces
         List<ClassCase> lc;
         if (superclass == null) {
             lc = interfaces;
         } else {
             lc = new ArrayList<>();
             lc.add(superclass);
             lc.addAll(interfaces);
         }
         this.supertypes = lc;
     }
     public final boolean isInterface() { return kind.isInterface; }
     public final boolean isClass() { return !kind.isInterface; }
     public Set<ClassCase> get_mprov() {
         exec(RuleGroup.PROVENENCE);
         return _mprov;
     }
     public void set_mprov(ClassCase cc) {
         Set<ClassCase> s = new HashSet<>();
         s.add(cc);
         _mprov = s;
     }
     public void set_mprov(Set<ClassCase> s) {
         _mprov = s;
     }
     public ClassCase get_mres() {
         exec(RuleGroup.RESOLUTION);
         return _mres;
     }
     public void set_mres(ClassCase cc) {
         _mres = cc;
     }
     public ClassCase get_mdefend() {
         exec(RuleGroup.DEFENDER);
         return _mdefend;
     }
     public void set_mdefend(ClassCase cc) {
         _mdefend = cc;
     }
     public boolean get_HasClassMethod() {
         exec(RuleGroup.PROVENENCE);
         return _HasClassMethod;
     }
     public void set_HasClassMethod(boolean bool) {
         _HasClassMethod = bool;
     }
     public boolean get_HasDefault() {
         exec(RuleGroup.MARKER);
         return _HasDefault;
     }
     public void set_HasDefault(boolean bool) {
         _HasDefault = bool;
     }
     public boolean get_IsConcrete() {
         exec(RuleGroup.MARKER);
         return _IsConcrete;
     }
     public void set_IsConcrete(boolean bool) {
         _IsConcrete = bool;
     }
     public boolean get_OK() {
         exec(RuleGroup.CHECKING);
         return _OK;
     }
     public void set_OK(boolean bool) {
         _OK = bool;
     }
     public boolean isMethodDefined() {
         for (ClassCase cc : supertypes) {
             if (cc.isMethodDefined()) {
                 return true;
             }
         }
         switch (kind) {
             case CCONCRETE:
             case CABSTRACT:
             case IPRESENT:
             case IDEFAULT:
                 return true;
             default:
                 return false;
         }
     }
     public boolean isAbstract() {
         return isMethodDefined() && (get_mres()==null);
     }
     public boolean hasSuperclass() {
         return superclass != null;
     }
     public ClassCase getSuperclass() {
         return superclass;
     }
     public List<ClassCase> getSupertypes() {
         return supertypes;
     }
     public List<ClassCase> getInterfaces() {
         if (superclass != null) {
             if (supertypes.get(0) != superclass) {
                 throw new AssertionError("superclass missing from supertypes");
             }
             return supertypes.subList(1, supertypes.size());
         } else {
             return supertypes;
         }
     }
     public boolean isSubtypeOf(ClassCase cc) {
         // S-Refl
         if (cc.equals(this)) {
             return true;
         }
         // S-Def
         for (ClassCase sp : getSupertypes()) {
             if (cc.equals(sp)) {
                 return true;
             }
         }
         // _S-Trans
         for (ClassCase sp : getSupertypes()) {
             if (sp.isSubtypeOf(cc)) {
                 return true;
             }
         }
         return false;
     }
     public void init(Map<String, Integer> namingContext) {
         if (name != null) {
             return; // Already inited
         }
         for (ClassCase sup : supertypes) {
             sup.init(namingContext);
         }
         // Build name
         StringBuilder sb = new StringBuilder();
         if (!supertypes.isEmpty()) {
             sb.append(isInterface() ? "I" : "C");
             for (ClassCase cc : supertypes) {
                 sb.append(cc.getName());
             }
             sb.append(kind.isInterface ? "i" : "c");
         }
         sb.append(kind.prefix);
         String pname = sb.toString();
         Integer icnt = namingContext.get(pname);
         int cnt = icnt == null ? 0 : icnt;
         ++cnt;
         namingContext.put(pname, cnt);
         if (cnt > 1) {
             sb.append(cnt);
         }
         this.name = sb.toString();
     }
     public boolean isa(Kind... kinds) {
         for (Kind k : kinds) {
             if (kind == k) {
                 return true;
             }
         }
         return false;
     }
     private void exec(RuleGroup rg ) {
         if (!executed.contains(rg)) {
             rg.exec(this);
             executed.add(rg);
         }
     }
     public void collectClasses(Set<ClassCase> seen) {
         seen.add(this);
         for (ClassCase cc : supertypes) {
             cc.collectClasses(seen);
         }
     }
     public String getID() {
         if (name == null) {
             throw new Error("Access to uninitialized ClassCase");
         } else {
             return name;
         }
     }
     public final String getName() {
         if (name == null) {
             return "ClassCase uninited@" + hashCode();
         } else {
             return name;
         }
     }
     @Override
     public boolean equals(Object obj) {
         return obj instanceof ClassCase && getID().equals(((ClassCase)obj).getID());
     }
     @Override
     public int hashCode() {
         return getID().hashCode();
     }
     @Override
     public String toString() {
         return getName();
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/lambdaShapes/org/openjdk/tests/shapegen/ClassCase.java@b12ffdfa1341 (annotated)

test/tools/javac/lambdaShapes/org/openjdk/tests/shapegen/ClassCase.java