From c245c4b5d2a7e8898220c47c64586c336d6db561 Mon Sep 17 00:00:00 2001 From: Willem Date: Thu, 22 May 2025 15:52:55 +0200 Subject: [PATCH] Added Kanji JIS spec to FC18 maisdoc --- .../nx01/mushroom/mais/fc18/FCDocWriter.java | 74 +++++++++++- .../mushroom/mais/fc18/kanji/KanjiDict.java | 39 +++++- .../mais/fc18/kanji/KanjiDictTest.java | 22 ++-- .../{ => print}/FCDocPageWriterBaklava.java | 2 +- .../{ => print}/FCDocPageWriterMuffin.java | 2 +- .../fc18/{ => print}/FCDocSegmentWriter.java | 17 ++- .../{ => print}/FCDocSegmentWriterCake.java | 8 +- .../FCDocSegmentWriterCakeSlice.java | 4 +- .../FCDocSegmentWriterCakeWord.java | 29 ++--- .../FCDocSegmentWriterKanjiDictLiteral.java | 114 ++++++++++++++++++ .../metamodel/doc/DocModelWriter.java | 2 +- .../org/x4o/xml/eld/doc/EldDocWriter.java | 15 ++- .../java/org/x4o/maisdoc/model/MaisDoc.java | 9 +- .../org/x4o/maisdoc/model/MaisDocConcept.java | 2 +- 14 files changed, 284 insertions(+), 55 deletions(-) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocPageWriterBaklava.java (98%) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocPageWriterMuffin.java (99%) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocSegmentWriter.java (91%) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocSegmentWriterCake.java (97%) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocSegmentWriterCakeSlice.java (96%) rename nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/{ => print}/FCDocSegmentWriterCakeWord.java (86%) create mode 100644 nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterKanjiDictLiteral.java diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocWriter.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocWriter.java index ee34d44..b4a9b61 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocWriter.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocWriter.java @@ -23,7 +23,9 @@ package love.distributedrebirth.nx01.mushroom.mais.fc18; import java.io.File; +import java.io.FileInputStream; import java.io.IOException; +import java.io.InputStream; import java.util.Arrays; import java.util.Iterator; import java.util.List; @@ -42,6 +44,15 @@ import org.x4o.maisdoc.model.MaisDocConcept; import org.x4o.maisdoc.model.MaisDocNode; import org.xml.sax.SAXException; +import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDict; +import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDictLiteral; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocPageWriterBaklava; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocPageWriterMuffin; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCake; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCakeSlice; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterCakeWord; +import love.distributedrebirth.nx01.mushroom.mais.fc18.print.FCDocSegmentWriterKanjiDictLiteral; + /** * Cake doc writer. * @@ -54,14 +65,18 @@ public class FCDocWriter { private static final String[] C_FC_TOWER = {"fc-tower","Tower","All cake slices.","The cake slices of the four corner cake tower."}; private static final String[] C_FC_SLICE = {"fc-slice","Cake","The cake slice information.","The four corner cake slice provides the layout of boundries."}; private static final String[] C_FC_WORD = {"fc-word","Word","An FC18 word.","The word of an number."}; + private static final String[] C_FC_KD = {"fc-kd","Kanji","An kanji spec.","The format spec of kanji."}; + private static final String[] C_FC_KDL = {"fc-kdl","Kanji Literal","An kanji literal.","The kanji defined literal."}; private MaisDocGenerator writer = null; private MaisDoc doc = null; + private KanjiDict kanjiDict = null; static public void main(String[] args) { Iterator arguments = Arrays.asList(args).iterator(); String outputFolder = null; Integer stopCakePoint = null; + KanjiDict kanjiDictArgu = null; while (arguments.hasNext()) { String arg = arguments.next(); if ("-output".equals(arg)) { @@ -81,6 +96,21 @@ public class FCDocWriter { String stopNum = arguments.next(); stopCakePoint = Integer.parseInt(stopNum); } + if ("-kanji".equals(arg)) { + if (!arguments.hasNext()) { + System.err.println("No kanji file argument given."); + System.exit(1); + return; + } + kanjiDictArgu = new KanjiDict(); + try (InputStream in = new FileInputStream(new File(arguments.next()))) { + kanjiDictArgu.parseXML(in); + System.out.println("Parsed kanji, mapKuTen208=" + kanjiDictArgu.mapKuTen208().size()); + } catch (Exception e) { + e.printStackTrace(); + System.exit(1); + } + } } if (outputFolder == null) { System.err.println("Missing output argument"); @@ -91,7 +121,7 @@ public class FCDocWriter { if (stopCakePoint != null) { System.out.println("Writing fcdoc, stop requested at: " + stopCakePoint); } - FCDocWriter run = new FCDocWriter(stopCakePoint); + FCDocWriter run = new FCDocWriter(stopCakePoint, kanjiDictArgu); try { File out = new File(outputFolder); //out.mkdir(); @@ -102,7 +132,8 @@ public class FCDocWriter { System.out.println("Writing fcdoc, DONE"); } - public FCDocWriter(Integer stopCakePoint) { + public FCDocWriter(Integer stopCakePoint, KanjiDict kanjiDict) { + this.kanjiDict = kanjiDict; this.doc = buildApiDoc(new TDocCake(), stopCakePoint); this.writer = new MaisDocGenerator(); } @@ -132,22 +163,27 @@ public class FCDocWriter { doc.setGroupTypeName("overview", "Overview",2); doc.addTreeNodeClassExclude(TDocCakeWord.class); + doc.addTreeNodeClassExclude(KanjiDictLiteral.class); doc.setFrameNavConceptClass(TDocCakeSlice.class); doc.addTreeNodePageModeClass(TDocCake.class); doc.addTreeNodePageModeClass(TDocCakeTower.class); + doc.addTreeNodePageModeClass(KanjiDict.class); doc.addAnnotatedClasses(FCDocSegmentWriterCake.class); doc.addAnnotatedClasses(FCDocSegmentWriterCakeWord.class); doc.addAnnotatedClasses(FCDocSegmentWriterCakeSlice.class); + doc.addAnnotatedClasses(FCDocSegmentWriterKanjiDictLiteral.class); MaisDocConcept adc1 = doc.addConcept(new MaisDocConcept(null,C_FC_ROOT,TDocCake.class)); MaisDocConcept adc2 = doc.addConcept(new MaisDocConcept(adc1,C_FC_TOWER,TDocCakeTower.class)); MaisDocConcept adc3 = doc.addConcept(new MaisDocConcept(adc2,C_FC_SLICE,TDocCakeSlice.class)); /*ApiDocConcept adc4 = */doc.addConcept(new MaisDocConcept(adc3,C_FC_WORD,TDocCakeWord.class)); - //ApiDocConcept adc4 = doc.addConcept(new ApiDocConcept(adc3,C_TABLE,Table.class)); - //adc4.addChildConcepts(new ApiDocConcept(adc4, CC_RS, Relationship.class)); + MaisDocConcept kanjiDoc = new MaisDocConcept(adc1,C_FC_KD,KanjiDict.class); + MaisDocConcept kanjiDocLit = new MaisDocConcept(adc1,C_FC_KDL,KanjiDictLiteral.class); + adc1.addChildConcept(kanjiDoc); + adc1.addChildConcept(kanjiDocLit); doc.addDocPage(FCDocPageWriterMuffin.createDocPage()); doc.addDocPage(FCDocPageWriterBaklava.createDocPage()); @@ -172,9 +208,39 @@ public class FCDocWriter { // TODO: print full 21 bit unicode range too } } + if (kanjiDict != null) { + MaisDocNode kanjiDictNode208 = rootNode.addNode(createNodeKanjiDict("208")); + for (KanjiDictLiteral literal : kanjiDict.mapKuTen208Sorted()) { + kanjiDictNode208.addNode(createNodeKanjiDictLiteral(literal, true)); + } + MaisDocNode kanjiDictNode213 = rootNode.addNode(createNodeKanjiDict("213")); + for (KanjiDictLiteral literal : kanjiDict.mapKuTen213Sorted()) { + kanjiDictNode213.addNode(createNodeKanjiDictLiteral(literal, false)); + } + } return doc; } + private MaisDocNode createNodeKanjiDict(String version) { + return new MaisDocNode(kanjiDict, "jis_x_0" + version, "JIS X 0" + version, "Kanji JIS X 0" + version); + } + + private MaisDocNode createNodeKanjiDictLiteral(KanjiDictLiteral literal, boolean is208) { + //String hexPoint = Integer.toHexString(literal.getCodePoint()).toUpperCase(); + String utfPoint = new StringBuilder().appendCodePoint(literal.getCodePoint()).toString(); + String kuTen = is208?literal.getKuTen208():literal.getKuTen213(); + String kuTenPath = kuTen.replaceAll("-", "_"); + String firstMean = ""; + if (literal.getMeaningDefault() != null) { + firstMean = literal.getMeaningDefault().stream().findFirst().orElse(""); + } + String desc = utfPoint; + if (!firstMean.isEmpty()) { + desc = desc + " (" + firstMean + ")"; + } + return new MaisDocNode(literal, kuTenPath, kuTen, desc); + } + private MaisDocNode createNodeCakeTower(FourCornerDotCakeTower tower) { return new MaisDocNode(new TDocCakeTower(tower), tower.name(), tower.nameNice(), tower.description()); } diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDict.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDict.java index b5469ba..3c517ef 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDict.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDict.java @@ -24,7 +24,10 @@ package love.distributedrebirth.nx01.mushroom.mais.fc18.kanji; import java.io.IOException; import java.io.InputStream; +import java.util.ArrayList; +import java.util.Comparator; import java.util.HashMap; +import java.util.List; import java.util.Map; import javax.xml.parsers.ParserConfigurationException; @@ -46,13 +49,43 @@ import org.xml.sax.XMLReader; */ public class KanjiDict { - Map mapKuTen208 = new HashMap<>(); - Map mapKuTen213 = new HashMap<>(); - Map mapFourCorner = new HashMap<>(); + private final Map mapKuTen208 = new HashMap<>(); + private final Map mapKuTen213 = new HashMap<>(); + private final Map mapFourCorner = new HashMap<>(); public KanjiDict() { } + public Map mapKuTen208() { + return mapKuTen208; + } + + public List mapKuTen208Sorted() { + return new ArrayList<>(mapKuTen208.values()).stream().sorted(new Comparator() { + @Override + public int compare(KanjiDictLiteral arg0, KanjiDictLiteral arg1) { + return arg0.getKuTen208().compareTo(arg1.getKuTen208()); + } + }).toList(); + } + + public Map mapKuTen213() { + return mapKuTen213; + } + + public List mapKuTen213Sorted() { + return new ArrayList<>(mapKuTen213.values()).stream().sorted(new Comparator() { + @Override + public int compare(KanjiDictLiteral arg0, KanjiDictLiteral arg1) { + return arg0.getKuTen213().compareTo(arg1.getKuTen213()); + } + }).toList(); + } + + public Map mapFourCorner() { + return mapFourCorner; + } + public void parseXML(InputStream input) throws ParserConfigurationException, SAXException, IOException { SAXParserFactory factory = SAXParserFactory.newInstance(); SAXParser parser = factory.newSAXParser(); diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDictTest.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDictTest.java index 9a0f6cd..e6de093 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDictTest.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/kanji/KanjiDictTest.java @@ -59,8 +59,8 @@ public class KanjiDictTest { dict.parseXML(in); } System.out.println("======================================="); - for (Integer key : dict.mapFourCorner.keySet()) { - KanjiDictLiteral lit = dict.mapFourCorner.get(key); + for (Integer key : dict.mapFourCorner().keySet()) { + KanjiDictLiteral lit = dict.mapFourCorner().get(key); int meanCnt = lit.getMeaningDefault().size(); String meaning = lit.getMeaningDefault().stream().map(v -> v.replaceAll(" ", "\u3000")).collect(Collectors.joining(" - ")); System.out.print(new StringBuilder().appendCodePoint(lit.getCodePoint()).toString()); @@ -76,16 +76,16 @@ public class KanjiDictTest { } List kuTen2UNI2K = new ArrayList<>(); - for (String key : dict.mapKuTen208.keySet()) { - KanjiDictLiteral lit = dict.mapKuTen208.get(key); + for (String key : dict.mapKuTen208().keySet()) { + KanjiDictLiteral lit = dict.mapKuTen208().get(key); String valueUnicode = new StringBuilder().appendCodePoint(lit.getCodePoint()).toString(); kuTen2UNI2K.addAll(FourCornerUnicodeImport.strict().convertToInt18(key)); kuTen2UNI2K.add(FCDotCDC1604DashP6.NY09_EQUALS.cakePointDotIndex()); kuTen2UNI2K.addAll(FourCornerUnicodeMapper.DICTIONARY.embedUNI2K(valueUnicode)); kuTen2UNI2K.addAll(FCDotCMD5401Dash2D.CMD_F4TTY0001_NL.cakePointSequence()); } - for (String key : dict.mapKuTen213.keySet()) { - KanjiDictLiteral lit = dict.mapKuTen213.get(key); + for (String key : dict.mapKuTen213().keySet()) { + KanjiDictLiteral lit = dict.mapKuTen213().get(key); String valueUnicode = new StringBuilder().appendCodePoint(lit.getCodePoint()).toString(); kuTen2UNI2K.addAll(FourCornerUnicodeImport.strict().convertToInt18(key)); kuTen2UNI2K.add(FCDotCDC1604DashP6.NY09_EQUALS.cakePointDotIndex()); @@ -119,8 +119,8 @@ public class KanjiDictTest { int meanUse2 = 0; int meanUse1 = 0; Map uniqMean = new HashMap<>(); - for (Integer key : dict.mapFourCorner.keySet()) { - KanjiDictLiteral lit = dict.mapFourCorner.get(key); + for (Integer key : dict.mapFourCorner().keySet()) { + KanjiDictLiteral lit = dict.mapFourCorner().get(key); if (lit.getMeaningDefault().isEmpty()) { meanEmpty++; continue; @@ -156,9 +156,9 @@ public class KanjiDictTest { // JIS X 0213 + 0208 have total characters 11233 // Japanese engineers have defined System.out.println("======================================="); - System.out.println("mapFourCorner: " + dict.mapFourCorner.size()); - System.out.println("mapKuTen208: " + dict.mapKuTen208.size()); - System.out.println("mapKuTen213: " + dict.mapKuTen213.size()); + System.out.println("mapFourCorner: " + dict.mapFourCorner().size()); + System.out.println("mapKuTen208: " + dict.mapKuTen208().size()); + System.out.println("mapKuTen213: " + dict.mapKuTen213().size()); System.out.println("======================================="); System.out.println("meanUniq: " + uniqMean.size()); System.out.println("meanEmpty: " + meanEmpty); diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterBaklava.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterBaklava.java similarity index 98% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterBaklava.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterBaklava.java index 23807e2..bc3855e 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterBaklava.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterBaklava.java @@ -20,7 +20,7 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; import java.util.ArrayList; diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterMuffin.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterMuffin.java similarity index 99% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterMuffin.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterMuffin.java index 9c563e2..1cefd85 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocPageWriterMuffin.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocPageWriterMuffin.java @@ -20,7 +20,7 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; import java.util.List; diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriter.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriter.java similarity index 91% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriter.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriter.java index 71b49a3..69c7c94 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriter.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriter.java @@ -20,9 +20,10 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; +import java.util.List; import java.util.function.Function; import org.x4o.fc18.cake2.FourCornerDotCake; @@ -155,4 +156,18 @@ public interface FCDocSegmentWriter { } writer.printTagEnd(Tag.tr); } + + default void writeTableRowSequenceHex(MaisDocContentWriter writer, String system, int minHex, List sequence) throws IOException { + String displayFormat = "0x%0" + minHex + "X"; + StringBuilder buf = new StringBuilder(); + for (int i = 0; i < sequence.size(); i++) { + int seq = sequence.get(i); + String hex = String.format(displayFormat, seq); + buf.append(hex); + if (i + 1 < sequence.size()) { + buf.append(" - "); + } + } + writer.docTableRow(system, buf.toString()); + } } diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCake.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCake.java similarity index 97% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCake.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCake.java index a01406c..109c3c7 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCake.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCake.java @@ -20,7 +20,7 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; import java.util.HashSet; @@ -39,6 +39,9 @@ import org.x4o.maisdoc.model.MaisDocWriteEvent; import org.x4o.sax3.SAX3WriterHtml.Tag; import org.x4o.sax3.io.ContentCloseable; +import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCake; +import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeSlice; + /** * Cake doc slice writer. * @@ -159,6 +162,9 @@ public class FCDocSegmentWriterCake implements FCDocSegmentWriter { Set linkableSlices = new HashSet<>(); for (MaisDocNode towerNode : e.getEventObject().getNodes()) { for (MaisDocNode sliceNode : towerNode.getNodes()) { + if (!(sliceNode.getUserData() instanceof TDocCakeSlice)) { + continue; + } FourCornerDotCake slice = sliceNode.toUserData(TDocCakeSlice.class).getSlice(); linkableSlices.add(slice); StringBuilder buf = new StringBuilder(); diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeSlice.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeSlice.java similarity index 96% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeSlice.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeSlice.java index f7538f3..2691a7c 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeSlice.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeSlice.java @@ -20,7 +20,7 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; import java.util.List; @@ -35,6 +35,8 @@ import org.x4o.maisdoc.model.MaisDocNodeBody; import org.x4o.maisdoc.model.MaisDocWriteEvent; import org.x4o.sax3.io.ContentCloseable; +import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeSlice; + /** * Cake doc segment slice writer. * diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeWord.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeWord.java similarity index 86% rename from nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeWord.java rename to nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeWord.java index 625b5ac..e80c108 100644 --- a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/FCDocSegmentWriterCakeWord.java +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterCakeWord.java @@ -20,7 +20,7 @@ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package love.distributedrebirth.nx01.mushroom.mais.fc18; +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; import java.io.IOException; import java.nio.charset.StandardCharsets; @@ -44,6 +44,8 @@ import org.x4o.maisdoc.model.MaisDocWriteEvent; import org.x4o.fc18.cake2.FourCornerX00PetitVide; import org.x4o.sax3.SAX3WriterHtml.Tag; +import love.distributedrebirth.nx01.mushroom.mais.fc18.TDocCakeWord; + /** * Cake doc word writer. * @@ -85,16 +87,16 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter { writer.docTableRow(name, value); if (x06BaklavaSequence.isPresent()) { - writeSequence(writer, "Sequence-X06", 2, x06BaklavaSequence.get().baklavaPointSequence()); + writeTableRowSequenceHex(writer, "Sequence-X06", 2, x06BaklavaSequence.get().baklavaPointSequence()); } if (x08MuffinSequence.isPresent()) { - writeSequence(writer, "Sequence-X08", 2, x08MuffinSequence.get().muffinPointSequence()); + writeTableRowSequenceHex(writer, "Sequence-X08", 2, x08MuffinSequence.get().muffinPointSequence()); } if (x18CakeSequence.isPresent()) { - writeSequence(writer, "Sequence-X18", 6, x18CakeSequence.get().cakePointSequence()); + writeTableRowSequenceHex(writer, "Sequence-X18", 6, x18CakeSequence.get().cakePointSequence()); } if (x21CodeDisplay.isPresent()) { - writeSequence(writer, "Sequence-X21", 6, x21CodeDisplay.get().codePointSequence()); + writeTableRowSequenceHex(writer, "Sequence-X21", 6, x21CodeDisplay.get().codePointSequence()); StringBuilder bufUTF8 = new StringBuilder(); x21CodeDisplay.get().codePointSequence().forEach(v -> bufUTF8.appendCodePoint(v)); byte[] sequenceUTF8Bytes = bufUTF8.toString().getBytes(StandardCharsets.UTF_8); @@ -102,7 +104,7 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter { for (int i = 0; i < sequenceUTF8Bytes.length; i++) { sequenceUTF8.add(Byte.toUnsignedInt(sequenceUTF8Bytes[i])); } - writeSequence(writer, "Sequence-X21-UTF8", 2, sequenceUTF8); + writeTableRowSequenceHex(writer, "Sequence-X21-UTF8", 2, sequenceUTF8); StringBuilder bufXML = new StringBuilder(); PrimitiveIterator.OfInt codePoints = bufUTF8.codePoints().iterator(); @@ -137,19 +139,4 @@ public class FCDocSegmentWriterCakeWord implements FCDocSegmentWriter { writer.docTableEnd(); } } - - - private void writeSequence(MaisDocContentWriter writer, String system, int minHex, List sequence) throws IOException { - String displayFormat = "0x%0" + minHex + "X"; - StringBuilder buf = new StringBuilder(); - for (int i = 0; i < sequence.size(); i++) { - int seq = sequence.get(i); - String hex = String.format(displayFormat, seq); - buf.append(hex); - if (i + 1 < sequence.size()) { - buf.append(" - "); - } - } - writer.docTableRow(system, buf.toString()); - } } diff --git a/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterKanjiDictLiteral.java b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterKanjiDictLiteral.java new file mode 100644 index 0000000..94705a1 --- /dev/null +++ b/nx01-mushroom-mais-fc18/src/main/java/love/distributedrebirth/nx01/mushroom/mais/fc18/print/FCDocSegmentWriterKanjiDictLiteral.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2004-2014, Willem Cazander + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted provided + * that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this list of conditions and the + * following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and + * the following disclaimer in the documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package love.distributedrebirth.nx01.mushroom.mais.fc18.print; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import java.util.PrimitiveIterator; +import java.util.stream.Collectors; + +import org.x4o.maisdoc.flake.MaisDocContentCss; +import org.x4o.maisdoc.flake.MaisDocContentWriter; +import org.x4o.maisdoc.flake.MaisDocNodeWriterMethod; +import org.x4o.maisdoc.model.MaisDocNode; +import org.x4o.maisdoc.model.MaisDocNodeBody; +import org.x4o.maisdoc.model.MaisDocWriteEvent; +import org.x4o.sax3.SAX3WriterHtml.Tag; + +import love.distributedrebirth.nx01.mushroom.mais.fc18.kanji.KanjiDictLiteral; + +/** + * Kanji dict literal doc segment writer. + * + * @author Willem Cazander + * @version 1.0 May 21, 2025 + */ +public class FCDocSegmentWriterKanjiDictLiteral implements FCDocSegmentWriter { + + @MaisDocNodeWriterMethod(nodeBody=MaisDocNodeBody.SUMMARY,targetClasses={KanjiDictLiteral.class}) + public void writeCakeWordSummary(MaisDocWriteEvent event) throws IOException { + MaisDocContentWriter writer = event.getWriter(); + KanjiDictLiteral literal = event.getEventObject().toUserData(KanjiDictLiteral.class); + if (literal == null) { + writer.printTagStart(Tag.pre); + writer.printCharacters("No literal data for: " + event.getEventObject()); + writer.printTagEnd(Tag.pre); + return; + } + writer.docTableStart("Literal Summary", "The kanji literal value information.",MaisDocContentCss.overviewSummary); + writer.docTableHeader("Point", "Value"); + String name = "" + literal.getCodePoint(); + String value = ""; + StringBuilder buf = new StringBuilder(); + buf.appendCodePoint(literal.getCodePoint()); + value = buf.toString(); + writer.docTableRow(name, value); + + if (literal.getFourCorner() != null) { + writer.docTableRow("Four-Corner", "" + literal.getFourCorner()); + } + if (literal.getKuTen208() != null) { + writer.docTableRow("KuTen-208", "" + literal.getKuTen208()); + } + if (literal.getKuTen213() != null) { + writer.docTableRow("KuTen-213", "" + literal.getKuTen213()); + } + + writeTableRowSequenceHex(writer, "Sequence-X21", 6, List.of(literal.getCodePoint())); + StringBuilder bufUTF8 = new StringBuilder(); + bufUTF8.appendCodePoint(literal.getCodePoint()); + byte[] sequenceUTF8Bytes = bufUTF8.toString().getBytes(StandardCharsets.UTF_8); + List sequenceUTF8 = new ArrayList<>(); + for (int i = 0; i < sequenceUTF8Bytes.length; i++) { + sequenceUTF8.add(Byte.toUnsignedInt(sequenceUTF8Bytes[i])); + } + writeTableRowSequenceHex(writer, "Sequence-X21-UTF8", 2, sequenceUTF8); + + StringBuilder bufXML = new StringBuilder(); + PrimitiveIterator.OfInt codePoints = bufUTF8.codePoints().iterator(); + while (codePoints.hasNext()) { + int codePoint = codePoints.nextInt(); + bufXML.append("&#x"); // manual & to show literal escape string + bufXML.append(Integer.toHexString(codePoint)); + bufXML.append(";"); + } + writer.docTableRow("Sequence-X21-XML", bufXML.toString()); + + writer.docTableEnd(); + + writer.docTableStart("Meaning Summary", "The kanji literal meaning information.",MaisDocContentCss.overviewSummary); + writer.docTableHeader("Locale", "Value"); + for (String key : literal.getMeaning().keySet()) { + String meanLocale = key; + if (key.isEmpty()) { + meanLocale = "en"; + } + List meanings = literal.getMeaning().get(key); + String meanLocal = meanings.stream().collect(Collectors.joining(", ")); + writer.docTableRow(meanLocale, meanLocal); + } + writer.docTableEnd(); + } +} diff --git a/nx01-mushroom-mais-mm/src/main/java/org/eobjects/metamodel/doc/DocModelWriter.java b/nx01-mushroom-mais-mm/src/main/java/org/eobjects/metamodel/doc/DocModelWriter.java index 7a69464..2810787 100644 --- a/nx01-mushroom-mais-mm/src/main/java/org/eobjects/metamodel/doc/DocModelWriter.java +++ b/nx01-mushroom-mais-mm/src/main/java/org/eobjects/metamodel/doc/DocModelWriter.java @@ -111,7 +111,7 @@ public class DocModelWriter { MaisDocConcept adc3 = doc.addConcept(new MaisDocConcept(adc2,C_SCHEMA,Schema.class)); MaisDocConcept adc4 = doc.addConcept(new MaisDocConcept(adc3,C_TABLE,Table.class)); - adc4.addChildConcepts(new MaisDocConcept(adc4, CC_RS, Relationship.class)); + adc4.addChildConcept(new MaisDocConcept(adc4, CC_RS, Relationship.class)); doc.addDocPage(DefaultPageWriterTree.createDocPage()); doc.addDocPage(DefaultPageWriterIndexAll.createDocPage()); diff --git a/nx01-x4o-driver/src/main/java/org/x4o/xml/eld/doc/EldDocWriter.java b/nx01-x4o-driver/src/main/java/org/x4o/xml/eld/doc/EldDocWriter.java index c181702..0859adb 100644 --- a/nx01-x4o-driver/src/main/java/org/x4o/xml/eld/doc/EldDocWriter.java +++ b/nx01-x4o-driver/src/main/java/org/x4o/xml/eld/doc/EldDocWriter.java @@ -52,7 +52,6 @@ import org.x4o.xml.element.ElementNamespace; import org.x4o.xml.lang.X4OLanguage; import org.x4o.xml.lang.X4OLanguageModule; import org.x4o.xml.lang.X4OLanguageSession; -import org.xml.sax.SAXException; /** * EldDocWriter writes the x4o eld documentation. @@ -210,13 +209,13 @@ public class EldDocWriter { MaisDocConcept adcEc = doc.addConcept(new MaisDocConcept(adcNs,C_ELEMENT,ElementClass.class)); // mm maybe redo something here - adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_ATTRIBUTE_H,ElementNamespaceAttribute.class)); - adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_CONFIGURATOR_G,ElementConfiguratorGlobal.class)); - adcMod.addChildConcepts(new MaisDocConcept(adcMod,CC_BINDING,ElementBindingHandler.class)); - adcIface.addChildConcepts(new MaisDocConcept(adcMod,CC_ATTRIBUTE,ElementClassAttribute.class)); - adcIface.addChildConcepts(new MaisDocConcept(adcMod,CC_CONFIGURATOR,ElementConfigurator.class)); - adcEc.addChildConcepts(new MaisDocConcept(adcEc,CC_CONFIGURATOR,ElementConfigurator.class)); - adcEc.addChildConcepts(new MaisDocConcept(adcEc,CC_ATTRIBUTE,ElementClassAttribute.class)); + adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_ATTRIBUTE_H,ElementNamespaceAttribute.class)); + adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_CONFIGURATOR_G,ElementConfiguratorGlobal.class)); + adcMod.addChildConcept(new MaisDocConcept(adcMod,CC_BINDING,ElementBindingHandler.class)); + adcIface.addChildConcept(new MaisDocConcept(adcMod,CC_ATTRIBUTE,ElementClassAttribute.class)); + adcIface.addChildConcept(new MaisDocConcept(adcMod,CC_CONFIGURATOR,ElementConfigurator.class)); + adcEc.addChildConcept(new MaisDocConcept(adcEc,CC_CONFIGURATOR,ElementConfigurator.class)); + adcEc.addChildConcept(new MaisDocConcept(adcEc,CC_ATTRIBUTE,ElementClassAttribute.class)); // Non-tree pages config if (propertyConfig.getPropertyBoolean(PAGE_PRINT_XTREE)) { doc.addDocPage(EldDocXTreePageWriter.createDocPage()); } diff --git a/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDoc.java b/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDoc.java index c15ae77..264a23b 100644 --- a/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDoc.java +++ b/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDoc.java @@ -196,9 +196,16 @@ public class MaisDoc { if (concept.getConceptClass().isAssignableFrom(objClass)) { return concept; } + // NOTE: only 2 level search for sub child concepts for (MaisDocConcept c:concept.getChildConcepts()) { if (c.getConceptClass().isAssignableFrom(objClass)) { - return concept; + //return concept; + return c; + } + for (MaisDocConcept cc:c.getChildConcepts()) { + if (cc.getConceptClass().isAssignableFrom(objClass)) { + return cc; + } } } } diff --git a/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDocConcept.java b/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDocConcept.java index 151be68..67dc773 100644 --- a/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDocConcept.java +++ b/nx01-x4o-maisdoc/src/main/java/org/x4o/maisdoc/model/MaisDocConcept.java @@ -133,7 +133,7 @@ public class MaisDocConcept { this.conceptClass = conceptClass; } - public void addChildConcepts(MaisDocConcept childConcept) { + public void addChildConcept(MaisDocConcept childConcept) { childConcepts.add(childConcept); }