/// <summary>
/// Creates a new relation between the supplied <see cref="InstanceDescriptor"/> and instance.
/// </summary>
/// <param name="instanceDescriptor">The <see cref="InstanceDescriptor"/>.</param>
/// <param name="instance">The instance.</param>
/// <exception cref="InvalidOperationException">The relation between the supplied <see cref="InstanceDescriptor"/> and instance already exists.</exception>
/// <exception cref="ArgumentNullException">The value of '<paramref name="instanceDescriptor"/>' and '<paramref name="instance"/>' cannot be null.</exception>
public void CreateRelation(InstanceDescriptor instanceDescriptor, Object instance)
{
if (instanceDescriptor == null)
{
throw new ArgumentNullException(nameof(instanceDescriptor));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (
this.instanceDescriptorInstanceRelations.Any(
idir => idir.InstanceDescriptor == instanceDescriptor && idir.Instance == instance))
{
throw new InvalidOperationException(String.Format(ExceptionMessages.RelationAlreadyPresentExceptionMessage, instanceDescriptor.AssemblyQualifiedTypeName, instance.GetType().Name));
}
var newInstanceRelation = new InstanceDescriptorInstanceRelation(instanceDescriptor, instance);
this.instanceDescriptorInstanceRelations.Add(newInstanceRelation);
this.OnInstanceRelationChanged(newInstanceRelation, InstanceRelationChangeType.Created);
}
private static void Refresh()
{
var db = Redis.GetDatabase();
const string TEMPLATE = "{0,10} {1,10} {2,-20}";
var sb = new StringBuilder();
sb.AppendLine("Monitor");
sb.AppendLine("--------------------------------------------");
sb.AppendLine(String.Format(TEMPLATE, "Session", "Revision", "Last value"));
sb.AppendLine("--------------------------------------------");
foreach (var entry in Session.SessionIds(Redis))
{
var id = new InstanceDescriptor()
{
Id = entry
};
var session = Session.ReadOnly(Redis, id);
sb.AppendLine(String.Format(TEMPLATE, id.Id, session.Revision, session.LastResult));
}
sb.AppendLine("--------------------------------------------");
sb.AppendLine(String.Format("{0} work entries in queue {1}", db.ListLength(Tools.WORKQUEUE), Tools.WORKQUEUE));
sb.AppendLine("--------------------------------------------");
sb.AppendLine("Hit <ESC> to shutdown this monitor. ");
//Console.Clear();
Console.CursorTop = 0;
Console.CursorLeft = 0;
Console.WriteLine(sb);
}
private static object ReadInstanceDescriptor(XmlNode node, ArrayList errors)
{
XmlAttribute memberAttr = node.Attributes["member"];
if (memberAttr == null)
{
errors.Add("No member attribute on instance descriptor");
return(null);
}
byte[] data = Convert.FromBase64String(memberAttr.Value);
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(data);
MemberInfo mi = (MemberInfo)formatter.Deserialize(stream);
object[] args = null;
if (mi is MethodBase)
{
ParameterInfo[] paramInfos = ((MethodBase)mi).GetParameters();
args = new object[paramInfos.Length];
int idx = 0;
foreach (XmlNode child in node.ChildNodes)
{
if (child.Name.Equals("Argument"))
{
object value;
if (!ReadValue(child, TypeDescriptor.GetConverter(paramInfos[idx].ParameterType), errors, out value))
{
return(null);
}
args[idx++] = value;
}
}
if (idx != paramInfos.Length)
{
errors.Add(string.Format("Member {0} requires {1} arguments, not {2}.", mi.Name, args.Length, idx));
return(null);
}
}
InstanceDescriptor id = new InstanceDescriptor(mi, args);
object instance = id.Invoke();
foreach (XmlNode prop in node.ChildNodes)
{
if (prop.Name.Equals("Property"))
{
ReadProperty(prop, instance, errors);
}
}
return(instance);
}
protected CodeExpression SerializeCreationExpression(IDesignerSerializationManager manager, object value, out bool isComplete)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
CodeExpression expression = null;
TypeConverter converter = TypeDescriptor.GetConverter(value);
if (converter != null && converter.CanConvertTo(typeof(InstanceDescriptor)))
{
InstanceDescriptor descriptor = converter.ConvertTo(value, typeof(InstanceDescriptor)) as InstanceDescriptor;
isComplete = descriptor.IsComplete;
expression = this.SerializeInstanceDescriptor(manager, descriptor);
}
else
{
expression = new CodeObjectCreateExpression(value.GetType().FullName, new CodeExpression[0]);
isComplete = false;
}
if (value.GetType().Name.EndsWith("Color"))
{
Console.WriteLine("SerializeCreationExpression: " + expression);
}
return(expression);
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionAddMethodInterceptor"/> class.
/// </summary>
/// <param name="instanceDescriptor">The <see cref="Model.InstanceDescriptor"/>.</param>
/// <param name="collectionPropertyAssociation">The <see cref="Model.Values.CollectionPropertyAssociation"/>.</param>
/// <param name="collectionItemFactoryProvider">The <see cref="ICollectionItemFactoryProvider"/>.</param>
/// <param name="instanceRelationStore">The <see cref="IInstanceRelationStore"/>.</param>
/// <exception cref="ArgumentNullException">The value of '<paramref name="collectionPropertyAssociation"/>', '<paramref name="collectionItemFactoryProvider"/>', '<paramref name="instanceDescriptor"/>' and '<paramref name="instanceRelationStore"/>' cannot be null.</exception>
public CollectionAddMethodInterceptor([NotNull] InstanceDescriptor instanceDescriptor, [NotNull] CollectionPropertyAssociation collectionPropertyAssociation, [NotNull] ICollectionItemFactoryProvider collectionItemFactoryProvider, [NotNull] IInstanceRelationStore instanceRelationStore)
{
if (instanceDescriptor == null)
{
throw new ArgumentNullException(nameof(instanceDescriptor));
}
if (collectionPropertyAssociation == null)
{
throw new ArgumentNullException(nameof(collectionPropertyAssociation));
}
if (collectionItemFactoryProvider == null)
{
throw new ArgumentNullException(nameof(collectionItemFactoryProvider));
}
if (instanceRelationStore == null)
{
throw new ArgumentNullException(nameof(instanceRelationStore));
}
this.instanceDescriptor = instanceDescriptor;
this.collectionPropertyAssociation = collectionPropertyAssociation;
this.collectionItemFactoryProvider = collectionItemFactoryProvider;
this.instanceRelationStore = instanceRelationStore;
}
private static InstanceState Read(ConnectionMultiplexer Redis, InstanceDescriptor instanceDescriptor, bool forChange, out string lockId)
{
var db = Redis.GetDatabase();
RedisKey keyLock = Tools.MakeLockKey(instanceDescriptor.Id);
RedisKey keyData = Tools.MakeDataKey(instanceDescriptor.Id);
lockId = String.Empty;
if (forChange)
{
while (!LockSession(db, instanceDescriptor.Id, LOCK_TTL_MSEC, out lockId))
{
Console.Write(instanceDescriptor.Id); // waiting for this lock
Thread.Sleep(0);
}
}
if (db.KeyExists(keyData))
{
RedisValue data = db.StringGet(keyData);
return(Tools.DeSerialize <InstanceState>((byte[])data));
}
else
{
return(new InstanceState()
{
Id = instanceDescriptor.Id,
LastResult = 0,
Revision = 0
});
}
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo constructorInfo = typeof(SelfDictionary).GetConstructor(new Type[] { typeof(string) });
InstanceDescriptor instanceDescriptor = new InstanceDescriptor(constructorInfo, new object[] { value });
return(instanceDescriptor);
}
else if (destinationType == typeof(string))
{
StringBuilder sb = new StringBuilder();
foreach (KeyValuePair <string, string> pair in (Dictionary <string, string>)value)
{
if (sb.Length > 0)
{
sb.Append(',');
}
sb.Append(pair.Key + "=" + pair.Value);
}
return(sb.ToString());
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public void CreateInstance(InstanceDescriptor instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
lock (_syncHandle)
{
// Verify instance name is unique
var existingInstance = InstanceManager.Instances[instance.Name];
if (existingInstance != null)
{
throw new InvalidOperationException(String.Format("An instance named {0} already exists on this node.", instance.Name));
}
// TODO: Verify port number is not in use
// Establish server configuration based on instance descriptor
var serverConfig = new ServerConfiguration();
serverConfig.Name = instance.Name;
serverConfig.PortNumber = instance.PortNumber;
serverConfig.ShouldListen = false;
// TODO: Catalog class name
// TODO: Initial device script
// Save instance configuration
InstanceManager.Instances.Add(serverConfig);
InstanceManager.Save();
}
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
InstanceDescriptor id = (value as InstanceDescriptor);
if (id != null)
{
IEnumerator ie = id.Arguments.GetEnumerator();
object[] obj = new object[2];
int i = 0;
while (ie.MoveNext())
{
obj[i++] = ie.Current;
}
return(new UnicodeType((UnicodeIndex)obj[0], (string)obj[1]));
}
string unicodeName = value as string;
if (unicodeName != null)
{
UnicodeView uv = ((UnicodeView)context.Instance);
UnicodeCollection ul = uv.Collection;
return(new UnicodeType(ul[unicodeName]));
}
return(base.ConvertFrom(context, culture, value));
}
public void ConvertTo_TypeDescriptorContext()
{
object o;
o = converter.ConvertTo(context, null, uri, typeof(string));
Assert.AreEqual(url, (o as String), "uri-string");
o = converter.ConvertTo(context, CultureInfo.InvariantCulture, uri, typeof(Uri));
Assert.AreEqual(uri, (o as Uri), "uri-uri");
#if MOBILE
try {
o = converter.ConvertTo(context, CultureInfo.InvariantCulture, url, typeof(string));
Assert.AreEqual(url, (o as String), "string-string");
} catch (NotSupportedException) {
}
#else
o = converter.ConvertTo(context, CultureInfo.InvariantCulture, url, typeof(string));
Assert.AreEqual(url, (o as String), "string-string");
o = converter.ConvertTo(context, CultureInfo.CurrentCulture, uri, typeof(InstanceDescriptor));
Assert.IsTrue(o is InstanceDescriptor, "uri-InstanceDescriptor");
InstanceDescriptor descriptor = (o as InstanceDescriptor);
o = converter.ConvertTo(context, CultureInfo.InvariantCulture, descriptor, typeof(string));
Assert.AreEqual("System.ComponentModel.Design.Serialization.InstanceDescriptor", (o as string), "InstanceDescriptor-string");
#endif
// InstanceDescriptor to Uri or to InstanceDescriptor aren't supported either
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (!CanConvertTo(context, value.GetType()))
{
throw new NotSupportedException(Locale.GetText("Cannot convert from value."));
}
if (value is Uri)
{
return(value);
}
string s = (value as string);
if (s != null)
{
return(new Uri(s, UriKind.RelativeOrAbsolute));
}
InstanceDescriptor id = (value as InstanceDescriptor);
if (id != null)
{
return(id.Invoke());
}
return(base.ConvertFrom(context, culture, value));
}
public static void ConvertFrom_InstanceDescriptor()
{
RemoteExecutorForUap.Invoke(() =>
{
using (new ThreadCultureChange("fr-FR"))
{
DateTime testDateAndTime = DateTime.UtcNow;
ConstructorInfo ctor = typeof(DateTime).GetConstructor(new Type[]
{
typeof(int), typeof(int), typeof(int), typeof(int),
typeof(int), typeof(int), typeof(int)
});
InstanceDescriptor descriptor = new InstanceDescriptor(ctor, new object[]
{
testDateAndTime.Year, testDateAndTime.Month, testDateAndTime.Day, testDateAndTime.Hour,
testDateAndTime.Minute, testDateAndTime.Second, testDateAndTime.Millisecond
});
const string format = "dd MMM yyyy hh:mm";
object o = s_converter.ConvertFrom(descriptor);
Assert.Equal(testDateAndTime.ToString(format), ((DateTime)o).ToString(format));
}
}).Dispose();
}
/// <summary>
/// Creates new instances of <see cref="InstanceDescriptor"/> instances based on the information contained by the supplied <see cref="InstanceDescriptorCreationContext"/>.
/// </summary>
/// <param name="instanceDescriptorCreationContext">The <see cref="InstanceDescriptorCreationContext"/>.</param>
/// <exception cref="ArgumentNullException">The value of '<paramref name="instanceDescriptorCreationContext"/>' cannot be null.</exception>
/// <returns>The newly created <see cref="InstanceDescriptor"/>.</returns>
public InstanceDescriptor CreateInstanceDescriptor(InstanceDescriptorCreationContext instanceDescriptorCreationContext)
{
if (instanceDescriptorCreationContext == null)
{
throw new ArgumentNullException(nameof(instanceDescriptorCreationContext));
}
InstanceDescriptor resultInstanceDescriptor;
if (!instanceDescriptorCreationContext.InstanceRelationStore.TryGetRelated(instanceDescriptorCreationContext.CurrentInstance, out resultInstanceDescriptor))
{
var instanceType = instanceDescriptorCreationContext.CurrentInstance.GetType().TryUnwrapProxiedType();
resultInstanceDescriptor = new InstanceDescriptor(instanceType);
foreach (var propertyInfo in this.propertyReflector.ReflectProperties(instanceDescriptorCreationContext.CurrentInstance))
{
var propertyValueFactory = this.propertyValueFactoryProvider.GetPropertyValueFactory(propertyInfo.PropertyType);
var propertyValue = propertyValueFactory.CreatePropertyValue(instanceDescriptorCreationContext.CreatePropertyValueCreationContext(propertyInfo));
var propertyValueHandler = this.propertyValueHandlerFactory.GetPropertyValueHandler(propertyValue, propertyInfo);
propertyValueHandler.HandlePropertyValue(resultInstanceDescriptor, propertyValue, propertyInfo);
}
this.typeAliasWalker.CreateAliases(resultInstanceDescriptor, instanceDescriptorCreationContext.CurrentInstance.GetType());
instanceDescriptorCreationContext.InstanceRelationStore.CreateRelation(resultInstanceDescriptor, instanceDescriptorCreationContext.CurrentInstance);
}
return(resultInstanceDescriptor);
}
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
InstanceDescriptor id = value as InstanceDescriptor;
if (id != null)
{
IEnumerator ie = id.Arguments.GetEnumerator();
object[] obj = new object[4];
int i = 0;
while (ie.MoveNext())
{
obj[i++] = ie.Current;
}
return(new UnicodeCategory((UnicodeType)obj[0], (string)obj[1], (int)obj[2], (int)obj[3]));
}
string categoryName = value as string;
if (categoryName != null)
{
UnicodeView uv = ((UnicodeView)context.Instance);
UnicodeCollection ul = uv.Collection;
UnicodeCategory cat = ul.GetCategory(categoryName);
return(new UnicodeCategory(cat));
}
return(base.ConvertFrom(context, culture, value));
}
private XmlNode WriteInstanceDescriptor(XmlDocument document, InstanceDescriptor desc, object value)
{
XmlNode node = document.CreateElement("InstanceDescriptor");
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream();
formatter.Serialize(stream, desc.MemberInfo);
XmlAttribute memberAttr = document.CreateAttribute("member");
memberAttr.Value = Convert.ToBase64String(stream.ToArray());
node.Attributes.Append(memberAttr);
foreach (object arg in desc.Arguments)
{
XmlNode argNode = document.CreateElement("Argument");
if (WriteValue(document, arg, argNode))
{
node.AppendChild(argNode);
}
}
if (!desc.IsComplete)
{
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(value, propertyAttributes);
WriteProperties(document, props, value, node, "Property");
}
return(node);
}
protected override void run()
{
InstanceDescriptor inst = CopyPasteManager.Instance.pasteFromBuffer(Descriptor.Level);
inst.X = 0;
inst.Y = 0;
}
/// <summary>
/// Looks for an instance descriptor for the property value's type and then tries to convert
/// the object creation using this instance descriptor.
/// </summary>
static string ConvertTypeToString(object propertyValue)
{
TypeConverter converter = TypeDescriptor.GetConverter(propertyValue);
if (converter.CanConvertTo(typeof(InstanceDescriptor)))
{
InstanceDescriptor instanceDescriptor = converter.ConvertTo(propertyValue, typeof(InstanceDescriptor)) as InstanceDescriptor;
if (instanceDescriptor != null)
{
StringBuilder text = new StringBuilder();
MemberInfo memberInfo = instanceDescriptor.MemberInfo;
string fullName = memberInfo.DeclaringType.FullName.Replace('+', '.'); // Remove any + chars from enums.
text.Append(fullName);
if (memberInfo.MemberType != MemberTypes.Constructor)
{
text.Append('.');
text.Append(memberInfo.Name);
}
// Append arguments.
AppendArguments(text, instanceDescriptor.Arguments);
return(text.ToString());
}
}
return(converter.ConvertToString(null, CultureInfo.InvariantCulture, propertyValue));
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
object conversion = null;
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
BasicComponent component = value as BasicComponent;
if (basicComponent != null)
{
if (destinationType == typeof(InstanceDescriptor))
{
// Note that we convert the blobs to an array as this makes for nicer persisted code output.
// Without it, we might just get a resource blob which is not human-readable.
conversion = new InstanceDescriptor(
typeof(BasicComponent).GetConstructor(new Type[] { typeof(IEnumerable<Blob>) }),
new object[] { basicComponent.Blobs.ToArray() },
true);
}
}
if (conversion == null)
{
conversion = base.ConvertTo(context, culture, value, destinationType);
}
return conversion;
}
public void TableLayoutPanelCellPosition_ConverterConvertTo_InstanceDescriptor_ReturnsExpected()
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(new TableLayoutPanelCellPosition(1, 2), typeof(InstanceDescriptor)));
Assert.Equal(typeof(TableLayoutPanelCellPosition).GetConstructor(new Type[] { typeof(int), typeof(int) }), descriptor.MemberInfo);
Assert.Equal(new object[] { 1, 2 }, descriptor.Arguments);
}
public void ListViewItemConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ListViewItem value, Type[] parameterTypes, object[] arguments)
{
var converter = new ListViewItemConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
Assert.Equal(typeof(ListViewItem).GetConstructor(parameterTypes), descriptor.MemberInfo);
Assert.Equal(arguments, descriptor.Arguments);
}
public void TableLayoutStyle_ConverterConvertTo_InstanceDescriptorRowAbsolutePercent_ReturnsExpected(object value, ConstructorInfo expectedConstructor, object[] expectedArguments)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
Assert.Equal(expectedConstructor, descriptor.MemberInfo);
Assert.Equal(expectedArguments, descriptor.Arguments);
}
public void PaddingConverter_ConvertTo_InstanceDescriptor_ReturnsExpected()
{
var converter = new PaddingConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(new Padding(1, 2, 3, 4), typeof(InstanceDescriptor)));
Assert.Equal(typeof(Padding).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) }), descriptor.MemberInfo);
Assert.Equal(new object[] { 1, 2, 3, 4 }, descriptor.Arguments);
}
public void LinkAreaConverter_ConvertTo_InstanceDescriptor_ReturnsExpected()
{
var converter = new LinkArea.LinkAreaConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(new LinkArea(1, 2), typeof(InstanceDescriptor)));
Assert.Equal(typeof(LinkArea).GetConstructor(new Type[] { typeof(int), typeof(int) }), descriptor.MemberInfo);
Assert.Equal(new object[] { 1, 2 }, descriptor.Arguments);
}
public void ColumnHeaderConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ColumnHeader value, Type[] parameterTypes, object[] arguments)
{
var converter = new ColumnHeaderConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
Assert.Equal(value.GetType().GetConstructor(parameterTypes), descriptor.MemberInfo);
Assert.Equal(arguments, descriptor.Arguments);
}
/// <summary>
/// Convert to a specified type
/// </summary>
public override object ConvertTo(
ITypeDescriptorContext context,
CultureInfo culture, object value,
Type destinationType
)
{
object retVal = null;
var v = (__TVector__)value;
// If this is an instance descriptor...
if (destinationType == typeof(InstanceDescriptor))
{
var argTypes = new System.Type[__Dim__];
//# for (int i = 0; i < Dim; i++) {
argTypes[__i__] = typeof(__TPrimitive__);
//# }
// Lookup the appropriate $TVector$ constructor
ConstructorInfo constructor = typeof(__TVector__).GetConstructor(argTypes);
var arguments = new object[__Dim__];
//# for (int i = 0; i < Dim; i++) {
arguments[__i__] = v[__i__];
//# }
// And return an instance descriptor to the caller.
// Will fill in the CodeBehind stuff in VS.Net
retVal = new InstanceDescriptor(constructor, arguments);
}
else if (destinationType == typeof(string))
{
// If it's a string, return one to the caller
if (null == culture)
{
culture = CultureInfo.CurrentCulture;
}
var values = new string[__Dim__];
// I'm a bit of a culture vulture - do it properly!
TypeConverter numberConverter =
TypeDescriptor.GetConverter(typeof(__TPrimitive__));
//# for (int i = 0; i < Dim; i++) {
values[__i__] = numberConverter.ConvertToString(context, culture, v[__i__]);
//# }
// A useful method - join an array of strings using a separator, in this instance the culture specific one
retVal = String.Join(culture.TextInfo.ListSeparator + " ", values);
}
else
{
retVal = base.ConvertTo(context, culture, value, destinationType);
}
return(retVal);
}
public void copyToBuffer(InstanceDescriptor inst)
{
//instanceBuffer = inst;
if (inst != null)
{
instanceBuffer = inst.clone(objects);
objects.updateAll();
}
}
public void Constructor_Null_ICollection()
{
InstanceDescriptor id = new InstanceDescriptor(null, new object[] { });
Assert.AreEqual(0, id.Arguments.Count, "#1");
Assert.IsTrue(id.IsComplete, "#2");
Assert.IsNull(id.MemberInfo, "#3");
Assert.IsNull(id.Invoke(), "#4");
}
/// <summary>
/// Initializes a new instance of the <see cref="InstanceCollectionItemAssociation"/> class.
/// </summary>
/// <param name="instanceDescriptor">The <see cref="InstanceDescriptor"/>.</param>
internal InstanceCollectionItemAssociation([NotNull] InstanceDescriptor instanceDescriptor)
{
if (instanceDescriptor == null)
{
throw new ArgumentNullException(nameof(instanceDescriptor));
}
this.Instance = instanceDescriptor;
}
public void clearBuffer()
{
if (instanceBuffer != null)
{
objects.removeObject(instanceBuffer);
objects.updateAll();
}
instanceBuffer = null;
}
public void LinkConverter_ConvertTo_InstanceDescriptorWithLinkData_ReturnsExpected()
{
var converter = new LinkConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(new LinkLabel.Link(1, 2, "linkData"), typeof(InstanceDescriptor)));
Assert.Equal(typeof(LinkLabel.Link).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(object) }), descriptor.MemberInfo);
Assert.Equal(new object[] { 1, 2, "linkData" }, descriptor.Arguments);
Assert.True(descriptor.IsComplete);
}
/// <summary>
/// Gets the instance descriptor.
/// </summary>
/// <param name="engineInstance">The engine instance.</param>
/// <returns></returns>
private InstanceDescriptor GetInstanceDescriptor(IEngineInstance engineInstance)
{
if (engineInstance == null) {
return null;
}
InstanceDescriptor instanceDescriptor = new InstanceDescriptor();
instanceDescriptor.Id = engineInstance.Id;
instanceDescriptor.Name = engineInstance.Name;
instanceDescriptor.DataPublicationEndpoints = engineInstance.DataPublicationEndpoints.ToArray();
return instanceDescriptor;
}