public static object GetExceptionInfo(GenericWrapper wrapper, object state)
{
if ((wrapper.AvailableFormats & WrappedValueFormats.Object) != WrappedValueFormats.Object)
{
throw new ArgumentException("The GenericWrapper does not contain an object.");
}
object val = wrapper.GetWrappedObject();
var info = val as ExceptionInfo;
if (info != null)
{
return(info);
}
var ex = val as Exception;
if (ex != null)
{
return(new ExceptionInfo(ex, null));
}
throw new ArgumentException(string.Format("The GenericWrapper contains a '{0}' object, which"
+ " is not derived from '{1}' or '{2}'.",
val.GetType().FullName, typeof(ExceptionInfo).FullName, typeof(Exception).FullName));
}
private void nameColumn_Expand(object sender, MemberWrapperEventArgs e)
{
using (new LongRunningMonitor(this))
{
int index = m_properties.IndexOf(e.Wrapper);
Debug.Assert(index != -1, "index != -1");
Debug.Assert(!e.Wrapper.ValueIsNullOrUnavailable, "Trying to expand a null or unavailable value.");
CellEditorData cellData = (CellEditorData)e.Wrapper.Tag;
Debug.Assert(!cellData.IsExpanded, "Expanding an already expanded row.");
// Create a new GenericWrapper object for the expanded value and get its properties.
GenericWrapper genericWrapper = e.Wrapper.CreateWrapper();
Debug.Assert(genericWrapper != null, "CreateWrapper() returned null for the member being expanded.");
cellData.Children = genericWrapper.GetMembers();
foreach (MemberWrapper childProperty in cellData.Children)
{
childProperty.SetValueFormat(m_valueFormat);
childProperty.Tag = new CellEditorData(childProperty, cellData.Level + 1, cellData);
childProperty.ValueChanged += new EventHandler(m_handler.ItemValueChanged);
m_properties.Insert(++index, childProperty);
}
if (cellData.Children.Count == 0)
{
((DataGridExpandableColumn)sender).Invalidate();
}
else
{
((CellEditorData)cellData.Children[cellData.Children.Count - 1].Tag).IsLastInLevel = true;
}
}
}
public void WrapStringTest_GetFriendlyName()
{
GenericWrapper <string> typeWrapper = new GenericWrapper <string>("hello", TypeHelper.GetTypeFriendlyName);
Assert.AreEqual(typeWrapper.Item, "hello");
Assert.AreEqual(typeWrapper.DisplayName, "String");
}
public void WrapStringTest_GetCustomName()
{
GenericWrapper <string> typeWrapper = new GenericWrapper <string>("hello", "a random name");
Assert.AreEqual(typeWrapper.Item, "hello");
Assert.AreEqual(typeWrapper.DisplayName, "a random name");
}
private object CreateCustomDelegate(string funcName, Type delegateType)
{
Type retType = delegateType.GetMethod("Invoke").ReturnType;
var genericWrapper = new GenericWrapper(arguments =>
{
if (retType == typeof(void))
{
CallClientFunction(funcName, arguments);
// We do not wait here since SuperWebSocket doesn't process messages while the
// current thread is blocked. Waiting would bring the current client's thread
// into a deadlock.
return(null);
}
else
{
throw new NotImplementedException("We do not support callbacks with return " +
"value yet. This is because we cannot wait for a callback to complete. " +
"See more details here: https://redmine.viscenter.de/issues/1406.");
//object result = null;
//CallFunc(funcName, arguments)
// .OnSuccess(delegate(JToken res) { result = res.ToObject(retType); })
// .Wait();
//return result;
}
});
return(Dynamic.CoerceToDelegate(genericWrapper, delegateType));
}
public void WrapStringTest()
{
GenericWrapper <string> typeWrapper = new GenericWrapper <string>("hello");
Assert.AreEqual(typeWrapper.Item, "hello");
Assert.AreEqual(typeWrapper.DisplayName, "hello");
}
public override void Clear()
{
m_modified = false;
m_wrapper = null;
m_properties = null;
grid.SetDataBinding(null, null);
}
public void DisplayRemoteValue(GenericWrapper wrapper)
{
if (wrapper == null)
{
throw new ArgumentNullException("wrapper");
}
DisplayException((ExceptionInfo)wrapper.RunCustomWorker(Worker.GetExceptionInfo, null));
}
public Task <GenericWrapper <IPet> > GetPets(
int?arg1,
bool?arg2,
bool?arg3,
string?arg4,
GenericWrapper <string>?arg5,
Greetings?arg6,
CancellationToken cancellationToken) =>
throw new NotImplementedException();
public void TestGenericWrapper()
{
var test = new GenericWrapper(new NonGenericWrapper(new GenericClass()));
var prioritySet = false;
// GetDefault
Assert.AreEqual(default(int), test.GetDefault <int>());
Assert.AreEqual(default(string), test.GetDefault <string>());
Assert.AreEqual(default(Guid), test.GetDefault <Guid>());
// Equals
Assert.IsTrue(test.Equals(123, 123));
Assert.IsFalse(test.Equals("Some", null));
// GetVersion
Assert.AreEqual("DoSomething wasn't called yet", test.GetVersion());
// DoSomething
test.DoSomething(123, 'x', "y");
Assert.AreEqual("DoSomething: A = 123, B = x, C = y", test.GetVersion());
// Compute
var dt = test.Compute <Guid, DateTime>(Guid.Empty, 123, "123");
Assert.AreEqual(default(DateTime), dt);
// CreateGuid
var guid = test.CreateGuid(dt, 12345);
Assert.AreEqual("00003039-0001-0001-0000-000000000000", guid.ToString());
// LastDate
Assert.AreEqual(dt, test.LastDate);
test.LastDate = dt = DateTime.Now;
Assert.AreEqual(dt, test.LastDate);
// Name
Assert.AreEqual("GenericClass, priority = 123", test.Name);
// add OnPrioritySet
EventHandler <EventArgs> handler = (s, a) => prioritySet = true;
test.OnPrioritySet += handler;
Assert.IsFalse(prioritySet);
// Priority
test.Priority = 321;
Assert.IsTrue(prioritySet);
Assert.AreEqual("GenericClass, priority = 321", test.Name);
// remove OnPrioritySet
prioritySet = false;
test.OnPrioritySet -= handler;
test.Priority = 111;
Assert.IsFalse(prioritySet);
}
public void DisplayValue(GenericWrapper value)
{
if (value == null)
{
throw new ArgumentNullException("value", "This editor cannot display a null value.");
}
m_wrapper = value;
DisplayValueInternal(m_wrapper.GetMembers());
}
public void DisplayValue(MemberWrappers values)
{
if (values == null)
{
throw new ArgumentNullException("values", "This editor cannot display a null value.");
}
m_wrapper = null;
DisplayValueInternal(values);
}
private void CheckState()
{
if (txtName.Text != "")
{
GenericWrapper node = treeResource.SelectedNode as GenericWrapper;
btnOk.Enabled = node != null && node.Resource is RSARSoundNode;
}
else
{
btnOk.Enabled = false;
}
}
public void TestGenericWrapper()
{
var test = new GenericWrapper(new NonGenericWrapper(new GenericClass()));
var prioritySet = false;
// GetDefault
Assert.AreEqual(default(int), test.GetDefault<int>());
Assert.AreEqual(default(string), test.GetDefault<string>());
Assert.AreEqual(default(Guid), test.GetDefault<Guid>());
// Equals
Assert.IsTrue(test.Equals(123, 123));
Assert.IsFalse(test.Equals("Some", null));
// GetVersion
Assert.AreEqual("DoSomething wasn't called yet", test.GetVersion());
// DoSomething
test.DoSomething(123, 'x', "y");
Assert.AreEqual("DoSomething: A = 123, B = x, C = y", test.GetVersion());
// Compute
var dt = test.Compute<Guid, DateTime>(Guid.Empty, 123, "123");
Assert.AreEqual(default(DateTime), dt);
// CreateGuid
var guid = test.CreateGuid(dt, 12345);
Assert.AreEqual("00003039-0001-0001-0000-000000000000", guid.ToString());
// LastDate
Assert.AreEqual(dt, test.LastDate);
test.LastDate = dt = DateTime.Now;
Assert.AreEqual(dt, test.LastDate);
// Name
Assert.AreEqual("GenericClass, priority = 123", test.Name);
// add OnPrioritySet
EventHandler<EventArgs> handler = (s, a) => prioritySet = true;
test.OnPrioritySet += handler;
Assert.IsFalse(prioritySet);
// Priority
test.Priority = 321;
Assert.IsTrue(prioritySet);
Assert.AreEqual("GenericClass, priority = 321", test.Name);
// remove OnPrioritySet
prioritySet = false;
test.OnPrioritySet -= handler;
test.Priority = 111;
Assert.IsFalse(prioritySet);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="result"></param>
/// <returns></returns>
public static JsonResult CreateResponse <T>(T result)
{
return(IsSimpleType(typeof(T))
? new JsonResult(GenericWrapper <T> .Wrap(result))
{
StatusCode = (int)HttpStatusCode.OK
}
: new JsonResult(result)
{
StatusCode = (int)HttpStatusCode.OK
});
}
public override void CalulateResult(GenericWrapper from)
{
if (from == Result)
{
return;
}
var resultX = ((Point3DWrapper)Operand1).X + ((Point3DWrapper)Operand2).X;
var resultY = ((Point3DWrapper)Operand1).Y + ((Point3DWrapper)Operand2).Y;
var resultZ = ((Point3DWrapper)Operand1).Z + ((Point3DWrapper)Operand2).Z;
((Point3DWrapper)Result).X = resultX;
((Point3DWrapper)Result).Y = resultY;
((Point3DWrapper)Result).Z = resultZ;
}
public void DisplayRemoteValue(GenericWrapper wrapper)
{
if (CurrentEditor == null)
{
throw new InvalidOperationException("Unable to display the value, because there is no current editor.");
}
IRemoteEditor remoteEditor = CurrentEditor as IRemoteEditor;
if (remoteEditor == null)
{
throw new InvalidOperationException("Unable to display a remote value, because the current editor"
+ " is not a remote editor.");
}
remoteEditor.DisplayRemoteValue(wrapper);
}
public object[] Create_ProxiedChildGeneric_ComplexGenericArguments_Parameters <T0, T1, T2, T3> (T0 t0, T1 t1,
T2 t2, T3 t3)
{
var p0 = new List <List <T0> > {
new List <T0> {
t0
}
};
var p1 = new Dictionary <T2, T1> {
{ t2, t1 }
};
var p2 = new List <GenericWrapper <T2> > {
new GenericWrapper <T2> (t2)
};
var p3 = new GenericWrapper <T3> (t3);
return(new object[] { p0, p1, p2, p3 });
}
public void TestGenericWrapperOverZyan()
{
var serverProto = new IpcBinaryServerProtocolSetup("Test");
var clientProto = new IpcBinaryClientProtocolSetup();
var host = new ZyanComponentHost("TestServer", serverProto);
host.RegisterComponent <INonGenericInterface>(() => new NonGenericWrapper(new GenericClass()), ActivationType.Singleton);
var conn = new ZyanConnection("ipc://Test/TestServer");
var proxy = conn.CreateProxy <INonGenericInterface>();
// same as usual
var test = new GenericWrapper(proxy);
var prioritySet = false;
// GetDefault
Assert.AreEqual(default(int), test.GetDefault <int>());
Assert.AreEqual(default(string), test.GetDefault <string>());
Assert.AreEqual(default(Guid), test.GetDefault <Guid>());
// Equals
Assert.IsTrue(test.Equals(123, 123));
Assert.IsFalse(test.Equals("Some", null));
// GetVersion
Assert.AreEqual("DoSomething wasn't called yet", test.GetVersion());
// DoSomething
test.DoSomething(123, 'x', "y");
Assert.AreEqual("DoSomething: A = 123, B = x, C = y", test.GetVersion());
// Compute
var dt = test.Compute <Guid, DateTime>(Guid.Empty, 123, "123");
Assert.AreEqual(default(DateTime), dt);
// CreateGuid
var guid = test.CreateGuid(dt, 12345);
Assert.AreEqual("00003039-0001-0001-0000-000000000000", guid.ToString());
// LastDate
Assert.AreEqual(dt, test.LastDate);
test.LastDate = dt = DateTime.Now;
Assert.AreEqual(dt, test.LastDate);
// Name
Assert.AreEqual("GenericClass, priority = 123", test.Name);
// add OnPrioritySet
EventHandler <EventArgs> handler = (s, a) => prioritySet = true;
test.OnPrioritySet += handler;
Assert.IsFalse(prioritySet);
// Priority
test.Priority = 321;
Assert.IsTrue(prioritySet);
Assert.AreEqual("GenericClass, priority = 321", test.Name);
// remove OnPrioritySet
prioritySet = false;
test.OnPrioritySet -= handler;
test.Priority = 111;
Assert.IsFalse(prioritySet);
}
public static GenericWrapper<bool> Overloaded(
GenericWrapper<bool> v) {
return v;
}
public static GenericWrapper<sbyte> Overloaded(
GenericWrapper<sbyte> v) {
return v;
}
public static GenericWrapper<ulong> Overloaded(
GenericWrapper<ulong> v) {
return v;
}
public static GenericWrapper<float> Overloaded(
GenericWrapper<float> v) {
return v;
}
public static GenericWrapper<char>[] Overloaded(
GenericWrapper<char>[] v) {
return v;
}
public abstract void CalulateResult(GenericWrapper from);
public static GenericWrapper<ISayHello1>[] Overloaded(
GenericWrapper<ISayHello1>[] v) {
return v;
}
public static GenericWrapper<double>[] Overloaded(
GenericWrapper<double>[] v) {
return v;
}
public static GenericWrapper<InterfaceTest>[] Overloaded(
GenericWrapper<InterfaceTest>[] v) {
return v;
}
public static GenericWrapper<object>[] Overloaded(
GenericWrapper<object>[] v) {
return v;
}
public static GenericWrapper<ShortEnum>[] Overloaded(
GenericWrapper<ShortEnum>[] v) {
return v;
}
public void TestGenericWrapperOverZyan()
{
var serverProto = new IpcBinaryServerProtocolSetup("Test");
var clientProto = new IpcBinaryClientProtocolSetup();
var host = new ZyanComponentHost("TestServer", serverProto);
host.RegisterComponent<INonGenericInterface>(() => new NonGenericWrapper(new GenericClass()), ActivationType.Singleton);
var conn = new ZyanConnection("ipc://Test/TestServer");
var proxy = conn.CreateProxy<INonGenericInterface>();
// same as usual
var test = new GenericWrapper(proxy);
var prioritySet = false;
// GetDefault
Assert.AreEqual(default(int), test.GetDefault<int>());
Assert.AreEqual(default(string), test.GetDefault<string>());
Assert.AreEqual(default(Guid), test.GetDefault<Guid>());
// Equals
Assert.IsTrue(test.Equals(123, 123));
Assert.IsFalse(test.Equals("Some", null));
// GetVersion
Assert.AreEqual("DoSomething wasn't called yet", test.GetVersion());
// DoSomething
test.DoSomething(123, 'x', "y");
Assert.AreEqual("DoSomething: A = 123, B = x, C = y", test.GetVersion());
// Compute
var dt = test.Compute<Guid, DateTime>(Guid.Empty, 123, "123");
Assert.AreEqual(default(DateTime), dt);
// CreateGuid
var guid = test.CreateGuid(dt, 12345);
Assert.AreEqual("00003039-0001-0001-0000-000000000000", guid.ToString());
// LastDate
Assert.AreEqual(dt, test.LastDate);
test.LastDate = dt = DateTime.Now;
Assert.AreEqual(dt, test.LastDate);
// Name
Assert.AreEqual("GenericClass, priority = 123", test.Name);
// add OnPrioritySet
EventHandler<EventArgs> handler = (s, a) => prioritySet = true;
test.OnPrioritySet += handler;
Assert.IsFalse(prioritySet);
// Priority
test.Priority = 321;
Assert.IsTrue(prioritySet);
Assert.AreEqual("GenericClass, priority = 321", test.Name);
// remove OnPrioritySet
prioritySet = false;
test.OnPrioritySet -= handler;
test.Priority = 111;
Assert.IsFalse(prioritySet);
}
public static GenericWrapper<ushort>[] Overloaded(
GenericWrapper<ushort>[] v) {
return v;
}
public static GenericWrapper<string>[] Overloaded(
GenericWrapper<string>[] v) {
return v;
}
public static GenericWrapper<decimal>[] Overloaded(
GenericWrapper<decimal>[] v) {
return v;
}
