xlang 5.0内置类大全
xlang2025-03-19 03:05:22基础类库
注意: 此文档由AI生成。
String类
字符串类，包含了字符串的创建、查找、替换、截取、编码解码、比较等操作。
//final 类, 不可被继承
final class String{
// 构造函数：从字节数组创建字符串
String(byte [] /*Not Nilptr*/bytes);
// 构造函数：从字节数组的指定偏移量和长度创建字符串
String(byte [] /*Not Nilptr*/bytes, int offset, int len);
// 构造函数：从字符数组和小端序标志创建字符串
String(char [] /*Not Nilptr*/chars, bool bLittleEndian);
// 构造函数：从字符数组的指定偏移量、长度和小端序标志创建字符串
String(char [] /*Not Nilptr*/chars, int offset, int len, bool bLittleEndian);
// 构造函数：从字节数组和字符集创建字符串
String(byte [] /*Not Nilptr*/bytes, String charset);
// 构造函数：从字节数组的指定偏移量、长度和字符集创建字符串
String(byte [] /*Not Nilptr*/bytes, int offset, int len, String /*Not Nilptr*/charset);
// 构造函数：从另一个字符串创建字符串
String(String another);
// 返回字符串的长度
int length();
// 查找子字符串在字符串中的位置
int find(String /*Not Nilptr*/text);
// 从指定偏移量开始查找子字符串在字符串中的位置，指定长度，可能抛出IndexOutOfBoundsException和IllegalArgumentException
int find(String /*Not Nilptr*/text, int offset, int len) IndexOutOfBoundsException, IllegalArgumentException;
// 返回从指定开始位置到结束位置的子字符串，可能抛出IllegalArgumentException
String substring(int start, int end)IllegalArgumentException;
// 返回从指定偏移量开始的子字符串，可能抛出IllegalArgumentException
String substring(int offset)IllegalArgumentException;
// 对字符串进行转义
String escape();
// 根据指定分隔符拆分字符串
String[] split(String /*Not Nilptr*/separator);
// 根据指定字符分隔符拆分字符串
String[] split(char separator);
// 重载加法运算符，将对象值附加到字符串
String operator_addb(Object value);
// 判断字符串是否以指定文本开头
bool startsWith(String /*Not Nilptr*/text);
// 判断字符串是否以指定文本结尾
bool endsWith(String /*Not Nilptr*/text);
// 从指定偏移量开始查找子字符串在字符串中的位置，可能抛出IllegalArgumentException
int indexOf(String /*Not Nilptr*/text, int offset)IllegalArgumentException;
// 从指定偏移量开始查找字符在字符串中的位置，可能抛出IllegalArgumentException
int indexOf(char c, int offset)IllegalArgumentException;
// 查找子字符串在字符串中的位置
int indexOf(String /*Not Nilptr*/text);
// 查找字符在字符串中的位置
int indexOf(char c);
// 从指定偏移量开始忽略大小写查找子字符串在字符串中的位置，可能抛出IllegalArgumentException
int indexOfIgnoreCase(String /*Not Nilptr*/text, int offset)IllegalArgumentException;
// 从指定偏移量开始忽略大小写查找字符在字符串中的位置，可能抛出IllegalArgumentException
int indexOfIgnoreCase(char c, int offset)IllegalArgumentException;
// 忽略大小写查找子字符串在字符串中的位置
int indexOfIgnoreCase(String /*Not Nilptr*/text);
// 忽略大小写查找字符在字符串中的位置
int indexOfIgnoreCase(char c);
// 从指定偏移量开始查找子字符串在字符串中最后一次出现的位置，可能抛出IllegalArgumentException
int lastIndexOf(String /*Not Nilptr*/text, int offset)IllegalArgumentException;
// 从指定偏移量开始查找字符在字符串中最后一次出现的位置，可能抛出IllegalArgumentException
int lastIndexOf(char c, int offset)IllegalArgumentException;
// 查找子字符串在字符串中最后一次出现的位置
int lastIndexOf(String /*Not Nilptr*/text);
// 查找字符在字符串中最后一次出现的位置
int lastIndexOf(char c);
// 从指定偏移量开始忽略大小写查找子字符串在字符串中最后一次出现的位置，可能抛出IllegalArgumentException
int lastIndexOfIgnoreCase(String /*Not Nilptr*/text, int offset)IllegalArgumentException;
// 从指定偏移量开始忽略大小写查找字符在字符串中最后一次出现的位置，可能抛出IllegalArgumentException
int lastIndexOfIgnoreCase(char c, int offset)IllegalArgumentException;
// 忽略大小写查找子字符串在字符串中最后一次出现的位置
int lastIndexOfIgnoreCase(String /*Not Nilptr*/text);
// 忽略大小写查找字符在字符串中最后一次出现的位置
int lastIndexOfIgnoreCase(char c);
// 将对象值附加到字符串
String append(Object value);
// 在指定偏移量处插入对象值，可能抛出IllegalArgumentException
String insert(int offset, Object value)IllegalArgumentException;
// 将字符串转换为字节数组
byte[] getBytes();
// 使用指定字符集将字符串转换为字节数组，可能抛出IllegalArgumentException
byte[] getBytes(String /*Not Nilptr*/charset)IllegalArgumentException;
// 将字符串转换为字符数组，指定小端序标志
char[] toCharArray(bool bLittleEndian);
// 判断字符串是否为数字
bool isDigit();
// 将字符串解析为长整型
long parseLong();
// 将字符串解析为十六进制长整型
long parseHex();
// 将字符串解析为整型
int parseInt();
// 将字符串解析为布尔型
bool parseBool();
// 将字符串解析为浮点型
// 将字符串解析为浮点数
float parseFloat();
// 将字符串解析为双精度浮点数
double parseDouble();
// 从指定位置开始，替换到结束位置的字符串，并返回新的字符串
// 参数offset: 开始位置
// 参数end: 结束位置
// 参数text: 要替换的字符串，不能为空
// 抛出IllegalArgumentException: 如果参数不合法
String replace(int offset, int end, String /*Not Nilptr*/text)IllegalArgumentException;
// 替换字符串中的所有指定子字符串，并返回新的字符串
// 参数find: 要查找的子字符串，不能为空
// 参数text: 要替换的字符串，不能为空
String replace(String /*Not Nilptr*/find, String /*Not Nilptr*/text);
// 将字符串转换为小写，并返回新的字符串
String lower();
// 将字符串转换为大写，并返回新的字符串
String upper();
// 比较两个字符串是否相等
// 参数another: 要比较的字符串
bool equals(String another);
// 比较两个字符串是否相等，忽略大小写
// 参数another: 要比较的字符串
bool equalsIgnoreCase(String another);
// 计算字符串中指定字符的出现次数
// 参数c: 要计数的字符
int countChar(char c);
// 计算字符串中指定子字符串的出现次数
// 参数text: 要计数的子字符串，不能为空
int countString(String /*Not Nilptr*/text);
// 计算字符串中指定子字符串的出现次数，忽略大小写
// 参数text: 要计数的子字符串，不能为空
int countStringIgnoreCase(String /*Not Nilptr*/text);
// 追加路径到当前路径
String appendPath(String /*Not Nilptr*/path);
// 去除字符串的扩展名，如果Ext为true，则去除扩展名，否则返回原字符串
String trim(bool Ext);
// 从字符串左侧去除空格或指定字符，如果Ext为true，则去除指定字符，否则去除空格
String ltrim(bool Ext);
// 从字符串右侧去除空格或指定字符，如果Ext为true，则去除指定字符，否则去除空格
String rtrim(bool Ext);
// 替换字符串的扩展名
String replaceExtension(String /*Not Nilptr*/extsion);
// 移除字符串的扩展名
String removeExtension();
// 替换字符串的文件名和扩展名
String replaceFilenameAndExtension(String /*Not Nilptr*/newname);
// 替换字符串的文件名
String replaceFilename(String /*Not Nilptr*/filename);
// 查找字符串的扩展名
String findExtension();
// 查找字符串的文件名和扩展名
String findFilenameAndExtension();
// 查找字符串的文件名
String findFilename();
// 查找字符串的路径和文件名
String findPathFilename();
// 查找字符串的卷标
String findVolume();
// 查找字符串的卷标路径
String findVolumePath();
// 判断字符串是否为点
bool isDot();
// 将字符串转换为相对路径
String toRelativePath(String /*Not Nilptr*/refpath, bool ignoreCase, bool fixSlash);
// 将字符串转换为绝对路径
String toAbsolutePath(String /*Not Nilptr*/refpath);
// 获取字符串指定位置的字符，如果位置无效则抛出IllegalArgumentException
char charAt(int pos)IllegalArgumentException;
// 解码URI，返回解码后的字符串
String decodeURI();
// 编码URI，如果bComponent为true，则编码URI组件，否则编码整个URI
String encodeURI(bool bComponent);
// 获取字符集，如果字符集无效则抛出IllegalArgumentException
String charset()IllegalArgumentException;
// 比较当前字符串与另一个字符串，返回比较结果
int compare(String another);
// 判断当前字符串是否等于另一个字符串
bool operator_equ(String another);
// 判断当前字符串是否不等于另一个字符串
bool operator_nequ(String another);
// 解析Markdown文本，返回解析后的HTML字符串
String parseMarkdown();
// 判断当前字符串是否为空白字符串
bool isBlank();
// 解析日期字符串，根据指定的格式和偏移量返回对应的毫秒数，如果格式无效则抛出IllegalArgumentException
long parseDate(String /*Not Nilptr*/format, int offset)IllegalArgumentException;
// 获取指定索引位置的字符，如果索引超出范围则抛出IndexOutOfBoundsException
byte operator_get(int index)IndexOutOfBoundsException;
// 静态方法：检测字节数组的字符集，根据偏移量和长度返回检测到的字符集，如果偏移量或长度无效则抛出IllegalArgumentException或IndexOutOfBoundsException
static String detectCharset(byte [] /*Not Nilptr*/data, int offset, int len)IllegalArgumentException, IndexOutOfBoundsException;
// 静态方法：填充字符，根据指定的字符和长度返回填充后的字符串，如果长度无效则抛出IllegalArgumentException
static String fill(char c, int len)IllegalArgumentException;
// 静态方法：格式化路径，根据指定的路径和是否添加斜杠返回格式化后的路径字符串
static String formatPath(String /*Not Nilptr*/path, bool bReslash);
// 静态方法：格式化字符串，根据指定的格式和参数数组返回格式化后的字符串，如果格式或参数数组无效则抛出IllegalArgumentException
static String format(String /*Not Nilptr*/format, Object [] /*Not Nilptr*/args)IllegalArgumentException;
// 静态方法：格式化日期，根据指定的格式和毫秒数返回格式化后的日期字符串，如果格式无效则抛出IllegalArgumentException
static String formatDate(String /*Not Nilptr*/format, long millisecond)IllegalArgumentException;
};
Stream接口
定义了输入输出流的基本操作，如读、写、定位、获取长度等。
//Stream 接口, 方法 = nilptr 表示为纯虚方法, 继承需要实现
interface Stream{
static final int SeekBegin // 表示从流的开始位置查找
static final int SeekCurrent// 表示从当前位置查找
static final int SeekEnd // 表示从流的结束位置查找
// 读取数据到缓冲区，返回读取的字节数
// 参数：buffer-存储读取数据的缓冲区，offset-缓冲区的起始位置，length-要读取的字节数
// 抛出异常：IllegalArgumentException, IndexOutOfBoundsException, IOException, TimeoutException, InterruptedException
int read(byte [] /*Not Nilptr*/buffer, int offset, int length)
IllegalArgumentException,
IndexOutOfBoundsException,
IOException,
TimeoutException,
InterruptedException
= nilptr;
// 将数据写入流，返回写入的字节数
// 参数：buffer-要写入的数据，offset-数据的起始位置，length-要写入的字节数
// 抛出异常：IllegalArgumentException, IndexOutOfBoundsException, IOException, TimeoutException, InterruptedException
int write(byte [] /*Not Nilptr*/buffer, int offset, int length)
IllegalArgumentException,
IndexOutOfBoundsException,
IOException,
TimeoutException,
InterruptedException
= nilptr;
// 在流中查找指定位置，返回新的位置
// 参数：seektype-查找类型，offset-偏移量
// 抛出异常：IllegalArgumentException, IndexOutOfBoundsException, IOException
long seek(int seektype, long offset)
IllegalArgumentException,
IndexOutOfBoundsException,
IOException
= nilptr;
// 获取当前流的位置
// 抛出异常：IllegalArgumentException, IOException
long getPosition()
IllegalArgumentException,
IOException
= nilptr;
// 定义一个方法length，返回一个长整型值，表示长度
// 可能抛出的异常：IllegalArgumentException, IOException
long length()
IllegalArgumentException,
IOException
= nilptr;
// 定义一个方法available，接受一个布尔值bWait，返回一个长整型值，表示可用数据量
// 可能抛出的异常：IllegalArgumentException, InterruptedException, IOException
long available(bool bWait)
IllegalArgumentException,
InterruptedException,
IOException
= nilptr;
// 定义一个方法flush，用于刷新输出流
// 可能抛出的异常：IOException
void flush() IOException = nilptr;
// 定义一个方法close，用于关闭流
// 可能抛出的异常：IllegalArgumentException
void close() IllegalArgumentException = nilptr;
// 定义一个final方法writeChar，接受一个字符v，用于写入字符
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeChar(char v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeShort，接受一个短整型v，用于写入短整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeShort(short v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeInt，接受一个整型v，用于写入整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeInt(int v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeLong，接受一个长整型v，用于写入长整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeLong(long v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeFloat，接受一个浮点型v，用于写入浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeFloat(float v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeDouble，接受一个双精度浮点型v，用于写入双精度浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeDouble(double v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeBool，接受一个布尔型v，用于写入布尔型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeBool(bool v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeString，接受一个字符串v，用于写入字符串
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeString(String v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readChar，用于读取字符
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final char readChar()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readShort，用于读取短整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final short readShort()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readInt，用于读取整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final int readInt()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readLong，用于读取长整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final long readLong()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readFloat，用于读取浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final float readFloat()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readDouble，用于读取双精度浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final double readDouble()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readBool，用于读取布尔型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final bool readBool()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readString，用于读取字符串
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final String readString()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeCharLE，接受一个字符v，用于以小端模式写入字符
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeCharLE(char v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeShortLE，接受一个短整型v，用于以小端模式写入短整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeShortLE(short v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeIntLE，接受一个整型v，用于以小端模式写入整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeIntLE(int v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeLongLE，接受一个长整型v，用于以小端模式写入长整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeLongLE(long v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeFloatLE，接受一个浮点型v，用于以小端模式写入浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeFloatLE(float v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeDoubleLE，接受一个双精度浮点型v，用于以小端模式写入双精度浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeDoubleLE(double v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeBoolLE，接受一个布尔型v，用于以小端模式写入布尔型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeBoolLE(bool v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法writeStringLE，接受一个字符串v，用于以小端模式写入字符串
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final void writeStringLE(String v)
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readCharLE，用于以小端模式读取字符
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final char readCharLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readShortLE，用于以小端模式读取短整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final short readShortLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readIntLE，用于以小端模式读取整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final int readIntLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readLongLE，用于以小端模式读取长整型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final long readLongLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readFloatLE，用于以小端模式读取浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final float readFloatLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readDoubleLE，用于以小端模式读取双精度浮点型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final double readDoubleLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readBoolLE，用于以小端模式读取布尔型
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final bool readBoolLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
// 定义一个final方法readStringLE，用于以小端模式读取字符串
// 可能抛出的异常：IllegalArgumentException, IOException, TimeoutException, InterruptedException
final String readStringLE()
IllegalArgumentException,
IOException,
TimeoutException,
InterruptedException;
};GZipInputStream类
用于处理GZip压缩的输入流。
//GZipInputStream类，继承自Stream类
class GZipInputStream : Stream{
// 构造函数，接受一个字节数组buffer、偏移量offset和长度length作为参数
// buffer不能为空，否则抛出IllegalArgumentException异常
GZipInputStream(byte [] /*Not Nilptr*/buffer, int offset, int length)IllegalArgumentException;
// 构造函数，接受一个Stream对象作为参数
// stream不能为空，否则抛出IllegalArgumentException异常
GZipInputStream(Stream /*Not Nilptr*/stream);
// 从当前流中读取数据到buffer数组中，从offset位置开始，读取length个字节
// buffer不能为空，否则抛出IllegalArgumentException异常
int read(byte [] /*Not Nilptr*/buffer, int offset, int length)IllegalArgumentException;
// 根据seektype和offset移动流的当前位置
// seektype可以是0（从当前位置开始）、1（从起始位置开始）或2（从末尾位置开始）
long seek(int seektype, long offset);
// 获取当前文件或数据流的读取/写入位置
long getPosition();
// 获取文件或数据流的长度
long length();
// 获取当前可用的数据量
// 如果 bWait 为 true，则等待直到有数据可用
// 如果 bWait 为 false，则立即返回当前可用的数据量
long available(bool bWait);
// 刷新缓冲区，将缓冲的数据写入文件或数据流
void flush() ;
// 关闭文件或数据流，释放相关资源
void close() ;
};GZipOutputStream类
用于处理GZip压缩的输出流。
//GZipOutputStream类，继承自Stream类
class GZipOutputStream : Stream{
// 构造函数，接收一个非空的Stream对象作为参数
// 用于初始化GZipOutputStream，将数据写入到指定的输出流中
GZipOutputStream(Stream /*Not Nilptr*/outputstream);
// 写入方法，接收一个非空的字节数组buffer，以及偏移量offset和长度length作为参数
// 将buffer中从offset开始长度为length的字节写入到输出流中
// 返回写入的字节数
int write(byte [] /*Not Nilptr*/buffer, int offset, int length);
// 获取当前位置的方法，返回当前输出流的位置
long getPosition();
// 可用方法，接收一个布尔值bWait作为参数
// 如果bWait为true，则等待直到有数据可读
// 如果bWait为false，则立即返回当前可用的字节数
long available(bool bWait);
// 关闭方法，用于关闭输出流
void close() ;
// 完成方法，用于完成输出流的写入操作
void finish();
};ByteArrayOutputStream类
用于处理字节数组的输出流。
//ByteArrayOutputStream类，继承自Stream类
class ByteArrayOutputStream : Stream{
ByteArrayOutputStream(); // 构造函数，用于创建ByteArrayOutputStream对象
// 写入方法，将字节数组buffer从offset位置开始，长度为length的字节写入到流中
// 参数buffer：要写入的字节数组，不能为null
// 参数offset：开始写入的位置
// 参数length：要写入的字节数
// 返回值：写入的字节数
int write(byte [] /*Not Nilptr*/buffer, int offset, int length);
// 获取当前流的位置
// 返回值：当前流的位置
long getPosition();
// 获取流的长度
// 返回值：流的长度
long length();
// 关闭流，释放相关资源
void close() ;
// 将流中的数据转换为字节数组
// 返回值：包含流中所有数据的字节数组
byte [] toByteArray();
};
StreamSocket类
用于处理网络套接字的输入输出流。
//StreamSocket 流式套接字类(TCP)，继承自Stream类
class StreamSocket : Stream{
// 定义一些常量，用于表示不同的标志位
static final int FLAGS_READABLE = 1; // 可读标志
static final int FLAGS_WRITEABLE = 2; // 可写标志
static final int FLAGS_EXCEPTION = 4; // 异常标志
// 构造函数，可能抛出IllegalArgumentException异常
StreamSocket()IllegalArgumentException;
// 从Socket读取数据到buffer中，从offset位置开始，读取length长度的数据，返回读取的字节数
int read(byte [] /*Not Nilptr*/buffer, int offset, int length);
// 将buffer中的数据写入Socket，从offset位置开始，写入length长度的数据，返回写入的字节数
int write(byte [] /*Not Nilptr*/buffer, int offset, int length);
// 返回可读取的数据量，如果bWait为true，则等待数据可用
long available(bool bWait);
// 在指定的时间内等待可用的数据，返回可用的数据量，可能抛出IndexOutOfBoundsException和IllegalArgumentException异常
int available(long millisecond, int flags);
// 获取Socket的句柄
long getHandle();
// 连接到指定的主机和端口，超时时间为timeout毫秒，可能抛出TimeoutException和InterruptedException异常
bool connect(String /*Not Nilptr*/host, int port, int timeout)TimeoutException, InterruptedException;
// 绑定到指定的地址和端口，并开始监听，backlog表示等待连接的最大数量
bool listen(String /*Not Nilptr*/bind, int port, int backlog);
// 获取远程主机的InetAddress对象
InetAddress getRemoteInetAddress();
// 获取本地主机的InetAddress对象
InetAddress getLocalInetAddress();
// 获取远程主机的IP地址
String getRemoteIpAddress();
// 获取远程主机的端口号
int getRemotePort();
// 获取本地主机的IP地址
String getLocalIpAddress();
// 获取本地主机的端口号
int getLocalPort();
// 接受一个连接，返回一个新的StreamSocket对象，可能抛出IllegalArgumentException异常
StreamSocket accept()IllegalArgumentException;
// 检查是否已经连接
bool isConnected();
// 设置Socket的超时时间，单位为毫秒
bool setSoTimeout(int millisecond);
// 设置TCP无延迟选项
bool setTcpNoDelay(bool on);
// 设置TCP保活选项
bool setKeepAlive(bool on);
// 获取TCP无延迟选项的值
bool getTcpNoDelay();
// 获取TCP保活选项的值
bool getKeepAlive();
// 设置地址重用选项
bool setReuseAddress(bool on);
// 获取地址重用选项的值
bool getReuseAddress();
// 刷新输出流
void flush() ;
// 关闭Socket
void close() ;
// 关闭输入流
void shutdownInput();
// 关闭输出流
void shutdownOutput();
// 设置Socket的linger选项，on为true表示启用linger，linger表示等待的时间
bool setSoLinger(bool on, int linger);
// 获取Socket的linger选项的值
int getSoLinger();
// 静态方法，用于在指定的时间内等待多个Socket的状态变化，返回满足条件的Socket数量，可能抛出IndexOutOfBoundsException、IllegalArgumentException和InterruptedException异常
static int select(StreamSocket[] /*Not Nilptr*/sockets, int flags, int offset, int count, int []/*Not Nilptr*/sets, int timeout)IndexOutOfBoundsException, IllegalArgumentException, InterruptedException;
};
InetAddress类
用于处理网络地址。
class InetAddress{
// 构造函数，用于创建一个InetAddress对象
InetAddress();
// 构造函数，用于创建一个指定主机名和端口的InetAddress对象
// 参数host：表示主机名，不能为空
// 参数port：表示端口号
InetAddress(String /*Not Nilptr*/host, int port);
// 获取该InetAddress对象的主机地址字符串表示形式
// 返回值：表示主机地址的字符串
String getHostAddress();
// 获取该InetAddress对象的端口号
// 返回值：表示端口号的整数
int getPort();
// 获取该InetAddress对象的IP地址
// 返回值：表示IP地址的整数
int getAddress();
// 静态方法，用于根据主机名获取对应的InetAddress数组
// 参数hostname：表示主机名，不能为空
// 返回值：表示与主机名对应的InetAddress数组
static InetAddress [] getHostInetAddress(String /*Not Nilptr*/hostname);
};DatagramSocket类
用于处理UDP数据报的套接字。
class DatagramSocket {
// 定义常量，表示不同的标志位
static final int FLAGS_READABLE = 1; // 可读标志
static final int FLAGS_WRITEABLE = 2; // 可写标志
static final int FLAGS_EXCEPTION = 4; // 异常标志
// 内部类 DatagramPacket，表示数据报包
static class DatagramPacket{
// 构造函数，无参
DatagramPacket();
// 构造函数，指定缓冲区大小
DatagramPacket(int buffersize);
// 构造函数，指定缓冲区大小和目标地址
DatagramPacket(int buffersize, InetAddress /*Not Nilptr*/address);
// 绑定到指定的主机和端口
bool bind(String /*Not Nilptr*/host, int port);
// 构造函数，指定数据、位置、长度和目标地址
DatagramPacket(byte [] /*Not Nilptr*/data, int pos, int length, InetAddress /*Not Nilptr*/address)IllegalArgumentException, IndexOutOfBoundsException;
// 获取数据报包的源地址
InetAddress getAddress()IllegalArgumentException;
// 设置数据报包的数据
void setData(byte [] /*Not Nilptr*/data, int pos, int length)IllegalArgumentException, IndexOutOfBoundsException;
// 获取数据报包的长度
int length();
// 获取数据报包的数据
byte [] getData();
// 清理资源
void finalize() ;
};
// 构造函数，无参
DatagramSocket();
// 绑定到指定的主机和端口
bool bind(String /*Not Nilptr*/host, int port);
// 从数据报套接字中读取数据
int read(byte [] /*Not Nilptr*/buffer, int pos, int length)IllegalArgumentException, IndexOutOfBoundsException;
// 向数据报套接字中写入数据
int write(byte [] /*Not Nilptr*/buffer, int pos, int length)IllegalArgumentException, IndexOutOfBoundsException;
// 关闭数据报套接字
void close();
// 获取可用的数据量
long available(bool wait);
// 获取指定时间内可用的数据量
int available(long millisecond, int flags);
// 获取数据报套接字的句柄
long getHandle();
// 连接到指定的主机和端口
bool connect(String /*Not Nilptr*/host, int port)IllegalArgumentException;
// 获取远程主机的InetAddress对象
InetAddress getRemoteInetAddress();
// 获取本地主机的InetAddress对象
InetAddress getLocalInetAddress();
// 获取远程主机的IP地址
String getRemoteIpAddress();
// 获取远程主机的端口号
int getRemotePort();
// 获取本地主机的IP地址
String getLocalIpAddress();
// 获取本地主机的端口号
int getLocalPort();
int sendTo(String /*Not Nilptr*/host, int port, byte [] /*Not Nilptr*/buffer, int pos, int length)IllegalArgumentException, IndexOutOfBoundsException;
int sendTo(InetAddress /*Not Nilptr*/host, byte [] /*Not Nilptr*/buffer, int pos, int length)IllegalArgumentException, IndexOutOfBoundsException;
// 设置Socket的超时时间，单位为毫秒
bool setSoTimeout(int millisecond);
// 接收一个数据报包，参数packet不能为空
bool receive(DatagramPacket /*Not Nilptr*/packet);
// 设置Socket的地址重用选项，on为true表示允许重用地址，false表示不允许
void setReuseAddress(bool on);
// 获取Socket的地址重用选项，返回true表示允许重用地址，false表示不允许
bool getReuseAddress();
// 设置Socket的广播选项，on为true表示允许广播，false表示不允许
void setBroadcast(bool on);
// 发送一个数据报包，参数packet不能为空
bool send(DatagramPacket /*Not Nilptr*/packet);
// 设置Socket的混杂模式，b为true表示开启混杂模式，false表示关闭
bool setPromiscuousMode(bool b);
// 检查Socket是否正在监听
bool isListenning();
// 获取Socket的保持连接选项，返回true表示保持连接，false表示不保持
bool getKeepAlive();
// 设置Socket的保持连接选项，b为true表示保持连接，false表示不保持
bool setKeepAlive(bool b);
// 获取Socket的接收缓冲区大小
int getRecvBufferSize();
// 设置Socket的接收缓冲区大小，size为缓冲区大小
bool setRecvBufferSize(int size);
// 获取Socket的发送缓冲区大小
int getSendBufferSize();
// 设置Socket的发送缓冲区大小，size为缓冲区大小
bool setSendBufferSize(int size);
static int select(DatagramSocket[] /*Not Nilptr*/sockets, int flags, int offset, int count, int []/*Not Nilptr*/sets, int timeout)IndexOutOfBoundsException, IllegalArgumentException, InterruptedException;
};Pattern类
用于处理正则表达式匹配。
class Pattern{
// 定义一个静态内部类Result，用于存储匹配结果
static class Result{
// 构造函数，用于创建Result对象
Result();
// 根据索引获取匹配结果
Result get(int index)IllegalArgumentException;
// 获取匹配结果的起始位置
int start()IllegalArgumentException;
// 获取匹配结果的结束位置
int end()IllegalArgumentException;
// 获取匹配结果的长度
int length()IllegalArgumentException;
// 获取错误代码
int errorCode()IllegalArgumentException;
};
// 定义各种模式选项的常量
static int CASELESS = 0x00000001; // 忽略大小写
static int MULTILINE = 0x00000002; // 多行模式
static int DOTALL = 0x00000004; // 点匹配所有字符，包括换行符
static int EXTENDED = 0x00000008; // 扩展的正则表达式语法
static int ANCHORED = 0x00000010; // 匹配必须从字符串开始
static int DOLLAR_ENDONLY = 0x00000020; // $只匹配字符串结束
static int EXTRA = 0x00000040; // 使用额外的特性
static int NOTBOL = 0x00000080; // ^不匹配字符串开始
static int NOTEOL = 0x00000100; // $不匹配字符串结束
static int UNGREEDY = 0x00000200; // 非贪婪匹配
static int NOTEMPTY = 0x00000400; // 空字符串不匹配
static int UTF8 = 0x00000800; // UTF-8编码
static int UTF16 = 0x00000800; // UTF-16编码
static int UTF32 = 0x00000800; // UTF-32编码
static int NO_AUTO_CAPTURE = 0x00001000; // 不自动捕获
static int NO_UTF8_CHECK = 0x00002000; // 不检查UTF-8编码
static int NO_UTF16_CHECK = 0x00002000; // 不检查UTF-16编码
static int NO_UTF32_CHECK = 0x00002000; // 不检查UTF-32编码
static int AUTO_CALLOUT = 0x00004000; // 自动调用
static int PARTIAL_SOFT = 0x00008000; // 部分匹配（软）
static int PARTIAL = 0x00008000; // 部分匹配
static int NEVER_UTF = 0x00010000; // 从不使用UTF编码
static int DFA_SHORTEST = 0x00010000; // DFA最短匹配
static int NO_AUTO_POSSESS = 0x00020000; // 不自动 possessive 量词
static int DFA_RESTART = 0x00020000; // DFA重新启动
static int FIRSTLINE = 0x00040000; // 只匹配第一行
static int DUPNAMES = 0x00080000; // 允许重复的命名组
static int NEWLINE_CR = 0x00100000; // 换行符为CR
static int NEWLINE_LF = 0x00200000; // 换行符为LF
static int NEWLINE_CRLF = 0x00300000; // 换行符为CRLF
static int NEWLINE_ANY = 0x00400000; // 任意换行符
static int NEWLINE_ANYCRLF = 0x00500000; // 任意换行符或CRLF
static int BSR_ANYCRLF = 0x00800000; // BSR为任意换行符或CRLF
static int BSR_UNICODE = 0x01000000; // BSR为Unicode换行符
static int JAVASCRIPT_COMPAT = 0x02000000; // JavaScript兼容模式
static int NO_START_OPTIMIZE = 0x04000000; // 不优化起始位置
static int NO_START_OPTIMISE = 0x04000000; // 不优化起始位置（同上）
static int PARTIAL_HARD = 0x08000000; // 部分匹配（硬）
static int NOTEMPTY_ATSTART = 0x10000000; // 非空字符串从起始位置匹配
static int UCP = 0x20000000; // 使用Unicode字符属性
// 构造函数，使用给定的正则表达式创建Pattern对象
Pattern(String /*Not Nilptr*/regx);
// 构造函数，使用给定的正则表达式和选项创建Pattern对象
Pattern(String /*Not Nilptr*/regx, int options);
// 静态方法，编译给定的正则表达式
static Pattern Compile(String /*Not Nilptr*/regx)IllegalArgumentException;
// 静态方法，编译给定的正则表达式和选项
static Pattern Compile(String /*Not Nilptr*/regx, int options)IllegalArgumentException;
// 匹配所有结果
Result matchAll(String /*Not Nilptr*/text, int offset, int length, int options)IllegalArgumentException, IndexOutOfBoundsException;
// 匹配给定文本，并返回匹配结果
int match(String /*Not Nilptr*/text, Result /*Not Nilptr*/result, int offset, int length, int options)IllegalArgumentException, IndexOutOfBoundsException;
// 测试给定文本是否匹配给定的正则表达式
static bool test(String /*Not Nilptr*/text, String /*Not Nilptr*/regex, int options, bool bFull)IllegalArgumentException;
};Lock接口
用于处理线程同步的锁机制。
interface Lock{
// 定义一个lock方法，用于锁定资源，方法体为nilptr，表示该方法没有具体实现
void lock() = nilptr;
// 定义一个unlock方法，用于解锁资源，方法体为nilptr，表示该方法没有具体实现
void unlock() = nilptr;
// 定义一个trylock方法，用于尝试锁定资源，如果锁定成功返回true，否则返回false，方法体为nilptr，表示该方法没有具体实现
bool trylock() = nilptr;
};ReentrantLock类：
用于处理线程同步的可重入锁。
//ReentrantLock的类，继承自Lock类
class ReentrantLock : Lock{
ReentrantLock(); // 构造函数，用于创建ReentrantLock对象
void lock(); // 锁定方法，用于获取锁，如果锁已被其他线程持有，则当前线程会等待直到获取锁
void unlock(); // 解锁方法，用于释放锁，使其他等待的线程可以获取锁
bool trylock(); // 尝试锁定方法，尝试获取锁，如果锁可用则获取并返回true，否则返回false，不会阻塞当前线程
};UnreentrantLock 类:
用于处理线程同步的不可重入锁。
//不可重入锁类，继承自Lock接口
class UnreentrantLock : Lock{
// 构造函数，用于初始化UnreentrantLock对象
UnreentrantLock();
// 锁定方法，用于获取锁，如果锁已被其他线程持有，则当前线程会阻塞直到获取锁
void lock();
// 解锁方法，用于释放锁，使其他等待的线程可以获取锁
void unlock();
// 尝试锁定方法，用于尝试获取锁，如果锁可用则获取锁并返回true，否则返回false，不会阻塞当前线程
bool trylock();
};ReadWriteLock接口
用于处理读写锁的线程同步机制。
// 定义一个读写锁接口
interface ReadWriteLock{
// 锁定读操作，该方法没有具体实现，需要子类实现
void lockRead() = nilptr;
// 解锁读操作，该方法没有具体实现，需要子类实现
void unlockRead() = nilptr;
// 尝试锁定读操作，如果锁定成功返回true，否则返回false，该方法没有具体实现，需要子类实现
bool trylockRead() = nilptr;
// 锁定写操作，该方法没有具体实现，需要子类实现
void lockWrite() = nilptr;
// 解锁写操作，该方法没有具体实现，需要子类实现
void unlockWrite() = nilptr;
// 尝试锁定写操作，如果锁定成功返回true，否则返回false，该方法没有具体实现，需要子类实现
bool trylockWrite() = nilptr;
};ReentrantReadWriteLock类
用于处理读写锁的线程同步机制。
//可重入的读写锁类，继承自ReadWriteLock接口
class ReentrantReadWriteLock : ReadWriteLock{
// 构造函数，用于创建ReentrantReadWriteLock对象
ReentrantReadWriteLock();
// 获取读锁，如果当前没有写锁持有者，则获取读锁成功
void lockRead();
// 释放读锁，减少读锁计数
void unlockRead();
// 尝试获取读锁，如果当前没有写锁持有者，则获取读锁成功，返回true；否则返回false
bool trylockRead();
// 获取写锁，如果当前没有其他锁持有者，则获取写锁成功
// 用于锁定写操作
void lockWrite();
// 用于解锁写操作
void unlockWrite();
// 尝试锁定写操作
// 如果锁定成功，返回true；如果锁定失败（例如已经被其他线程锁定），返回false
bool trylockWrite();
};AsyncInput和AsyncOutput接口
用于处理异步输入输出操作。
// 异步输入输出接口
interface AsyncInput{
void notify(AsyncOutput /*Not Nilptr*/output, int type, long distbind,bool bSuccess, long context, int processedLen) = nilptr;
bool newInstance(AsyncOutput /*Not Nilptr*/output, int type,long distbind, long context) = nilptr;
bool dataArrives(AsyncOutput /*Not Nilptr*/output, long context, byte [] /*Not Nilptr*/data, int offset, int length) = nilptr;
bool deleteInstance(AsyncOutput /*Not Nilptr*/output, long context) = nilptr;
bool inactiveTimeout(AsyncOutput /*Not Nilptr*/output, long context) = nilptr;
};
interface AsyncOutput{
bool dataDeparture(AsyncInput /*Not Nilptr*/input, long context, long distbind, byte [] /*Not Nilptr*/data, int offset, int length) = nilptr;
void deleteInstance(AsyncInput /*Not Nilptr*/input, long context) = nilptr;
long newInstance(AsyncInput /*Not Nilptr*/input, String /*Not Nilptr*/linkstring, int port, long distbind) = nilptr;
long getInstanceId(long context) = nilptr;
long cloneContext(long context) = nilptr;
void releaseContext(long context) = nilptr;
};
这段代码定义了两个接口 AsyncInput 和 AsyncOutput，它们用于处理异步输入和输出操作。这些接口可能用于网络编程、文件IO或其他需要异步处理的场景。下面是对这两个接口及其方法的详细解释：
AsyncInput 接口
AsyncInput 接口定义了处理输入相关事件的方法：
-
notify方法：- 参数：
output：一个AsyncOutput实例，用于输出操作。type：事件的类型，具体类型由实现者定义。distbind：一个绑定值，用于标识特定的连接或数据流。bSuccess：一个布尔值，表示操作是否成功。context：上下文信息，用于关联特定的操作或状态。processedLen：已处理的长度，通常用于指示已处理的数据量。
- 返回值：无（
nilptr）。 - 用途：用于通知输入操作的结果或状态变化。
- 参数：
-
newInstance方法：- 参数：与
notify方法的前四个参数相同。 - 返回值：布尔值，表示是否成功创建新实例。
- 用途：用于创建一个新的异步输入实例。
- 参数：与
-
dataArrives方法：- 参数：
output：一个AsyncOutput实例。context：上下文信息。data：到达的数据，以字节数组形式表示。offset：数据的偏移量。length：数据的长度。
- 返回值：布尔值，表示是否成功处理到达的数据。
- 用途：用于处理到达的新数据。
- 参数：
-
deleteInstance方法：- 参数：
output和context。 - 返回值：布尔值，表示是否成功删除实例。
- 用途：用于删除一个异步输入实例。
- 参数：
-
inactiveTimeout方法：- 参数：
output和context。 - 返回值：布尔值，表示是否成功处理超时事件。
- 用途：用于处理在指定时间内无活动的情况。
- 参数：
AsyncOutput 接口
AsyncOutput 接口定义了处理输出相关操作的方法：
-
dataDeparture方法：- 参数：
input：一个AsyncInput实例，用于输入操作。context：上下文信息。distbind：绑定值。data：要发送的数据，以字节数组形式表示。offset：数据的偏移量。length：数据的长度。
- 返回值：布尔值，表示是否成功发送数据。
- 用途：用于处理数据的发送操作。
- 参数：
-
deleteInstance方法：- 参数：
input和context。 - 返回值：无（
nilptr）。 - 用途：用于删除一个异步输出实例。
- 参数：
-
newInstance方法：- 参数：
input：一个AsyncInput实例。linkstring：连接字符串，用于建立连接。port：端口号。distbind：绑定值。
- 返回值：长整型，表示新实例的ID。
- 用途：用于创建一个新的异步输出实例，并返回其ID。
- 参数：
-
getInstanceId方法：- 参数：
context。 - 返回值：长整型，表示实例的ID。
- 用途：用于获取特定上下文关联的实例ID。
- 参数：
-
cloneContext方法：- 参数：
context。 - 返回值：长整型，表示克隆的上下文ID。
- 用途：用于克隆一个上下文，并返回新上下文的ID。
- 参数：
-
releaseContext方法：- 参数：
context。 - 返回值：无（
nilptr）。 - 用途：用于释放一个上下文资源。
- 参数：
注意事项
- 注释中的
Not Nilptr：注释表明参数不应为null，这在实际实现中需要特别注意。 - 返回值
nilptr：在某些方法中，返回值被标记为nilptr，表示该方法没有返回值。 - 接口设计：这些接口设计用于异步操作，因此在实现时需要考虑线程安全和性能问题。
接口设计背景
这两个接口（AsyncInput & AsyncOutput）定义了异步双向通信机制，常用于事件驱动型架构（如网络通信、跨进程调用）。二者的核心关系是：
- 生产者-消费者模式：
AsyncInput是事件接收方（消费者），AsyncOutput是事件发送方（生产者）。 - 双向绑定：通过互相持有对方的实例引用实现双向通信。
// 异步输入事件处理器
interface AsyncInput {
// 事件通知回调
void notify(
AsyncOutput /*Not Nilptr*/ output, // 绑定的输出通道（必须非空）
int type, // 事件类型标识（如连接成功/失败）
long distbind, // 分布式绑定标识（用于跨节点通信）
bool bSuccess, // 操作是否成功
long context, // 上下文标识（用于追踪会话）
int processedLen // 已处理的数据长度
) = nilptr; // ❗存在问题：接口方法应为纯虚函数，建议改为 `= 0`
// 创建新实例
bool newInstance(
AsyncOutput /*Not Nilptr*/ output, // 绑定的输出通道
int type, // 实例类型
long distbind, // 分布式绑定标识
long context // 上下文标识
);
// 数据到达回调
bool dataArrives(
AsyncOutput /*Not Nilptr*/ output,
long context, // 当前会话上下文
byte[] /*Not Nilptr*/ data, // 接收到的二进制数据（必须非空）
int offset, // 数据起始偏移量
int length // 数据有效长度
);
// 删除实例
bool deleteInstance(
AsyncOutput /*Not Nilptr*/ output,
long context
);
// 连接超时回调
bool inactiveTimeout(
AsyncOutput /*Not Nilptr*/ output,
long context
);
};
// 异步输出事件处理器
interface AsyncOutput {
// 发送数据到远端
bool dataDeparture(
AsyncInput /*Not Nilptr*/ input, // 绑定的输入通道
long context,
long distbind,
byte[] /*Not Nilptr*/ data, // 待发送的数据
int offset,
int length
);
// 删除实例
void deleteInstance(
AsyncInput /*Not Nilptr*/ input,
long context
);
// 创建新实例
long newInstance(
AsyncInput /*Not Nilptr*/ input,
String /*Not Nilptr*/ linkstring, // 连接地址（如"tcp://127.0.0.1:8080"）
int port, // 端口号
long distbind // 分布式绑定标识
);
// 获取实例ID
long getInstanceId(long context);
// 克隆上下文（用于会话复制）
long cloneContext(long context);
// 释放上下文资源
void releaseContext(long context);
};
(1) 核心交互流程
mermaidCopy Code
sequenceDiagram
participant Input as AsyncInput
participant Output as AsyncOutput
Output->>Input: newInstance() 创建会话
Input->>Output: notify() 反馈状态
Output->>Input: dataDeparture() 发送数据
Input->>Output: dataArrives() 响应接收
Output->>Input: deleteInstance() 终止会话
(2) 参数设计亮点
-
上下文标识 (
context)
用于跟踪单个会话生命周期，类似HTTP请求的SessionID。 -
分布式绑定标识 (
distbind)
适用于微服务/集群环境，标识跨节点通信的绑定关系。 -
Not Nilptr 标注
强制要求调用方传递非空对象，避免空指针异常。
(3) 典型应用场景
- 网络通信框架
- 实现TCP/UDP协议栈的异步收发
- 示例：当数据包到达时触发
dataArrives()
- 分布式系统
- 跨服务节点的事件通知（通过
distbind标识）
- 跨服务节点的事件通知（通过
- 音视频流处理
- 分片数据的异步传输（
offset和length控制数据块）
- 分片数据的异步传输（
HttpRequest类
用于处理HTTP请求。
class HttpRequest{
// 定义代理类型常量
static final int PROXY_HTTP = 0; // HTTP代理
static final int PROXY_HTTP_10 = 1; // HTTP 1.0代理
static final int PROXY_SOCKS4 = 4; // SOCKS4代理
static final int PROXY_SOCKS5 = 5; // SOCKS5代理
static final int PROXY_SOCKS4A = 6; // SOCKS4A代理
static final int PROXY_HTTP_SOCKS5_HOSTNAME = 7; // HTTP SOCKS5主机名代理
// 构造函数
HttpRequest();
// 发送GET请求
// 参数：url - 请求的URL，timeout - 超时时间，bSecure - 是否使用安全连接
// 返回：请求是否成功
// 异常：IllegalArgumentException - 如果参数不合法
bool get(String /*Not Nilptr*/url, int timeout, bool bSecure)IllegalArgumentException;
// 发送POST请求
// 参数：url - 请求的URL，timeout - 超时时间，bSecure - 是否使用安全连接
// 返回：请求是否成功
// 异常：IllegalArgumentException - 如果参数不合法
bool post(String /*Not Nilptr*/url, int timeout, bool bSecure)IllegalArgumentException;
// 设置代理
// 参数：url - 代理服务器URL，port - 代理服务器端口，optionType - 代理类型，username - 用户名，password - 密码
// 返回：设置是否成功
bool setProxy(String /*Not Nilptr*/url, int port, int optionType, String username, String password);
// 添加表单字段
// 参数：name - 字段名称，alias - 字段别名，fieldType - 字段类型，path - 字段路径
// 返回：添加是否成功
bool putFormField(String /*Not Nilptr*/name, String alias, String fieldType, String path);
// 添加表单字段
// 参数：name - 字段名称，fieldName - 字段名，fieldType - 字段类型，data - 字段数据
// 返回：添加是否成功
bool putFormField(String /*Not Nilptr*/name, String /*Not Nilptr*/fieldName, String fieldType, byte [] /*Not Nilptr*/data);
// 添加字段
// 参数：name - 字段名称，value - 字段值
// 返回：添加是否成功
bool putField(String /*Not Nilptr*/name, String /*Not Nilptr*/value);
// 添加字段
// 参数：name - 字段名称，data - 字段数据，offset - 数据偏移量，length - 数据长度
// 返回：添加是否成功
bool putField(String /*Not Nilptr*/name, byte [] /*Not Nilptr*/data, int offset, int length);
// 添加表单字段
// 参数：name - 字段名称，value - 字段值
// 返回：添加是否成功
bool putFormField(String /*Not Nilptr*/name, String /*Not Nilptr*/value);
// 添加表单字段
// 参数：name - 字段名称，fieldName - 字段名，fieldType - 字段类型，data - 字段数据流
// 返回：添加是否成功
bool putFormField(String /*Not Nilptr*/name, String /*Not Nilptr*/fieldName, String fieldType, Stream /*Not Nilptr*/data);
// 移除字段
// 参数：name - 字段名称
// 返回：移除是否成功
bool removeField(String /*Not Nilptr*/name);
// 设置Cookie
// 参数：name - Cookie名称
// 返回：设置是否成功
bool setCookie(String /*Not Nilptr*/name);
// 设置Cookie输入文件
// 参数：filepath - Cookie输入文件路径
// 返回：设置是否成功
bool setCookieInputFile(String /*Not Nilptr*/filepath);
// 设置Cookie输出文件
// 参数：filepath - Cookie输出文件路径
// 返回：设置是否成功
bool setCookieOutputFile(String /*Not Nilptr*/filepath);
// 设置User-Agent
// 参数：agent - User-Agent字符串
// 返回：设置是否成功
bool setUserAgent(String /*Not Nilptr*/agent);
// 添加请求头
// 参数：header - 请求头字符串
// 返回：添加是否成功
bool putHeader(String /*Not Nilptr*/header);
// 移除请求头
// 参数：header - 请求头名称
// 返回：移除是否成功
bool removeHeader(String /*Not Nilptr*/header);
// 获取响应代码
// 返回：响应代码
int getResponseCode();
// 获取响应头数量
// 返回：响应头数量
int getResponseHeaderCount();
// 获取指定索引的响应头值
// 参数：n - 响应头索引
// 返回：响应头值
String getResponseHeaderValue(int n);
// 获取指定键的响应头值
// 参数：key - 响应头键
// 返回：响应头值
String getResponseHeaderValue(String key);
// 获取可用的数据长度
// 参数：bWait - 是否等待数据
// 返回：可用的数据长度
long available(bool bWait);
// 获取响应数据长度
// 返回：响应数据长度
long getLength();
// 读取响应数据
// 参数：buffer - 数据缓冲区，offset - 偏移量，length - 读取长度
// 返回：读取的数据长度
int read(byte [] /*Not Nilptr*/buffer, int offset, int length);
// 重置请求
// 返回：重置是否成功
bool reset();
};
ZipFile、ZipEntry和ZipArchive类
用于处理ZIP文件的压缩和解压缩。
class ZipFile{
ZipFile(String /*Not Nilptr*/name, Stream /*Not Nilptr*/stream, bool isDir, long millisecond)IllegalArgumentException;
bool open();
bool eof();
void close();
int read(byte [] /*Not Nilptr*/data, int offet, int length)IllegalArgumentException, IndexOutOfBoundsException;
};
class ZipEntry{ // 定义一个名为ZipEntry的类，用于表示ZIP文件中的一个条目（文件或目录）
ZipEntry(); // 构造函数，用于创建一个ZipEntry对象，没有参数
ZipFile getFile()IllegalArgumentException;
bool isDirectory();
void setComment(String /*Not Nilptr*/text);
void setName(String /*Not Nilptr*/text);
String getComment();
String getName();
};
//ZipArchive的类，用于处理ZIP归档文件
class ZipArchive{
ZipArchive(); // 构造函数，用于创建ZipArchive对象
// 打开一个ZIP归档文件
// 参数：inputStream - 输入流，不能为空
// 返回值：成功返回true，失败返回false
// 异常：IllegalArgumentException - 如果输入流为空
bool open(Stream /*Not Nilptr*/inputStream)IllegalArgumentException;
// 创建一个新的ZIP归档文件
// 参数：outputStream - 输出流，不能为空
// 返回值：成功返回true，失败返回false
// 异常：IllegalArgumentException - 如果输出流为空
bool create(Stream /*Not Nilptr*/outputStream)IllegalArgumentException;
// 获取ZIP归档中的条目数量
// 返回值：条目数量
int getEntriesCount();
// 根据索引获取ZIP条目
// 参数：n - 条目的索引
// 返回值：指定索引的ZipEntry对象
ZipEntry getEntry(int n);
// 根据名称查找ZIP条目
// 参数：name - 条目的名称，不能为空
// 返回值：找到的ZipEntry对象，未找到返回null
ZipEntry findEntry(String /*Not Nilptr*/name);
// 关闭ZIP归档文件，释放资源
void close();
// 完成ZIP归档文件的写入操作
void finish();
// 在ZIP归档中创建一个新的条目
// 参数：filename - 要创建的条目的文件名，不能为空
// 返回值：成功返回true，失败返回false
bool createEntry(ZipFile /*Not Nilptr*/filename);
// 设置ZIP归档的注释
// 参数：text - 注释文本，不能为空
void setComment(String /*Not Nilptr*/text);
// 获取ZIP归档的注释
// 返回值：注释文本
String getComment();
};ZipFile 类
ZipFile 类用于处理单个ZIP文件。它包含以下成员：
- 构造函数
ZipFile(String name, Stream stream, bool isDir, long millisecond)：用于创建一个ZipFile对象，参数包括文件名、输入流、是否为目录和时间戳。如果参数为空，会抛出IllegalArgumentException异常。 bool open()：打开ZIP文件，返回true表示成功，false表示失败。bool eof()：检查是否已到达文件末尾，返回true表示已到达末尾，false表示未到达末尾。void close()：关闭ZIP文件，释放资源。int read(byte[] data, int offset, int length)：从ZIP文件中读取数据到data数组中，从offset开始，读取length个字节。如果参数无效，会抛出IllegalArgumentException和IndexOutOfBoundsException异常。
ZipEntry 类
ZipEntry 类表示ZIP文件中的一个条目（文件或目录）。它包含以下成员：
- 构造函数
ZipEntry()：用于创建一个ZipEntry对象。 ZipFile getFile()：获取该条目所属的ZipFile对象，如果ZipEntry不属于任何ZipFile，会抛出IllegalArgumentException异常。bool isDirectory()：检查该条目是否为目录。void setComment(String text)：设置该条目的注释。void setName(String text)：设置该条目的名称。String getComment()：获取该条目的注释。String getName()：获取该条目的名称。
ZipArchive 类
ZipArchive 类用于处理ZIP归档文件。它包含以下成员：
- 构造函数
ZipArchive()：用于创建一个ZipArchive对象。 bool open(Stream inputStream)：打开一个ZIP归档文件，如果输入流为空，会抛出IllegalArgumentException异常。bool create(Stream outputStream)：创建一个新的ZIP归档文件，如果输出流为空，会抛出IllegalArgumentException异常。int getEntriesCount()：获取ZIP归档中的条目数量。ZipEntry getEntry(int n)：根据索引获取ZIP条目。ZipEntry findEntry(String name)：根据名称查找ZIP条目，如果未找到，返回null。void close()：关闭ZIP归档文件，释放资源。void finish()：完成ZIP归档文件的写入操作。bool createEntry(ZipFile filename)：在ZIP归档中创建一个新的条目，如果文件名为空，会抛出IllegalArgumentException异常。void setComment(String text)：设置ZIP归档的注释。String getComment()：获取ZIP归档的注释。
注意事项
- 所有方法中的参数都不能为空，否则会抛出
IllegalArgumentException异常。 read方法的参数data、offset和length必须有效，否则会抛出IndexOutOfBoundsException异常。- 在使用
ZipFile和ZipArchive对象时，需要确保在操作完成后调用close方法释放资源。
Timer和TimerTask类
用于处理定时任务。
// 定义一个接口 TimerTask，用于表示定时任务
interface TimerTask{
// 定义一个抽象方法 run，用于执行任务。默认返回值为 nilptr，表示空指针
void run() = nilptr;
};
// 定义一个类 Timer，用于管理定时任务
class Timer{
// 构造函数，用于创建 Timer 对象
Timer();
// 定义一个方法 schedule，用于安排一个任务在指定的延迟后执行
// 参数 task：要执行的任务，不能为空指针
// 参数 delay：延迟时间，单位为毫秒
// 返回值：布尔值，表示任务是否成功安排
// 抛出异常：IllegalArgumentException，如果参数不合法
// 定义一个方法，用于安排一个定时任务在指定的延迟后执行一次
// 参数task是一个非空的TimerTask对象，表示要执行的任务
// 参数delay是一个整数，表示任务执行的延迟时间（以毫秒为单位）
// 返回一个布尔值，表示任务是否成功安排
// 如果参数不合法，抛出IllegalArgumentException异常
bool schedule(TimerTask /*Not Nilptr*/task, int delay)IllegalArgumentException;
bool schedule(TimerTask /*Not Nilptr*/task, int delay, int period)IllegalArgumentException;
void cancel();
};
Map类
用于处理集合数据结构。
class Map<Key, Value>{ // 定义一个泛型类Map，其中Key和Value是类型参数
Map(); // 构造函数，用于创建Map对象
Iterator put(Key key, Value val); // 向Map中插入键值对，返回一个迭代器
Value get(Key key); // 根据键获取对应的值
Iterator findHigher(Key key, bool bIgnoreEqu); // 查找大于指定键的元素，bIgnoreEqu表示是否忽略等于指定键的元素，返回一个迭代器
Iterator findLower(Key key, bool bIgnoreEqu); // 查找小于指定键的元素，bIgnoreEqu表示是否忽略等于指定键的元素，返回一个迭代器
bool containsKey(Key key); // 检查Map中是否包含指定键
Value remove(Key key); // 根据键删除对应的键值对，并返回被删除的值
void remove(%Iterator /*Not Nilptr*/iterator); // 根据迭代器删除对应的键值对
void clear(); // 清空Map中的所有元素
Iterator iterator(); // 返回一个迭代器，用于遍历Map中的元素
Iterator find(Key /*Not Nilptr*/key); // 根据键查找对应的元素，返回一个迭代器
Value operator_set(Key key, Value val); // 设置指定键的值为val，并返回旧的值
Value operator_set(Key key); // 获取指定键的值
int size(); // 返回Map中的元素数量
static class Iterator<Key, Value>{ // 定义一个静态内部类Iterator，用于遍历Map中的元素
bool hasNext()InvalidIteratorException; // 检查是否有下一个元素，如果没有则抛出InvalidIteratorException
void next()IllegalArgumentException, InvalidIteratorException; // 移动到下一个元素，如果没有下一个元素则抛出IllegalArgumentException或InvalidIteratorException
bool hasPrevious()IllegalArgumentException; // 检查是否有上一个元素，如果没有则抛出IllegalArgumentException
Key getKey()IllegalArgumentException, InvalidIteratorException; // 获取当前元素的键，如果没有当前元素则抛出IllegalArgumentException或InvalidIteratorException
Value getValue()IllegalArgumentException, InvalidIteratorException; // 获取当前元素的值，如果没有当前元素则抛出IllegalArgumentException或InvalidIteratorException
void setValue(Value value)IllegalArgumentException, InvalidIteratorException; // 设置当前元素的值，如果没有当前元素则抛出IllegalArgumentException或InvalidIteratorException
Iterator head();
Iterator tail(); // 返回最后一个元素
void previous()IllegalArgumentException, InvalidIteratorException; // 移动到上一个元素，如果没有上一个元素则抛出IllegalArgumentException或InvalidIteratorException
Object clone(); // 克隆当前迭代器
bool equals(Iterator iter)NullPointerException; // 检查当前迭代器是否等于另一个迭代器，如果iter为null则抛出NullPointerException
};
};Vector类
用于处理集合数据结构。
class Vector<Element>{ // 定义一个泛型类Vector，用于存储任意类型的元素
// 构造函数，无参数，返回类型为int，但通常构造函数不应有返回类型
int Vector();
// 构造函数，带一个整数参数size，用于初始化向量的大小，返回类型为int，但通常构造函数不应有返回类型
int Vector(int size);
// 返回向量的大小，即元素的数量
int size();
// 向向量中添加一个元素e
void add(Element e);
// 在指定位置插入元素e，如果位置无效则抛出IndexOutOfBoundsException异常
void insert(int position, Element e)throws IndexOutOfBoundsException;
// 获取指定位置的元素，如果位置无效则抛出IllegalArgumentException异常
Element get(int position)throws IllegalArgumentException;
// 移除指定位置的元素，如果位置无效则抛出IllegalArgumentException异常
void remove(int position)throws IllegalArgumentException;
// 移除指定的对象，如果对象不存在则抛出IllegalArgumentException异常
void remove(Object obj)throws IllegalArgumentException;
// 返回指定对象在列表中的第一次出现的索引，如果对象不存在则返回-1
int indexOf(Object obj);
// 返回指定对象在列表中的最后一次出现的索引，如果对象不存在则返回-1
int lastIndexOf(Object obj);
// 检查列表中是否包含指定的元素e
bool contains(Element e);
// 移除指定位置开始的指定数量的元素，如果位置或数量无效则抛出IllegalArgumentException异常
void removeRange(int position, int size)throws IllegalArgumentException;
// 清空列表中的所有元素
void clear();
// 将列表中的元素复制到指定的数组中，如果数组为null则抛出IllegalArgumentException异常
Element[] toArray(Element [] /*Not Nilptr*/array)throws IllegalArgumentException;
// 在指定位置设置元素e，如果位置无效则抛出IndexOutOfBoundsException异常，如果元素无效则抛出IllegalArgumentException异常
void set(int position, Element e)throws IndexOutOfBoundsException, IllegalArgumentException;
// 重载运算符set，在指定位置设置元素e，如果位置无效则抛出IndexOutOfBoundsException异常，如果元素无效则抛出IllegalArgumentException异常
Element operator [](int position, Element e)IndexOutOfBoundsException, IllegalArgumentException;
// 定义一个操作符重载方法，允许使用下标访问元素
// 参数position表示要访问的元素位置
// 抛出IndexOutOfBoundsException异常，当位置超出有效范围时
// 抛出IllegalArgumentException异常，当传入的位置参数不合法时
Element operator [](int position)throws IndexOutOfBoundsException, IllegalArgumentException;
// 定义一个方法，用于将一个Element数组中的所有元素添加到当前集合中
// 参数e是一个Element数组，数组不能为空（注释中明确指出）
void addAll(Element [] /*Not Nilptr*/e);
};XmlObject类
用于处理XML
// 定义一个名为XmlObject的类，用于表示XML对象
class XmlObject{
// 定义静态常量，表示不同类型的XML节点
static const int Document = 1; // 文档类型
static const int Element = 2; // 元素类型
static const int Declaration = 3; // 声明类型
static const int Comment = 4; // 注释类型
static const int Text = 5; // 文本类型
static const int Attribute = 6; // 属性类型
// 默认构造函数
XmlObject();
// 带参数的构造函数，接受一个字符串参数text，不能为空，否则抛出IllegalArgumentException
XmlObject(String /*Not Nilptr*/text)throws IllegalArgumentException;
// 添加声明节点，接受一个字符串参数declare，不能为空，否则抛出NullPointerException和IllegalArgumentException
XmlObject addDeclaration(String /*Not Nilptr*/declare)throws NullPointerException, IllegalArgumentException;
// 添加元素节点，接受一个字符串参数name，不能为空，否则抛出NullPointerException和IllegalArgumentException
XmlObject addElement(String /*Not Nilptr*/name)throws NullPointerException, IllegalArgumentException;
// 添加注释节点，接受一个字符串参数name，不能为空，否则抛出NullPointerException和IllegalArgumentException
XmlObject addComment(String /*Not Nilptr*/name)throws NullPointerException, IllegalArgumentException;
// 添加文本节点，接受一个字符串参数text，不能为空，否则抛出NullPointerException和IllegalArgumentException
XmlObject addText(String /*Not Nilptr*/text)throws NullPointerException, IllegalArgumentException;
// 设置节点的值，接受一个字符串参数value，不能为空，否则抛出NullPointerException
void setValue(String /*Not Nilptr*/value)throws NullPointerException;
// 设置节点的名称，接受一个字符串参数value，不能为空，否则抛出NullPointerException
void setName(String /*Not Nilptr*/value)throws NullPointerException;
// 设置节点的文本内容，接受一个字符串参数value，不能为空，否则抛出NullPointerException
void setText(String /*Not Nilptr*/value)throws NullPointerException;
// 设置节点的属性，接受两个字符串参数name和val，都不能为空
void setAttribute(String /*Not Nilptr*/name, String /*Not Nilptr*/val);
// 获取根节点
XmlObject root();
// 获取子节点，如果没有子节点则抛出NullPointerException
XmlObject child()throws NullPointerException;
// 获取属性节点，如果没有属性节点则抛出NullPointerException
XmlObject attribute()throws NullPointerException;
// 获取节点的类型，如果没有类型则抛出NullPointerException
int type()throws NullPointerException;
// 获取节点的值，不能为空，否则抛出NullPointerException和IllegalArgumentException
String /*Not Nilptr*/value()throws NullPointerException, IllegalArgumentException;
// 获取前一个兄弟节点，如果没有前一个兄弟节点则抛出NullPointerException和IllegalArgumentException
XmlObject previous()throws NullPointerException, IllegalArgumentException;
// 获取下一个兄弟节点，如果没有下一个兄弟节点则抛出NullPointerException
XmlObject next()throws NullPointerException;
// 获取父节点，如果没有父节点则抛出NullPointerException
XmlObject parent()throws NullPointerException;
// 移除指定的节点，节点不能为空，否则抛出NullPointerException和IllegalArgumentException
bool remove(XmlObject node)throws NullPointerException, IllegalArgumentException;
// 获取节点的名称，不能为空，否则抛出NullPointerException
String name()throws NullPointerException;
// 获取指定名称的子元素节点数组
XmlObject [] getElements(String name);
// 获取指定名称的属性节点
XmlObject getAttributes(String name);
// 返回节点的字符串表示，不能为空，否则抛出NullPointerException和IllegalArgumentException
String toString()throws NullPointerException, IllegalArgumentException;
// 将XML节点转换为JsonNode对象
JsonNode asJson();
};
JsonNode、JsonObject、JsonArray 类
处理JSON数据。
class JsonNode{
// 定义JSON类型的常量
static const int JSONTYPE_BOOL = 1; // 布尔类型
static const int JSONTYPE_NULL = 2; // 空类型
static const int JSONTYPE_NUMBER = 3; // 数字类型
static const int JSONTYPE_STRING = 4; // 字符串类型
static const int JSONTYPE_ARRAY = 5; // 数组类型
static const int JSONTYPE_OBJECT = 6; // 对象类型
// 判断当前节点是否为数组类型
bool isArray();
// 获取当前节点的下一个兄弟节点
JsonNode next();
// 获取当前节点的上一个兄弟节点
JsonNode prev();
// 获取当前节点的子节点
JsonNode child();
// 获取当前节点的名称
String getName();
// 克隆当前节点
JsonNode clone();
// 获取当前节点的类型
final int getType();
// 判断当前节点是否与另一个节点相等
bool equals(JsonNode /*Not Nilptr*/another);
// 将当前节点转换为字符串，可以选择是否格式化
String toString(bool bFormat);
// 清理当前节点，释放资源
void finalize();
// 从字符串中解析出JSON节点
static JsonNode From(String text);
// 将当前节点转换为XmlObject
XmlObject asXml();
};
// 定义一个JsonObject类，继承自JsonNode类
class JsonObject : JsonNode{
// 默认构造函数
JsonObject();
// 带参数的构造函数，接受一个字符串参数，如果为空则抛出IllegalArgumentException异常
JsonObject(String /*Not Nilptr*/text)IllegalArgumentException;
// 根据键获取整数值，如果键为空则抛出IllegalArgumentException异常
int getInt (Object /*Not Nilptr*/key);
// 根据键获取长整数值，如果键为空则抛出IllegalArgumentException异常
long getLong (Object /*Not Nilptr*/key);
// 根据键获取双精度浮点数值，如果键为空则抛出IllegalArgumentException异常
double getDouble (Object /*Not Nilptr*/key);
// 根据键获取布尔值，如果键为空则抛出IllegalArgumentException异常
bool getBool (Object /*Not Nilptr*/key);
// 根据键获取字符串值，如果键为空则抛出IllegalArgumentException异常
String getString (Object /*Not Nilptr*/key);
// 获取默认整数值
int getInt();
// 获取默认长整数值
long getLong();
// 获取默认双精度浮点数值
double getDouble();
// 获取默认布尔值
bool getBool();
// 获取默认字符串值
String getString();
// 根据键获取JsonArray对象，如果键为空则抛出IllegalArgumentException异常
JsonArray getArray(Object /*Not Nilptr*/key);
// 根据键获取JsonObject对象，如果键为空则抛出IllegalArgumentException异常
JsonObject getObject(Object /*Not Nilptr*/key);
// 根据键获取JsonNode对象，如果键为空则抛出IllegalArgumentException异常
JsonNode get(Object /*Not Nilptr*/key);
// 检查键对应的值是否为空，如果键为空则抛出IllegalArgumentException异常
bool isNull(String /*Not Nilptr*/key);
// 检查是否包含指定键，如果键为空则抛出IllegalArgumentException异常
bool has(Object /*Not Nilptr*/key);
// 移除指定键，如果键为空则抛出IllegalArgumentException异常
bool remove(Object /*Not Nilptr*/key);
// 添加或更新键值对，如果键或值为空则抛出IllegalArgumentException异常
void put(Object /*Not Nilptr*/key, Object val);
// 使用重载的赋值运算符添加或更新键值对，如果键或值为空则抛出IllegalArgumentException异常
Object operator [](Object /*Not Nilptr*/key, Object val)IllegalArgumentException;
// 使用重载的赋值运算符添加或更新键值对，如果键为空则抛出IllegalArgumentException异常
Object operator [](Object /*Not Nilptr*/key);
};
// 定义一个JsonArray类，继承自JsonNode类
class JsonArray : JsonNode{
// 默认构造函数
JsonArray();
// 带参数的构造函数，接受一个字符串参数，如果为空则抛出IllegalArgumentException异常
JsonArray(String /*Not Nilptr*/text)IllegalArgumentException;
// 根据索引获取整数值，如果索引无效则抛出IllegalArgumentException异常
int getInt(int index)IllegalArgumentException;
// 根据索引获取长整数值，如果索引无效则抛出IllegalArgumentException异常
long getLong(int index)IllegalArgumentException;
// 根据索引获取双精度浮点数值，如果索引无效则抛出IllegalArgumentException异常
double getDouble(int index)IllegalArgumentException;
// 根据索引获取布尔值，如果索引无效则抛出IllegalArgumentException异常
bool getBool(int index)IllegalArgumentException;
// 根据索引获取字符串值，如果索引无效则抛出IllegalArgumentException异常
String getString(int index)IllegalArgumentException;
// 根据索引获取JsonArray对象，如果索引无效则抛出IllegalArgumentException异常
JsonArray getArray(int index)IllegalArgumentException;
// 根据索引获取JsonObject对象，如果索引无效则抛出IllegalArgumentException异常
JsonObject getObject(int index)IllegalArgumentException;
// 根据索引获取JsonNode对象，如果索引无效则抛出IllegalArgumentException异常
JsonNode get(int index)IllegalArgumentException;
// 检查索引对应的值是否为空，如果索引无效则抛出IllegalArgumentException异常
bool isNull(int index)IllegalArgumentException;
// 移除指定索引的元素，如果索引无效则抛出IllegalArgumentException异常
bool remove(int index)IllegalArgumentException;
// 根据索引添加或更新元素，如果索引或值为空则抛出IllegalArgumentException异常
void put (int index, Object /*Not Nilptr*/val)IllegalArgumentException;
// 添加元素到数组末尾
void put (Object val);
// 获取数组长度
int length();
// 使用重载的赋值运算符添加或更新元素，如果索引或值为空则抛出IllegalArgumentException异常
Object operator [] (int index, Object /*Not Nilptr*/val)IllegalArgumentException;
// 使用重载的赋值运算符添加或更新元素，如果索引为空则抛出IllegalArgumentException异常
Object operator [](int index);
};
Math类
用于处理数学运算。
class Math{
// 定义自然对数的底数e
static const double E = 2.718281828459045;
// 定义圆周率π
static const double PI = 3.141592653589793;
// 计算整数的绝对值
static int abs(int v);
// 计算长整型的绝对值
static long abs(long v);
// 计算双精度浮点数的绝对值
static double abs(double v);
// 计算反余弦值
static double acos(double v);
// 计算反正弦值
static double asin(double v);
// 计算反正切值
static double atan(double v);
// 计算双曲正切值
static double tanh(double v);
// 计算两个数的反正切值
static double atan2(double x, double y);
// 计算立方根
static double cbrt(double v);
// 向上取整
static double ceil(double v);
// 计算余弦值
static double cos(double v);
// 计算双曲余弦值
static double cosh(double v);
// 计算指数函数值
static double exp(double v);
// 计算exp(v) - 1
static double expm1(double v);
// 向下取整
static double floor(double v);
// 计算两个整数的向下取整除法结果
static int floorDiv(int y, int v);
// 计算两个长整型的向下取整除法结果
static long floorDiv(long y, long v);
// 计算两个整数的最大值
static int max(int a, int b);
// 计算两个长整型的最大值
static long max(long a, long b);
// 计算两个双精度浮点数的最大值
static double max(double a, double b);
// 计算两个整数的最小值
static int min(int a, int b);
// 计算两个长整型的最小值
static long min(long a, long b);
// 计算两个双精度浮点数的最小值
static double min(double a, double b);
// 计算a的b次幂
static double pow(double a, double b);
// 计算双曲正弦值
static double sinh(double v);
// 计算log(1 + v)
static double log1p(double v);
// 计算自然对数
static double log(double v);
// 将双精度浮点数四舍五入为长整型
static long round(double v);
// 生成一个0.0到1.0之间的随机双精度浮点数
static double random();
// 判断一个双精度浮点数是否为NaN
static bool isNan(double v);
// 判断一个双精度浮点数是否为正无穷或负无穷
static bool isINF(double v);
// 将长整型转换为双精度浮点数
static double longBitsToDouble(long v);
// 将整型转换为双精度浮点数
static double intBitsToDouble(int v);
// 将双精度浮点数转换为长整型
static long doubleToLongBits(double v);
// 计算平方根
static double sqrt(double v);
// 计算正弦值
static double sin(double v);
// 将字符串解析为整数，指定进制
static int parseInt(String /*Not Nilptr*/text, int radix)IllegalArgumentException;
// 将字符串解析为长整型，指定进制
static long parseLong(String /*Not Nilptr*/text, int radix)IllegalArgumentException;
// 将字符串解析为浮点数
static float parseFloat(String /*Not Nilptr*/text)IllegalArgumentException;
// 将字符串解析为双精度浮点数
static double parseDouble(String /*Not Nilptr*/text)IllegalArgumentException;
// 将双精度浮点数转换为整型
static int doubleToIntBits(double v);
// 将整型转换为浮点数
static float intBitsToFloat(int v);
// 将浮点数转换为整型
static int floatToIntBits(float v);
};Crypto类
用于处理加密和解密操作。
class Crypto{
// 定义填充模式常量
static const int NoPadding = 0; // 无填充
static const int PKCS1Padding = 1; // PKCS1填充
static const int PKCS5Padding = 2; // PKCS5填充
static const int SSLV23Padding = 3; // SSLV23填充
static const int ZerosPadding = 4; // 零填充
// 定义AES加密模式常量
static const int AES_CBC = 0; // CBC模式
static const int AES_CFB1 = 1; // CFB1模式
static const int AES_CFB128 = 2; // CFB128模式
static const int AES_CFB8 = 3; // CFB8模式
static const int AES_ECB = 4; // ECB模式
// MD5初始化
static long md5_init();
// MD5更新，处理数据块
static void md5_update(long hmd5, byte [] /*Not Nilptr*/data, int offset, int length)IndexOutOfBoundsException;
// MD5最终处理
static void md5_final(long hmd5);
// 获取MD5结果
static byte [] md5_result(long hmd5);
// 关闭MD5处理
static void md5_close(long hmd5);
// SHA1初始化
static long sha1_init();
// SHA1更新，处理数据块
static void sha1_update(long hsha1, byte [] /*Not Nilptr*/data, int offset, int length)IndexOutOfBoundsException;
// SHA1最终处理
static void sha1_final(long hsha1);
// 获取SHA1结果
static byte [] sha1_result(long hsha1);
// 关闭SHA1处理
static void sha1_close(long hsha1);
// 初始化RSA加密算法，返回一个RSA算法的句柄
static long rsa_init();
// 从公钥数据加载RSA算法，参数包括RSA句柄、公钥数据、偏移量和长度
// 抛出IndexOutOfBoundsException和IllegalArgumentException异常
static bool rsa_loadFromPublicKey(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length)throws IndexOutOfBoundsException, IllegalArgumentException;
// 从私钥数据加载RSA算法，参数包括RSA句柄、私钥数据、偏移量和长度
// 抛出IndexOutOfBoundsException和IllegalArgumentException异常
static bool rsa_loadFromPrivateKey(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length)throws IndexOutOfBoundsException, IllegalArgumentException;
// 创建指定长度的RSA密钥对，参数包括RSA句柄和密钥长度
// 抛出IllegalArgumentException异常
static bool rsa_create(long hrsa, int length)throws IllegalArgumentException;
// 使用公钥加密数据，参数包括RSA句柄、待加密数据、偏移量、长度和填充方式
// 返回加密后的数据，抛出IndexOutOfBoundsException和IllegalArgumentException异常
static byte [] rsa_publicEncrypto(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length, int padding)throws IndexOutOfBoundsException, IllegalArgumentException;
// 使用私钥解密数据，参数包括RSA句柄、待解密数据、偏移量、长度和填充方式
// 返回解密后的数据，抛出IndexOutOfBoundsException和IllegalArgumentException异常
static byte [] rsa_privateDecrypto(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length, int padding)throws IndexOutOfBoundsException, IllegalArgumentException;
// 使用私钥加密数据，参数包括RSA句柄、待加密数据、偏移量、长度和填充方式
// 返回加密后的数据，抛出IndexOutOfBoundsException和IllegalArgumentException异常
static byte [] rsa_privateEncrypto(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length, int padding)throws IndexOutOfBoundsException, IllegalArgumentException;
// 使用公钥解密数据，参数包括RSA句柄、待解密数据、偏移量、长度和填充方式
// 返回解密后的数据，抛出IndexOutOfBoundsException和IllegalArgumentException异常
static byte [] rsa_publicDecrypto(long hrsa, byte [] /*Not Nilptr*/data, int offset, int length, int padding)throws IndexOutOfBoundsException, IllegalArgumentException;
// 获取RSA私钥数据，参数为RSA句柄，返回私钥数据，抛出IllegalArgumentException异常
static byte [] rsa_getPrivateKey(long hrsa)throws IllegalArgumentException;
// 获取RSA公钥数据，参数为RSA句柄，返回公钥数据，抛出IllegalArgumentException异常
static byte [] rsa_getPublicKey(long hrsa)throws IllegalArgumentException;
// 获取RSA解密时的最大数据大小，参数为RSA句柄，返回最大数据大小，抛出IllegalArgumentException异常
static int rsa_decryptoMaxSize(long hrsa)throws IllegalArgumentException;
// 获取RSA加密时的最大数据大小，参数为RSA句柄，返回最大数据大小，抛出IllegalArgumentException异常
static int rsa_encryptoMaxSize(long hrsa)throws IllegalArgumentException;
// 关闭RSA算法，释放资源，参数为RSA句柄，抛出IllegalArgumentException异常
static void rsa_close(long hrsa)throws IllegalArgumentException;
// 打开AES加密算法，参数包括密码、初始向量、加密方法和解密标志
// 返回AES算法的句柄，抛出IllegalArgumentException异常
static long aes_open(String pwd, String ivec_init, int method, bool bDecrypto)throws IllegalArgumentException;
// 使用AES加密数据，参数包括AES句柄、输入数据、输入偏移量、输入长度、输出数据、输出偏移量、输出长度和填充方式
// 返回加密后的数据长度，抛出IndexOutOfBoundsException和IllegalArgumentException异常
static int aes_encrypt(long haes, byte [] /*Not Nilptr*/in_data, int in_offset, int in_length, byte [] /*Not Nilptr*/out_data, int out_offset, int out_length, int padding)throws IndexOutOfBoundsException, IllegalArgumentException;
// 关闭AES算法，释放资源，参数为AES句柄，抛出IllegalArgumentException异常
static void aes_close(long haes)throws IllegalArgumentException;
// 初始化SM3哈希算法，返回SM3算法的句柄
static long sm3_init();
// 更新SM3哈希算法的数据，参数包括SM3句柄、数据、偏移量和长度
// 抛出IndexOutOfBoundsException异常
static void sm3_update(long hsm3, byte [] /*Not Nilptr*/data, int offset, int length)throws IndexOutOfBoundsException;
// 完成SM3哈希算法的计算，参数为SM3句柄
static void sm3_final(long hsm3);
// 获取SM3哈希算法的结果，参数为SM3句柄，返回哈希结果
static byte [] sm3_result(long hsm3);
// 关闭SM3哈希算法，释放资源，参数为SM3句柄
static void sm3_close(long hsm3);
};
Unsi类
用于处理网络通信。
class Unsi{
// 默认上下文ID
static const int DEFAULT_CONTEXTID = 0;
// 禁用监听端口
static const int UNSI_LISTENPORT_DISABLE = 0;
// TCP协议
static const int UNSI_TCP = 1;
// UDP协议
static const int UNSI_UDP = 2;
// 禁用名单
static const int DISABLE_NAMELIST = -1;
// 黑名单
static const int BLACK_NAMELIST = 0;
// 定义一个静态常量WHITE_NAMELIST，值为1，用于表示白名单模式
static const int WHITE_NAMELIST = 1;
// 定义一系列静态常量，用于表示不同的网络状态和操作
static const int UNSI_INVALID ; // 无效状态
static const int UNSI_CONNECT ; // 连接状态
static const int UNSI_DISCONNECT ; // 断开连接状态
static const int UNSI_ACCEPT ; // 接受连接状态
static const int UNSI_TCP_SEND ; // TCP发送数据状态
static const int UNSI_UDP_SEND ; // UDP发送数据状态
static const int UNSI_UDP_SENDCOMPLETE ; // UDP发送完成状态
static const int UNSI_TCP_SENDCOMPLETE ; // TCP发送完成状态
static const int UNSI_TCP_RECV ; // TCP接收数据状态
static const int UNSI_UDP_RECV ; // UDP接收数据状态
static const int UNSI_TCP_RECVCOMPLETE ; // TCP接收完成状态
static const int UNSI_UDP_RECVCOMPLETE ; // UDP接收完成状态
// 构造函数，用于初始化Unsi对象
Unsi();
// 启动网络操作，返回布尔值表示是否成功
bool start();
// 断开指定上下文的连接，返回布尔值表示是否成功
bool disconnect(long context);
// 配置网络参数，包括线程数、缓冲区大小和超时时间，返回布尔值表示是否成功
bool config(int threads, int buffersize, int timeout);
// 获取异步直接输出对象
AsyncOutput getAsyncDirectOutput();
// 发送数据到指定上下文和ID，data为数据数组，offset为数据偏移量，length为数据长度
// 可能抛出IllegalArgumentException和IndexOutOfBoundsException异常
bool send(long context, long id, byte [] data, int offset, int length)IllegalArgumentException, IndexOutOfBoundsException;
// 创建异步输入对象，mode为模式，port为端口号，timeout为超时时间
// 可能抛出IllegalArgumentException异常
bool create(AsyncInput input, int mode, int port, int timeout)IllegalArgumentException;
// 获取指定上下文的远程IP地址
InetAddress getRemoteInetAddress(long context);
// 克隆指定上下文，返回新的上下文ID
long clone(long context);
// 获取指定上下文的ID
int getId(long context);
// 比较两个上下文的句柄是否相等，返回布尔值表示是否相等
bool equalsHandle(long context, long another);
// 获取当前的白名单模式
// 获取当前名称列表模式的方法
int getNamelistMode();
// 设置名称列表模式的方法
void setNamelistMode(int mode);
// 向名称列表中添加或移除IP地址的方法
// 参数ip表示要添加或移除的IP地址
// 参数remove表示是否移除，true表示移除，false表示添加
// 返回一个布尔值，表示操作是否成功
bool addToNamelist(String ip, bool remove);
// 获取当前连接数的方法
// 返回一个长整型数值，表示当前的连接数
long getConnectionNumber();
};
Base64类
用于处理Base64编码和解码。
class Base64{
// 将字节数组编码为Base64字符串，可以选择是否换行
// 参数data：待编码的字节数组，不能为null
// 参数warp：是否在编码后的字符串中添加换行符
static String encodeToString(byte [] /*Not Nilptr*/data, bool warp);
// 将字节数组从指定偏移量开始编码为Base64字符串，可以选择是否换行
// 参数data：待编码的字节数组，不能为null
// 参数offset：编码的起始偏移量
// 参数length：编码的长度
// 参数warp：是否在编码后的字符串中添加换行符
static String encodeToString(byte [] /*Not Nilptr*/data, int offset, int length, bool warp);
// 将Base64字符串解码为字节数组
// 参数text：待解码的Base64字符串，不能为null
static byte [] decodeString(String /*Not Nilptr*/text);
};Library类
用于加载和释放动态库。
class Library{
// 加载指定模块的库，如果模块名为null，则抛出NullPointerException
static void loadLibrary(String /*Not Nilptr*/module)NullPointerException;
// 释放已加载的库
static void freeLibrary();
};File类
用于处理文件操作。
class File{
// 构造函数，无参数
File();
// 构造函数，接受一个字符串参数path，表示文件路径
// 注释：/*Not Nilptr*/ 表示参数不能为空
File(String /*Not Nilptr*/path);
// 构造函数，接受一个File对象和一个字符串参数，表示父目录和子对象
// 注释：/*Not Nilptr*/ 表示参数不能为空
File(File /*Not Nilptr*/parent, String /*Not Nilptr*/object);
// 获取文件的完整路径
String getPath();
// 获取文件名
String getName();
// 判断是否为目录
bool isDirectory();
// 打开文件，返回文件句柄
long open();
// 在文件句柄hfind中查找文件，将找到的文件信息存储在recv对象中
// 注释：/*Not Nilptr*/ 表示参数不能为空
bool find(long hfind, File /*Not Nilptr*/recv);
// 关闭文件句柄
void close(long hfind);
// 更改文件权限
bool chmod(int mod);
// 获取文件权限
int mode();
// 删除文件
bool remove();
// 重命名文件
bool rename(String /*Not Nilptr*/newname);
// 获取文件最后修改时间
long lastModifiedTime();
// 获取文件长度
long length();
// 创建目录
bool mkdir();
// 判断文件是否存在
bool exists();
// 获取父目录路径
String parentPath();
// 获取文件扩展名
String extension();
};HttpServlet类
用于处理HTTP服务器业务
class HttpServlet{
// 定义常量，用于标识不同的标志位
static const int FLAG_POSTSTREAM = 1; // 标识POST流
static const int FLAG_LOGERROR = 2; // 标识日志错误
static const int FLAG_SERVLET = 4; // 标识Servlet
static const int FLAG_WEBSOCKETLET = 8; // 标识WebSocket
// 构造函数，接受标志位和URL模式
HttpServlet(int flags, String pattern);
// 构造函数，接受HTTP状态码
HttpServlet(int httpcode);
// 处理GET请求的方法
void doGet(HttpServletRequest request, HttpServletResponse resp);
// 处理POST请求的方法
void doPost(HttpServletRequest request, HttpServletResponse resp);
// WebSocket连接打开时调用的方法
void onOpen(WebSocketSession session);
// WebSocket连接关闭时调用的方法
void onClose(WebSocketSession session, String reason);
// WebSocket发生错误时调用的方法
void onError(WebSocketSession session);
// WebSocket接收到文本消息时调用的方法
void onMessage(WebSocketSession session, String message);
// WebSocket接收到二进制消息时调用的方法
void onBinary(WebSocketSession session, byte [] message);
};Website类
用户处理HTTP服务器网站
class Website{
// 定义一个长整型变量handle，用于存储网站的唯一标识符
long handle ;
// 构造函数，用于创建Website对象
Website();
// 注册一个HttpServlet对象到网站中
bool registryServlet(HttpServlet servlet);
// 设置网站的根目录路径
void setRootDirectory(String path);
// 获取网站的根目录路径
String getRootDirectory();
// 获取网站的临时目录路径
String getTempDirectory();
// 设置网站是否启用
void setEnabled(bool on);
// 设置网站的临时目录路径
void setTempDirectory(String path);
// 配置缓存器，on表示是否启用缓存，singlemax表示单个缓存的最大大小，totalmax表示总缓存的最大大小
void configCacher(bool on, int singlemax, long totalmax);
// 配置会话，sessionMax表示会话的最大数量，timeout表示会话的超时时间
void configSession(int sessionMax, int timeout);
// 清除缓存器中的所有缓存
void clearCacher();
// 清除会话中的所有会话
void clearSession();
// 设置HTTP响应头，pattern表示URL模式，key表示头名称，value表示头值
bool setHeader(String pattern, String key, String value);
// 设置HTTP响应尾，pattern表示URL模式，key表示尾名称，value表示尾值
bool setFooter(String pattern, String key, String value);
// 添加默认页面，indexname表示默认页面的名称
bool addDefaultPage(String indexname);
// 添加MIME类型，pattern表示文件扩展名模式，key表示MIME类型
bool addMimeType(String pattern, String key);
// 将本地路径映射到服务器路径，local表示本地路径，host表示服务器主机名
String mapServerPath(String local, String host);
// 将URL映射到本地路径，url表示URL，host表示服务器主机名
String mapLocalPath(String url, String host);
// 移除指定本地路径的缓存
bool removeCache(String localpath);
// 析构函数，用于清理Website对象
void finalize();
};WebSocketSession类
用于处理WebSocket会话
// 定义一个WebSocketSession类，用于表示WebSocket会话
class WebSocketSession{
// handle字段，用于存储会话的唯一标识符
long handle ;
// 构造函数，用于创建WebSocketSession对象
WebSocketSession();
// 获取客户端地址的方法
InetAddress getClientAddress();
// 根据名称获取HTTP头信息的方法
String getHeader(String name);
// 根据键获取Cookie值的方法
String getCookie(String key);
// 根据键获取会话数据的方法
Object getSession(String key);
// 设置会话数据的方法
void setSession(String key, Object value);
// 根据键获取URL参数的方法
String getArg(String key);
// 根据键获取所有URL参数的方法
String [] getArgs(String key);
// 获取所有URL参数键的方法
String [] getArgKeys();
// 获取当前会话所属网站的方法
Website getWebsite();
// 获取当前会话的URL的方法
String getUrl();
// 获取当前会话的主机名的方法
String getHost();
// 获取当前会话的HTTP方法（如GET、POST）的方法
String getMethod();
// 设置用户数据的方法
void setUserData(Object data);
// 获取用户数据的方法
Object getUserData();
// 获取会话ID的方法
long getId();
// 发送文本消息的方法
bool sendText(String text);
// 发送二进制消息的方法，指定偏移量和大小
bool sendBinary(byte [] text, int offset, int size);
// 发送二进制消息的方法，默认从数组开头开始发送
bool sendBinary(byte [] text);
// 检查会话是否打开的方法
bool isOpened();
// 关闭会话的方法
bool close();
// 获取服务器名称的方法
String getServerName();
// 获取服务器端口号的方法
int getServerPort();
// 获取查询字符串的方法
String getQueryString();
// 获取URL方案（如http、https）的方法
String getScheme();
};
HttpServletRequest类
用于处理HTTP请求。
class HttpServletRequest{
// 构造函数，用于创建HttpServletRequest对象
HttpServletRequest();
// 获取客户端的IP地址
InetAddress getClientAddress();
// 根据给定的名称获取请求头
String getHeader(String name);
// 根据给定的键获取Cookie值
String getCookie(String key);
// 根据给定的键获取会话数据
Object getSession(String key);
// 设置会话数据，键值对形式
void setSession(String key, Object value);
// 根据给定的键获取请求参数
String getParam(String key);
// 根据给定的键获取请求参数数组
ServletRequestItem [] getParameter(String key);
// 根据给定的键获取请求参数数组
String [] getParams(String key);
// 获取所有请求参数的键
String [] getParamKeys();
// 根据给定的键获取请求参数
String getArg(String key);
// 根据给定的键获取请求参数数组
String [] getArgs(String key);
// 获取所有请求参数的键
String [] getArgKeys();
// 根据给定的键获取本地文件路径
String [] getLocalFilepath(String key);
// 根据给定的键获取文件名
String [] getFileName(String key);
// 获取当前网站对象
Website getWebsite();
// 获取请求的URL
String getUrl();
// 获取请求的主机名
String getHost();
// 获取请求的方法（如GET、POST等）
String getMethod();
// 设置用户数据
void setUserData(Object data);
// 获取用户数据
Object getUserData();
// 获取服务器名称
String getServerName();
// 获取服务器端口号
int getServerPort();
// 获取查询字符串的方法
String getQueryString();
// 获取URL方案（如http、https等）的方法
String getScheme();
// 读取POST数据的方法，将数据存储到data数组中，从offset位置开始，读取长度为len的数据
int readPostData(byte [] data, int offset, int len);
// 设置解析监听器的方法，listener是实现了RequestParseListener接口的对象
bool setOnParseListener(RequestParseListener listener);
// 解析POST数据的方法，data是包含POST数据的字节数组，offset是数据开始的位置，length是数据的长度
bool parsePostedData(byte [] data, int offset, int length);
};HttpServletResponse类
用于处理HTTP响应。
// 定义一个名为HttpServletResponse的类，用于模拟HTTP响应
class HttpServletResponse{
// 定义HTTP状态码常量
static const int SC_CONTINUE = 100; // 100 Continue
static const int SC_SWITCHING_PROTOCOLS = 101; // 101 Switching Protocols
static const int SC_OK = 200; // 200 OK
static const int SC_CREATED = 201; // 201 Created
static const int SC_ACCEPTED = 202; // 202 Accepted
static const int SC_NON_AUTHORITATIVE_INFORMATION = 203; // 203 Non-Authoritative Information
static const int SC_NO_CONTENT = 204; // 204 No Content
static const int SC_RESET_CONTENT = 205; // 205 Reset Content
static const int SC_PARTIAL_CONTENT = 206; // 206 Partial Content
static const int SC_MULTIPLE_CHOICES = 300; // 300 Multiple Choices
static const int SC_MOVED_PERMANENTLY = 301; // 301 Moved Permanently
static const int SC_MOVED_TEMPORARILY = 302; // 302 Moved Temporarily
static const int SC_FOUND = 302; // 302 Found
static const int SC_SEE_OTHER = 303; // 303 See Other
static const int SC_NOT_MODIFIED = 304; // 304 Not Modified
static const int SC_USE_PROXY = 305; // 305 Use Proxy
static const int SC_TEMPORARY_REDIRECT = 307; // 307 Temporary Redirect
static const int SC_BAD_REQUEST = 400; // 400 Bad Request
static const int SC_UNAUTHORIZED = 401; // 401 Unauthorized
static const int SC_PAYMENT_REQUIRED = 402; // 402 Payment Required
static const int SC_FORBIDDEN = 403; // 403 Forbidden
static const int SC_NOT_FOUND = 404; // 404 Not Found
static const int SC_METHOD_NOT_ALLOWED = 405; // 405 Method Not Allowed
static const int SC_NOT_ACCEPTABLE = 406; // 406 Not Acceptable
static const int SC_PROXY_AUTHENTICATION_REQUIRED = 407; // 407 Proxy Authentication Required
static const int SC_REQUEST_TIMEOUT = 408; // 408 Request Timeout
static const int SC_CONFLICT = 409; // 409 Conflict
static const int SC_GONE = 410; // 410 Gone
static const int SC_LENGTH_REQUIRED = 411; // 411 Length Required
static const int SC_PRECONDITION_FAILED = 412; // 412 Precondition Failed
static const int SC_REQUEST_ENTITY_TOO_LARGE = 413; // 413 Request Entity Too Large
static const int SC_REQUEST_URI_TOO_LONG = 414; // 414 Request-URI Too Long
static const int SC_UNSUPPORTED_MEDIA_TYPE = 415; // 415 Unsupported Media Type
static const int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416; // 416 Requested Range Not Satisfiable
static const int SC_EXPECTATION_FAILED = 417; // 417 Expectation Failed
static const int SC_INTERNAL_SERVER_ERROR = 500; // 500 Internal Server Error
static const int SC_NOT_IMPLEMENTED = 501;
static const int SC_BAD_GATEWAY = 502; // 502 Bad Gateway
static const int SC_SERVICE_UNAVAILABLE = 503; // 503 Service Unavailable
static const int SC_GATEWAY_TIMEOUT = 504; // 504 Gateway Timeout
static const int SC_HTTP_VERSION_NOT_SUPPORTED = 505; // 505 HTTP Version Not Supported
// 构造函数，用于创建HttpServletResponse对象
HttpServletResponse();
// 打印文本到响应体
void print(String text);
// 写入字节数组到响应体，从指定位置开始，写入指定长度
void write(byte [] buffer, int pos, int length);
// 设置响应的输出流
void setOutputStream(Stream stream);
// 设置HTTP响应状态码
void setResponseCode(int code);
// 设置Cookie
void setCookie(String key, String value);
// 添加HTTP响应头
void addHeader(String key, String value);
// 设置HTTP响应头
void setHeader(String key, String value);
// 设置响应的内容类型
void setContentType(String sType);
};
HttpServer类
用于创建HTTP服务器。
class HttpServer{
// 定义默认模型常量，值为0
static const int DEFAULT_MODEL = 0;
// 定义SELECT模型常量，值为8
static const int SELECT_MODEL = 8;
// 定义POLL模型常量，值为72
static const int POLL_MODEL = 72;
// 定义EPOLL模型常量，值为520
static const int EPOLL_MODEL = 520;
// 定义允许升级的常量，值为32768
static const int ALLOW_UPGRADE = 32768;
// 构造函数，用于创建HttpServer对象
HttpServer();
// 设置最大连接数的函数，参数为最大连接数，返回bool值表示设置是否成功
bool setMaxConnection(int max);
// 设置连接超时的函数，参数为超时时间（毫秒），返回bool值表示设置是否成功
bool setConnectionTimeout(int millisec);
// 设置IP连接限制的函数，参数为限制数，返回bool值表示设置是否成功
bool setIpConnectionLimit(int limit);
// 设置线程池大小的函数，参数为线程池大小，返回bool值表示设置是否成功
bool setThreadPoolSize(int size);
// 添加网站的函数，参数为域名和Website对象，返回网站ID
int addWebsite(String domain, Website website);
// 使服务器进入静默状态的函数，不接收新的连接，但处理现有连接
void quiesce();
// 关闭服务器的函数，停止所有连接和线程
void close();
// 停止服务器的函数，返回bool值表示停止是否成功
bool stop();
// 检查服务器是否正在运行的函数，返回bool值表示服务器是否正在运行
bool isRunning();
// 启动服务器的函数，参数为启动标志和端口号，返回bool值表示启动是否成功
bool start(int flags, int port);
// 配置HTTPS的函数，参数为是否启用、证书内容和私钥内容，返回bool值表示配置是否成功
bool configHttps(bool enable, String certContent, String keyContent);
};
List类
用于处理列表
class List<Element>{ // 定义一个泛型类List，用于存储Element类型的元素
// 定义一个静态内部类Iterator，用于遍历List中的元素
static class Iterator<Element>{
long ownner; // 用于记录迭代器的所有者，防止并发修改
// 判断是否还有下一个元素，如果无效则抛出InvalidIteratorException异常
bool hasNext()InvalidIteratorException;
// 返回下一个元素
Element next();
// 判断是否还有上一个元素
bool hasPrevious();
// 设置当前元素为指定元素
void set(Element e);
// 获取当前元素
Element get ();
// 获取前一个元素的迭代器
Iterator getPrev();
// 获取后一个元素的迭代器
Iterator getNext();
// 获取头元素的迭代器
Iteratorhead();
// 获取尾元素的迭代器
Iterator tail();
// 克隆当前迭代器
Iterator clone();
// 判断当前迭代器是否与另一个迭代器相等
bool equals(Iterator another);
};
// 构造函数，用于创建一个空的List
List();
// 在List末尾添加一个元素
void add(Element e);
// 在指定位置添加一个元素
void add(int pos, Element e);
// 在指定迭代器位置插入一个元素
void insert(%iterator pos, Element e);
// 移除指定迭代器位置的元素
void remove(%iterator pos);
// 移除指定位置的元素
void remove(int e);
// 移除指定元素
void remove(Object e);
// 获取指定位置的元素
Element get(int n);
// 清空List中的所有元素
void clear();
// 获取List的迭代器
iterator iterator();
// 获取并移除List末尾的元素
Element pollLast();
// 获取并移除List头部的元素
Element pollHead();
// 将List中的元素转换为数组
Element [] toArray(Element [] ready);
// 判断List中是否包含指定元素
bool contains(Element e);
// 获取指定元素第一次出现的位置
int indexOf(Element e);
// 获取指定元素最后一次出现的位置
int lastIndexOf(Element e);
// 将指定数组中的所有元素添加到List中
void addAll(Element [] ready);
// 获取List的大小
int size();
};XRegular类
用于处理模式(二进制)匹配。
class XRegular{
// 定义一个静态内部类Result，用于存储匹配结果
static class Result{
// 构造函数，用于初始化Result对象
Result();
// 判断匹配是否成功
bool isSucceed();
// 根据标签获取匹配到的值
long getValue(char label);
// 获取匹配结果
int getMatchResult();
// 获取正则表达式的长度
int getRegularLength();
// 获取正则表达式在数据中的位置
int getRegularPosition();
// 根据id获取正则表达式某一部分的长度
int getRegularSectionLength(int id);
// 根据id获取正则表达式某一部分在数据中的位置
int getRegularSectionPosition(int id);
// 根据id获取表达式某一部分的长度
int getExpressionSectionLength(int id);
// 根据id获取表达式某一部分在数据中的位置
int getExpressionSectionPosition(int id);
// 获取匹配到的部分数量
int getSectionCount();
// 清理资源
void finalize();
};
// 静态方法，用于匹配数据
static Result Match (byte [] data ,int pos, int length, String expression);
};
StringBuffer类
用于处理字符串缓冲区。
// 基本同String， 该类主要处理缓冲区，大多数情况下对现有数据进行更改而不生成新对象，因此性能高于String，但注意该类是线程不安全对象
class StringBuffer{
// 构造函数，创建一个空的StringBuffer对象
StringBuffer();
// 构造函数，根据字节数组创建一个StringBuffer对象
// 参数buffer：字节数组，不能为null
StringBuffer(byte [] /*Not Nilptr*/buffer);
// 构造函数，创建一个指定容量的StringBuffer对象
// 参数capacity：初始容量
StringBuffer(int capacity);
StringBuffer(byte [] /*Not Nilptr*/buffer, int offset, int length)throws IndexOutOfBoundsException, IllegalArgumentException;
StringBuffer(char [] /*Not Nilptr*/buffer, bool bLittleEndian);
StringBuffer(char [] /*Not Nilptr*/buffer, int offset, int length, bool bLittleEndian)throws IndexOutOfBoundsException, IllegalArgumentException;
StringBuffer(byte [] /*Not Nilptr*/buffer, String charset);
StringBuffer(byte [] /*Not Nilptr*/buffer, int offset, int length, String /*Not Nilptr*/charset)throws IndexOutOfBoundsException, IllegalArgumentException;
StringBuffer(String /*Not Nilptr*/text);
int length();
int find(String /*Not Nilptr*/text);
int find(String /*Not Nilptr*/text, int start, int length)throws IllegalArgumentException;
String substring(int start, int end)throws IllegalArgumentException;
StringBuffer escape();
String [] split(String /*Not Nilptr*/sp);
String [] split(char sp);
StringBuffer operator_addset(Object v);
bool startsWith(String /*Not Nilptr*/text);
bool endsWith(String /*Not Nilptr*/text);
int indexOf(String /*Not Nilptr*/text, int start)throws IllegalArgumentException;
int indexOf(char c, int start)throws IllegalArgumentException;
int indexOf(String /*Not Nilptr*/text);
int indexOf(char c);
int indexOfIgnoreCase(String /*Not Nilptr*/text, int start)throws IllegalArgumentException;
int indexOfIgnoreCase(char c, int start)throws IllegalArgumentException;
int indexOfIgnoreCase(String /*Not Nilptr*/text);
int indexOfIgnoreCase(char c);
int lastIndexOf(String /*Not Nilptr*/text, int start)throws IllegalArgumentException;
int lastIndexOf(char c, int start)throws IllegalArgumentException;
int lastIndexOf(String /*Not Nilptr*/text);
int lastIndexOf(char c);
int lastIndexOfIgnoreCase(String /*Not Nilptr*/text, int start)throws IllegalArgumentException;
int lastIndexOfIgnoreCase(char c, int start)throws IllegalArgumentException;
int lastIndexOfIgnoreCase(String /*Not Nilptr*/text);
int lastIndexOfIgnoreCase(char c);
StringBuffer append(Object val);
StringBuffer insert(int offset, String /*Not Nilptr*/text)throws IllegalArgumentException;
StringBuffer insert(int offset, char c)throws IllegalArgumentException;
byte [] getBytes();
byte [] getBytes(String charset)throws IllegalArgumentException;
char [] toCharArray(bool bLittleEndian);
bool isDigit();
long parseLong();
long parseHex();
int parseInt();
bool parseBool();
float parseFloat();
double parseDouble();
StringBuffer replace(int offset, int end, String /*Not Nilptr*/newText)throws IllegalArgumentException;
StringBuffer replace(String /*Not Nilptr*/find, String /*Not Nilptr*/newText);
StringBuffer lower();
StringBuffer upper();
bool equals(String another);
bool equalsIgnoreCase(String another);
int countChar(char c);
int countString(String /*Not Nilptr*/text);
int countStringIgnoreCase(String /*Not Nilptr*/text);
StringBuffer appendPath(String /*Not Nilptr*/path);
static StringBuffer formatPath(bool bReslash);
StringBuffer trim(bool bExt);
StringBuffer ltrim(bool bExt);
StringBuffer rtrim(bool bExt);
StringBuffer replaceExtension(String /*Not Nilptr*/extsion);
StringBuffer removeExtension();
StringBuffer replaceFilenameAndExtension(String /*Not Nilptr*/newname);
StringBuffer replaceFilename(String /*Not Nilptr*/newname);
String findExtension();
String findFilenameAndExtension();
String findFilename();
String findPathFilename();
String findVolume();
String findVolumePath();
bool isDot();
bool isBlank();
StringBuffer toRelativePath(String /*Not Nilptr*/refpath, bool ignoreCase, bool fixSlash);
StringBuffer toAbsolutePath(String /*Not Nilptr*/refpath);
char charAt(int position);
StringBuffer appendFill(char c, int length)throws IllegalArgumentException;
StringBuffer decodeURI();
StringBuffer encodeURI(bool bComponent);
String charset();
int compare(String another);
int capacity();
StringBuffer resizeCapacity(int size);
String toString();
StringBuffer append(byte [] /*Not Nilptr*/data, int offset, int length)throws IndexOutOfBoundsException, IllegalArgumentException;
StringBuffer append(char [] /*Not Nilptr*/data, int offset, int length, bool bLittleEndian)throws IndexOutOfBoundsException, IllegalArgumentException;
void clear();
void finalize();
String substring(int start)throws IllegalArgumentException;
char operator [](int position)throws IllegalArgumentException;
};IRCPEventHandler类
用于处理RCP事件。
class IRCPEventHandler{
// 定义一个常量，表示不需要处理的情况，值为0xffffffff
static const int DONT_NEED_PROCESS = (int32)0xffffffff;
// 定义一个虚函数，当创建新实例时调用，参数为上下文和进程长度，返回值为bool类型
bool onNewInstance(long context, int processLength) = nilptr;
// 定义一个虚函数，当删除实例时调用，参数为上下文，返回值为bool类型
bool onDeleteInstance(long context) = nilptr;
// 定义一个虚函数，当访问失败时调用，参数为上下文，返回值为void类型
void onAccessFailed(long context) = nilptr;
// 定义一个虚函数，当超时时调用，参数为上下文，返回值为bool类型
bool onTimeout(long context) = nilptr;
// 定义一个虚函数，用于解码，参数为上下文、字节数组、长度和输出流，返回值为int类型
int onDecode(long context, byte [] buffer, int length, Stream outStream);
// 定义一个虚函数，用于编码，参数为上下文、字节数组、长度和输出流，返回值为int类型
int onEncode(long context, byte [] buffer, int length, Stream outStream);
// 定义一个虚函数，用于获取解码长度，参数为上下文、字节数组和长度，返回值为int类型
int getDecodeLength(long context, byte [] buffer, int length);
};Cipher、Key和KeyFactory类
用于处理加密和解密操作。
class Cipher{ // 定义一个名为Cipher的类，用于加密和解密操作
// 定义静态常量，表示不同的操作模式
static const int ENCRYPT_MODE = 1; // 加密模式
static const int DECRYPT_MODE = 2; // 解密模式
static const int WRAP_MODE = 3; // 包装模式，用于包装密钥
static const int UNWRAP_MODE = 4; // 解包模式，用于解包密钥
// 获取Cipher实例的静态方法，参数为转换算法的字符串
static Cipher getInstance(String transformation);
// 注册新的Cipher实例到系统中，参数为转换算法的字符串和Cipher实例
static bool registryCipher(String transformation, Cipher cipher);
// 获取支持的算法列表的静态方法
static String getSupportAlgorithms();
// 创建一个新的Cipher实例，参数为转换算法的字符串
Cipher newInstance(String transformation);
// 初始化Cipher实例，参数为操作模式和初始化参数
bool init(int mode, Object initParam);
// 更新数据块，参数为数据字节数组、起始位置和长度，返回处理后的数据长度
int update(byte[] data, int pos, int length);
// 转换数据块，参数为数据字节数组、起始位置和长度，返回转换后的数据字节数组
byte [] transform(byte[] data, int pos, int length);
// 完成数据处理，参数为数据字节数组、起始位置和长度，返回最终处理后的数据字节数组
byte [] doFinal(byte[] data, int pos, int length);
// 获取初始化向量（IV）的方法
byte [] getIV();
// 获取输出大小的静态方法，参数为输入数据的长度，返回输出数据的长度
int getOutputSize(int inputLen);
// 获取块大小的静态方法，返回加密算法的块大小
int getBlockSize();
// 获取算法名称的静态方法，返回加密算法的名称
String getAlgorithm();
};
class Key{
// 定义常量，表示公钥类型
static const int PUBLIC_KEY = 1;
// 定义常量，表示私钥类型
static const int PRIVATE_KEY = 2;
// 定义常量，表示密钥类型
static const int SECRET_KEY = 3;
// 创建密钥的方法，返回布尔值表示是否创建成功
bool create();
// 设置密钥参数的方法，参数为键和值
void setParam(String key, Object value);
// 获取密钥参数的方法，参数为键，返回对应的值
Object getParam(String key);
// 从字节数组中加载密钥的方法，参数为数据、位置、长度和格式，返回布尔值表示是否加载成功
bool load(byte[] data, int pos, int length, String format);
// 从文件中加载密钥的方法，参数为文件路径和格式，返回布尔值表示是否加载成功
bool load(String file, String format);
// 获取密钥算法的方法，返回算法名称
String getAlgorithm();
// 获取密钥格式的方法，返回格式名称
String getFormat();
// 获取密钥类型的方法，返回密钥类型常量
int keyType();
// 获取密钥数据的字节数组表示，返回字节数组
byte[] getData();
// 获取密钥长度的方法，返回长度值
int length();
// 将密钥转换为另一种类型的方法，参数为要转换的密钥，返回转换后的密钥
Key translateKey(Key key);
};
class KeyFactory{
// 获取KeyFactory实例的方法，参数为转换方式，返回KeyFactory实例
static KeyFactory getInstance(String transformation);
// 生成密钥的方法，参数为转换方式和密钥模式，返回生成的密钥
Key generateKey(String transformation, int keyMode);
// 注册密钥工厂的方法，参数为转换方式和密钥，返回布尔值表示是否注册成功
static bool registryKeyFactory(String transformation, Key key);
};X509Certificate类
用于处理X.509证书。
class X509Certificate{
// 构造函数，使用字节数组、位置和长度来创建X509Certificate对象
X509Certificate(byte [] data, int pos, int len);
// 构造函数，使用文件路径来创建X509Certificate对象
X509Certificate(String filepath);
// 获取证书的类型
int getType();
// 获取证书的编码
byte[] getEncoded();
// 使用给定的密钥验证证书
bool verify(Key key);
// 使用给定的密钥和签名提供者验证证书
bool verify(Key key, String sigProvider);
// 返回证书的字符串表示
String toString();
// 检查证书是否有效
bool checkValidity();
// 检查证书在指定时间是否有效
bool checkValidity(long timemillis);
// 获取证书的版本号
long getVersion();
// 获取证书的序列号
String getSerialNumber();
// 获取证书的颁发者DN（Distinguished Name）
String getIssuerDN();
// 获取证书的主题DN（Distinguished Name）
String getSubjectDN();
// 获取证书的有效期开始时间
long getNotBefore();
// 获取证书的有效期结束时间
long getNotAfter();
// 获取证书的签名
byte[] getSignature();
// 获取证书的签名算法名称
String getSigAlgName();
// 获取证书的签名算法OID（Object Identifier）
String getSigAlgOID();
// 获取证书的密钥使用情况
bool[] getKeyUsage();
// 获取证书的基本约束
int getBasicConstraints();
// 获取证书的公钥
Key getPublicKey();
};
Signature类
用于处理数字签名。
class Signature{
// 定义常量SIGN，表示签名状态
static const int SIGN = 2;
// 定义常量UNINITIALIZED，表示未初始化状态
static const int UNINITIALIZED = 0;
// 定义常量VERIFY，表示验证状态
static const int VERIFY = 3;
// 静态方法，用于注册签名算法，返回布尔值表示是否成功
static bool registrySignature(String algorithm, Signature cipher);
// 静态方法，用于获取指定算法的签名实例，可能抛出IllegalArgumentException
static Signature getInstance(String algorithm) IllegalArgumentException ;
// 实例方法，用于创建新的签名实例
Signature newInstance(String algorithm);
// 实例方法，用于初始化验证，使用公钥，可能抛出IllegalArgumentException
void initVerify(Key publicKey) IllegalArgumentException ;
// 实例方法，用于初始化签名，使用私钥，可能抛出IllegalArgumentException
void initSign(Key privateKey) IllegalArgumentException ;
// 实例方法，用于初始化签名，使用私钥和随机数生成器
void initSign(Key privateKey, Object random) ;
// 实例方法，用于签名数据，返回签名字节数组，可能抛出IllegalArgumentException
byte[] sign() IllegalArgumentException;
// 实例方法，用于签名数据，将签名结果写入指定字节数组，返回签名长度，可能抛出IllegalArgumentException
int sign(byte[] outbuf, int offset, int len) IllegalArgumentException;
// 实例方法，用于验证签名，返回布尔值表示验证结果，可能抛出IllegalArgumentException
bool verify(byte[] signature, int offset, int length) IllegalArgumentException ;
// 实例方法，用于更新要签名或验证的数据，可能抛出IllegalArgumentException
void update(byte[] data, int off, int len) IllegalArgumentException ;
// 实例方法，用于获取签名算法名称
String getAlgorithm() ;
// 实例方法，用于设置签名参数，可能抛出IllegalArgumentException
void setParameter(String param, Object value) IllegalArgumentException;
// 实例方法，用于获取签名参数，可能抛出IllegalArgumentException
Object getParameter(String param) IllegalArgumentException ;
};上一篇:tomcat 内存占用问题排查下一篇:tomcat 服务器问题排查及优化
