1

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitCNService.java

@@ -42,9 +42,9 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                 } else {  //若没有句号"。"，则全文按照权要序号如 "1." "2." "3."进行拆分
                     Matcher matcher = Pattern.compile("[0-9]+\\.").matcher(content);
                     while (matcher.find()) {
-                        String macherGroup = matcher.group();
+                        String macherGroup = matcher.group();  //2.
                         if (!macherGroup.equals("1.")) {
-                            content = content.replaceFirst(macherGroup, "\n" + macherGroup);
+                            content = content.replaceFirst(macherGroup, "\n" + macherGroup);  //\n2.
                         }
                     }
                 }
@@ -73,6 +73,7 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                         .setSort(i);
                 //创建父级排序号集合，装载父级序号
                 ArrayList<Integer> parentSorts = new ArrayList<>();
+                String macherGroup;
 
                 //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
                 if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
@@ -82,7 +83,8 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                     Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
                     Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
                     if (matcher2.find()) {  //"权利要求2~4"、权利要求"2-4"、权利要求"2至4"、权利要求"2或4"
-                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"、"2-4"、"2至4"、"2或4"
+                        macherGroup = matcher2.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("权利要求") + 4);  //"2~4"、"2-4"、"2至4"、"2或4"
                         String[] parentNumStrs = new String[0];  //[2, 4]
                         if (parentNum.contains("～")) {
                             parentNumStrs = parentNum.split("～");
@@ -104,7 +106,8 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                             }
                         }
                     } else if (matcher1.find()) {  //"权利要求4"
-                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);  //"4"
+                        macherGroup = matcher1.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("权利要求") + 4);  //"4"
                         int parentSort = Integer.parseInt(parentNum) - 1;
                         parentSorts.add(parentSort);  //sort：{3}
                     }

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitENService.java

@@ -71,6 +71,7 @@ public class PatentRightSplitENService implements PatentRightSplitService {
                         .setSort(i);
                 //创建父级排序号集合，装载父级序号
                 ArrayList<Integer> parentSorts = new ArrayList<>();
+                String macherGroup;
 
                 //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
                 if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("claim")) || (!strs[i].contains("，") && strs[i].contains("claim"))) {
@@ -82,19 +83,22 @@ public class PatentRightSplitENService implements PatentRightSplitService {
                     Matcher matcher3 = Pattern.compile(regex3).matcher(strs[i]);
                     Matcher matcher4 = Pattern.compile(regex4).matcher(strs[i]);
                     if (matcher2.find()) {  //"claims 2 or 4"
-                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("claims") + 7);  //"2 or 4"
+                        macherGroup = matcher2.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("claims") + 7);  //"2 or 4"
                         String[] parentNumStrs = parentNum.split(" or ");  //[2, 4]
                         for (String parentNumStr : parentNumStrs) {
                             parentSorts.add(Integer.parseInt(parentNumStr) - 1);  //sort：{1, 3}
                         }
                     } else if (matcher4.find()) {  //"claims 2 to 4"
-                        String parentNum = matcher4.group().substring(matcher4.group().indexOf("claims") + 7);  //"2 to 4"
+                        macherGroup = matcher4.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("claims") + 7);  //"2 to 4"
                         String[] parentNumStrs = parentNum.split(" to ");  //[2, 4]
                         for (int i1 = Integer.parseInt(parentNumStrs[0]); i1 <= Integer.parseInt(parentNumStrs[parentNumStrs.length - 1]); i1++) {
                             parentSorts.add(i1 - 1);  //sort：{1, 2, 3}
                         }
                     } else if (matcher1.find()) {  //"claim 4"
-                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("claim") + 6);  //"4"
+                        macherGroup = matcher1.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("claim") + 6);  //"4"
                         int parentSort = Integer.parseInt(parentNum) - 1;
                         parentSorts.add(parentSort);  //sort：{3}
                     } else if (matcher3.find()) {  //"any preceding claim"

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitJPService.java

@@ -1,84 +1,84 @@
-//package cn.cslg.pas.service.patentRightSplit;
-//
-//import cn.cslg.pas.common.PatentRightContent;
-//import cn.cslg.pas.common.model.params.PatentRightParams;
-//import org.springframework.stereotype.Service;
-//
-//import java.util.ArrayList;
-//import java.util.List;
-//import java.util.regex.Matcher;
-//import java.util.regex.Pattern;
-//
-///**
-// * 拆分权要类（日本专利JP）
-// *
-// * @author chenyu
-// * @date 2023/8/30
-// */
-//@Service
-//public class PatentRightSplitJPService implements PatentRightSplitService {
-//
-//    @Override
-//    public List<PatentRightContent> formatPatentRight(PatentRightParams params) {
-//        try {
-//            //创建一个权要集合，用于返回结果
-//            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
-//            //原文
-//            String content = params.getContent();
-//
-//            //将原文从"1"截取到末尾（为了去除首行"声称的是:"）
-//            if (!content.equals("") && content.contains("声称的是") && content.contains("1")) {
-//                content = content.substring(content.indexOf("1"));
-//            }
-//
-//            //第1步 ↓：拆分权要原文
-//            //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
-//            content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
-//
-//            //若原文没有换行符则全文按照句号"。"拆分
-//            if (!content.contains("##@@&&")) {
-//                if (content.contains("。")) {  //若有句号"。"
-//                    content = content.replace("。", "。\n");
-//                } else {  //若没有句号"。"，则全文按照权要序号如 "1." "2." "3."进行拆分
-//                    Matcher matcher = Pattern.compile("[0-9]+\\.").matcher(content);
-//                    while (matcher.find() && !matcher.group().equals("1.")) {
-//                        String macherGroup = matcher.group();
-//                        content = content.replaceFirst(macherGroup, "\n" + macherGroup);
-//                    }
-//                }
-//            } else {
-//                //定义正则表达式
-//                String regex = "##@@&&[0-9]+";
-//                Matcher matcher = Pattern.compile(regex).matcher(content);
-//                while (matcher.find()) {
-//                    String macherGroup = matcher.group();
-//                    content = content.replaceFirst(macherGroup, "\n" + macherGroup.substring(macherGroup.indexOf("##@@&&") + 6));
-//                }
-//                //去除所有特殊符号"##@@&&"
-//                content = content.replace("##@@&&", "");
-//            }
-//            //最后按照换行符"\n"将权要拆成多个
-//            String[] strs = content.split("\n");
-//
-//
-//            //第2步 ↓：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort）
-//            String regex1 = "权利要求[0-9]+";
-//            String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
-//            for (int i = 0; i < strs.length; i++) {
-//                //创建权要对象装载当前权要
-//                PatentRightContent patentRightContent = new PatentRightContent()
-//                        .setContent(strs[i])
-//                        .setSort(i);
-//                //创建父级排序号集合，装载父级序号
-//                ArrayList<Integer> parentSorts = new ArrayList<>();
-//
-//                //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
-//                if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
-//                    //则该权要为附权要
-//                    patentRightContent.setType(0);
-//
-//                    Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
-//                    Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+package cn.cslg.pas.service.patentRightSplit;
+
+import cn.cslg.pas.common.PatentRightContent;
+import cn.cslg.pas.common.model.params.PatentRightParams;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 拆分权要类（日本专利JP）
+ *
+ * @author chenyu
+ * @date 2023/8/30
+ */
+@Service
+public class PatentRightSplitJPService implements PatentRightSplitService {
+
+    @Override
+    public List<PatentRightContent> formatPatentRight(PatentRightParams params) {
+        try {
+            //创建一个权要集合，用于返回结果
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
+            //原文
+            String content = params.getContent();
+
+            //第1步 ↓：拆分权要原文
+            //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
+            content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
+
+            //若原文没有换行符则全文按照句号"。"拆分
+            if (!content.contains("##@@&&")) {
+                if (content.contains("。")) {  //若有句号"。"
+                    content = content.replace("。", "。\n");
+                } else {  //若没有句号"。"，则全文按照权要序号如 "【請求項1】" "【請求項2】" "【請求項3】"进行拆分
+                    Matcher matcher = Pattern.compile("【請求項[0-9]+】").matcher(content);
+                    while (matcher.find()) {
+                        String macherGroup = matcher.group();  //"【請求項1】"、"【請求項2】"
+                        if (!macherGroup.equals("【請求項1】")) {
+                            content = content.replaceFirst(macherGroup, "\n" + macherGroup);
+                        }
+                    }
+                }
+            } else {
+                //定义正则表达式
+                String regex = "##@@&&【請求項[0-9]+】";
+                Matcher matcher = Pattern.compile(regex).matcher(content);
+                while (matcher.find()) {
+                    String macherGroup = matcher.group();  //"##@@&&【請求項1】"、""##@@&&【請求項2】""
+                    content = content.replaceFirst(macherGroup, "\n" + macherGroup.substring(macherGroup.indexOf("##@@&&") + 6));
+                }
+                //去除所有特殊符号"##@@&&"
+                content = content.replace("##@@&&", "");
+            }
+            //最后按照换行符"\n"将权要拆成多个
+            String[] strs = content.split("\n");
+
+
+            //第2步 ↓：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort）
+            String regex1 = "請求項[0-9]+";
+            //String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
+            for (int i = 0; i < strs.length; i++) {
+                //创建权要对象装载当前权要
+                PatentRightContent patentRightContent = new PatentRightContent()
+                        .setContent(strs[i])
+                        .setSort(i);
+                //创建父级排序号集合，装载父级序号
+                ArrayList<Integer> parentSorts = new ArrayList<>();
+                String macherGroup;
+
+                //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
+                //if ((strs[i].contains("、") && strs[i].substring(strs[i].indexOf("】"), strs[i].indexOf("、")).contains("請求項")) || (!strs[i].contains("、") && strs[i].substring(strs[i].indexOf("】")).contains("請求項"))) {
+                //判断若不是权要1，并且含有"請求項"三个字，则为附属权要
+                if (i != 0 && strs[i].contains("請求項")) {
+                    //则该权要为附权要
+                    patentRightContent.setType(0);
+
+                    Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+                    //Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
 //                    if (matcher2.find()) {  //"权利要求2~4"、权利要求"2-4"、权利要求"2至4"、权利要求"2或4"
 //                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"、"2-4"、"2至4"、"2或4"
 //                        String[] parentNumStrs = new String[0];  //[2, 4]
@@ -101,32 +101,34 @@
 //                                parentSorts.add(i1 - 1);  //sort：{1, 2, 3}
 //                            }
 //                        }
-//                    } else if (matcher1.find()) {  //"权利要求4"
-//                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);  //"4"
-//                        int parentSort = Integer.parseInt(parentNum) - 1;
-//                        parentSorts.add(parentSort);  //sort：{3}
-//                    }
-//
-//                    patentRightContent.setParentSorts(parentSorts);
-//                } else {
-//                    //否则该权要为主权要
-//                    parentSorts.add(-1);  //sort：{-1}
-//                    patentRightContent
-//                            .setType(1)
-//                            .setParentSorts(parentSorts);
-//                }
-//
-//                patentRightContents.add(patentRightContent);
-//            }
-//
-//            return patentRightContents;
-//        } catch (Exception e) {
-//            e.printStackTrace();
-//            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
-//            patentRightContents.add(new PatentRightContent().setContent(params.getContent()));
-//            return patentRightContents;
-//        }
-//
-//    }
-//
-//}
+//                    } else
+                    if (matcher1.find()) {  //"請求項4"
+                        macherGroup = matcher1.group();
+                        String parentNum = macherGroup.substring(macherGroup.indexOf("請求項") + 3);  //4
+                        int parentSort = Integer.parseInt(parentNum) - 1;
+                        parentSorts.add(parentSort);  //sort：{3}
+                    }
+
+                    patentRightContent.setParentSorts(parentSorts);
+                } else if (i == 0 || !strs[i].contains("請求項")) {
+                    //否则该权要为主权要
+                    parentSorts.add(-1);  //sort：{-1}
+                    patentRightContent
+                            .setType(1)
+                            .setParentSorts(parentSorts);
+                }
+
+                patentRightContents.add(patentRightContent);
+            }
+
+            return patentRightContents;
+        } catch (Exception e) {
+            e.printStackTrace();
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
+            patentRightContents.add(new PatentRightContent().setContent(params.getContent()));
+            return patentRightContents;
+        }
+
+    }
+
+}

PAS/src/test/java/cn/cslg/pas/service/test.java

@@ -0,0 +1,36 @@
+package cn.cslg.pas.service;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+/**
+ * @author chenyu
+ * @date 2023/9/1
+ */
+@SpringBootTest
+public class test {
+
+    @Test
+    void test() {
+        String text = "【請求項1】\n" +
+                "複数の電源と;\n" +
+                "各々が前記電源の1つに関連し、前記関連する電源の性能データを収集する複数の監視モジュールと;\n" +
+                "各々が前記監視モジュールの1つに関連し、前記性能データを送信する複数の送信機と;\n" +
+                "各々が前記送信機の1つに関連し、タイマーの初期化からの経過時間に応じて送信イベントを制御する複数のコントローラと\n" +
+                "を具えていることを特徴とする分散型DC電力設備用監視システム。\n";
+        boolean result1 = text.contains("、");
+        boolean result2 = text.substring(0, text.indexOf("、")).contains("請求項");
+        boolean result3 = text.contains("、");
+        boolean result4 = text.contains("請求項");
+
+        if ((text.contains("、") && text.substring(0, text.indexOf("、")).contains("請求項")) || (!text.contains("、") && text.contains("請求項"))) {
+            System.out.println("通过");
+        }
+
+//        if ((strs[i].contains("、") && strs[i].substring(0, strs[i].indexOf("、")).contains("請求項")) || (!strs[i].contains("、") && strs[i].contains("請求項"))) {
+//
+//        }
+
+    }
+
+}