IRedisMessage NewInlineRedisMessage(RedisMessageType messageType, IByteBuffer content)
{
if (messageType == RedisMessageType.InlineCommand)
{
return(new InlineCommandRedisMessage(content.ToString(Encoding.UTF8)));
}
else if (messageType == RedisMessageType.SimpleString)
{
if (this.messagePool.TryGetSimpleString(content, out SimpleStringRedisMessage cached))
{
return(cached);
}
return(new SimpleStringRedisMessage(content.ToString(Encoding.UTF8)));
}
else if (messageType == RedisMessageType.Error)
{
if (this.messagePool.TryGetError(content, out ErrorRedisMessage cached))
{
return(cached);
}
return(new ErrorRedisMessage(content.ToString(Encoding.UTF8)));
}
else if (messageType == RedisMessageType.Integer)
{
if (this.messagePool.TryGetInteger(content, out IntegerRedisMessage cached))
{
return(cached);
}
return(new IntegerRedisMessage(this.ParseRedisNumber(content)));
}
throw new RedisCodecException($"bad type: {messageType}");
}
static void WriteString(IByteBufferAllocator allocator, RedisMessageType type, string content, List <object> output)
{
IByteBuffer buf = allocator.Buffer(type.Length + ByteBufferUtil.Utf8MaxBytes(content) +
RedisConstants.EndOfLineLength);
type.WriteTo(buf);
ByteBufferUtil.WriteUtf8(buf, content);
buf.WriteShort(RedisConstants.EndOfLineShort);
output.Add(buf);
}
bool DecodeType(IByteBuffer input)
{
if (!input.IsReadable())
{
return(false);
}
this.type = RedisMessageType.ReadFrom(input, this.decodeInlineCommands);
this.state = this.type.Inline ? State.DecodeInline : State.DecodeLength;
return(true);
}
bool DecodeType(IByteBuffer byteBuffer)
{
Contract.Requires(byteBuffer != null);
if (!byteBuffer.IsReadable())
{
return(false);
}
RedisMessageType redisMessageType = RedisCodecUtil.ParseMessageType(byteBuffer.ReadByte());
this.state = IsInline(redisMessageType)
? State.DecodeInline
: State.DecodeLength;
this.messageType = redisMessageType;
return(true);
}
static IByteBuffer WriteString(IByteBufferAllocator allocator, RedisMessageType messageType, string content)
{
Contract.Requires(allocator != null);
IByteBuffer buffer = allocator.Buffer(
RedisConstants.TypeLength
+ Encoding.UTF8.GetMaxByteCount(content.Length)
+ RedisConstants.EndOfLineLength);
// Header
buffer.WriteByte((char)messageType);
// Content
buffer.WriteBytes(Encoding.UTF8.GetBytes(content));
// EOL
buffer.WriteShort(RedisConstants.EndOfLine);
return(buffer);
}
IRedisMessage ReadInlineMessage(RedisMessageType redisMessageType, IByteBuffer byteBuffer)
{
Contract.Requires(byteBuffer != null);
switch (redisMessageType)
{
case RedisMessageType.SimpleString:
return(this.GetSimpleStringMessage(byteBuffer));
case RedisMessageType.Error:
return(this.GetErrorMessage(byteBuffer));
case RedisMessageType.Integer:
return(this.GetIntegerMessage(byteBuffer));
default:
throw new RedisCodecException(
$"Message type {redisMessageType} must be inline messageType of SimpleString, Error or Integer");
}
}
static bool IsInline(RedisMessageType messageType) => messageType == RedisMessageType.SimpleString || messageType == RedisMessageType.Error || messageType == RedisMessageType.Integer;
