protected RedisMessage(int db, RedisLiteral command)
{
bool isDbFree = false;
for (int i = 0; i < dbFree.Length; i++)
{
if (dbFree[i] == command)
{
isDbFree = true;
break;
}
}
if (isDbFree)
{
if (db >= 0)
{
throw new ArgumentOutOfRangeException("db", "A db is not required for " + command);
}
}
else
{
if (db < 0)
{
throw new ArgumentOutOfRangeException("db", "A db must be specified for " + command);
}
}
this.db = db;
this.command = command;
}
public RedisMessageTri(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1, RedisParameter arg2)
: base(db, command)
{
this.arg0 = arg0;
this.arg1 = arg1;
this.arg2 = arg2;
}
public static RedisMessage Create(int db, RedisLiteral command, params RedisParameter[] args)
{
if (args == null)
{
return(new RedisMessageNix(db, command));
}
switch (args.Length)
{
case 0:
return(new RedisMessageNix(db, command));
case 1:
return(new RedisMessageUni(db, command, args[0]));
case 2:
return(new RedisMessageBi(db, command, args[0], args[1]));
case 3:
return(new RedisMessageTri(db, command, args[0], args[1], args[2]));
case 4:
return(new RedisMessageQuad(db, command, args[0], args[1], args[2], args[3]));
default:
return(new RedisMessageMulti(db, command, args));
}
}
private Task <long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task <bool>[] tasks = new Task <bool> [values.Length];
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
TaskCompletionSource <long> final = new TaskCompletionSource <long>();
tasks[values.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute)
{
tran.Execute(queueJump);
}
return(final.Task);
}
else
{
var args = new RedisMessage.RedisParameter[values.Length + 1];
args[0] = key;
for (int i = 0; i < values.Length; i++)
{
args[i + 1] = values[i];
}
return(ExecuteInt64(RedisMessage.Create(db, command, args), queueJump));
}
}
public ScanIterator(RedisConnection connection, int db, RedisLiteral command, string key, string pattern)
{
this.connection = connection;
this.db = db;
this.pattern = pattern;
this.command = command;
this.key = key;
}
public RedisMessageQuad(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1, RedisParameter arg2, RedisParameter arg3)
: base(db, command)
{
this.arg0 = arg0;
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
}
public RedisMessageUniString(int db, RedisLiteral command, string arg0)
: base(db, command)
{
if (arg0 == null)
{
throw new ArgumentNullException("arg0");
}
this.arg0 = arg0;
}
Task <string> IStringCommands.GetString(int db, string key, int start, int end, bool queueJump)
{
var features = this.Features;
RedisLiteral cmd = features != null && features.Version < RedisFeatures.v2_1_0
? RedisLiteral.SUBSTR
: RedisLiteral.GETRANGE;
return(ExecuteString(RedisMessage.Create(db, cmd, key, start, end), queueJump));
}
private Task <long> ExecMultiAddRemove(int db, RedisLiteral command, string key, string[] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
var tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
var tasks = new Task <bool> [values.Length];
ISetCommands sets = tran.Sets;
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
var final = new TaskCompletionSource <long>();
tasks[values.Length - 1].ContinueWith(t =>
{
if (t.IsFaulted)
{
final.SetException(t.Exception);
}
try
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.SetResult(count);
}
catch (Exception ex)
{
final.SetException(ex);
}
});
if (execute)
{
tran.Execute(queueJump);
}
return(final.Task);
}
else
{
return(ExecuteInt64(RedisMessage.Create(db, command, key, values), queueJump));
}
}
static RedisMessage GetBlockingPop(int db, RedisLiteral command, string[] keys, int timeoutSeconds)
{
var args = new RedisMessage.RedisParameter[keys.Length + 1];
for (int i = 0; i < keys.Length; i++)
{
args[i] = keys[i];
}
args[keys.Length] = timeoutSeconds;
return(RedisMessage.Create(db, command, args));
}
public RedisMessage Expect(RedisLiteral result)
{
if (expected == RedisLiteral.None)
{
expected = result;
}
else
{
throw new InvalidOperationException();
}
return(this);
}
public RedisMessageSub(RedisLiteral command, string[] keys)
: base(-1, command)
{
if (keys == null)
{
throw new ArgumentNullException("keys");
}
if (keys.Length == 0)
{
throw new ArgumentException("keys cannot be empty", "keys");
}
this.keys = keys;
this.remainingReplies = keys.Length;
}
public static RedisMessage Create(int db, RedisLiteral command, string arg0, string[] args)
{
if (args == null)
{
return(Create(db, command, arg0));
}
switch (args.Length)
{
case 0:
return(Create(db, command, arg0));
case 1:
return(Create(db, command, arg0, args[0]));
default:
return(new RedisMessageMultiString(db, command, arg0, args));
}
}
private Task <long> BitOp(int db, RedisLiteral operation, string destination, string[] keys, bool queueJump)
{
if (keys == null)
{
throw new ArgumentNullException("keys");
}
if (keys.Length == 0)
{
throw new ArgumentException("keys");
}
var args = new RedisMessage.RedisParameter[keys.Length + 2];
args[0] = operation;
args[1] = destination;
for (int i = 0; i < keys.Length; i++)
{
args[i + 2] = keys[i];
}
return(ExecuteInt64(RedisMessage.Create(db, RedisLiteral.BITOP, args), queueJump));
}
public RedisMessageMultiString(int db, RedisLiteral command, string arg0, string[] args)
: base(db, command)
{
if (arg0 == null)
{
throw new ArgumentNullException("arg0");
}
if (args == null)
{
throw new ArgumentNullException("args");
}
for (int i = 0; i < args.Length; i++)
{
if (args[i] == null)
{
throw new ArgumentNullException("args:" + i);
}
}
this.arg0 = arg0;
this.args = args;
}
protected static void WriteUnified(Stream stream, RedisLiteral value)
{
WriteUnified(stream, literals[(int)value]);
}
public static RedisMessage Create(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1,
RedisParameter arg2, RedisParameter arg3)
{
return(new RedisMessageQuad(db, command, arg0, arg1, arg2, arg3));
}
public static RedisMessage Create(int db, RedisLiteral command)
{
return(new RedisMessageNix(db, command));
}
private Task<long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task<bool>[] tasks = new Task<bool>[values.Length];
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
TaskCompletionSource<long> final = new TaskCompletionSource<long>();
tasks[values.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute) tran.Execute(queueJump);
return final.Task;
}
else
{
var args = new RedisMessage.RedisParameter[values.Length + 1];
args[0] = key;
for (int i = 0; i < values.Length; i++)
{
args[i + 1] = values[i];
}
return ExecuteInt64(RedisMessage.Create(db, command, args), queueJump);
}
}
internal static RedisMessage CreateMultiSub(RedisLiteral redisLiteral, string[] keys)
{
return(keys.Length == 1 ? Create(-1, redisLiteral, keys[0])
: new RedisMessageSub(redisLiteral, keys));
}
public RedisMessageUni(int db, RedisLiteral command, RedisParameter arg0)
: base(db, command)
{
this.arg0 = arg0;
}
public RedisMessageTri(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1, RedisParameter arg2)
: base(db, command)
{
this.arg0 = arg0;
this.arg1 = arg1;
this.arg2 = arg2;
}
public RedisMessageSub(RedisLiteral command, string[] keys)
: base(-1, command)
{
if (keys == null) throw new ArgumentNullException("keys");
if (keys.Length == 0) throw new ArgumentException("keys cannot be empty", "keys");
this.keys = keys;
this.remainingReplies = keys.Length;
}
public RedisMessageQuad(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1, RedisParameter arg2, RedisParameter arg3)
: base(db, command)
{
this.arg0 = arg0;
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
}
public RedisMessageNix(int db, RedisLiteral command)
: base(db, command)
{
}
public RedisMessageMultiString(int db, RedisLiteral command, string arg0, string[] args)
: base(db, command)
{
if (arg0 == null) throw new ArgumentNullException("arg0");
if (args == null) throw new ArgumentNullException("args");
for (int i = 0; i < args.Length; i++)
{
if (args[i] == null) throw new ArgumentNullException("args:" + i);
}
this.arg0 = arg0;
this.args = args;
}
public RedisMessageNix(int db, RedisLiteral command)
: base(db, command)
{
}
private Task<long> BitOp(int db, RedisLiteral operation, string destination, string[] keys, bool queueJump)
{
if (keys == null) throw new ArgumentNullException("keys");
if (keys.Length == 0) throw new ArgumentException("keys");
var args = new RedisMessage.RedisParameter[keys.Length + 2];
args[0] = operation;
args[1] = destination;
for (int i = 0; i < keys.Length; i++)
{
args[i + 2] = keys[i];
}
return ExecuteInt64(RedisMessage.Create(db, RedisLiteral.BITOP, args), queueJump);
}
public RedisMessageUniString(int db, RedisLiteral command, string arg0)
: base(db, command)
{
if (arg0 == null) throw new ArgumentNullException("arg0");
this.arg0 = arg0;
}
public RedisMessageMulti(int db, RedisLiteral command, RedisParameter[] args)
: base(db, command)
{
this.args = args;
}
protected RedisMessage(int db, RedisLiteral command)
{
bool isDbFree = false;
for (int i = 0; i < dbFree.Length; i++)
{
if (dbFree[i] == command)
{
isDbFree = true;
break;
}
}
if (isDbFree)
{
if (db >= 0) throw new ArgumentOutOfRangeException("db", "A db is not required for " + command);
}
else
{
if (db < 0) throw new ArgumentOutOfRangeException("db", "A db must be specified for " + command);
}
this.db = db;
this.command = command;
}
public RedisMessageBiString(int db, RedisLiteral command, string arg0, string arg1)
: base(db, command)
{
this.arg0 = arg0;
this.arg1 = arg1;
}
public static RedisMessage Create(int db, RedisLiteral command)
{
return new RedisMessageNix(db, command);
}
public static RedisMessage Create(int db, RedisLiteral command, string arg0, string arg1)
{
return(new RedisMessageBiString(db, command, arg0, arg1));
}
public static RedisMessage Create(int db, RedisLiteral command, string arg0, string arg1)
{
return new RedisMessageBiString(db, command, arg0, arg1);
}
public static RedisMessage Create(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1)
{
return(new RedisMessageBi(db, command, arg0, arg1));
}
private Task<long> ExecMultiAddRemove(int db, RedisLiteral command, string key, string[] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task<bool>[] tasks = new Task<bool>[values.Length];
var sets = tran.Sets;
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
TaskCompletionSource<long> final = new TaskCompletionSource<long>();
tasks[values.Length - 1].ContinueWith(t =>
{
if (t.IsFaulted) final.SetException(t.Exception);
try
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.SetResult(count);
}
catch (Exception ex)
{
final.SetException(ex);
}
});
if (execute) tran.Execute(queueJump);
return final.Task;
}
else
{
return ExecuteInt64(RedisMessage.Create(db, command, key, values), queueJump);
}
}
public RedisMessageUniString(int db, RedisLiteral command, string arg0)
: base(db, command)
{
this.arg0 = arg0;
}
public static RedisMessage Create(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1, RedisParameter arg2, RedisParameter arg3)
{
return new RedisMessageQuad(db, command, arg0, arg1, arg2, arg3);
}
public RedisMessageMulti(int db, RedisLiteral command, RedisParameter[] args)
: base(db, command)
{
this.args = args;
}
public static RedisMessage Create(int db, RedisLiteral command, params RedisParameter[] args)
{
if (args == null) return new RedisMessageNix(db, command);
switch (args.Length)
{
case 0: return new RedisMessageNix(db, command);
case 1: return new RedisMessageUni(db, command, args[0]);
case 2: return new RedisMessageBi(db, command, args[0], args[1]);
case 3: return new RedisMessageTri(db, command, args[0], args[1], args[2]);
case 4: return new RedisMessageQuad(db, command, args[0], args[1], args[2], args[3]);
default: return new RedisMessageMulti(db, command, args);
}
}
public RedisMessageMultiString(int db, RedisLiteral command, string arg0, string[] args)
: base(db, command)
{
this.arg0 = arg0;
this.args = args;
}
public RedisMessage Expect(RedisLiteral result)
{
if (expected == RedisLiteral.None)
{
expected = result;
}
else
{
throw new InvalidOperationException();
}
return this;
}
public RedisMessageUni(int db, RedisLiteral command, RedisParameter arg0)
: base(db, command)
{
this.arg0 = arg0;
}
internal static RedisMessage CreateMultiSub(RedisLiteral redisLiteral, string[] keys)
{
return keys.Length == 1 ? Create(-1, redisLiteral, keys[0])
: new RedisMessageSub(redisLiteral, keys);
}
public RedisLiteralParameter(RedisLiteral value)
{
this.value = value;
}
protected static void WriteUnified(Stream stream, RedisLiteral value)
{
WriteUnified(stream, literals[(int)value]);
}
public static RedisMessage Create(int db, RedisLiteral command, string arg0, string[] args)
{
if (args == null) return Create(db, command, arg0);
switch (args.Length)
{
case 0:
return Create(db, command, arg0);
case 1:
return Create(db, command, arg0, args[0]);
default:
return new RedisMessageMultiString(db, command, arg0, args);
}
}
public RedisLiteralParameter(RedisLiteral value)
{
this.value = value;
}
static RedisMessage GetBlockingPop(int db, RedisLiteral command, string[] keys, int timeoutSeconds)
{
var args = new RedisMessage.RedisParameter[keys.Length + 1];
for (int i = 0; i < keys.Length; i++)
args[i] = keys[i];
args[keys.Length] = timeoutSeconds;
return RedisMessage.Create(db, command, args);
}
public static RedisMessage Create(int db, RedisLiteral command, RedisParameter arg0, RedisParameter arg1)
{
return new RedisMessageBi(db, command, arg0, arg1);
}
