当前位置：源码 > Java源码 >

Java源码示例：shapegen.ClassCase.Kind

示例1

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例2

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例3

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例4

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例5

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例6

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例7

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例8

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例9

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例10

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例11

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例12

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例13

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例14

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例15

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例16

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例17

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例18

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例19

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例20

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例21

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例22

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例23

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例24

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例25

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例26

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例27

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

示例28

public void start(boolean includeClasses) {
    kinds =
         supertypes.isEmpty()?
            (new Kind[]{IDEFAULT, IPRESENT})
         :  ((includeClasses && canBeClass)?
              new Kind[]{CNONE, IVAC, IDEFAULT, IPRESENT}
            : new Kind[]{IVAC, IDEFAULT, IPRESENT});
    currentKindIndex = 0;

    for (TTNode sub : supertypes) {
        sub.start(includeClasses);
    }
}

示例29

public List<Hierarchy> cExhaustive() {
    final Kind[] iKinds = new Kind[]{IDEFAULT, IVAC, IPRESENT, null};
    final Kind[] cKinds = new Kind[]{CNONE, CABSTRACT, CCONCRETE};
    List<Hierarchy> totest = new ArrayList<>();
    for (int i1 = 0; i1 < iKinds.length; ++i1) {
        for (int i2 = 0; i2 < iKinds.length; ++i2) {
            for (int i3 = 0; i3 < iKinds.length; ++i3) {
                for (int c1 = 0; c1 < cKinds.length; ++c1) {
                    for (int c2 = 0; c2 < cKinds.length; ++c2) {
                        for (int c3 = 0; c3 < cKinds.length; ++c3) {
                            totest.add( new Hierarchy(
                                    new ClassCase(cKinds[c1],
                                        new ClassCase(cKinds[c2],
                                            new ClassCase(cKinds[c3],
                                                null,
                                                iList(iKinds[i1])
                                            ),
                                            iList(iKinds[i2])
                                        ),
                                        iList(iKinds[i3])
                                    )));
                        }
                    }
                }
            }
        }
    }
    return totest;
}

示例30

private List<ClassCase> iList(Kind kind) {
    if (kind == null) {
        return EMPTY_LIST;
    } else {
        List<ClassCase> itfs = new ArrayList<>();
        itfs.add(new ClassCase(kind, null, EMPTY_LIST));
        return itfs;
    }
}

Java源码示例：shapegen.ClassCase.Kind

微信关注