/*
* 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.
*
* 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();
}
}