public override Collection <PSAdaptedProperty> GetProperties(object baseObject) { CimInstance cimInstance = baseObject as CimInstance; if (cimInstance == null) { throw new PSInvalidOperationException(string.Format(CultureInfo.InvariantCulture, CimInstanceTypeAdapterResources.BaseObjectNotCimInstance, new object[] { "baseObject", typeof(CimInstance).ToString() })); } Collection <PSAdaptedProperty> collection = new Collection <PSAdaptedProperty>(); if (cimInstance.CimInstanceProperties != null) { foreach (CimProperty property in cimInstance.CimInstanceProperties) { PSAdaptedProperty cimPropertyAdapter = GetCimPropertyAdapter(property, baseObject); if (cimPropertyAdapter != null) { collection.Add(cimPropertyAdapter); } } } PSAdaptedProperty pSComputerNameAdapter = GetPSComputerNameAdapter(cimInstance); if (pSComputerNameAdapter != null) { collection.Add(pSComputerNameAdapter); } return(collection); }
public override void SetPropertyValue(PSAdaptedProperty adaptedProperty, object value) { if (adaptedProperty == null) { throw new ArgumentNullException("adaptedProperty"); } if (!this.IsSettable(adaptedProperty)) { throw new SetValueException("ReadOnlyCIMProperty", null, CimInstanceTypeAdapterResources.ReadOnlyCIMProperty, new object[] { adaptedProperty.Name }); } CimProperty tag = adaptedProperty.Tag as CimProperty; object obj2 = value; if (obj2 != null) { Type dotNetType; CimType cimType = tag.CimType; if (cimType == CimType.DateTime) { dotNetType = typeof(object); } else if (cimType == CimType.DateTimeArray) { dotNetType = typeof(object[]); } else { dotNetType = CimConverter.GetDotNetType(tag.CimType); } obj2 = Adapter.PropertySetAndMethodArgumentConvertTo(value, dotNetType, CultureInfo.InvariantCulture); } tag.Value = obj2; }
/// <inheritdoc/> public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { var instance = adaptedProperty.BaseObject as Instance; if (instance != null) { var name = adaptedProperty.Name; if (string.Equals(name, PSPathPropertyName, StringComparison.OrdinalIgnoreCase)) { return(GetPSPath(instance)); } object value = null; var property = adaptedProperty.Tag as InstanceProperty; if (property?.Property != null) { return(property.Property.GetValue(instance, null)); } else if (instance.AdditionalProperties.TryGetValue(name, out value)) { return(value); } } return(null); }
public override string GetPropertyTypeName(PSAdaptedProperty adaptedProperty) { if (adaptedProperty == null) { throw new ArgumentNullException("adaptedProperty"); } CimProperty tag = adaptedProperty.Tag as CimProperty; if (tag == null) { if (!adaptedProperty.Name.Equals(RemotingConstants.ComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase)) { throw new ArgumentNullException("adaptedProperty"); } return(ToStringCodeMethods.Type(typeof(string), false)); } switch (tag.CimType) { case CimType.DateTime: case CimType.Reference: case CimType.Instance: case CimType.DateTimeArray: case CimType.ReferenceArray: case CimType.InstanceArray: return("CimInstance#" + tag.CimType.ToString()); } return(ToStringCodeMethods.Type(CimConverter.GetDotNetType(tag.CimType), false)); }
public override string GetPropertyTypeName(PSAdaptedProperty adaptedProperty) { if (adaptedProperty.BaseObject is Microsoft.Build.Evaluation.Project proj) { switch (adaptedProperty.Name) { case "ClCompile": return("KeyValuePair<string, string>[]"); case "IncludePath": return("System.String[]"); case "LibPath": return("System.String[]"); case "Libs": return("System.String[]"); case "Defines": return("System.String[]"); case "Directory": return("System.String"); case "Fullname": return("System.String"); case "ImportedProjects": return("System.String[]"); case "ProjectItems": return("PowerCode.Items"); } } else if (adaptedProperty.BaseObject is Items items) { return(typeof(Collection <Project>).FullName); } return(null); }
/// <summary> /// /// </summary> /// <param name="baseObject"></param> /// <param name="propertyName"></param> /// <returns></returns> public override PSAdaptedProperty GetProperty(object baseObject, string propertyName) { if (propertyName == null) { throw new PSArgumentNullException("propertyName"); } // baseObject should never be null CimInstance cimInstance = baseObject as CimInstance; if (null == cimInstance) { string msg = string.Format(CultureInfo.InvariantCulture, CimInstanceTypeAdapterResources.BaseObjectNotCimInstance, "baseObject", typeof(CimInstance).ToString()); throw new PSInvalidOperationException(msg); } CimProperty cimProperty = cimInstance.CimInstanceProperties[propertyName]; if (cimProperty != null) { PSAdaptedProperty prop = GetCimPropertyAdapter(cimProperty, baseObject, propertyName); return(prop); } if (propertyName.Equals(RemotingConstants.ComputerNameNoteProperty, StringComparison.OrdinalIgnoreCase)) { PSAdaptedProperty prop = GetPSComputerNameAdapter(cimInstance); return(prop); } return(null); }
private PropertySet EnsurePropertyCache(AttributeColumn column) { PropertySet properties; if (!this.cache.TryGetValue(column.Type, out properties)) { properties = new PropertySet(); foreach (var name in column.GetNames()) { var property = new PSAdaptedProperty(PropertyPrefix + name, name); properties.Add(property); } // Add a property for the numeric value. properties.Add(new PSAdaptedProperty(ValueProperty, null)); // Add the enumeration type to the list of type names. properties.TypeName = typeof(AttributeColumn).FullName + "#" + column.Type.Name; // Cache the properties to avoid extra allocations. this.cache.Add(column.Type, properties); } return(properties); }
/// <summary> /// /// </summary> /// <param name="adaptedProperty"></param> /// <returns></returns> public override bool IsSettable(PSAdaptedProperty adaptedProperty) { /* I was explicitly asked to only use MI_FLAG_READONLY for now * // based on DSP0004, version 2.6.0, section "5.5.3.55 Write" (pages 89-90, lines 3056-3061) * bool writeQualifierValue = this.GetPropertyQualifierValue(adaptedProperty, "Write", defaultValue: false); * return writeQualifierValue; */ if (null == adaptedProperty) { return(false); } CimProperty cimProperty = adaptedProperty.Tag as CimProperty; if (cimProperty == null) { return(false); } bool isReadOnly = (CimFlags.ReadOnly == (cimProperty.Flags & CimFlags.ReadOnly)); bool isSettable = !isReadOnly; return(isSettable); }
private object ConvertValue(PSAdaptedProperty property, object valueObject, Type attrType, Type valType) { Exception exception = null; object obj = null; if (!this.TryConvertValue(property, valueObject, attrType, valType, out obj, out exception)) { if (exception == null) { object[] name = new object[3]; name[0] = property.Name; name[1] = valType; name[2] = attrType; throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, StringResources.NoConversionExists, name)); } else { object[] message = new object[3]; message[0] = valType; message[1] = attrType; message[2] = exception.Message; throw new FormatException(string.Format(CultureInfo.CurrentCulture, StringResources.TypeConversionError, message), exception); } } else { return(obj); } }
public override bool IsSettable(PSAdaptedProperty property) { if (property != null) { ADEntity baseObject = property.BaseObject as ADEntity; if (baseObject != null) { PropertyInfo dotNetProperty = baseObject.GetDotNetProperty(property.Name); if (dotNetProperty == null) { return(baseObject.PropertyIsWritable(property.Name)); } else { return(dotNetProperty.CanWrite); } } else { object[] typeAdapterTypeName = new object[2]; typeAdapterTypeName[0] = ADEntityAdapter.TypeAdapterTypeName; typeAdapterTypeName[1] = ADEntityAdapter.ADEntityTypeName; throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, StringResources.TypeAdapterForADEntityOnly, typeAdapterTypeName)); } } else { throw new ArgumentNullException("property"); } }
/// <inheritdoc/> public override string GetPropertyTypeName(PSAdaptedProperty adaptedProperty) { var property = adaptedProperty.Tag as InstanceProperty; var type = property?.Type ?? typeof(object); // TODO: If upgrading to newer PowerShell version use LanguagePrimitives.ConvertTypeNameToPSTypeName. return(type.FullName); }
private static PSAdaptedProperty GetCimPropertyAdapter(CimProperty property, object baseObject, string propertyName) { PSAdaptedProperty propertyToAdd = new PSAdaptedProperty(propertyName, property); propertyToAdd.baseObject = baseObject; //propertyToAdd.adapter = this; return(propertyToAdd); }
/// <summary> /// Ensures that the adapter and base object are set in the given PSAdaptedProperty. /// </summary> private void InitializeProperty(PSAdaptedProperty property, object baseObject) { if (property.adapter == null) { property.adapter = this; property.baseObject = baseObject; } }
private static PSAdaptedProperty GetPSComputerNameAdapter(CimInstance cimInstance) { PSAdaptedProperty psComputerNameProperty = new PSAdaptedProperty(RemotingConstants.ComputerNameNoteProperty, cimInstance); psComputerNameProperty.baseObject = cimInstance; //psComputerNameProperty.adapter = this; return(psComputerNameProperty); }
/// <summary> /// Gets the property value. /// </summary> /// <param name="adaptedProperty">The property to get.</param> /// <returns>The property value.</returns> /// <exception cref="InvalidOperationException">The property did not contain enough information to complete this operation.</exception> public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { if (null != adaptedProperty) { return(GetPropertyValue(adaptedProperty, adaptedProperty.BaseObject as Record)); } throw new InvalidOperationException(); }
private void RunOnJProp(PSAdaptedProperty adaptedProperty, Action <JProperty> action) { JProperty prop = adaptedProperty.Tag as JProperty; if (prop != null) { action(prop); } }
/// <summary> /// /// </summary> /// <param name="adaptedProperty"></param> /// <returns></returns> public override bool IsGettable(PSAdaptedProperty adaptedProperty) { /* I was explicitly asked to only use MI_FLAG_READONLY for now * // based on DSP0004, version 2.6.0, section "5.5.3.41 Read" (page 85, lines 2881-2884) * bool readQualifierValue = this.GetPropertyQualifierValue(adaptedProperty, "Read", defaultValue: true); * return readQualifierValue; */ return(true); }
public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { string[] filterItemMetaData(ICollection <ProjectMetadata> input, string metaName, string itemType) { return(input .Where(m => m.ItemType == itemType && m.Name == metaName) .Select(md => md.EvaluatedValue.Split(';').Where(c => !string.IsNullOrWhiteSpace(c))) .SelectMany(c => c).ToArray()); } switch (adaptedProperty.BaseObject) { case Project proj: { switch (adaptedProperty.Name.ToLowerInvariant()) { case "clcompile": return(proj.AllEvaluatedItems.Where(i => i.ItemType == "ClCompile") .Select(i => new KeyValuePair <string, string>(i.ItemType, i.EvaluatedInclude)) .ToArray()); case "link": return(proj.AllEvaluatedItems.Where(i => i.ItemType == "Link") .Select(i => new KeyValuePair <string, string>(i.ItemType, i.EvaluatedInclude)) .ToArray()); case "includepath": return(filterItemMetaData(proj.AllEvaluatedItemDefinitionMetadata, "AdditionalIncludeDirectories", "ClCompile")); case "libpath": return(filterItemMetaData(proj.AllEvaluatedItemDefinitionMetadata, "AdditionalLibraryDirectories", "Link")); case "libs": return(filterItemMetaData(proj.AllEvaluatedItemDefinitionMetadata, "AdditionalDependencies", "Link")); case "defines": return(filterItemMetaData(proj.AllEvaluatedItemDefinitionMetadata, "PreprocessorDefinitions", "ClCompile")); case "directory": return(proj.DirectoryPath); case "fullname": return(proj.FullPath); case "importedprojects": return(proj.Imports.Select(c => c.ImportedProject.FullPath).ToArray()); case "projectitems": return(new Items(proj)); } break; } case Items items: return(items.GetPropertyValue(adaptedProperty.Name)); } return(null); }
private T RunOnJProp <T>(PSAdaptedProperty adaptedProperty, Func <JProperty, T> action) { JProperty prop = adaptedProperty.Tag as JProperty; if (prop == null) { return(default(T)); } return(action(prop)); }
public override bool IsSettable(PSAdaptedProperty adaptedProperty) { if (adaptedProperty.Tag != null) { if (adaptedProperty.Tag is IAdaptedPropertyHandler <T> propHandler) { return(propHandler.IsSettable); } } return(false); }
public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { var uiObject = adaptedProperty.BaseObject as UIObject; if (uiObject == null) { return(null); } return(uiObject.valueDict[adaptedProperty.Name]); }
internal static object GetPropertyValue(PSAdaptedProperty adaptedProperty, Record record) { var column = adaptedProperty.Tag as Column; if (null != column && null != record) { return(record.Data[column.Index]); } throw new InvalidOperationException(); }
public override void SetPropertyValue(PSAdaptedProperty adaptedProperty, object value) { var uiObject = adaptedProperty.BaseObject as UIObject; if (uiObject == null) { return; } uiObject.SetProperty(adaptedProperty.Name, value); }
/// <summary> /// Gets the native <see cref="Type"/> name for the property value. /// </summary> /// <param name="adaptedProperty">The property to check.</param> /// <returns>The native <see cref="Type"/> name for the property value.</returns> /// <exception cref="InvalidOperationException">The property did not contain enough information to complete this operation.</exception> public override string GetPropertyTypeName(PSAdaptedProperty adaptedProperty) { var column = adaptedProperty.Tag as Column; if (null != column) { return(column.ColumnType.FullName); } throw new InvalidOperationException(); }
public override string GetPropertyTypeName(PSAdaptedProperty adaptedProperty) { if (adaptedProperty.Tag != null) { if (adaptedProperty.Tag is IAdaptedPropertyHandler <T> propHandler) { return(propHandler.TypeName); } } return(typeof(object).FullName); }
public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { if (adaptedProperty.BaseObject is T internalObject && adaptedProperty.Tag != null && IsGettable(adaptedProperty)) { if (adaptedProperty.Tag is IAdaptedPropertyHandler <T> propHandler) { return(propHandler.GetValue(internalObject)); } } return(null); }
public override PSAdaptedProperty GetProperty(object baseObject, string propertyName) { if (baseObject is T internalObject) { var properties = GetAdaptedProperties(internalObject); PSAdaptedProperty property = properties.SingleOrDefault(p => p.Name.Equals(propertyName, StringComparison.InvariantCultureIgnoreCase)); if (property != null) { return(property); } } return(null); }
public override object GetPropertyValue(PSAdaptedProperty adaptedProperty) { DataCollection <string, TValue> internalObject = adaptedProperty.BaseObject as DataCollection <string, TValue>; if (internalObject != null) { TValue resultValue; if (internalObject.TryGetValue(adaptedProperty.Name, out resultValue)) { return(resultValue); } } return(null); }
public override void SetPropertyValue(PSAdaptedProperty adaptedProperty, object value) { if (adaptedProperty.BaseObject is T internalObject && adaptedProperty.Tag != null && IsSettable(adaptedProperty)) { if (adaptedProperty.Tag is IAdaptedPropertyHandler <T> propHandler) { object internalValue = value; if (value is PSObject) { internalValue = ((PSObject)value).BaseObject; } propHandler.SetValue(internalObject, internalValue); } } }
public override bool IsSettable(PSAdaptedProperty adaptedProperty) { if (adaptedProperty == null) { return(false); } CimProperty tag = adaptedProperty.Tag as CimProperty; if (tag == null) { return(false); } bool flag = CimFlags.ReadOnly == (tag.Flags & CimFlags.ReadOnly); return(!flag); }