public PropertyBaseClipboardFormat(PropertyBase property)
: base(property)
{
_propertyName = property.LocalName.Value;
_setter = property.Setter.IsDefaulted ? String.Empty : property.Setter.Value;
_getter = property.Getter.IsDefaulted ? String.Empty : property.Getter.Value;
ValidateAttributes(property);
}
private void ValidateAttributes(PropertyBase property)
{
#if DEBUG
ICollection<string> attributesCollection = new List<string>();
foreach (var propertyInfo in GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
{
var attributes =
propertyInfo.GetCustomAttributes(typeof(ClipboardPropertyMapAttribute), false) as ClipboardPropertyMapAttribute[];
if (attributes != null
&& attributes.Length > 0)
{
Debug.Assert(
attributes.Length == 1,
String.Format(
CultureInfo.CurrentCulture, "There exist more than 1 instance of {0} for {1}", "ClipboardPropertyMapAttribute",
propertyInfo.Name));
Debug.Assert(
!attributes[0].IsExcluded,
String.Format(CultureInfo.CurrentCulture, "Attribute {0} is misplaced.", attributes[0].AttributeName));
attributesCollection.Add(attributes[0].AttributeName);
}
}
var excludedAttributes =
GetType().GetCustomAttributes(typeof(ClipboardPropertyMapAttribute), false) as ClipboardPropertyMapAttribute[];
if (excludedAttributes != null)
{
foreach (var excludedAttribute in excludedAttributes)
{
Debug.Assert(
excludedAttribute.IsExcluded,
String.Format(CultureInfo.CurrentCulture, "Attribute {0} is misplaced.", excludedAttribute.AttributeName));
attributesCollection.Add(excludedAttribute.AttributeName);
}
}
foreach (var attributeName in property.MyAttributeNames())
{
Debug.Assert(
attributesCollection.Contains(attributeName),
String.Format(CultureInfo.CurrentCulture, "Clipboard format for {0} does not exist", attributeName));
}
#endif
}
/// <summary>
/// Return the number of steps in which the property will be moved.
/// The logic is to return the Math.Min of the # of steps passed in to the command and the # of steps from the property to the previously moved property.
/// If previously moved property is null, just return the # of steps passed in to the command.
/// </summary>
/// <param name="property"></param>
/// <param name="previouslyMovedProperty"></param>
/// <returns></returns>
private uint GetNumberOfMoveStep(PropertyBase property, PropertyBase previouslyMovedProperty)
{
if (previouslyMovedProperty == null)
{
return _step;
}
uint numberOfSteps = 0;
var insertLocation = _moveDirection == MoveDirection.Up
? property.PreviousSiblingInPropertyXElementOrder
: property.NextSiblingInPropertyXElementOrder;
for (; numberOfSteps < _step && insertLocation != null && insertLocation != previouslyMovedProperty; numberOfSteps++)
{
insertLocation = _moveDirection == MoveDirection.Up
? insertLocation.PreviousSiblingInPropertyXElementOrder
: insertLocation.NextSiblingInPropertyXElementOrder;
}
return numberOfSteps;
}
/// <summary>
/// Return the number of steps in which the property will be moved.
/// The logic is to return the Math.Min of the # of steps passed in to the command and the # of steps from the property to the previously moved property.
/// If previously moved property is null, just return the # of steps passed in to the command.
/// </summary>
/// <param name="property"></param>
/// <param name="previouslyMovedProperty"></param>
/// <returns></returns>
private uint GetNumberOfMoveStep(PropertyBase property, PropertyBase previouslyMovedProperty)
{
if (previouslyMovedProperty == null)
{
return(_step);
}
uint numberOfSteps = 0;
var insertLocation = _moveDirection == MoveDirection.Up
? property.PreviousSiblingInPropertyXElementOrder
: property.NextSiblingInPropertyXElementOrder;
for (; numberOfSteps < _step && insertLocation != null && insertLocation != previouslyMovedProperty; numberOfSteps++)
{
insertLocation = _moveDirection == MoveDirection.Up
? insertLocation.PreviousSiblingInPropertyXElementOrder
: insertLocation.NextSiblingInPropertyXElementOrder;
}
return(numberOfSteps);
}
public bool IsDefaultValue(IBusinessObject obj, PropertyBase property)
{
var domainObject = ArgumentUtility.CheckNotNullAndType <IDomainObject> ("obj", obj);
ArgumentUtility.CheckNotNull("property", property);
if (domainObject.GetState() != StateType.New)
{
return(false);
}
var propertyDefinition = domainObject.ID.ClassDefinition.ResolveProperty(property.PropertyInfo);
if (propertyDefinition != null)
{
var properties = new PropertyIndexer(domainObject);
return(!properties[propertyDefinition.PropertyName].HasBeenTouched);
}
return(_innerDefaultValueStrategy.IsDefaultValue(obj, property));
}
public void CullDisassociatedProperties()
{
for (int index = this.basicProperties.Count - 1; index >= 0; --index)
{
PropertyBase propertyBase = (PropertyBase)this.basicProperties[index];
if (!propertyBase.Associated && propertyBase.RemoveFromCategoryWhenDisassociated)
{
propertyBase.OnRemoveFromCategory();
this.basicProperties.RemoveAt(index);
}
}
for (int index = this.advancedProperties.Count - 1; index >= 0; --index)
{
PropertyBase propertyBase = (PropertyBase)this.advancedProperties[index];
if (!propertyBase.Associated && propertyBase.RemoveFromCategoryWhenDisassociated)
{
propertyBase.OnRemoveFromCategory();
this.advancedProperties.RemoveAt(index);
}
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual bool CanSetField(string?fieldName, ConfigurationSource?configurationSource)
{
if (configurationSource.Overrides(Metadata.GetFieldInfoConfigurationSource()))
{
if (fieldName == null)
{
return(true);
}
var fieldInfo = PropertyBase.GetFieldInfo(
fieldName, Metadata.DeclaringType, Metadata.Name,
shouldThrow: configurationSource == ConfigurationSource.Explicit);
return(fieldInfo != null &&
PropertyBase.IsCompatible(
fieldInfo, Metadata.ClrType, Metadata.DeclaringType.ClrType, Metadata.Name,
shouldThrow: configurationSource == ConfigurationSource.Explicit));
}
return(Metadata.FieldInfo?.GetSimpleMemberName() == fieldName);
}
// is the property key a textCode?
private bool IsKeyMatchProperty(PropertyBase property, string key, TextCode tcKey)
{
PropertyKeyTextCode keyTextCode = property.Key as PropertyKeyTextCode;
if (keyTextCode != null)
{
if (tcKey != null)
{
// the key to find is a TextCode
if (keyTextCode.TextCodeId.Equals(tcKey.Id))
{
return(true);
}
}
else
{
// the property key is a textCode, load it to get the code, because the key is a string
TextCode tcPropKey = _reposit.Finder.FindTextCodeById(keyTextCode.TextCodeId);
if (tcPropKey.Code.Equals(key))
{
return(true);
}
}
}
// is the property key a string?
PropertyKeyString keyString = property.Key as PropertyKeyString;
if (keyString != null)
{
// compare strings
if (keyString.Key.Equals(key))
{
return(true);
}
}
// the property doesn't match the key (string or TextCode)
return(false);
}
public void EntOneProp_KTextCode_VTextCode()
{
EtagairCore core = Common.CreateCore(RepositConfig);
TextCode tcKeyType = core.Editor.CreateTextCode("Type");
TextCode tcValueType = core.Editor.CreateTextCode("Computer");
// create an entity template to instantiate
EntityTempl templComputer = core.EditorTempl.CreateEntityTempl("TemplComputer");
// add property
core.EditorTempl.CreatePropTempl(templComputer, tcKeyType, tcValueType);
//====Instanciate the template, create an entity, under the root folder
EntityTemplToInst templToInst = core.ProcessTempl.CreateEntity(templComputer);
// check that the execution finishes with success
Assert.AreEqual(TemplToInstState.Success, templToInst.State, "the state should be sucess");
Assert.AreEqual(TemplToInstStep.Ends, templToInst.NextStep, "the next step should be ends");
// check, get the property: Type=Computer
PropertyBase propBase = core.Searcher.FindPropertyByKey(templToInst.Entity, templToInst.Entity.PropertyRoot, "Type", false);
Assert.IsNotNull(propBase, "the propBase Type=Computer should exists");
Property prop = propBase as Property;
Assert.IsNotNull(prop, "the prop Type=Computer should exists");
//----check the prop key
PropertyKeyTextCode propKeyTextCode = prop.Key as PropertyKeyTextCode;
Assert.IsNotNull(propKeyTextCode, "the prop key string Type should exists");
Assert.AreEqual(tcKeyType.Id, propKeyTextCode.TextCodeId, "the prop value should be the textCode id of the text Name");
//----check the prop value
ValTextCodeId propValueTextCode = prop.Value as ValTextCodeId;
Assert.IsNotNull(propValueTextCode, "the prop key string Typeshould exists");
Assert.AreEqual(tcValueType.Id, propValueTextCode.TextCodeId, "the prop value should be the textCode id of text Toshiba");
}
private bool PropertyBase_ReadPropertiesFromAttributes(SerializationContext serializationContext,
PropertyBase propertyBase, XmlReader reader)
{
// Access
if (!serializationContext.Result.Failed)
{
string attribAccess = DONetEntityModelDesignerSerializationHelper.Instance.ReadAttribute(serializationContext, propertyBase, reader, "access");
if (attribAccess != null)
{
AccessModifier valueOfAccess;
if (SerializationUtilities.TryGetValue <AccessModifier>(serializationContext, attribAccess, out valueOfAccess))
{
propertyBase.PropertyAccess = new PropertyAccessModifiers();
PropertyAccessModifier modifier = valueOfAccess == AccessModifier.Public
? PropertyAccessModifier.Public
: PropertyAccessModifier.Internal;
propertyBase.PropertyAccess.Getter = modifier;
propertyBase.PropertyAccess.Setter = modifier;
return(true);
}
else
{ // Invalid property value, ignored.
EntityModelDesignerSerializationBehaviorSerializationMessages.IgnoredPropertyValue(serializationContext, reader, "access", typeof(AccessModifier), attribAccess);
}
}
else
{
propertyBase.PropertyAccess = new PropertyAccessModifiers();
propertyBase.PropertyAccess.Getter = PropertyAccessModifier.Public;
propertyBase.PropertyAccess.Setter = PropertyAccessModifier.Public;
return(false);
}
}
return(false);
}
public void EntOneProp_KString_VString()
{
EtagairCore core = Common.CreateCore(RepositConfig);
// create an entity template to instantiate
EntityTempl templComputer = core.EditorTempl.CreateEntityTempl("TemplComputer");
// add property
core.EditorTempl.CreatePropTempl(templComputer, "Type", "Computer");
//====Instanciate the template, create an entity, under the root folder
EntityTemplToInst templToInst = core.ProcessTempl.CreateEntity(templComputer);
//====check that the execution finishes with success
Assert.AreEqual(TemplToInstState.Success, templToInst.State, "the state should be sucess");
Assert.AreEqual(TemplToInstStep.Ends, templToInst.NextStep, "the next step should be ends");
// check, get the property: Type=Computer
PropertyBase propBase = core.Searcher.FindPropertyByKey(templToInst.Entity, templToInst.Entity.PropertyRoot, "Type", false);
Assert.IsNotNull(propBase, "the propBase Type=Computer should exists");
Property prop = propBase as Property;
Assert.IsNotNull(prop, "the prop Type=Computer should exists");
// check the key prop
PropertyKeyString propKeyString = prop.Key as PropertyKeyString;
Assert.IsNotNull(propKeyString, "the prop key string Type should exists");
Assert.AreEqual("Type", propKeyString.Key, "the key should be Type");
// check the prop value
//PropertyValueString propValueString = prop.Value as PropertyValueString;
ValString propValueString = prop.Value as ValString;
Assert.IsNotNull(propValueString, "the prop key string Typeshould exists");
Assert.AreEqual("Computer", propValueString.Value, "the value should be Computer");
}
///--------------------------------------------------------------------------------
/// <summary>This method adds this item to the parent, if not found.</summary>
///--------------------------------------------------------------------------------
public void AddToParent()
{
PropertyBase propertyBase = Solution.PropertyBaseList.Find(i => i.PropertyID == PropertyID);
if (propertyBase != null)
{
PropertyBase = propertyBase;
SetID(); // id (from saved ids) may change based on parent info
PropertyRelationship propertyRelationship = propertyBase.PropertyRelationshipList.Find(i => i.PropertyRelationshipID == PropertyRelationshipID);
if (propertyRelationship != null)
{
if (propertyRelationship != this)
{
propertyBase.PropertyRelationshipList.Remove(propertyRelationship);
propertyBase.PropertyRelationshipList.Add(this);
}
}
else
{
propertyBase.PropertyRelationshipList.Add(this);
}
}
}
private void UnPackProperty(ByteBuffer buf)
{
if (buf.ReadableBytes() < 2)
{
return;
}
int index = buf.ReadUshort();
if (index == MESSAGE_OVER_MASK)
{
return;
}
if (index < 0 || index >= properties.Count)
{
throw new Exception("proto index is invalid->" + index);
}
PropertyBase pb = properties[index];
pb.UnPack(buf);
UnPackProperty(buf);
}
public bool IsPropertyAccessException(
IBusinessObject businessObject,
PropertyBase bindableProperty,
Exception exception,
out BusinessObjectPropertyAccessException propertyAccessException)
{
ArgumentUtility.DebugCheckNotNull("businessObject", businessObject);
ArgumentUtility.DebugCheckNotNull("bindableProperty", bindableProperty);
ArgumentUtility.DebugCheckNotNull("exception", exception);
// This section does represent an inherrent hot-path but the for-loop is chosen for symmetry with the CanRead()-method.
// ReSharper disable once ForCanBeConvertedToForeach
for (int i = 0; i < _bindablePropertyReadAccessStrategies.Length; i++)
{
var bindablePropertyReadAccessStrategy = _bindablePropertyReadAccessStrategies[i];
if (bindablePropertyReadAccessStrategy.IsPropertyAccessException(businessObject, bindableProperty, exception, out propertyAccessException))
{
return(true);
}
}
propertyAccessException = null;
return(false);
}
///--------------------------------------------------------------------------------
/// <summary>This method gets the current model context for the item.</summary>
///
/// <param name="parentModelContext">The parent model context from which to get current model context.</param>
/// <param name="isValidContext">Output flag, signifying whether context returned is a valid one.</param>
///--------------------------------------------------------------------------------
public static IDomainEnterpriseObject GetModelContext(Solution solutionContext, IDomainEnterpriseObject parentModelContext, out bool isValidContext)
{
isValidContext = true;
IDomainEnterpriseObject modelContext = parentModelContext;
while (modelContext != null)
{
if (modelContext is PropertyRelationship)
{
return(modelContext);
}
else if (solutionContext.IsSampleMode == true && solutionContext.NeedsSample == true && modelContext is PropertyBase)
{
solutionContext.NeedsSample = false;
PropertyBase parent = modelContext as PropertyBase;
if (parent.PropertyRelationshipList.Count > 0)
{
return(parent.PropertyRelationshipList[DataHelper.GetRandomInt(0, parent.PropertyRelationshipList.Count - 1)]);
}
}
#region protected
#endregion protected
if (modelContext is Solution)
{
break;
}
modelContext = modelContext.GetParentItem();
}
if (solutionContext.IsSampleMode == true && solutionContext.NeedsSample == true && solutionContext.PropertyRelationshipList.Count > 0)
{
solutionContext.NeedsSample = false;
return(solutionContext.PropertyRelationshipList[DataHelper.GetRandomInt(0, solutionContext.PropertyRelationshipList.Count - 1)]);
}
isValidContext = false;
return(null);
}
/// <summary>Creates service definition that can be registered with a server</summary>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static grpc::ServerServiceDefinition BindService(PropertyBase serviceImpl)
{
return(grpc::ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_GetDetail, serviceImpl.GetDetail)
.AddMethod(__Method_GetDetailByName, serviceImpl.GetDetailByName).Build());
}
/// <summary> /// Tries the parse value. /// </summary> /// <param name="logger">The logger.</param> /// <param name="item">The item.</param> /// <param name="entry">The entry.</param> /// <param name="value">The value.</param> /// <param name="accountDisabled">if set to <c>true</c> [account disabled].</param> /// <param name="attr">The attribute.</param> /// <returns></returns> protected virtual bool TryParseValue(PropertyBase item, CsvRow entry, string value, bool accountDisabled, DirectoryAttribute attr, SearchResultEntry sre) => false;
public DatabaseProperty(PropertyBase propertyBase)
{
Name = propertyBase.Name ?? "default";
Type = DatabaseType.GetOrAdd(propertyBase.Type);
}
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public static bool IsIndexerProperty(this PropertyBase propertyBase) => ((IReadOnlyPropertyBase)propertyBase).IsIndexerProperty();
protected void Add(PropertyBase property)
{
property.OnValueChanged += OnPropertyValueChanged;
properties.Add(property);
}
/// <summary>
/// Given a DSL Property return the previous sibling.
/// The method will do the following:
/// - Given the DSL Property get its model property from Model XRef.
/// - Loop model property's previous siblings.
/// - For each model property's previous sibling, get the corresponding DSL property from Model XRef.
/// - If the DSL property is not null, return immediately.
/// - If the DSL property is null, check its previous sibling.
/// </summary>
/// <param name="property"></param>
/// <returns></returns>
private PropertyBase FindPreviousProperty(PropertyBase property)
{
var modelProperty = ModelXRef.GetExisting(property) as Model.Entity.PropertyBase;
Debug.Assert(modelProperty != null, "Unable to get Entity Designer Model for :" + property.Name + " from model xref.");
if (modelProperty != null)
{
var previousModelProperty = modelProperty.PreviousSiblingInPropertyXElementOrder;
while (previousModelProperty != null)
{
var previousProperty = ModelXRef.GetExisting(previousModelProperty) as PropertyBase;
if (previousProperty != null)
{
return previousProperty;
}
previousModelProperty = previousModelProperty.PreviousSiblingInPropertyXElementOrder;
}
}
return null;
}
private static Func <IUpdateEntry, TProperty> CreateCurrentValueGetter <TProperty>(
IPropertyBase propertyBase,
bool useStoreGeneratedValues)
{
var entityClrType = propertyBase.DeclaringType.ClrType;
var updateParameter = Expression.Parameter(typeof(IUpdateEntry), "entry");
var entryParameter = Expression.Convert(updateParameter, typeof(InternalEntityEntry));
var shadowIndex = propertyBase.GetShadowIndex();
Expression currentValueExpression;
if (shadowIndex >= 0)
{
currentValueExpression = Expression.Call(
entryParameter,
InternalEntityEntry.ReadShadowValueMethod.MakeGenericMethod(typeof(TProperty)),
Expression.Constant(shadowIndex));
}
else
{
var convertedExpression = Expression.Convert(
Expression.Property(entryParameter, "Entity"),
entityClrType);
var memberInfo = propertyBase.GetMemberInfo(forMaterialization: false, forSet: false);
currentValueExpression = PropertyBase.CreateMemberAccess(propertyBase, convertedExpression, memberInfo);
if (currentValueExpression.Type != typeof(TProperty))
{
currentValueExpression = Expression.Condition(
currentValueExpression.MakeHasDefaultValue(propertyBase),
Expression.Constant(default(TProperty), typeof(TProperty)),
Expression.Convert(currentValueExpression, typeof(TProperty)));
}
}
var storeGeneratedIndex = propertyBase.GetStoreGeneratedIndex();
if (storeGeneratedIndex >= 0)
{
if (useStoreGeneratedValues)
{
currentValueExpression = Expression.Condition(
Expression.Equal(
currentValueExpression,
Expression.Constant(default(TProperty), typeof(TProperty))),
Expression.Call(
entryParameter,
InternalEntityEntry.ReadStoreGeneratedValueMethod.MakeGenericMethod(typeof(TProperty)),
Expression.Constant(storeGeneratedIndex)),
currentValueExpression);
}
currentValueExpression = Expression.Condition(
Expression.Equal(
currentValueExpression,
Expression.Constant(default(TProperty), typeof(TProperty))),
Expression.Call(
entryParameter,
InternalEntityEntry.ReadTemporaryValueMethod.MakeGenericMethod(typeof(TProperty)),
Expression.Constant(storeGeneratedIndex)),
currentValueExpression);
}
return(Expression.Lambda <Func <IUpdateEntry, TProperty> >(
currentValueExpression,
updateParameter)
.Compile());
}
public SaveWindow(Gwen.Controls.ControlBase parent, MainWindow glgame) : base(parent, "Save Track")
{
game = glgame;
game.Track.Stop();
MakeModal(true);
Label l = new Label(this);
l.Text = "Tracks are saved to\r\nDocuments/LRA/Tracks";
var bottom = new PropertyBase(this)
{
Name = "bottom", Margin = new Margin(0, 10, 0, 5), Height = 30
};
var cb = new ComboBox(this);
cb.ItemSelected += (o, e) =>
{
var snd = ((ComboBox)o);
var txt = snd.SelectedItem.Text;
this.UserData = txt;
};
var tb = new TextBox(bottom)
{
Name = "tb"
};
tb.Dock = Pos.Left;
bottom.Dock = Pos.Bottom;
cb.Dock = Pos.Bottom;
cb.Margin = new Margin(0, 0, 0, 0);
this.Width = 200;
this.Height = 130;
var dir = Program.UserDirectory + "Tracks";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var folders = Directory.GetDirectories(Program.UserDirectory + "Tracks");
cb.AddItem("<create new track>"); //< used as it cant be used as a file character
cb.SelectByText("<create new track>");
foreach (var folder in folders)
{
var trackname = Path.GetFileName(folder);
if (trackname != Utils.Constants.DefaultTrackName)
{
cb.AddItem(trackname);
}
}
cb.SelectByText(game.Track.Name);
var btn = new Button(bottom)
{
Name = "savebtn"
};
btn.Width = 50;
btn.Text = "Save";
btn.Dock = Pos.Right;
btn.Clicked += savebtn_Clicked;
DisableResizing();
game.Cursor = game.Cursors["default"];
}
public override bool ValueEquals(PropertyBase <char> other) => other.Value == Value;
/// <summary>
/// Find a property by the key "raw" string (can be a textCode).
/// From a property parent.
/// </summary>
/// <param name="entity"></param>
/// <param name="key"></param>
/// <returns></returns>
public PropertyBase FindPropertyByKey(Entity entity, PropertyGroup propertyParent, string key, bool goInsideChilds)
{
if (entity == null)
{
return(null);
}
if (propertyParent == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(key))
{
return(null);
}
// load the textCode of the key, if exists
TextCode tcKey = _reposit.Finder.FindTextCodeByCode(key);
List <PropertyGroup> listPropGroup = new List <PropertyGroup>();
// the key can be a string or a textCode
foreach (var propertyBase in propertyParent.ListProperty)
{
// is it a final property?
Property property = propertyBase as Property;
if (property != null)
{
// is the property key a textCode?
if (IsKeyMatchProperty(property, key, tcKey))
{
return(property);
}
// next property
continue;
}
// is it a group property?
PropertyGroup propertyGroup = propertyBase as PropertyGroup;
if (propertyGroup != null)
{
// is the property key a textCode?
if (IsKeyMatchProperty(propertyGroup, key, tcKey))
{
return(propertyGroup);
}
// save the prop Group
listPropGroup.Add(propertyGroup);
// next property
continue;
}
}
if (!goInsideChilds)
{
// not found
return(null);
}
// now scan props in childs
foreach (PropertyGroup propertyGroup in listPropGroup)
{
PropertyBase propFound = FindPropertyByKey(entity, propertyGroup, key, goInsideChilds);
if (propFound != null)
{
return(propFound);
}
}
// not found
return(null);
}
/// <summary>Register service method with a service binder with or without implementation. Useful when customizing the service binding logic.
/// Note: this method is part of an experimental API that can change or be removed without any prior notice.</summary>
/// <param name="serviceBinder">Service methods will be bound by calling <c>AddMethod</c> on this object.</param>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static void BindService(grpc::ServiceBinderBase serviceBinder, PropertyBase serviceImpl)
{
serviceBinder.AddMethod(__Method_GetDetail, serviceImpl == null ? null : new grpc::UnaryServerMethod <global::LocationProxy.Point, global::LocationProxy.Detail>(serviceImpl.GetDetail));
serviceBinder.AddMethod(__Method_GetDetailByName, serviceImpl == null ? null : new grpc::UnaryServerMethod <global::LocationProxy.DetailRequest, global::LocationProxy.Detail>(serviceImpl.GetDetailByName));
}
public PropertySerializationModel(PropertyBase baseProperty)
{
this.Name = baseProperty.Name;
this.Type = TypeSerializationModel.GetOrAdd(baseProperty.Type);
}
internal MovePropertyCommand(PropertyBase property, MoveDirection dir, uint step)
{
_property = property;
_moveDirection = dir;
_step = step;
}
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public static bool IsShadowProperty(this PropertyBase propertyBase) => ((IReadOnlyPropertyBase)propertyBase).IsShadowProperty();
public UIRelatedProperty(IUIType parentType, PropertyBase property)
: base(parentType, property)
{
}
public string PropertyOutputTypeName(PropertyBase property) => OutputTypeName(property.Type);
public string PropertyFieldName(PropertyBase property)
{
return("_" + Utils.PascalCaseToCamelCase(property.Name));
}
public static string GetFullyQualifiedName(PropertyBase propertyBase)
{
var qName = propertyBase.QName;
return qName.Namespace + "#" + qName.Name;
}
public string DefaultValue(PropertyBase property)
{
ITypeSymbol propertyType = property.Type;
string typeFullName = Utils.GetTypeFullName(propertyType);
if (property.SpecifiedDefaultValue != null)
{
TypedConstant specifiedDefaultValue = property.SpecifiedDefaultValue.Value;
if (specifiedDefaultValue.IsNull)
{
return("null");
}
var kind = specifiedDefaultValue.Kind;
object value = specifiedDefaultValue.Value !;
if (kind == TypedConstantKind.Primitive)
{
if (value is string stringArgumentValue)
{
if (typeFullName == "Microsoft.StandardUI.Point" && stringArgumentValue == "0.5,0.5")
{
return($"{OutputTypeName(propertyType)}.CenterDefault");
}
else if (stringArgumentValue == "")
{
return("\"\"");
}
else
{
new UserViewableException($"Unknown string literal based default value: {stringArgumentValue}");
}
}
else if (value is double doubleArgumentValue)
{
if (double.IsPositiveInfinity(doubleArgumentValue))
{
return("double.PositiveInfinity");
}
else if (double.IsNegativeInfinity(doubleArgumentValue))
{
return("double.NegativeInfinity");
}
else if (double.IsNaN(doubleArgumentValue))
{
return("double.NaN");
}
else if (doubleArgumentValue - Math.Truncate(doubleArgumentValue) == 0)
{
return(doubleArgumentValue.ToString("F1", CultureInfo.InvariantCulture));
}
else
{
return(doubleArgumentValue.ToString(CultureInfo.InvariantCulture));
}
}
else if (value is int intArgumentValue)
{
return(intArgumentValue.ToString(CultureInfo.InvariantCulture));
}
else if (value is bool boolArgumentValue)
{
return(boolArgumentValue ? "true" : "false");
}
throw new UserViewableException($"{property.FullPropertyName} default value {value.ToString()} not yet supported");
}
else if (kind == TypedConstantKind.Enum)
{
object enumValue = value;
ITypeSymbol type = specifiedDefaultValue.Type !;
ImmutableArray <ISymbol> enumMembers = type.GetMembers();
foreach (IFieldSymbol enumFieldMember in enumMembers)
{
object?enumFieldValue = enumFieldMember.ConstantValue;
if (enumFieldValue != null && enumFieldValue.Equals(value))
{
return($"{type.Name}.{enumFieldMember.Name}");
}
}
throw new UserViewableException($"No symbol found in enum {type.Name} for value {enumValue}");
}
// TODO: add explicit checks for different expression types
return(value.ToString());
// throw new UserViewableException($"Default value type {argument} not yet supported");
}
if (typeFullName == "System.Collections.Generic.IEnumerable")
{
return("null");
}
if (Utils.IsUICollectionType(propertyType))
{
return("null");
}
if (typeFullName == "Microsoft.StandardUI.Color" ||
typeFullName == "Microsoft.StandardUI.Point" ||
typeFullName == "Microsoft.StandardUI.Points" ||
typeFullName == "Microsoft.StandardUI.Size" ||
typeFullName == "Microsoft.StandardUI.Thickness" ||
typeFullName == "Microsoft.StandardUI.CornerRadius" ||
typeFullName == "Microsoft.StandardUI.Text.FontWeight" ||
typeFullName == "Microsoft.StandardUI.GridLength")
{
return($"{GetTypeNameWrapIfNeeded(propertyType)}.Default");
}
if (typeFullName == "Microsoft.StandardUI.Media.FontFamily")
{
return(FontFamilyDefaultValue);
}
// TODO: Implement this
#if false
else if (propertyType is IArrayTypeSymbol arrayTypeSymbol)
{
return
(InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("Array"),
GenericName(
Identifier("Empty"))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(arrayType.ElementType))))));
}
#endif
throw new UserViewableException($"Property {property.FullPropertyName} has no [DefaultValue] attribute nor hardcoded default");
}
static XmlCompleteValidator()
{
XmlCompleteValidator._documentSpecNameProperty = new DocumentSpecName();
}
internal MovePropertyCommand(PropertyBase property, MoveDirection dir, uint step)
{
_property = property;
_moveDirection = dir;
_step = step;
}
