internal static string FormatField(FieldFormattingDirective directive, object val, int enumerationLimit, StringFormatError formatErrorObject, MshExpressionFactory expressionFactory) { PSObject so = AsPSObject(val); if ((directive != null) && !string.IsNullOrEmpty(directive.formatString)) { try { if (directive.formatString.Contains("{0") || directive.formatString.Contains("}")) { return string.Format(CultureInfo.CurrentCulture, directive.formatString, new object[] { so }); } return so.ToString(directive.formatString, null); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); if (formatErrorObject != null) { formatErrorObject.sourceObject = so; formatErrorObject.exception = exception; formatErrorObject.formatString = directive.formatString; return ""; } } } return SmartToString(so, expressionFactory, enumerationLimit, formatErrorObject); }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult) { StringFormatError formatErrorObject = null; if (_errorManager.DisplayFormatErrorString) { // we send a format error object down to the formatting calls // only if we want to show the formatting error strings formatErrorObject = new StringFormatError(); } string retVal = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, expressionFactory, out expressionResult); if (expressionResult != null) { // we obtained a result, check if there is an error if (expressionResult.Exception != null) { _errorManager.LogMshExpressionFailedResult(expressionResult, so); if (_errorManager.DisplayErrorStrings) { retVal = _errorManager.ErrorString; } } else if (formatErrorObject != null && formatErrorObject.exception != null) { // if we did no thave any errors in the expression evaluation // we might have errors in the formatting, if present _errorManager.LogStringFormatError(formatErrorObject); if (_errorManager.DisplayErrorStrings) { retVal = _errorManager.FormatErrorString; } } } return(retVal); }
private WideViewEntry GenerateWideViewEntryFromProperties(PSObject so, int enumerationLimit) { if (base.activeAssociationList == null) { this.SetUpActiveProperty(so); } WideViewEntry entry = new WideViewEntry(); FormatPropertyField field = new FormatPropertyField(); entry.formatPropertyField = field; if (base.activeAssociationList.Count > 0) { MshResolvedExpressionParameterAssociation association = base.activeAssociationList[0]; FieldFormattingDirective directive = null; if (association.OriginatingParameter != null) { directive = association.OriginatingParameter.GetEntry("formatString") as FieldFormattingDirective; } field.propertyValue = base.GetExpressionDisplayValue(so, enumerationLimit, association.ResolvedExpression, directive); } base.activeAssociationList = null; return(entry); }
/// <summary> /// helper to retrieve the value of an PSPropertyExpression and to format it /// </summary> /// <param name="so">shell object to process</param> /// <param name="enumerationLimit">limit on IEnumerable enumeration</param> /// <param name="ex">expression to use for retrieval</param> /// <param name="directive">format directive to use for formatting</param> /// <param name="formatErrorObject"></param> /// <param name="expressionFactory">expression factory to create PSPropertyExpression</param> /// <param name="result"> not null if an error condition arose</param> /// <returns>formatted string</returns> internal static string GetExpressionDisplayValue( PSObject so, int enumerationLimit, PSPropertyExpression ex, FieldFormattingDirective directive, StringFormatError formatErrorObject, PSPropertyExpressionFactory expressionFactory, out PSPropertyExpressionResult result) { result = null; List <PSPropertyExpressionResult> resList = ex.GetValues(so); if (resList.Count == 0) { return(string.Empty); } result = resList[0]; if (result.Exception != null) { return(string.Empty); } return(PSObjectHelper.FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory)); }
internal static string FormatField( FieldFormattingDirective directive, object val, int enumerationLimit, StringFormatError formatErrorObject, MshExpressionFactory expressionFactory) { PSObject so = PSObjectHelper.AsPSObject(val); if (directive != null) { if (!string.IsNullOrEmpty(directive.formatString)) { try { if (!directive.formatString.Contains("{0") && !directive.formatString.Contains("}")) { return(so.ToString(directive.formatString, (IFormatProvider)null)); } return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, directive.formatString, (object)so)); } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); if (formatErrorObject != null) { formatErrorObject.sourceObject = (object)so; formatErrorObject.exception = ex; formatErrorObject.formatString = directive.formatString; return(""); } } } } return(PSObjectHelper.SmartToString(so, expressionFactory, enumerationLimit, formatErrorObject)); }
private void ExecuteFormatTokenList(TraversalInfo level, PSObject so, List <FormatToken> formatTokenList, List <FormatValue> formatValueList) { if (so == null) { throw PSTraceSource.NewArgumentNullException("so"); } // guard against infinite loop if (level.Level == level.MaxDepth) { return; } FormatEntry fe = new FormatEntry(); formatValueList.Add(fe); #region foreach loop foreach (FormatToken t in formatTokenList) { TextToken tt = t as TextToken; if (tt != null) { FormatTextField ftf = new FormatTextField(); ftf.text = _db.displayResourceManagerCache.GetTextTokenString(tt); fe.formatValueList.Add(ftf); continue; } var newline = t as NewLineToken; if (newline != null) { for (int i = 0; i < newline.count; i++) { fe.formatValueList.Add(new FormatNewLine()); } continue; } FrameToken ft = t as FrameToken; if (ft != null) { // instantiate a new entry and attach a frame info object FormatEntry feFrame = new FormatEntry(); feFrame.frameInfo = new FrameInfo(); // add the frame info feFrame.frameInfo.firstLine = ft.frameInfoDefinition.firstLine; feFrame.frameInfo.leftIndentation = ft.frameInfoDefinition.leftIndentation; feFrame.frameInfo.rightIndentation = ft.frameInfoDefinition.rightIndentation; // execute the list inside the frame ExecuteFormatTokenList(level, so, ft.itemDefinition.formatTokenList, feFrame.formatValueList); // add the frame computation results to the current format entry fe.formatValueList.Add(feFrame); continue; } #region CompoundPropertyToken CompoundPropertyToken cpt = t as CompoundPropertyToken; if (cpt != null) { if (!EvaluateDisplayCondition(so, cpt.conditionToken)) { // token not active, skip it continue; } // get the property from the object object val = null; // if no expression was specified, just use the // object itself if (cpt.expression == null || string.IsNullOrEmpty(cpt.expression.expressionValue)) { val = so; } else { PSPropertyExpression ex = _expressionFactory.CreateFromExpressionToken(cpt.expression, _loadingInfo); List <PSPropertyExpressionResult> resultList = ex.GetValues(so); if (resultList.Count > 0) { val = resultList[0].Result; if (resultList[0].Exception != null) { _errorManager.LogPSPropertyExpressionFailedResult(resultList[0], so); } } } // if the token is has a formatting string, it's a leaf node, // do the formatting and we will be done if (cpt.control == null || cpt.control is FieldControlBody) { // Since it is a leaf node we just consider it an empty string and go // on with formatting if (val == null) { val = string.Empty; } FieldFormattingDirective fieldFormattingDirective = null; StringFormatError formatErrorObject = null; if (cpt.control != null) { fieldFormattingDirective = ((FieldControlBody)cpt.control).fieldFormattingDirective; if (fieldFormattingDirective != null && _errorManager.DisplayFormatErrorString) { formatErrorObject = new StringFormatError(); } } IEnumerable e = PSObjectHelper.GetEnumerable(val); FormatPropertyField fpf = new FormatPropertyField(); if (cpt.enumerateCollection && e != null) { foreach (object x in e) { if (x == null) { // nothing to process continue; } fpf = new FormatPropertyField(); fpf.propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, x, _enumerationLimit, formatErrorObject, _expressionFactory); fe.formatValueList.Add(fpf); } } else { fpf = new FormatPropertyField(); fpf.propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, val, _enumerationLimit, formatErrorObject, _expressionFactory); fe.formatValueList.Add(fpf); } if (formatErrorObject != null && formatErrorObject.exception != null) { _errorManager.LogStringFormatError(formatErrorObject); fpf.propertyValue = _errorManager.FormatErrorString; } } else { // An empty result that is not a leaf node should not be expanded if (val == null) { continue; } IEnumerable e = PSObjectHelper.GetEnumerable(val); if (cpt.enumerateCollection && e != null) { foreach (object x in e) { if (x == null) { // nothing to process continue; } // proceed with the recursion ExecuteFormatControl(level.NextLevel, cpt.control, PSObject.AsPSObject(x), fe.formatValueList); } } else { // proceed with the recursion ExecuteFormatControl(level.NextLevel, cpt.control, PSObjectHelper.AsPSObject(val), fe.formatValueList); } } } #endregion CompoundPropertyToken } #endregion foreach loop }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult) { StringFormatError formatErrorObject = null; if (_errorManager.DisplayFormatErrorString) { // we send a format error object down to the formatting calls // only if we want to show the formatting error strings formatErrorObject = new StringFormatError(); } string retVal = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, expressionFactory, out expressionResult); if (expressionResult != null) { // we obtained a result, check if there is an error if (expressionResult.Exception != null) { _errorManager.LogMshExpressionFailedResult(expressionResult, so); if (_errorManager.DisplayErrorStrings) { retVal = _errorManager.ErrorString; } } else if (formatErrorObject != null && formatErrorObject.exception != null) { // if we did no thave any errors in the expression evaluation // we might have errors in the formatting, if present _errorManager.LogStringFormatError(formatErrorObject); if (_errorManager.DisplayErrorStrings) { retVal = _errorManager.FormatErrorString; } } } return retVal; }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive) { MshExpressionResult resolvedExpression; return GetExpressionDisplayValue(so, enumerationLimit, ex, directive, out resolvedExpression); }
internal override object Verify(object val, TerminatingErrorContext invocationContext, bool originalParameterWasHashTable) { if (!originalParameterWasHashTable) { // this should never happen throw PSTraceSource.NewInvalidOperationException(); } string s = val as string; if (string.IsNullOrEmpty(s)) { string msg = StringUtil.Format(FormatAndOut_MshParameter.EmptyFormatStringValueError, this.KeyName ); ParameterProcessor.ThrowParameterBindingException(invocationContext, "FormatStringEmpty", msg); } // we expect a string and we build a field formatting directive FieldFormattingDirective directive = new FieldFormattingDirective(); directive.formatString = s; return directive; }
/// <summary> /// helper to retrieve the value of an MshExpression and to format it /// </summary> /// <param name="so">shell object to process</param> /// <param name="enumerationLimit">limit on IEnumerable enumeration</param> /// <param name="ex">expression to use for retrieval</param> /// <param name="directive">format directive to use for formatting</param> /// <param name="formatErrorObject"></param> /// <param name="expressionFactory">expression factory to create MshExpression</param> /// <param name="result"> not null if an error condition arose</param> /// <returns>formatted string</returns> internal static string GetExpressionDisplayValue( PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, StringFormatError formatErrorObject, MshExpressionFactory expressionFactory, out MshExpressionResult result) { result = null; List<MshExpressionResult> resList = ex.GetValues(so); if (resList.Count == 0) { return ""; } result = resList[0]; if (result.Exception != null) { return ""; } return PSObjectHelper.FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory); }
/// <summary> /// format an object using a provided format string directive /// </summary> /// <param name="directive">format directive object to use</param> /// <param name="val">object to format</param> /// <param name="enumerationLimit">limit on IEnumerable enumeration</param> /// <param name="formatErrorObject">formatting error object, if present</param> /// <param name="expressionFactory">expression factory to create MshExpression</param> /// <returns>string representation</returns> internal static string FormatField(FieldFormattingDirective directive, object val, int enumerationLimit, StringFormatError formatErrorObject, MshExpressionFactory expressionFactory) { PSObject so = PSObjectHelper.AsPSObject(val); if (directive != null && !string.IsNullOrEmpty(directive.formatString)) { // we have a formatting directive, apply it // NOTE: with a format directive, we do not make any attempt // to deal with IEnumerable try { // use some heuristics to determine if we have "composite formatting" // 2004/11/16-JonN This is heuristic but should be safe enough if (directive.formatString.Contains("{0") || directive.formatString.Contains("}")) { // we do have it, just use it return String.Format(CultureInfo.CurrentCulture, directive.formatString, so); } // we fall back to the PSObject's IFormattable.ToString() // pass a null IFormatProvider return so.ToString(directive.formatString, null); } catch (Exception e) // 2004/11/17-JonN This covers exceptions thrown in // String.Format and PSObject.ToString(). // I think we can swallow these. { CommandProcessorBase.CheckForSevereException(e); // NOTE: we catch all the exceptions, since we do not know // what the underlying object access would throw if (formatErrorObject != null) { formatErrorObject.sourceObject = so; formatErrorObject.exception = e; formatErrorObject.formatString = directive.formatString; return ""; } } } // we do not have a formatting directive or we failed the formatting (fallback) // but we did not report as an error; // this call would deal with IEnumerable if the object implements it return PSObjectHelper.SmartToString(so, expressionFactory, enumerationLimit, formatErrorObject); }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult) { StringFormatError formatErrorObject = null; if (this.errorManager.DisplayFormatErrorString) { formatErrorObject = new StringFormatError(); } string errorString = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, this.expressionFactory, out expressionResult); if (expressionResult != null) { if (expressionResult.Exception != null) { this.errorManager.LogMshExpressionFailedResult(expressionResult, so); if (this.errorManager.DisplayErrorStrings) { errorString = this.errorManager.ErrorString; } return errorString; } if ((formatErrorObject != null) && (formatErrorObject.exception != null)) { this.errorManager.LogStringFormatError(formatErrorObject); if (this.errorManager.DisplayErrorStrings) { errorString = this.errorManager.FormatErrorString; } } } return errorString; }
private void ExecuteFormatTokenList(TraversalInfo level, PSObject so, List <FormatToken> formatTokenList, List <FormatValue> formatValueList) { if (so == null) { throw PSTraceSource.NewArgumentNullException("so"); } if (level.Level != level.MaxDepth) { FormatEntry item = new FormatEntry(); formatValueList.Add(item); foreach (FormatToken token in formatTokenList) { TextToken tt = token as TextToken; if (tt != null) { FormatTextField field = new FormatTextField { text = this.db.displayResourceManagerCache.GetTextTokenString(tt) }; item.formatValueList.Add(field); } else if (token is NewLineToken) { item.formatValueList.Add(new FormatNewLine()); } else { FrameToken token3 = token as FrameToken; if (token3 != null) { FormatEntry entry2 = new FormatEntry { frameInfo = new FrameInfo() }; entry2.frameInfo.firstLine = token3.frameInfoDefinition.firstLine; entry2.frameInfo.leftIndentation = token3.frameInfoDefinition.leftIndentation; entry2.frameInfo.rightIndentation = token3.frameInfoDefinition.rightIndentation; this.ExecuteFormatTokenList(level, so, token3.itemDefinition.formatTokenList, entry2.formatValueList); item.formatValueList.Add(entry2); } else { CompoundPropertyToken token4 = token as CompoundPropertyToken; if ((token4 != null) && this.EvaluateDisplayCondition(so, token4.conditionToken)) { object result = null; if ((token4.expression == null) || string.IsNullOrEmpty(token4.expression.expressionValue)) { result = so; } else { List <MshExpressionResult> values = this.expressionFactory.CreateFromExpressionToken(token4.expression, this.loadingInfo).GetValues(so); if (values.Count > 0) { result = values[0].Result; if (values[0].Exception != null) { this.errorManager.LogMshExpressionFailedResult(values[0], so); } } } if ((token4.control == null) || (token4.control is FieldControlBody)) { if (result == null) { result = ""; } FieldFormattingDirective fieldFormattingDirective = null; StringFormatError formatErrorObject = null; if (token4.control != null) { fieldFormattingDirective = ((FieldControlBody)token4.control).fieldFormattingDirective; if ((fieldFormattingDirective != null) && this.errorManager.DisplayFormatErrorString) { formatErrorObject = new StringFormatError(); } } IEnumerable enumerable = PSObjectHelper.GetEnumerable(result); FormatPropertyField field2 = new FormatPropertyField(); if (token4.enumerateCollection && (enumerable != null)) { foreach (object obj3 in enumerable) { if (obj3 != null) { field2 = new FormatPropertyField { propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, obj3, this.enumerationLimit, formatErrorObject, this.expressionFactory) }; item.formatValueList.Add(field2); } } } else { field2 = new FormatPropertyField { propertyValue = PSObjectHelper.FormatField(fieldFormattingDirective, result, this.enumerationLimit, formatErrorObject, this.expressionFactory) }; item.formatValueList.Add(field2); } if ((formatErrorObject != null) && (formatErrorObject.exception != null)) { this.errorManager.LogStringFormatError(formatErrorObject); field2.propertyValue = this.errorManager.FormatErrorString; } } else if (result != null) { IEnumerable enumerable2 = PSObjectHelper.GetEnumerable(result); if (token4.enumerateCollection && (enumerable2 != null)) { foreach (object obj4 in enumerable2) { if (obj4 != null) { this.ExecuteFormatControl(level.NextLevel, token4.control, PSObject.AsPSObject(obj4), item.formatValueList); } } } else { this.ExecuteFormatControl(level.NextLevel, token4.control, PSObjectHelper.AsPSObject(result), item.formatValueList); } } } } } } } }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, out MshExpressionResult expressionResult) { StringFormatError formatErrorObject = null; if (this.errorManager.DisplayFormatErrorString) { formatErrorObject = new StringFormatError(); } string errorString = PSObjectHelper.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, formatErrorObject, this.expressionFactory, out expressionResult); if (expressionResult != null) { if (expressionResult.Exception != null) { this.errorManager.LogMshExpressionFailedResult(expressionResult, so); if (this.errorManager.DisplayErrorStrings) { errorString = this.errorManager.ErrorString; } return(errorString); } if ((formatErrorObject != null) && (formatErrorObject.exception != null)) { this.errorManager.LogStringFormatError(formatErrorObject); if (this.errorManager.DisplayErrorStrings) { errorString = this.errorManager.FormatErrorString; } } } return(errorString); }
protected string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive) { MshExpressionResult result; return(this.GetExpressionDisplayValue(so, enumerationLimit, ex, directive, out result)); }
internal static string GetExpressionDisplayValue(PSObject so, int enumerationLimit, MshExpression ex, FieldFormattingDirective directive, StringFormatError formatErrorObject, MshExpressionFactory expressionFactory, out MshExpressionResult result) { result = null; List <MshExpressionResult> values = ex.GetValues(so); if (values.Count == 0) { return(""); } result = values[0]; if (result.Exception != null) { return(""); } return(FormatField(directive, result.Result, enumerationLimit, formatErrorObject, expressionFactory)); }