├── .github
└── workflows
│ └── gradle.yml
├── .gitignore
├── LICENSE
├── README.MD
├── build.gradle
├── gradle
└── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── jitpack.yml
├── settings.gradle
└── src
├── main
├── java
│ └── cc
│ │ └── sfclub
│ │ ├── Internal.java
│ │ ├── catcode
│ │ ├── Base64.java
│ │ ├── CatCodeHelper.java
│ │ └── entities
│ │ │ ├── At.java
│ │ │ ├── Image.java
│ │ │ ├── Plain.java
│ │ │ └── package-info.java
│ │ ├── command
│ │ ├── CommandListener.java
│ │ ├── Source.java
│ │ └── internal
│ │ │ ├── Me.java
│ │ │ ├── Op.java
│ │ │ └── Stop.java
│ │ ├── core
│ │ ├── Core.java
│ │ ├── CoreCfg.java
│ │ ├── DatabaseCfg.java
│ │ ├── I18N.java
│ │ ├── Initializer.java
│ │ ├── PermCfg.java
│ │ ├── ShutdownHook.java
│ │ └── security
│ │ │ ├── PolarSec.java
│ │ │ └── modules
│ │ │ ├── HarmfulMessage.java
│ │ │ ├── HighFrequencyMessage.java
│ │ │ └── SpamMessage.java
│ │ ├── database
│ │ └── converter
│ │ │ ├── PermListConverter.java
│ │ │ └── StrListConverter.java
│ │ ├── events
│ │ ├── Event.java
│ │ ├── GroupEvent.java
│ │ ├── MemberEvent.java
│ │ ├── MessageEvent.java
│ │ ├── PlatformEvent.java
│ │ ├── internal
│ │ │ └── MessageListener.java
│ │ ├── member
│ │ │ ├── MemberLeaveEvent.java
│ │ │ └── MemberRequestJoinEvent.java
│ │ ├── message
│ │ │ ├── Message.java
│ │ │ ├── MessageDeletedEvent.java
│ │ │ ├── MessageModifiedEvent.java
│ │ │ ├── direct
│ │ │ │ ├── PrivateMessage.java
│ │ │ │ ├── PrivateMessageDeletedEvent.java
│ │ │ │ └── PrivateMessageModifiedEvent.java
│ │ │ └── group
│ │ │ │ ├── GroupMessage.java
│ │ │ │ ├── GroupMessageDeletedEvent.java
│ │ │ │ └── GroupMessageModifiedEvent.java
│ │ └── server
│ │ │ ├── ServerStartedEvent.java
│ │ │ └── ServerStoppingEvent.java
│ │ ├── plugin
│ │ ├── Plugin.java
│ │ ├── PluginDescription.java
│ │ ├── PluginLoader.java
│ │ ├── PluginManager.java
│ │ ├── SimpleConfig.java
│ │ ├── exception
│ │ │ ├── DependencyMissingException.java
│ │ │ ├── InvalidPluginException.java
│ │ │ └── PluginNotLoadedException.java
│ │ └── java
│ │ │ ├── JavaPluginLoader.java
│ │ │ ├── NullCatWillDress.java
│ │ │ └── PolarClassloader.java
│ │ ├── service
│ │ ├── Registry.java
│ │ ├── Service.java
│ │ └── ServiceProvider.java
│ │ ├── transform
│ │ ├── Bot.java
│ │ ├── ChatGroup.java
│ │ ├── Contact.java
│ │ ├── Receiver.java
│ │ ├── exception
│ │ │ ├── ContactNotFoundException.java
│ │ │ ├── GroupNotFoundException.java
│ │ │ └── PlatformNotFoundException.java
│ │ └── internal
│ │ │ ├── ConsoleBot.java
│ │ │ ├── VirtContact.java
│ │ │ └── VirtGroup.java
│ │ └── user
│ │ ├── Group.java
│ │ ├── User.java
│ │ ├── UserManager.java
│ │ ├── exception
│ │ └── UserPlatformUnboundException.java
│ │ └── perm
│ │ ├── Perm.java
│ │ ├── Permissible.java
│ │ └── PureStringPerm.java
└── resources
│ └── logback.xml
└── test
└── java
└── cc
└── sfclub
└── test
├── ListConverterTest.java
└── PermEqualsTest.java
/.github/workflows/gradle.yml:
--------------------------------------------------------------------------------
1 | # This workflow will build a Java project with Gradle
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
3 |
4 | name: Java CI with Gradle
5 |
6 | on:
7 | push:
8 | branches: [ master ]
9 | pull_request:
10 | branches: [ master ]
11 |
12 | jobs:
13 | build:
14 | runs-on: ubuntu-latest
15 | steps:
16 | - uses: actions/checkout@v2
17 | - name: Set up JDK 11
18 | uses: actions/setup-java@v1
19 | with:
20 | java-version: 11.0.7
21 | - name: Grant execute permission for gradlew
22 | run: chmod +x gradlew
23 | - name: Build with Gradle
24 | run: ./gradlew shadowjar
25 | - name: Upload artifact
26 | uses: actions/upload-artifact@v1.0.0
27 | with:
28 | name: "Core"
29 | # Directory containing files to upload
30 | path: build/libs
31 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | build
3 | .gradle
4 | logs
5 | plugins
6 | config.json
7 | gradlew.bat
8 | sonar.sh
9 | /database.json
10 | /groups.json
11 | locale
12 | *.db
13 | /plugins/
14 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "[]"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright [2020] [SaltedFish Club]
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
--------------------------------------------------------------------------------
/README.MD:
--------------------------------------------------------------------------------
1 | # PolarCore
2 | [](https://app.codacy.com/gh/saltedfishclub/PolarCore?utm_source=github.com&utm_medium=referral&utm_content=saltedfishclub/PolarCore&utm_campaign=Badge_Grade_Dashboard).
3 | v4 refactored.
4 |
5 | Under Heavy Development.
6 | Open source / Apache2.0 License
7 | ## What
8 | A Chatbot kernel which had built-in User,Permission,SpecialMessages,Command systems.
9 | Also,It support to use `adapters` to warp diffirient messages into polarCore's.
10 |
11 |
12 | ## Dependency
13 | ```groovy
14 | maven { url 'https://jitpack.io' }
15 | ```
16 | and
17 | `compileOnly 'com.github.saltedfishclub:PolarCore:{{ VERSION }}`
18 | If you want to use the latest build:
19 | `compileOnly 'com.github.saltedfishclub:dev-SNAPSHOT`
20 |
21 | ## How messages process
22 | User Messages from diffirient platforms <-> Adapter (Convert to CatCodes) <-> PolarCore and plugins
23 |
24 |
--------------------------------------------------------------------------------
/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id "java"
3 | id "de.lukaskoerfer.gradle.delombok" version "0.2"
4 | id 'com.github.johnrengelman.shadow' version "6.0.0"
5 | }
6 | group 'com.github.saltedfishclub'
7 | version '4.8.0' //EDIT CORE.JAVA
8 |
9 | assemble.dependsOn(shadowJar)
10 | sourceCompatibility = 11
11 | targetCompatibility = 11
12 |
13 | repositories {
14 | maven { url 'https://jitpack.io' }
15 | maven {
16 | name = "mavenCentral"
17 | url = "http://maven.aliyun.com/nexus/content/groups/public/"
18 | }
19 | maven { url "https://libraries.minecraft.net"}
20 | }
21 | javadoc {
22 | options.encoding "UTF-8"
23 | options.charSet 'UTF-8'
24 | source = "build/delombok/delombok"
25 | failOnError = false
26 | }
27 |
28 | shadowJar {
29 | zip64 true
30 | manifest {
31 | attributes 'Main-Class': 'cc.sfclub.core.Initializer'
32 | }
33 | }
34 | dependencies {
35 | testCompile group: 'junit', name: 'junit', version: '4.12'
36 | implementation 'org.greenrobot:eventbus:3.2.0'
37 | compileOnly 'org.projectlombok:lombok:1.18.12'
38 | implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.6'
39 | //Loggers
40 | implementation 'org.slf4j:slf4j-api:1.7.30'
41 | implementation group: 'ch.qos.logback', name: 'logback-core', version: '1.2.3'
42 | implementation group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
43 | //Database
44 | implementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.19'
45 | implementation 'org.xerial:sqlite-jdbc:3.32.3.2'
46 | // https://mvnrepository.com/artifact/com.dieselpoint/norm
47 | implementation group: 'com.dieselpoint', name: 'norm', version: '0.8.10'
48 |
49 | //Utils
50 | implementation 'org.reflections:reflections:0.9.12'
51 | compile 'com.github.iceBear67:Util:96b6e38669'
52 | compile 'com.mojang:brigadier:1.0.17'
53 | annotationProcessor 'org.projectlombok:lombok:1.18.12'
54 | }
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/saltedfishclub/PolarCore/148b1e225295b4677977f60273ec421700622a5f/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env sh
2 |
3 | #
4 | # Copyright 2015 the original author or authors.
5 | #
6 | # Licensed under the Apache License, Version 2.0 (the "License");
7 | # you may not use this file except in compliance with the License.
8 | # You may obtain a copy of the License at
9 | #
10 | # https://www.apache.org/licenses/LICENSE-2.0
11 | #
12 | # Unless required by applicable law or agreed to in writing, software
13 | # distributed under the License is distributed on an "AS IS" BASIS,
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | # See the License for the specific language governing permissions and
16 | # limitations under the License.
17 | #
18 |
19 | ##############################################################################
20 | ##
21 | ## Gradle start up script for UN*X
22 | ##
23 | ##############################################################################
24 |
25 | # Attempt to set APP_HOME
26 | # Resolve links: $0 may be a link
27 | PRG="$0"
28 | # Need this for relative symlinks.
29 | while [ -h "$PRG" ] ; do
30 | ls=`ls -ld "$PRG"`
31 | link=`expr "$ls" : '.*-> \(.*\)$'`
32 | if expr "$link" : '/.*' > /dev/null; then
33 | PRG="$link"
34 | else
35 | PRG=`dirname "$PRG"`"/$link"
36 | fi
37 | done
38 | SAVED="`pwd`"
39 | cd "`dirname \"$PRG\"`/" >/dev/null
40 | APP_HOME="`pwd -P`"
41 | cd "$SAVED" >/dev/null
42 |
43 | APP_NAME="Gradle"
44 | APP_BASE_NAME=`basename "$0"`
45 |
46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
48 |
49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
50 | MAX_FD="maximum"
51 |
52 | warn () {
53 | echo "$*"
54 | }
55 |
56 | die () {
57 | echo
58 | echo "$*"
59 | echo
60 | exit 1
61 | }
62 |
63 | # OS specific support (must be 'true' or 'false').
64 | cygwin=false
65 | msys=false
66 | darwin=false
67 | nonstop=false
68 | case "`uname`" in
69 | CYGWIN* )
70 | cygwin=true
71 | ;;
72 | Darwin* )
73 | darwin=true
74 | ;;
75 | MINGW* )
76 | msys=true
77 | ;;
78 | NONSTOP* )
79 | nonstop=true
80 | ;;
81 | esac
82 |
83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84 |
85 |
86 | # Determine the Java command to use to start the JVM.
87 | if [ -n "$JAVA_HOME" ] ; then
88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
89 | # IBM's JDK on AIX uses strange locations for the executables
90 | JAVACMD="$JAVA_HOME/jre/sh/java"
91 | else
92 | JAVACMD="$JAVA_HOME/bin/java"
93 | fi
94 | if [ ! -x "$JAVACMD" ] ; then
95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
96 |
97 | Please set the JAVA_HOME variable in your environment to match the
98 | location of your Java installation."
99 | fi
100 | else
101 | JAVACMD="java"
102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 |
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 |
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 | MAX_FD_LIMIT=`ulimit -H -n`
111 | if [ $? -eq 0 ] ; then
112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 | MAX_FD="$MAX_FD_LIMIT"
114 | fi
115 | ulimit -n $MAX_FD
116 | if [ $? -ne 0 ] ; then
117 | warn "Could not set maximum file descriptor limit: $MAX_FD"
118 | fi
119 | else
120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 | fi
122 | fi
123 |
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 |
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 |
134 | JAVACMD=`cygpath --unix "$JAVACMD"`
135 |
136 | # We build the pattern for arguments to be converted via cygpath
137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 | SEP=""
139 | for dir in $ROOTDIRSRAW ; do
140 | ROOTDIRS="$ROOTDIRS$SEP$dir"
141 | SEP="|"
142 | done
143 | OURCYGPATTERN="(^($ROOTDIRS))"
144 | # Add a user-defined pattern to the cygpath arguments
145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 | fi
148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 | i=0
150 | for arg in "$@" ; do
151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
153 |
154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 | else
157 | eval `echo args$i`="\"$arg\""
158 | fi
159 | i=`expr $i + 1`
160 | done
161 | case $i in
162 | 0) set -- ;;
163 | 1) set -- "$args0" ;;
164 | 2) set -- "$args0" "$args1" ;;
165 | 3) set -- "$args0" "$args1" "$args2" ;;
166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 | esac
173 | fi
174 |
175 | # Escape application args
176 | save () {
177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 | echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 |
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 |
185 | exec "$JAVACMD" "$@"
186 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @rem
2 | @rem Copyright 2015 the original author or authors.
3 | @rem
4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
5 | @rem you may not use this file except in compliance with the License.
6 | @rem You may obtain a copy of the License at
7 | @rem
8 | @rem https://www.apache.org/licenses/LICENSE-2.0
9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 |
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 |
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 |
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 |
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 |
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 |
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 |
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto init
44 |
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 |
51 | goto fail
52 |
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 |
57 | if exist "%JAVA_EXE%" goto init
58 |
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 |
65 | goto fail
66 |
67 | :init
68 | @rem Get command-line arguments, handling Windows variants
69 |
70 | if not "%OS%" == "Windows_NT" goto win9xME_args
71 |
72 | :win9xME_args
73 | @rem Slurp the command line arguments.
74 | set CMD_LINE_ARGS=
75 | set _SKIP=2
76 |
77 | :win9xME_args_slurp
78 | if "x%~1" == "x" goto execute
79 |
80 | set CMD_LINE_ARGS=%*
81 |
82 | :execute
83 | @rem Setup the command line
84 |
85 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
86 |
87 |
88 | @rem Execute Gradle
89 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
90 |
91 | :end
92 | @rem End local scope for the variables with windows NT shell
93 | if "%ERRORLEVEL%"=="0" goto mainEnd
94 |
95 | :fail
96 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
97 | rem the _cmd.exe /c_ return code!
98 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
99 | exit /b 1
100 |
101 | :mainEnd
102 | if "%OS%"=="Windows_NT" endlocal
103 |
104 | :omega
105 |
--------------------------------------------------------------------------------
/jitpack.yml:
--------------------------------------------------------------------------------
1 | jdk:
2 | - openjdk11
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | rootProject.name = 'Core'
2 |
3 |
--------------------------------------------------------------------------------
/src/main/java/cc/sfclub/Internal.java:
--------------------------------------------------------------------------------
1 | package cc.sfclub;
2 |
3 | import java.lang.annotation.Documented;
4 |
5 | /**
6 | * 带有这个注解的方法表示仅PolarCore内部使用,不要调用。
7 | */
8 | @Documented
9 | @Internal
10 | public @interface Internal {
11 | }
12 |
--------------------------------------------------------------------------------
/src/main/java/cc/sfclub/catcode/Base64.java:
--------------------------------------------------------------------------------
1 | package cc.sfclub.catcode;
2 |
3 | import java.util.Arrays;
4 |
5 | /**
6 | * Base64工具类
7 | * A very fast and memory efficient class to encode and decode to and from BASE64 in full accordance
8 | * with RFC 2045.
9 | * On Windows XP sp1 with 1.4.2_04 and later ;), this encoder and decoder is about 10 times faster
10 | * on small arrays (10 - 1000 bytes) and 2-3 times as fast on larger arrays (10000 - 1000000 bytes)
11 | * compared to sun.misc.Encoder()/Decoder().
12 | *
13 | * On byte arrays the encoder is about 20% faster than Jakarta Commons Base64 Codec for encode and
14 | * about 50% faster for decoding large arrays. This implementation is about twice as fast on very small
15 | * arrays (< 30 bytes). If source/destination is a String this
16 | * version is about three times as fast due to the fact that the Commons Codec result has to be recoded
17 | * to a String from byte[], which is very expensive.
18 | *
19 | * This encode/decode algorithm doesn't create any temporary arrays as many other codecs do, it only
20 | * allocates the resulting array. This produces less garbage and it is possible to handle arrays twice
21 | * as large as algorithms that create a temporary array. (E.g. Jakarta Commons Codec). It is unknown
22 | * whether Sun's sun.misc.Encoder()/Decoder() produce temporary arrays but since performance
23 | * is quite low it probably does.
24 | *
25 | * The encoder produces the same output as the Sun one except that the Sun's encoder appends
26 | * a trailing line separator if the last character isn't a pad. Unclear why but it only adds to the
27 | * length and is probably a side effect. Both are in conformance with RFC 2045 though.
28 | * Commons codec seem to always att a trailing line separator.
29 | *
30 | * Note!
31 | * The encode/decode method pairs (types) come in three versions with the exact same algorithm and
32 | * thus a lot of code redundancy. This is to not create any temporary arrays for transcoding to/from different
33 | * format types. The methods not used can simply be commented out.
34 | *
35 | * There is also a "fast" version of all decode methods that works the same way as the normal ones, but
36 | * har a few demands on the decoded input. Normally though, these fast verions should be used if the source if
37 | * the input is known and it hasn't bee tampered with.
38 | *
39 | * If you find the code useful or you find a bug, please send me a note at base64 @ miginfocom . com.
40 | *
44 | * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (base64 @ miginfocom . com)
45 | * All rights reserved.
46 | *
47 | * Redistribution and use in source and binary forms, with or without modification,
48 | * are permitted provided that the following conditions are met:
49 | * Redistributions of source code must retain the above copyright notice, this list
50 | * of conditions and the following disclaimer.
51 | * Redistributions in binary form must reproduce the above copyright notice, this
52 | * list of conditions and the following disclaimer in the documentation and/or other
53 | * materials provided with the distribution.
54 | * Neither the name of the MiG InfoCom AB nor the names of its contributors may be
55 | * used to endorse or promote products derived from this software without specific
56 | * prior written permission.
57 | *
58 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
59 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
60 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
61 | * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
62 | * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
63 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
64 | * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
65 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
66 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
67 | * OF SUCH DAMAGE.
68 | *
69 | * @author Mikael Grev
70 | * Date: 2004-aug-02
71 | * Time: 11:31:11
72 | * @version 2.2
73 | */
74 |
75 | @SuppressWarnings("all")
76 | public class Base64 {
77 | private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
78 | private static final int[] IA = new int[256];
79 |
80 | static {
81 | Arrays.fill(IA, -1);
82 | for (int i = 0, iS = CA.length; i < iS; i++)
83 | IA[CA[i]] = i;
84 | IA['='] = 0;
85 | }
86 |
87 | // ****************************************************************************************
88 | // * char[] version
89 | // ****************************************************************************************
90 |
91 | /**
92 | * Encodes a raw byte array into a BASE64 char[] representation i accordance with RFC 2045.
93 | *
94 | * @param sArr The bytes to convert. If null or length 0 an empty array will be returned.
95 | * @param lineSep Optional "\r\n" after 76 characters, unless end of file.
96 | * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
97 | * little faster.
98 | * @return A BASE64 encoded array. Never null.
99 | */
100 | public static char[] encodeToChar(byte[] sArr, boolean lineSep) {
101 | // Check special case
102 | int sLen = sArr != null ? sArr.length : 0;
103 | if (sLen == 0)
104 | return new char[0];
105 |
106 | int eLen = (sLen / 3) * 3; // Length of even 24-bits.
107 | int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count
108 | int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array
109 | char[] dArr = new char[dLen];
110 |
111 | // Encode even 24-bits
112 | for (int s = 0, d = 0, cc = 0; s < eLen; ) {
113 | // Copy next three bytes into lower 24 bits of int, paying attension to sign.
114 | int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff);
115 |
116 | // Encode the int into four chars
117 | dArr[d++] = CA[(i >>> 18) & 0x3f];
118 | dArr[d++] = CA[(i >>> 12) & 0x3f];
119 | dArr[d++] = CA[(i >>> 6) & 0x3f];
120 | dArr[d++] = CA[i & 0x3f];
121 |
122 | // Add optional line separator
123 | if (lineSep && ++cc == 19 && d < dLen - 2) {
124 | dArr[d++] = '\r';
125 | dArr[d++] = '\n';
126 | cc = 0;
127 | }
128 | }
129 |
130 | // Pad and encode last bits if source isn't even 24 bits.
131 | int left = sLen - eLen; // 0 - 2.
132 | if (left > 0) {
133 | // Prepare the int
134 | int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0);
135 |
136 | // Set last four chars
137 | dArr[dLen - 4] = CA[i >> 12];
138 | dArr[dLen - 3] = CA[(i >>> 6) & 0x3f];
139 | dArr[dLen - 2] = left == 2 ? CA[i & 0x3f] : '=';
140 | dArr[dLen - 1] = '=';
141 | }
142 | return dArr;
143 | }
144 |
145 | /**
146 | * Decodes a BASE64 encoded char array. All illegal characters will be ignored and can handle both arrays with
147 | * and without line separators.
148 | *
149 | * @param sArr The source array. null or length 0 will return an empty array.
150 | * @return The decoded array of bytes. May be of length 0. Will be null if the legal characters
151 | * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
152 | */
153 | public static byte[] decode(char[] sArr) {
154 | // Check special case
155 | int sLen = sArr != null ? sArr.length : 0;
156 | if (sLen == 0)
157 | return new byte[0];
158 |
159 | // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
160 | // so we don't have to reallocate & copy it later.
161 | int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
162 | for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
163 | if (IA[sArr[i]] < 0)
164 | sepCnt++;
165 |
166 | // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
167 | if ((sLen - sepCnt) % 4 != 0)
168 | return null;
169 |
170 | int pad = 0;
171 | for (int i = sLen; i > 1 && IA[sArr[--i]] <= 0; )
172 | if (sArr[i] == '=')
173 | pad++;
174 |
175 | int len = ((sLen - sepCnt) * 6 >> 3) - pad;
176 |
177 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
178 |
179 | for (int s = 0, d = 0; d < len; ) {
180 | // Assemble three bytes into an int from four "valid" characters.
181 | int i = 0;
182 | for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
183 | int c = IA[sArr[s++]];
184 | if (c >= 0)
185 | i |= c << (18 - j * 6);
186 | else
187 | j--;
188 | }
189 | // Add the bytes
190 | dArr[d++] = (byte) (i >> 16);
191 | if (d < len) {
192 | dArr[d++] = (byte) (i >> 8);
193 | if (d < len)
194 | dArr[d++] = (byte) i;
195 | }
196 | }
197 | return dArr;
198 | }
199 |
200 | /**
201 | * Decodes a BASE64 encoded char array that is known to be resonably well formatted. The method is about twice as
202 | * fast as {@link #decode(char[])}. The preconditions are:
203 | * + The array must have a line length of 76 chars OR no line separators at all (one line).
204 | * + Line separator must be "\r\n", as specified in RFC 2045
205 | * + The array must not contain illegal characters within the encoded string
206 | * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.
207 | *
208 | * @param sArr The source array. Length 0 will return an empty array. null will throw an exception.
209 | * @return The decoded array of bytes. May be of length 0.
210 | */
211 | public static byte[] decodeFast(char[] sArr) {
212 | // Check special case
213 | int sLen = sArr.length;
214 | if (sLen == 0)
215 | return new byte[0];
216 |
217 | int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
218 |
219 | // Trim illegal chars from start
220 | while (sIx < eIx && IA[sArr[sIx]] < 0)
221 | sIx++;
222 |
223 | // Trim illegal chars from end
224 | while (eIx > 0 && IA[sArr[eIx]] < 0)
225 | eIx--;
226 |
227 | // get the padding count (=) (0, 1 or 2)
228 | int pad = sArr[eIx] == '=' ? (sArr[eIx - 1] == '=' ? 2 : 1) : 0; // Count '=' at end.
229 | int cCnt = eIx - sIx + 1; // Content count including possible separators
230 | int sepCnt = sLen > 76 ? (sArr[76] == '\r' ? cCnt / 78 : 0) << 1 : 0;
231 |
232 | int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
233 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
234 |
235 | // Decode all but the last 0 - 2 bytes.
236 | int d = 0;
237 | for (int cc = 0, eLen = (len / 3) * 3; d < eLen; ) {
238 | // Assemble three bytes into an int from four "valid" characters.
239 | int i = IA[sArr[sIx++]] << 18 | IA[sArr[sIx++]] << 12 | IA[sArr[sIx++]] << 6 | IA[sArr[sIx++]];
240 |
241 | // Add the bytes
242 | dArr[d++] = (byte) (i >> 16);
243 | dArr[d++] = (byte) (i >> 8);
244 | dArr[d++] = (byte) i;
245 |
246 | // If line separator, jump over it.
247 | if (sepCnt > 0 && ++cc == 19) {
248 | sIx += 2;
249 | cc = 0;
250 | }
251 | }
252 |
253 | if (d < len) {
254 | // Decode last 1-3 bytes (incl '=') into 1-3 bytes
255 | int i = 0;
256 | for (int j = 0; sIx <= eIx - pad; j++)
257 | i |= IA[sArr[sIx++]] << (18 - j * 6);
258 |
259 | for (int r = 16; d < len; r -= 8)
260 | dArr[d++] = (byte) (i >> r);
261 | }
262 |
263 | return dArr;
264 | }
265 |
266 | // ****************************************************************************************
267 | // * byte[] version
268 | // ****************************************************************************************
269 |
270 | /**
271 | * Encodes a raw byte array into a BASE64 byte[] representation i accordance with RFC 2045.
272 | *
273 | * @param sArr The bytes to convert. If null or length 0 an empty array will be returned.
274 | * @param lineSep Optional "\r\n" after 76 characters, unless end of file.
275 | * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
276 | * little faster.
277 | * @return A BASE64 encoded array. Never null.
278 | */
279 | public static byte[] encodeToByte(byte[] sArr, boolean lineSep) {
280 | // Check special case
281 | int sLen = sArr != null ? sArr.length : 0;
282 | if (sLen == 0)
283 | return new byte[0];
284 |
285 | int eLen = (sLen / 3) * 3; // Length of even 24-bits.
286 | int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count
287 | int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array
288 | byte[] dArr = new byte[dLen];
289 |
290 | // Encode even 24-bits
291 | for (int s = 0, d = 0, cc = 0; s < eLen; ) {
292 | // Copy next three bytes into lower 24 bits of int, paying attension to sign.
293 | int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff);
294 |
295 | // Encode the int into four chars
296 | dArr[d++] = (byte) CA[(i >>> 18) & 0x3f];
297 | dArr[d++] = (byte) CA[(i >>> 12) & 0x3f];
298 | dArr[d++] = (byte) CA[(i >>> 6) & 0x3f];
299 | dArr[d++] = (byte) CA[i & 0x3f];
300 |
301 | // Add optional line separator
302 | if (lineSep && ++cc == 19 && d < dLen - 2) {
303 | dArr[d++] = '\r';
304 | dArr[d++] = '\n';
305 | cc = 0;
306 | }
307 | }
308 |
309 | // Pad and encode last bits if source isn't an even 24 bits.
310 | int left = sLen - eLen; // 0 - 2.
311 | if (left > 0) {
312 | // Prepare the int
313 | int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0);
314 |
315 | // Set last four chars
316 | dArr[dLen - 4] = (byte) CA[i >> 12];
317 | dArr[dLen - 3] = (byte) CA[(i >>> 6) & 0x3f];
318 | dArr[dLen - 2] = left == 2 ? (byte) CA[i & 0x3f] : (byte) '=';
319 | dArr[dLen - 1] = '=';
320 | }
321 | return dArr;
322 | }
323 |
324 | /**
325 | * Decodes a BASE64 encoded byte array. All illegal characters will be ignored and can handle both arrays with
326 | * and without line separators.
327 | *
328 | * @param sArr The source array. Length 0 will return an empty array. null will throw an exception.
329 | * @return The decoded array of bytes. May be of length 0. Will be null if the legal characters
330 | * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
331 | */
332 | public static byte[] decode(byte[] sArr) {
333 | // Check special case
334 | int sLen = sArr.length;
335 |
336 | // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
337 | // so we don't have to reallocate & copy it later.
338 | int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
339 | for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
340 | if (IA[sArr[i] & 0xff] < 0)
341 | sepCnt++;
342 |
343 | // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
344 | if ((sLen - sepCnt) % 4 != 0)
345 | return null;
346 |
347 | int pad = 0;
348 | for (int i = sLen; i > 1 && IA[sArr[--i] & 0xff] <= 0; )
349 | if (sArr[i] == '=')
350 | pad++;
351 |
352 | int len = ((sLen - sepCnt) * 6 >> 3) - pad;
353 |
354 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
355 |
356 | for (int s = 0, d = 0; d < len; ) {
357 | // Assemble three bytes into an int from four "valid" characters.
358 | int i = 0;
359 | for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
360 | int c = IA[sArr[s++] & 0xff];
361 | if (c >= 0)
362 | i |= c << (18 - j * 6);
363 | else
364 | j--;
365 | }
366 |
367 | // Add the bytes
368 | dArr[d++] = (byte) (i >> 16);
369 | if (d < len) {
370 | dArr[d++] = (byte) (i >> 8);
371 | if (d < len)
372 | dArr[d++] = (byte) i;
373 | }
374 | }
375 |
376 | return dArr;
377 | }
378 |
379 |
380 | /**
381 | * Decodes a BASE64 encoded byte array that is known to be resonably well formatted. The method is about twice as
382 | * fast as {@link #decode(byte[])}. The preconditions are:
383 | * + The array must have a line length of 76 chars OR no line separators at all (one line).
384 | * + Line separator must be "\r\n", as specified in RFC 2045
385 | * + The array must not contain illegal characters within the encoded string
386 | * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.
387 | *
388 | * @param sArr The source array. Length 0 will return an empty array. null will throw an exception.
389 | * @return The decoded array of bytes. May be of length 0.
390 | */
391 | public static byte[] decodeFast(byte[] sArr) {
392 | // Check special case
393 | int sLen = sArr.length;
394 | if (sLen == 0)
395 | return new byte[0];
396 |
397 | int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
398 |
399 | // Trim illegal chars from start
400 | while (sIx < eIx && IA[sArr[sIx] & 0xff] < 0)
401 | sIx++;
402 |
403 | // Trim illegal chars from end
404 | while (eIx > 0 && IA[sArr[eIx] & 0xff] < 0)
405 | eIx--;
406 |
407 | // get the padding count (=) (0, 1 or 2)
408 | int pad = sArr[eIx] == '=' ? (sArr[eIx - 1] == '=' ? 2 : 1) : 0; // Count '=' at end.
409 | int cCnt = eIx - sIx + 1; // Content count including possible separators
410 | int sepCnt = sLen > 76 ? (sArr[76] == '\r' ? cCnt / 78 : 0) << 1 : 0;
411 |
412 | int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
413 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
414 |
415 | // Decode all but the last 0 - 2 bytes.
416 | int d = 0;
417 | for (int cc = 0, eLen = (len / 3) * 3; d < eLen; ) {
418 | // Assemble three bytes into an int from four "valid" characters.
419 | int i = IA[sArr[sIx++]] << 18 | IA[sArr[sIx++]] << 12 | IA[sArr[sIx++]] << 6 | IA[sArr[sIx++]];
420 |
421 | // Add the bytes
422 | dArr[d++] = (byte) (i >> 16);
423 | dArr[d++] = (byte) (i >> 8);
424 | dArr[d++] = (byte) i;
425 |
426 | // If line separator, jump over it.
427 | if (sepCnt > 0 && ++cc == 19) {
428 | sIx += 2;
429 | cc = 0;
430 | }
431 | }
432 |
433 | if (d < len) {
434 | // Decode last 1-3 bytes (incl '=') into 1-3 bytes
435 | int i = 0;
436 | for (int j = 0; sIx <= eIx - pad; j++)
437 | i |= IA[sArr[sIx++]] << (18 - j * 6);
438 |
439 | for (int r = 16; d < len; r -= 8)
440 | dArr[d++] = (byte) (i >> r);
441 | }
442 |
443 | return dArr;
444 | }
445 |
446 | // ****************************************************************************************
447 | // * String version
448 | // ****************************************************************************************
449 |
450 | /**
451 | * Encodes a raw byte array into a BASE64 String representation i accordance with RFC 2045.
452 | *
453 | * @param sArr The bytes to convert. If null or length 0 an empty array will be returned.
454 | * @param lineSep Optional "\r\n" after 76 characters, unless end of file.
455 | * No line separator will be in breach of RFC 2045 which specifies max 76 per line but will be a
456 | * little faster.
457 | * @return A BASE64 encoded array. Never null.
458 | */
459 | public static String encodeToString(byte[] sArr, boolean lineSep) {
460 | // Reuse char[] since we can't create a String incrementally anyway and StringBuffer/Builder would be slower.
461 | return new String(encodeToChar(sArr, lineSep));
462 | }
463 |
464 | /**
465 | * Decodes a BASE64 encoded String. All illegal characters will be ignored and can handle both strings with
466 | * and without line separators.
467 | * Note! It can be up to about 2x the speed to call decode(str.toCharArray()) instead. That
468 | * will create a temporary array though. This version will use str.charAt(i) to iterate the string.
469 | *
470 | * @param str The source string. null or length 0 will return an empty array.
471 | * @return The decoded array of bytes. May be of length 0. Will be null if the legal characters
472 | * (including '=') isn't divideable by 4. (I.e. definitely corrupted).
473 | */
474 | public static byte[] decode(String str) {
475 | // Check special case
476 | int sLen = str != null ? str.length() : 0;
477 | if (sLen == 0)
478 | return new byte[0];
479 |
480 | // Count illegal characters (including '\r', '\n') to know what size the returned array will be,
481 | // so we don't have to reallocate & copy it later.
482 | int sepCnt = 0; // Number of separator characters. (Actually illegal characters, but that's a bonus...)
483 | for (int i = 0; i < sLen; i++) // If input is "pure" (I.e. no line separators or illegal chars) base64 this loop can be commented out.
484 | if (IA[str.charAt(i)] < 0)
485 | sepCnt++;
486 |
487 | // Check so that legal chars (including '=') are evenly divideable by 4 as specified in RFC 2045.
488 | if ((sLen - sepCnt) % 4 != 0)
489 | return null;
490 |
491 | // Count '=' at end
492 | int pad = 0;
493 | for (int i = sLen; i > 1 && IA[str.charAt(--i)] <= 0; )
494 | if (str.charAt(i) == '=')
495 | pad++;
496 |
497 | int len = ((sLen - sepCnt) * 6 >> 3) - pad;
498 |
499 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
500 |
501 | for (int s = 0, d = 0; d < len; ) {
502 | // Assemble three bytes into an int from four "valid" characters.
503 | int i = 0;
504 | for (int j = 0; j < 4; j++) { // j only increased if a valid char was found.
505 | int c = IA[str.charAt(s++)];
506 | if (c >= 0)
507 | i |= c << (18 - j * 6);
508 | else
509 | j--;
510 | }
511 | // Add the bytes
512 | dArr[d++] = (byte) (i >> 16);
513 | if (d < len) {
514 | dArr[d++] = (byte) (i >> 8);
515 | if (d < len)
516 | dArr[d++] = (byte) i;
517 | }
518 | }
519 | return dArr;
520 | }
521 |
522 | /**
523 | * Decodes a BASE64 encoded string that is known to be resonably well formatted. The method is about twice as
524 | * fast as {@link #decode(String)}. The preconditions are:
525 | * + The array must have a line length of 76 chars OR no line separators at all (one line).
526 | * + Line separator must be "\r\n", as specified in RFC 2045
527 | * + The array must not contain illegal characters within the encoded string
528 | * + The array CAN have illegal characters at the beginning and end, those will be dealt with appropriately.
529 | *
530 | * @param s The source string. Length 0 will return an empty array. null will throw an exception.
531 | * @return The decoded array of bytes. May be of length 0.
532 | */
533 | public static byte[] decodeFast(String s) {
534 | // Check special case
535 | int sLen = s.length();
536 | if (sLen == 0)
537 | return new byte[0];
538 |
539 | int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
540 |
541 | // Trim illegal chars from start
542 | while (sIx < eIx && IA[s.charAt(sIx) & 0xff] < 0)
543 | sIx++;
544 |
545 | // Trim illegal chars from end
546 | while (eIx > 0 && IA[s.charAt(eIx) & 0xff] < 0)
547 | eIx--;
548 |
549 | // get the padding count (=) (0, 1 or 2)
550 | int pad = s.charAt(eIx) == '=' ? (s.charAt(eIx - 1) == '=' ? 2 : 1) : 0; // Count '=' at end.
551 | int cCnt = eIx - sIx + 1; // Content count including possible separators
552 | int sepCnt = sLen > 76 ? (s.charAt(76) == '\r' ? cCnt / 78 : 0) << 1 : 0;
553 |
554 | int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
555 | byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
556 |
557 | // Decode all but the last 0 - 2 bytes.
558 | int d = 0;
559 | for (int cc = 0, eLen = (len / 3) * 3; d < eLen; ) {
560 | // Assemble three bytes into an int from four "valid" characters.
561 | int i = IA[s.charAt(sIx++)] << 18 | IA[s.charAt(sIx++)] << 12 | IA[s.charAt(sIx++)] << 6 | IA[s.charAt(sIx++)];
562 |
563 | // Add the bytes
564 | dArr[d++] = (byte) (i >> 16);
565 | dArr[d++] = (byte) (i >> 8);
566 | dArr[d++] = (byte) i;
567 |
568 | // If line separator, jump over it.
569 | if (sepCnt > 0 && ++cc == 19) {
570 | sIx += 2;
571 | cc = 0;
572 | }
573 | }
574 |
575 | if (d < len) {
576 | // Decode last 1-3 bytes (incl '=') into 1-3 bytes
577 | int i = 0;
578 | for (int j = 0; sIx <= eIx - pad; j++)
579 | i |= IA[s.charAt(sIx++)] << (18 - j * 6);
580 |
581 | for (int r = 16; d < len; r -= 8)
582 | dArr[d++] = (byte) (i >> r);
583 | }
584 |
585 | return dArr;
586 | }
587 |
588 | public static String dup(char c, int num) {
589 | if (c == 0 || num < 1)
590 | return "";
591 | StringBuilder sb = new StringBuilder(num);
592 | for (int i = 0; i < num; i++)
593 | sb.append(c);
594 | return sb.toString();
595 | }
596 |
597 | @SuppressWarnings("StringBufferReplaceableByString")
598 | public static class URLSafe {
599 |
600 | /**
601 | * 返回一个不带折行的 Base64 编码的 URL 字符串
602 | *