/**
* 数据处理器实现
*/
import { logger } from '@/utils/logger';
import { IDataProcessor } from '@/types';
/**
* 数据处理器实现类
*/
export class DataProcessor implements IDataProcessor {
constructor() {
// TODO: 初始化数据处理器
logger.debug('DataProcessor initialized');
}
/**
* 十六进制字符串转Buffer
*/
hexToBuffer(hex: string): Buffer {
try {
// 移除空格和0x前缀
const cleanHex = hex.replace(/\s+/g, '').replace(/^0x/, '');
// 验证十六进制格式
if (!/^[0-9A-Fa-f]*$/.test(cleanHex)) {
throw new Error('Invalid hex string format');
}
// 确保偶数长度
const paddedHex = cleanHex.length % 2 === 0 ? cleanHex : '0' + cleanHex;
const buffer = Buffer.from(paddedHex, 'hex');
logger.debug('Hex converted to buffer', {
hex: cleanHex,
bufferSize: buffer.length
});
return buffer;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to convert hex to buffer', errorObj);
throw errorObj;
}
}
/**
* Buffer转十六进制字符串
*/
bufferToHex(buffer: Buffer): string {
try {
const hex = buffer.toString('hex').toUpperCase();
// 格式化为每两个字符一组
const formattedHex = hex.match(/.{2}/g)?.join(' ') || hex;
logger.debug('Buffer converted to hex', {
bufferSize: buffer.length,
hex: formattedHex
});
return hex;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to convert buffer to hex', errorObj);
throw errorObj;
}
}
/**
* Buffer转文本
*/
bufferToText(buffer: Buffer, encoding: BufferEncoding = 'utf8'): string {
try {
const text = buffer.toString(encoding);
logger.debug('Buffer converted to text', {
bufferSize: buffer.length,
encoding,
text: text.substring(0, 100) + (text.length > 100 ? '...' : '')
});
return text;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to convert buffer to text', errorObj);
throw errorObj;
}
}
/**
* 文本转Buffer
*/
textToBuffer(text: string, encoding: BufferEncoding = 'utf8'): Buffer {
try {
const buffer = Buffer.from(text, encoding);
logger.debug('Text converted to buffer', {
textLength: text.length,
encoding,
bufferSize: buffer.length
});
return buffer;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to convert text to buffer', errorObj);
throw errorObj;
}
}
/**
* 按分隔符分割数据
*/
splitData(data: Buffer, delimiters: Buffer[]): Buffer[] {
try {
if (delimiters.length === 0) {
return [data];
}
let result: Buffer[] = [data];
// 对每个分隔符进行分割
for (const delimiter of delimiters) {
const newResult: Buffer[] = [];
for (const chunk of result) {
const parts = this.splitByDelimiter(chunk, delimiter);
newResult.push(...parts);
}
result = newResult;
}
// 过滤空Buffer
result = result.filter(chunk => chunk.length > 0);
logger.debug('Data split by delimiters', {
dataSize: data.length,
delimiterCount: delimiters.length,
partCount: result.length
});
return result;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to split data', errorObj);
throw errorObj;
}
}
/**
* 验证数据格式
*/
validateData(data: Buffer, rules: any): boolean {
try {
// TODO: 实现数据验证规则
// 例如：长度检查、格式检查、校验和等
logger.debug('Data validation', {
dataSize: data.length,
rules
});
return true;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to validate data', errorObj);
return false;
}
}
/**
* 计算校验和
*/
calculateChecksum(data: Buffer, algorithm: 'xor' | 'sum' | 'crc16' = 'xor'): number {
try {
let checksum = 0;
switch (algorithm) {
case 'xor':
for (const byte of data) {
checksum ^= byte;
}
break;
case 'sum':
for (const byte of data) {
checksum += byte;
}
checksum &= 0xFF; // 保持单字节
break;
case 'crc16':
checksum = this.calculateCRC16(data);
break;
default:
throw new Error(`Unsupported checksum algorithm: ${algorithm}`);
}
logger.debug('Checksum calculated', {
algorithm,
dataSize: data.length,
checksum: checksum.toString(16).toUpperCase()
});
return checksum;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to calculate checksum', errorObj);
throw errorObj;
}
}
/**
* 验证校验和
*/
verifyChecksum(data: Buffer, expectedChecksum: number, algorithm: 'xor' | 'sum' | 'crc16' = 'xor'): boolean {
try {
const calculatedChecksum = this.calculateChecksum(data, algorithm);
const isValid = calculatedChecksum === expectedChecksum;
logger.debug('Checksum verification', {
algorithm,
expected: expectedChecksum.toString(16).toUpperCase(),
calculated: calculatedChecksum.toString(16).toUpperCase(),
valid: isValid
});
return isValid;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to verify checksum', errorObj);
return false;
}
}
/**
* 转义数据中的特殊字符
*/
escapeData(data: Buffer, escapeChar: number = 0x7D): Buffer {
try {
const result: number[] = [];
for (const byte of data) {
if (byte === escapeChar || byte === 0x7E || byte === 0x7D) {
result.push(escapeChar);
result.push(byte ^ 0x20);
} else {
result.push(byte);
}
}
const escapedBuffer = Buffer.from(result);
logger.debug('Data escaped', {
originalSize: data.length,
escapedSize: escapedBuffer.length,
escapeChar: escapeChar.toString(16).toUpperCase()
});
return escapedBuffer;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to escape data', errorObj);
throw errorObj;
}
}
/**
* 反转义数据中的特殊字符
*/
unescapeData(data: Buffer, escapeChar: number = 0x7D): Buffer {
try {
const result: number[] = [];
let isEscaped = false;
for (const byte of data) {
if (isEscaped) {
result.push(byte ^ 0x20);
isEscaped = false;
} else if (byte === escapeChar) {
isEscaped = true;
} else {
result.push(byte);
}
}
// 如果最后一个字符是转义字符，直接添加
if (isEscaped) {
result.push(escapeChar);
}
const unescapedBuffer = Buffer.from(result);
logger.debug('Data unescaped', {
escapedSize: data.length,
unescapedSize: unescapedBuffer.length,
escapeChar: escapeChar.toString(16).toUpperCase()
});
return unescapedBuffer;
} catch (error) {
const errorObj = error instanceof Error ? error : new Error(String(error));
logger.error('Failed to unescape data', errorObj);
throw errorObj;
}
}
/**
* 按单个分隔符分割数据
*/
private splitByDelimiter(data: Buffer, delimiter: Buffer): Buffer[] {
if (delimiter.length === 0) {
return [data];
}
const result: Buffer[] = [];
let start = 0;
for (let i = 0; i <= data.length - delimiter.length; i++) {
if (data.slice(i, i + delimiter.length).equals(delimiter)) {
if (i > start) {
result.push(data.slice(start, i));
}
start = i + delimiter.length;
i += delimiter.length - 1;
}
}
// 添加最后一部分
if (start < data.length) {
result.push(data.slice(start));
}
return result;
}
/**
* 计算CRC16校验和
*/
private calculateCRC16(data: Buffer): number {
// CRC16-CCITT (XModem)
let crc = 0x0000;
for (const byte of data) {
crc ^= (byte << 8);
for (let i = 0; i < 8; i++) {
if (crc & 0x8000) {
crc = (crc << 1) ^ 0x1021;
} else {
crc <<= 1;
}
crc &= 0xFFFF;
}
}
return crc;
}
}
