1

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

@@ -26,18 +26,28 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
             //原文
             String content = params.getContent();
 
-            //将原文从"1"截取到末尾（为了去除首行"声称的是:\n"）
+            //将原文从"1"截取到末尾（为了去除首行"声称的是:"）
             if (!content.equals("") && content.contains("声称的是") && content.contains("1")) {
                 content = content.substring(content.indexOf("1"));
             }
 
-            //第1步：拆分权要原文 ↓
+            //第1步 ↓：拆分权要原文
             //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
             content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
 
-            //若原文没有换行符，则全文按照句号"。"拆分
+            //若原文没有换行符则全文按照句号"。"拆分
             if (!content.contains("##@@&&")) {
-                content = content.replace("。", "。\n");
+                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();
+                        if (!macherGroup.equals("1.")) {
+                            content = content.replaceFirst(macherGroup, "\n" + macherGroup);
+                        }
+                    }
+                }
             } else {
                 //定义正则表达式
                 String regex = "##@@&&[0-9]+";
@@ -53,7 +63,7 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
             String[] strs = content.split("\n");
 
 
-            //第2步：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+            //第2步 ↓：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort）
             String regex1 = "权利要求[0-9]+";
             String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
             for (int i = 0; i < strs.length; i++) {
@@ -61,20 +71,21 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                 PatentRightContent patentRightContent = new PatentRightContent()
                         .setContent(strs[i])
                         .setSort(i);
+                //创建父级排序号集合，装载父级序号
+                ArrayList<Integer> parentSorts = new ArrayList<>();
 
                 //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
-                ArrayList<Integer> parentSorts = new ArrayList<>();
                 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]);
-                    if (matcher2.find()) {  //"权利要求2~4"
-                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"
-                        String[] parentNumStrs = new String[0];
+                    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]
                         if (parentNum.contains("～")) {
-                            parentNumStrs = parentNum.split("～");  //[2, 4]
+                            parentNumStrs = parentNum.split("～");
                         } else if (parentNum.contains("-")) {
                             parentNumStrs = parentNum.split("-");
                         } else if (parentNum.contains("至")) {
@@ -83,30 +94,25 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                             parentNumStrs = parentNum.split("或");
                         }
 
-                          //{1, 3}
-                        for (int i1 = 0; i1 < parentNumStrs.length; i1++) {
-                            parentSorts.add(Integer.parseInt(parentNumStrs[i1]) - 1);  //{1, 3}
-                        }
-
-                        if (parentNum.contains("或")) {
-                            patentRightContent.setParentSorts(parentSorts);
-                        } else {
-                            ArrayList<Integer> parentSorts2 = new ArrayList<>();
-                            for (int i1 = parentSorts.get(0); i1 < parentSorts.get(parentSorts.size() - 1); i1++) {
-                                parentSorts2.add(i1);
+                        if (parentNum.contains("或")) {  //"2或4"
+                            for (String parentNumStr : parentNumStrs) {
+                                parentSorts.add(Integer.parseInt(parentNumStr) - 1);  //sort：{1, 3}
+                            }
+                        } else {  //"2~4"、"2-4"、"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}
                             }
-                            patentRightContent.setParentSorts(parentSorts2);
                         }
-
-                    } else if (matcher1.find()) {
-                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);
+                    } else if (matcher1.find()) {  //"权利要求4"
+                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);  //"4"
                         int parentSort = Integer.parseInt(parentNum) - 1;
-                        parentSorts.add(parentSort);
-                        patentRightContent.setParentSorts(parentSorts);
+                        parentSorts.add(parentSort);  //sort：{3}
                     }
+
+                    patentRightContent.setParentSorts(parentSorts);
                 } else {
                     //否则该权要为主权要
-                    parentSorts.add(-1);
+                    parentSorts.add(-1);  //sort：{-1}
                     patentRightContent
                             .setType(1)
                             .setParentSorts(parentSorts);

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

@@ -23,32 +23,43 @@ public class PatentRightSplitENService implements PatentRightSplitService {
         try {
             //创建一个权要集合，用于返回结果
             ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
-            //取出原文
+            //原文
             String content = params.getContent();
 
-            //将原文从"1"截取到末尾（为了去除首行"What is claimed is:\n"）
+            //将原文从"1"截取到末尾（为了去除首行"What is claimed is:    "）
             if (!content.equals("") && content.contains("What is claimed is") && content.contains("1")) {
                 content = content.substring(content.indexOf("1"));
             }
 
-            //第1步：拆分权要原文 ↓
+            //第1步 ↓：拆分权要原文
             //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
             content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
 
-            //定义正则表达式
-            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));
+            //若原文没有换行符，则全文按照权要序号如 "1." "2." "3."进行拆分
+            if (!content.contains("##@@&&")) {
+                Matcher matcher = Pattern.compile("[0-9]+\\.").matcher(content);
+                while (matcher.find()) {  //"1."
+                    String macherGroup = matcher.group();
+                    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()) {  //"##@@&&1"
+                    String macherGroup = matcher.group();
+                    content = content.replaceFirst(macherGroup, "\n" + macherGroup.substring(macherGroup.indexOf("##@@&&") + 6));
+                }
+                //去除所有特殊符号"##@@&&"
+                content = content.replace("##@@&&", "");
             }
-            //去除所有特殊符号"##@@&&"
-            content = content.replace("##@@&&", "");
             //最后按照换行符"\n"将权要拆成多个
             String[] strs = content.split("\n");
 
 
-            //第2步：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+            //第2步 ↓：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort）
             String regex1 = "claim [0-9]+";
             String regex2 = "claims [0-9]+ or [0-9]+";
             String regex3 = "any preceding claim";
@@ -70,31 +81,32 @@ public class PatentRightSplitENService implements PatentRightSplitService {
                     Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
                     Matcher matcher3 = Pattern.compile(regex3).matcher(strs[i]);
                     Matcher matcher4 = Pattern.compile(regex4).matcher(strs[i]);
-                    if (matcher2.find()) {  //"claims 2 or 3"
-                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("claims") + 7);  //"2 or 3"
-                        String[] parentNumStrs = parentNum.split(" or ");  //[2, 3]
+                    if (matcher2.find()) {  //"claims 2 or 4"
+                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("claims") + 7);  //"2 or 4"
+                        String[] parentNumStrs = parentNum.split(" or ");  //[2, 4]
                         for (String parentNumStr : parentNumStrs) {
-                            parentSorts.add(Integer.parseInt(parentNumStr) - 1);
+                            parentSorts.add(Integer.parseInt(parentNumStr) - 1);  //sort：{1, 3}
                         }
-                    } else if (matcher4.find()) {
-                        String parentNum = matcher4.group().substring(matcher4.group().indexOf("claims") + 7);
-                        String[] parentNumStrs = parentNum.split(" to ");  //[2, 5]
+                    } else if (matcher4.find()) {  //"claims 2 to 4"
+                        String parentNum = matcher4.group().substring(matcher4.group().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);
+                            parentSorts.add(i1 - 1);  //sort：{1, 2, 3}
                         }
-                    } else if (matcher1.find()) {
-                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("claim") + 6);
+                    } else if (matcher1.find()) {  //"claim 4"
+                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("claim") + 6);  //"4"
                         int parentSort = Integer.parseInt(parentNum) - 1;
-                        parentSorts.add(parentSort);
-                    } else if (matcher3.find()) {
+                        parentSorts.add(parentSort);  //sort：{3}
+                    } else if (matcher3.find()) {  //"any preceding claim"
                         for (int sort = 0; sort < i; sort++) {
-                            parentSorts.add(sort);
+                            parentSorts.add(sort);  //sort：{0, 1, 2, 3,...i-1}
                         }
                     }
+
                     patentRightContent.setParentSorts(parentSorts);
                 } else {
                     //否则该权要为主权要
-                    parentSorts.add(-1);
+                    parentSorts.add(-1);  //sort：{-1}
                     patentRightContent
                             .setType(1)
                             .setParentSorts(parentSorts);

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

@@ -26,13 +26,26 @@
 //            //原文
 //            String content = params.getContent();
 //
-//            //第1步：拆分权要原文 ↓
+//            //将原文从"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("##@@&&")) {
-//                content = content.replace("。", "。\n");
+//                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]+";
@@ -48,7 +61,7 @@
 //            String[] strs = content.split("\n");
 //
 //
-//            //第2步：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+//            //第2步 ↓：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort）
 //            String regex1 = "权利要求[0-9]+";
 //            String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
 //            for (int i = 0; i < strs.length; i++) {
@@ -56,19 +69,21 @@
 //                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]);
-//                    if (matcher2.find()) {  //"权利要求2~4"
-//                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"
-//                        String[] parentNumStrs = new String[0];
+//                    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]
 //                        if (parentNum.contains("～")) {
-//                            parentNumStrs = parentNum.split("～");  //[2, 4]
+//                            parentNumStrs = parentNum.split("～");
 //                        } else if (parentNum.contains("-")) {
 //                            parentNumStrs = parentNum.split("-");
 //                        } else if (parentNum.contains("至")) {
@@ -77,49 +92,39 @@
 //                            parentNumStrs = parentNum.split("或");
 //                        }
 //
-//                        int[] parentSorts = new int[parentNumStrs.length];  //[1, 3]
-//                        for (int i1 = 0; i1 < parentSorts.length; i1++) {
-//                            parentSorts[i1] = Integer.parseInt(parentNumStrs[i1]) - 1;
-//                        }
-//
-//                        if (parentNum.contains("或")) {
-//                            StringBuilder builder = new StringBuilder();
-//                            for (int parentSort : parentSorts) {
-//                                builder.append(parentSort).append(",");
+//                        if (parentNum.contains("或")) {  //"2或4"
+//                            for (String parentNumStr : parentNumStrs) {
+//                                parentSorts.add(Integer.parseInt(parentNumStr) - 1);  //sort：{1, 3}
 //                            }
-//                            patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
-//                        } else {
-//                            StringBuilder builder = new StringBuilder();
-//                            for (int j = parentSorts[0]; j <= parentSorts[parentSorts.length - 1]; j++) {
-//                                if ((builder + "").equals("")) {
-//                                    builder.append(j);
-//                                } else {
-//                                    builder.append(",").append(j);
-//                                }
+//                        } else {  //"2~4"、"2-4"、"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}
 //                            }
-//                            patentRight.setParentSort(builder + "");
 //                        }
-//
-//                    } else if (matcher1.find()) {
-//                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);
-//                        patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
+//                    } 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 {
 //                    //否则该权要为主权要
-//                    patentRight
+//                    parentSorts.add(-1);  //sort：{-1}
+//                    patentRightContent
 //                            .setType(1)
-//                            .setParentSort("-1");
+//                            .setParentSorts(parentSorts);
 //                }
 //
-//                patentRights.add(patentRight);
+//                patentRightContents.add(patentRightContent);
 //            }
 //
-//            return patentRights;
+//            return patentRightContents;
 //        } catch (Exception e) {
 //            e.printStackTrace();
-//            ArrayList<PatentRight> patentRights = new ArrayList<>();
-//            patentRights.add(new PatentRight().setContent(params.getContent()));
-//            return patentRights;
+//            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
+//            patentRightContents.add(new PatentRightContent().setContent(params.getContent()));
+//            return patentRightContents;
 //        }
 //
 //    }