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);
}
