public RedisPubSubMessage(RedisPubSubMessageType type, string typeStr, string channel, string pattern, RedisResult data)
{
Channel = channel;
Pattern = pattern ?? "";
Data = data;
Type = type;
TypeStr = typeStr;
}
public void TrySetCompleted(RedisResult data)
{
try
{
if (m_IsAsync)
{
m_Completion.TrySetResult(data);
}
else
{
m_Result = data;
}
}
finally
{
m_Status |= RedisAsyncTaskStatus.Completed;
Pulse();
}
}
protected RedisResult ToExpectation(RedisResult response, RedisCommandExpect expectation, string expectedResult = null)
{
switch (expectation)
{
case RedisCommandExpect.BulkStringBytes:
{
var result = response as RedisBytes;
if (ReferenceEquals(result, null))
{
throw new RedisException("Unexpected type", RedisErrorCode.CorruptResponse);
}
return(result);
}
case RedisCommandExpect.Array:
{
if (!(response is RedisArray))
{
throw new RedisException("Unexpected type", RedisErrorCode.CorruptResponse);
}
return(response);
}
case RedisCommandExpect.BulkString:
{
var result = response as RedisBytes;
if (ReferenceEquals(result, null))
{
throw new RedisException("Unexpected type", RedisErrorCode.CorruptResponse);
}
var bytes = result.Value;
if (bytes == null)
{
return(new RedisString(null));
}
return(new RedisString(bytes.ToUTF8String()));
}
case RedisCommandExpect.OK:
{
var result = response as RedisString;
if (ReferenceEquals(result, null))
{
throw new RedisFatalException("Unexpected value returned");
}
return(new RedisBool(result.Value == RedisConstants.OK));
}
case RedisCommandExpect.SimpleString:
{
if (!(response is RedisString))
{
throw new RedisFatalException("Unexpected value returned");
}
return(response);
}
case RedisCommandExpect.SimpleStringResult:
{
var result = response as RedisString;
if (ReferenceEquals(result, null))
{
throw new RedisFatalException("Unexpected value returned");
}
return(new RedisBool(result.Value == expectedResult));
}
case RedisCommandExpect.Integer:
{
if (!(response is RedisInteger))
{
throw new RedisException("Not an integer result", RedisErrorCode.CorruptResponse);
}
return(response);
}
case RedisCommandExpect.MultiDataBytes:
{
var array = response as RedisArray;
if (ReferenceEquals(array, null))
{
return(new RedisMultiBytes(null));
}
return(new RedisMultiBytes(array.ToMultiBytes()));
}
case RedisCommandExpect.MultiDataStrings:
{
var array = response as RedisArray;
if (ReferenceEquals(array, null))
{
return(new RedisMultiString(null));
}
return(new RedisMultiString(array.ToMultiString()));
}
case RedisCommandExpect.Double:
{
if (!ReferenceEquals(response, null))
{
if (response is RedisInteger)
{
return(new RedisDouble(((RedisInteger)response).Value));
}
if (response is RedisString)
{
var str = ((RedisString)response).Value;
if (!String.IsNullOrEmpty(str))
{
double d;
if (double.TryParse(str, out d))
{
return(new RedisDouble(d));
}
}
}
else if (response is RedisBytes)
{
var bytes = ((RedisBytes)response).Value;
if (bytes != null && bytes.Length > 0)
{
double d;
if (double.TryParse(bytes.ToUTF8String(), out d))
{
return(new RedisDouble(d));
}
}
}
}
throw new RedisException("Not a double result", RedisErrorCode.CorruptResponse);
}
case RedisCommandExpect.NullableInteger:
{
if (response is RedisInteger)
{
return(new RedisNullableInteger(((RedisInteger)response).Value));
}
if (response is RedisString)
{
var str = ((RedisString)response).Value;
if (String.IsNullOrEmpty(str))
{
return(new RedisNullableInteger(null));
}
if (str == RedisConstants.NilStr)
{
return(new RedisNullableInteger(null));
}
long l;
if (str.TryParse(out l))
{
return(new RedisNullableInteger(l));
}
}
else if (response is RedisBytes)
{
var bytes = ((RedisBytes)response).Value;
if (bytes == null || bytes.Length == 0)
{
return(new RedisNullableInteger(null));
}
if (bytes.EqualTo(RedisConstants.Nil))
{
return(new RedisNullableInteger(null));
}
long l;
if (bytes.TryParse(out l))
{
return(new RedisNullableInteger(l));
}
}
throw new RedisException("Not an integer result", RedisErrorCode.CorruptResponse);
}
case RedisCommandExpect.NullableDouble:
{
if (ReferenceEquals(response, null))
{
return(new RedisNullableDouble(null));
}
if (response is RedisInteger)
{
return(new RedisNullableDouble(((RedisInteger)response).Value));
}
if (response is RedisString)
{
var str = ((RedisString)response).Value;
if (String.IsNullOrEmpty(str))
{
return(new RedisNullableDouble(null));
}
if (str == RedisConstants.NilStr)
{
return(new RedisNullableDouble(null));
}
double d;
if (double.TryParse(str, out d))
{
return(new RedisNullableDouble(d));
}
}
else if (response is RedisBytes)
{
var bytes = ((RedisBytes)response).Value;
if (bytes == null || bytes.Length == 0)
{
return(new RedisNullableDouble(null));
}
if (bytes.EqualTo(RedisConstants.Nil))
{
return(new RedisNullableDouble(null));
}
double d;
if (double.TryParse(bytes.ToUTF8String(), out d))
{
return(new RedisNullableDouble(d));
}
}
throw new RedisException("Not a double result", RedisErrorCode.CorruptResponse);
}
case RedisCommandExpect.GreaterThanZero:
{
var result = response as RedisInteger;
if (ReferenceEquals(result, null))
{
throw new RedisException("Not an integer result", RedisErrorCode.CorruptResponse);
}
return(new RedisBool(result.Value > RedisConstants.Zero));
}
case RedisCommandExpect.One:
{
var result = response as RedisInteger;
if (ReferenceEquals(result, null))
{
throw new RedisFatalException("Unexpected value returned");
}
return(new RedisBool(result.Value == RedisConstants.One));
}
case RedisCommandExpect.Void:
return(new RedisVoid(0));
}
throw new RedisException("Unexpected type", RedisErrorCode.CorruptResponse);
}
public static RedisGeoRadiusResult ToGeoRadiusResult(RedisResult obj)
{
if (obj != null)
{
if (obj.Type == RedisResultType.Bytes)
{
var member = ((RedisBytes)obj).Value;
if (member != null)
{
return(new RedisGeoRadiusResult(member.ToUTF8String()));
}
}
if (obj.Type == RedisResultType.String)
{
var member = ((RedisString)obj).Value;
if (member != null)
{
return(new RedisGeoRadiusResult(member));
}
}
else if (obj.Type == RedisResultType.Array)
{
var items = ((RedisArray)obj).Value;
if (items == null)
{
return(null);
}
var count = items.Count;
if (count < 1)
{
return(null);
}
object data;
string member = null;
double? distance = null;
long? hash = null;
RedisGeoPosition?coord = null;
var item = items[0];
if (item != null)
{
if (item.Type == RedisResultType.Bytes)
{
member = ((RedisBytes)item).Value.ToUTF8String();
}
else if (item.Type == RedisResultType.String)
{
member = ((RedisString)item).Value;
}
}
for (var i = 1; i < count; i++)
{
var child = items[i];
if (child != null)
{
if (child.Type == RedisResultType.Array)
{
coord = ToGeoPositionItem((RedisArray)child);
}
else
{
if (child.Type == RedisResultType.Integer)
{
data = ((RedisInteger)child).Value;
if (data is long)
{
hash = (long)data;
}
}
else
{
var str = (string)null;
if (child.Type == RedisResultType.Bytes)
{
str = ((RedisBytes)child).Value.ToUTF8String();
}
else if (child.Type == RedisResultType.String)
{
str = ((RedisString)child).Value;
}
if (str != null)
{
var d = 0d;
if (double.TryParse(str, out d))
{
distance = d;
}
}
}
}
}
}
return(new RedisGeoRadiusResult(member, coord, distance, hash));
}
}
return(null);
}
public RedisBatchRequest(RedisAsyncRequest request, RedisResult result)
{
Result = result;
Request = request;
}
protected virtual bool ProcessPingResponse(RedisResult response)
{
return((response as RedisString) == RedisConstants.PONG);
}
