///////////////////////////////////////////////////////////////////////
#region IComparer<IAnyPair<T1,T2>> Members
public int Compare(
IAnyPair <T1, T2> x,
IAnyPair <T1, T2> y
)
{
if ((x == null) && (y == null))
{
return(0);
}
else if (x == null)
{
return(-1);
}
else if (y == null)
{
return(1);
}
else
{
int result = Comparer <T1> .Default.Compare(x.X, y.X);
if (result != 0)
{
return(result);
}
return(Comparer <T2> .Default.Compare(x.Y, y.Y));
}
}
///////////////////////////////////////////////////////////////////////
#region Private Download Event Handlers
#region Download Data Event Handlers
private static void DownloadDataAsyncCompleted(
object sender,
DownloadDataCompletedEventArgs e
)
{
try
{
if (e == null)
{
return;
}
ICallback callback = e.UserState as ICallback;
if (callback == null)
{
return;
}
Uri uri = null;
IClientData clientData = callback.ClientData;
if (clientData != null)
{
IAnyPair <WebClient, Uri> anyPair =
clientData.Data as IAnyPair <WebClient, Uri>;
if (anyPair != null)
{
WebClient webClient = anyPair.X;
if (webClient != null)
{
webClient.Dispose();
webClient = null;
}
uri = anyPair.Y;
}
clientData.Data = null;
}
/* NO RESULT */
callback.FireEventHandler(sender, e,
GetAsyncCompletedArguments(
uri, null, null, null, null, e));
}
catch (Exception ex)
{
DebugOps.Complain(ReturnCode.Error, ex);
}
}
///////////////////////////////////////////////////////////////////////
#region IComparable Members
public int CompareTo(
object obj
)
{
IAnyPair <T1, T2> anyPair = obj as IAnyPair <T1, T2>;
if (anyPair == null)
{
throw new ArgumentException();
}
return(CompareTo(anyPair));
}
///////////////////////////////////////////////////////////////////////
#region System.Object Overrides
public override bool Equals(
object obj
)
{
IAnyPair <T1, T2> anyPair = obj as IAnyPair <T1, T2>;
if (anyPair != null)
{
return(GenericOps <T1> .Equals(this.X, anyPair.X) &&
GenericOps <T2> .Equals(this.Y, anyPair.Y));
}
else
{
return(false);
}
}
///////////////////////////////////////////////////////////////////////
public static IClientData UnwrapOrReturn(
IClientData clientData,
ref object data
)
{
object localData = null;
//
// NOTE: Does the IClientData instance have any data at all?
//
if (HasData(clientData, ref localData))
{
//
// NOTE: Is it wrapping another IClientData instance?
//
IAnyPair <IClientData, object> anyPair =
localData as IAnyPair <IClientData, object>;
if (anyPair != null)
{
//
// NOTE: Return the wrapped data. In this case, the
// original data can still be used by the caller
// if they extract it from the original (outer)
// IClientData instance.
//
data = anyPair.Y;
//
// NOTE: Return the wrapped (inner) IClientData instance
// to the caller.
//
return(anyPair.X);
}
//
// NOTE: Return the original contained data.
//
data = localData;
}
return(clientData);
}
///////////////////////////////////////////////////////////////////////
public static ReturnCode GetSynchronized(
Result synchronizedResult,
ref ReturnCode code,
ref Result result,
ref Result error
)
{
if (synchronizedResult != null)
{
lock (synchronizedResult)
{
IClientData clientData = synchronizedResult.ClientData;
if (clientData != null)
{
IAnyPair <ReturnCode, Result> anyPair =
clientData.Data as IAnyPair <ReturnCode, Result>;
if (anyPair != null)
{
result = anyPair.Y;
code = anyPair.X;
return(ReturnCode.Ok);
}
else
{
error = "synchronized result clientData is not a pair";
}
}
else
{
error = "invalid synchronized result clientData";
}
}
}
else
{
error = "invalid synchronized result";
}
return(ReturnCode.Error);
}
private static void RegsubMatchCallbackPrologue(
out Interpreter interpreter,
out RegsubClientData regsubClientData
)
{
IAnyPair <Interpreter, IClientData> anyPair =
Interpreter.GetActivePair(typeof(RegsubClientData));
if (anyPair == null)
{
throw new ScriptException(
ReturnCode.Error, "missing regsub data pair");
}
interpreter = anyPair.X;
if (interpreter == null)
{
throw new ScriptException(
ReturnCode.Error, "invalid interpreter");
}
regsubClientData = anyPair.Y as RegsubClientData;
if (regsubClientData == null)
{
throw new ScriptException(
ReturnCode.Error, "invalid clientData");
}
ReturnCode code;
Result error = null;
code = Interpreter.Ready(interpreter, ref error);
if (code != ReturnCode.Ok)
{
throw new ScriptException(code, error);
}
}
public static bool Extract(
IAnyPair <T1, T2> pair,
ref T3 x,
ref T4 y
)
{
try
{
//
// HACK: This is not ideal; however, we cannot use the "as"
// operator unless we place a restrictions on all the
// types (i.e. they must be classes).
//
T3 x2 = (T3)(object)pair.X; /* throw */
T4 y2 = (T4)(object)pair.Y; /* throw */
//
// NOTE: Assign to the variables provided by the caller now
// that we know the casts were all successful. These
// statements cannot throw.
//
x = x2; y = y2;
//
// NOTE: All of the casts succeeded.
//
return(true);
}
catch
{
// do nothing.
}
//
// NOTE: One of the casts failed.
//
return(false);
}
///////////////////////////////////////////////////////////////////////
public int GetHashCode(
IAnyPair <T1, T2> value
)
{
if (value == null)
{
return(0);
}
else
{
switch (comparisonType)
{
case PairComparison.LXRX:
{
IEqualityComparer <T1> xLocalEqualityComparer =
(xEqualityComparer != null) ?
xEqualityComparer : EqualityComparer <T1> .Default;
return(xLocalEqualityComparer.GetHashCode(value.X));
}
case PairComparison.LXRY:
{
IEqualityComparer <T1> xLocalEqualityComparer =
(xEqualityComparer != null) ?
xEqualityComparer : EqualityComparer <T1> .Default;
IEqualityComparer <T2> yLocalEqualityComparer =
(yEqualityComparer != null) ?
yEqualityComparer : EqualityComparer <T2> .Default;
return(CommonOps.HashCodes.Combine(
xLocalEqualityComparer.GetHashCode(value.X),
yLocalEqualityComparer.GetHashCode(value.Y)));
}
case PairComparison.LYRX:
{
IEqualityComparer <T1> xLocalEqualityComparer =
(xEqualityComparer != null) ?
xEqualityComparer : EqualityComparer <T1> .Default;
IEqualityComparer <T2> yLocalEqualityComparer =
(yEqualityComparer != null) ?
yEqualityComparer : EqualityComparer <T2> .Default;
return(CommonOps.HashCodes.Combine(
yLocalEqualityComparer.GetHashCode(value.Y),
xLocalEqualityComparer.GetHashCode(value.X)));
}
case PairComparison.LYRY:
{
IEqualityComparer <T2> yLocalEqualityComparer =
(yEqualityComparer != null) ?
yEqualityComparer : EqualityComparer <T2> .Default;
return(yLocalEqualityComparer.GetHashCode(value.Y));
}
}
}
if (throwOnError)
{
throw new ScriptException();
}
else
{
return(0);
}
}
///////////////////////////////////////////////////////////////////////
#region IEqualityComparer<IAnyPair<T1, T2>> Members
public bool Equals(
IAnyPair <T1, T2> left,
IAnyPair <T1, T2> right
)
{
if ((left == null) && (right == null))
{
return(true);
}
else if ((left == null) || (right == null))
{
return(false);
}
else
{
switch (comparisonType)
{
case PairComparison.LXRX:
{
IEqualityComparer <T1> xlocalEqualityComparer =
(xEqualityComparer != null) ?
xEqualityComparer : EqualityComparer <T1> .Default;
return(xlocalEqualityComparer.Equals(left.X, right.X));
}
case PairComparison.LXRY:
{
if (typeof(T1) != typeof(T2))
{
break;
}
IEqualityComparer <T1> xlocalEqualityComparer =
(xEqualityComparer != null) ?
xEqualityComparer : EqualityComparer <T1> .Default;
return(xlocalEqualityComparer.Equals(
left.X, CastToTypeParameter <T2, T1>(right.Y)));
}
case PairComparison.LYRX:
{
if (typeof(T1) != typeof(T2))
{
break;
}
IEqualityComparer <T2> ylocalEqualityComparer =
(yEqualityComparer != null) ?
yEqualityComparer : EqualityComparer <T2> .Default;
return(ylocalEqualityComparer.Equals(
left.Y, CastToTypeParameter <T1, T2>(right.X)));
}
case PairComparison.LYRY:
{
IEqualityComparer <T2> ylocalEqualityComparer =
(yEqualityComparer != null) ?
yEqualityComparer : EqualityComparer <T2> .Default;
return(ylocalEqualityComparer.Equals(left.Y, right.Y));
}
}
}
if (throwOnError)
{
throw new ScriptException();
}
else
{
return(false);
}
}
///////////////////////////////////////////////////////////////////////
#region IComparer<IAnyPair<T1, T2>> Members
public int Compare(
IAnyPair <T1, T2> left,
IAnyPair <T1, T2> right
)
{
if ((left == null) && (right == null))
{
return(0);
}
else if (left == null)
{
return(-1);
}
else if (right == null)
{
return(1);
}
else
{
switch (comparisonType)
{
case PairComparison.LXRX:
{
IComparer <T1> xLocalComparer = (xComparer != null) ?
xComparer : Comparer <T1> .Default;
return(xLocalComparer.Compare(left.X, right.X));
}
case PairComparison.LXRY:
{
if (typeof(T1) != typeof(T2))
{
break;
}
IComparer <T1> xLocalComparer = (xComparer != null) ?
xComparer : Comparer <T1> .Default;
return(xLocalComparer.Compare(
left.X, CastToTypeParameter <T2, T1>(right.Y)));
}
case PairComparison.LYRX:
{
if (typeof(T1) != typeof(T2))
{
break;
}
IComparer <T2> yLocalComparer = (yComparer != null) ?
yComparer : Comparer <T2> .Default;
return(yLocalComparer.Compare(
left.Y, CastToTypeParameter <T1, T2>(right.X)));
}
case PairComparison.LYRY:
{
IComparer <T2> yLocalComparer = (yComparer != null) ?
yComparer : Comparer <T2> .Default;
return(yLocalComparer.Compare(left.Y, right.Y));
}
}
}
if (throwOnError)
{
throw new ScriptException();
}
else
{
return(0);
}
}
///////////////////////////////////////////////////////////////////////
#region IEquatable<IAnyPair<T1,T2>> Members
public bool Equals(
IAnyPair <T1, T2> other
)
{
return(CompareTo(other) == 0);
}
///////////////////////////////////////////////////////////////////////
#region IComparable<IAnyPair<T1,T2>> Members
public int CompareTo(
IAnyPair <T1, T2> other
)
{
return(Compare(this, other));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecute Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count == 2)
{
IObject @object = null;
code = interpreter.GetObject(
Toplevel.CollectionName, LookupFlags.Default,
ref @object, ref result);
if (code == ReturnCode.Ok)
{
ToplevelDictionary toplevels = @object.Value as ToplevelDictionary;
if (toplevels != null)
{
IAnyPair <Thread, Toplevel> anyPair = null;
if (toplevels.TryGetValue(arguments[1], out anyPair))
{
if (anyPair != null)
{
Toplevel toplevel = anyPair.Y;
if (toplevel != null)
{
try
{
string name = ".fixme";
if (toplevel.InvokeRequired)
{
toplevel.BeginInvoke(
new Toplevel.AddButtonDelegate(toplevel.AddButton),
new object[] { name, "test", 0, 0, new EventHandler(button_Click) });
}
else
{
toplevel.AddButton(name, "test", 0, 0, new EventHandler(button_Click));
}
result = name;
}
catch (Exception e)
{
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"toplevel \"{0}\" window is invalid",
arguments[1]);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"toplevel \"{0}\" pair is invalid",
arguments[1]);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"toplevel \"{0}\" not found",
arguments[1]);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"object \"{0}\" is not a toplevel collection",
Toplevel.CollectionName);
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"button toplevel\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////
#region Upload File Event Handlers
private static void UploadFileAsyncCompleted(
object sender,
UploadFileCompletedEventArgs e
)
{
try
{
if (e == null)
{
return;
}
ICallback callback = e.UserState as ICallback;
if (callback == null)
{
return;
}
Uri uri = null;
string method = null;
string fileName = null;
IClientData clientData = callback.ClientData;
if (clientData != null)
{
IAnyTriplet <WebClient, Uri, IAnyPair <string, string> >
anyTriplet = clientData.Data as
IAnyTriplet <WebClient, Uri, IAnyPair <string, string> >;
if (anyTriplet != null)
{
WebClient webClient = anyTriplet.X;
if (webClient != null)
{
webClient.Dispose();
webClient = null;
}
uri = anyTriplet.Y;
IAnyPair <string, string> anyPair = anyTriplet.Z;
if (anyPair != null)
{
method = anyPair.X;
fileName = anyPair.Y;
}
}
clientData.Data = null;
}
ReturnCode code;
Result result = null;
code = callback.Invoke(
GetAsyncCompletedArguments(
uri, method, null, null, fileName, e),
ref result);
if (code != ReturnCode.Ok)
{
DebugOps.Complain(code, result);
}
}
catch (Exception ex)
{
DebugOps.Complain(ReturnCode.Error, ex);
}
}
///////////////////////////////////////////////////////////////////////
#region Upload Values Event Handlers
private static void UploadValuesAsyncCompleted(
object sender,
UploadValuesCompletedEventArgs e
)
{
try
{
if (e == null)
{
return;
}
ICallback callback = e.UserState as ICallback;
if (callback == null)
{
return;
}
Uri uri = null;
string method = null;
NameValueCollection collection = null;
IClientData clientData = callback.ClientData;
if (clientData != null)
{
IAnyTriplet <WebClient, Uri, IAnyPair <string, NameValueCollection> >
anyTriplet = clientData.Data as
IAnyTriplet <WebClient, Uri, IAnyPair <string, NameValueCollection> >;
if (anyTriplet != null)
{
WebClient webClient = anyTriplet.X;
if (webClient != null)
{
webClient.Dispose();
webClient = null;
}
uri = anyTriplet.Y;
IAnyPair <string, NameValueCollection>
anyPair = anyTriplet.Z;
if (anyPair != null)
{
method = anyPair.X;
collection = anyPair.Y;
}
}
clientData.Data = null;
}
/* NO RESULT */
callback.FireEventHandler(sender, e,
GetAsyncCompletedArguments(
uri, method, null, collection, null, e));
}
catch (Exception ex)
{
DebugOps.Complain(ReturnCode.Error, ex);
}
}
