static IEnumerable <AttributeValue> PositionParameters(this IAttributeInstance source) { for (int i = 0; i < source.PositionParameterCount; i++) { yield return(source.PositionParameter(i)); } }
private static int? GetTagFromProtoMember(IAttributeInstance attribute) { var tagParameter = attribute.PositionParameter(0); if (!tagParameter.IsConstant) return null; return Convert.ToInt32(tagParameter.ConstantValue.Value); }
private static string AnonymousPropertyInitializerRetriever(IAttributeInstance attr) { return(attr.PositionParameters() .Select(value => value.ConstantValue) .Where(value => value.IsString()).SelectNotNull(value => value.Value as string) .FirstOrDefault()); }
public CommonAttribute GetCommonAttribute(IAttributeInstance attributeInstance) { var type = GetCommonType(attributeInstance.GetAttributeType()); var positionalArguments = attributeInstance.PositionParameters().Select(GetPositionalArgument).WhereNotNull(); var namedArguments = attributeInstance.NamedParameters().Select(GetNamedArguments).WhereNotNull(); return new CommonAttribute(type, positionalArguments, namedArguments); }
public CommonAttribute GetCommonAttribute(IAttributeInstance attributeInstance) { var type = GetCommonType(attributeInstance.GetAttributeType()); var positionalArguments = attributeInstance.PositionParameters().Select(GetPositionalArgument).WhereNotNull(); var namedArguments = attributeInstance.NamedParameters().Select(GetNamedArguments).WhereNotNull(); return(new CommonAttribute(type, positionalArguments, namedArguments)); }
private string TryGetAnnotationShortName([CanBeNull] IAttributeInstance attribute, AnnotationsDisplayKind showAnnotations) { if (attribute != null && showAnnotations != AnnotationsDisplayKind.None) { string shortName = attribute.GetClrName().ShortName; if (IsDisplayedAnnotation(attribute, shortName, showAnnotations)) { return(shortName.TrimFromEnd("Attribute")); } } return(null); }
private void GetStateAndAttributes(IList state, IList attributeRows, String indentation, IFlow flow) { // add the flow to the state IEnumerator iter = flow.Children.GetEnumerator(); while (iter.MoveNext()) { state.Add(iter.Current); } // add the flow-name to the attributeRows System.Collections.IDictionary row = new System.Collections.Hashtable(); if (flow.IsRootFlow()) { row["name"] = indentation + "rootflow <b>[</b>" + flow.Name + "<b>]</b>"; } else { row["name"] = indentation + "subflow <b>[</b>" + flow.Name + "<b>]</b>"; } row["value"] = ""; attributeRows.Add(row); // add the flow-local attributes to the attributeRows iter = flow.AttributeInstances.GetEnumerator(); while (iter.MoveNext()) { IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current; row = new Hashtable(); log.Debug("adding attribute instance value " + attributeInstance.GetValue()); row["name"] = indentation + " +- <b>[</b>" + attributeInstance.Attribute.Name + "<b>]</b>"; row["value"] = attributeInstance.GetValue(); attributeRows.Add(row); } // recursively descend to the children iter = flow.Children.GetEnumerator(); while (iter.MoveNext()) { GetStateAndAttributes(state, attributeRows, indentation + " | ", (IFlow)iter.Current); } IProcessInstance processInstance = flow.GetSubProcessInstance(); if (processInstance != null) { state.Add(processInstance.RootFlow); GetStateAndAttributes(state, attributeRows, indentation + " | ", processInstance.RootFlow); } }
private static bool IsValidAttributeInstance([NotNull] IAttributeInstance instance) { if (instance.PositionParameterCount != 2) { return(false); } var categoryParam = instance.PositionParameter(0); if (!categoryParam.IsConstant || !categoryParam.ConstantValue.IsString() || (string)categoryParam.ConstantValue.Value != "ReSharper") { return(false); } var idParam = instance.PositionParameter(1); return(idParam.IsConstant && idParam.ConstantValue.IsString()); }
private void WriterAttributes(IFlow flow, StreamWriter xmlwriter) { //NHibernate.LazyInitializationException: Failed to lazily initialize a collection - no session IEnumerator iter = flow.AttributeInstances.GetEnumerator(); while (iter.MoveNext()) { IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current; xmlwriter.WriteLine(" <attribute type=\"AT_UDA_12_"+ attributeInstance.Attribute.Name + "\">" + attributeInstance.GetValue() + "</attribute>"); } // recursively descend to the children iter = flow.Children.GetEnumerator(); while (iter.MoveNext()) { WriterAttributes((IFlow)iter.Current, xmlwriter); } }
private bool IsDisplayedAnnotation([CanBeNull] IAttributeInstance attribute, [CanBeNull] string shortName, AnnotationsDisplayKind showAnnotations) { if (attribute == null || shortName == null) { return(false); } switch (showAnnotations) { case AnnotationsDisplayKind.Nullness: return(shortName == NullnessProvider.CanBeNullAttributeShortName || shortName == NullnessProvider.NotNullAttributeShortName); case AnnotationsDisplayKind.All: return(_codeAnnotationsConfiguration.IsAnnotationAttribute(attribute, shortName)); default: return(false); } }
public void CheckDelegateActivity(String authenticatedActorId, Int64 flowId, String delegateActorId) { //only director can delegate an activity IExecutionApplicationService executionComponent = (IExecutionApplicationService)serviceLocator.GetService(typeof(IExecutionApplicationService)); try { IFlow flow = executionComponent.GetFlow(flowId, new Relations("attributeInstances")); IActor director = null; ISet attributeInstances = flow.AttributeInstances; for (IEnumerator iter = attributeInstances.GetEnumerator(); iter.MoveNext();) { IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current; if ("director".Equals(attributeInstance.Attribute.Name)) { director = (IActor)attributeInstance.GetValue(); } } if (director.Id.Equals(authenticatedActorId) == false) { throw new AuthorizationException("Only director is allowed to delegate activity"); } } catch (AuthorizationException e) { throw e; } catch (System.Exception e) { log.Error("failed doing authorization : ", e); throw new System.SystemException("failed doing authorization : " + e.Message); } finally { serviceLocator.Release(executionComponent); } }
private static string TryExtractProjectNameFromAssemblyMetadataAttribute([NotNull] IAttributeInstance attributeInstance) { const string testProjectKey = "ReSharperHelpers.TestProject"; if (attributeInstance.PositionParameterCount != 2) { return(null); } var key = attributeInstance.PositionParameter(0); if (key.IsConstant && key.ConstantValue.IsString() && string.Equals((string)key.ConstantValue.Value, testProjectKey, StringComparison.Ordinal)) { var value = attributeInstance.PositionParameter(1); if (value.IsConstant && value.ConstantValue.IsString()) { return((string)value.ConstantValue.Value); } } return(null); }
public override IList <IAttributeInstance> GetAttributeInstances(IClrTypeName clrName) { if (AttributeClassNames.IsEmpty()) { return(EmptyList <IAttributeInstance> .Instance); } if (!((GetDeclaration() as IFSharpTypeDeclaration)?.GetFSharpSymbol() is FSharpEntity entity)) { return(EmptyList <IAttributeInstance> .Instance); } var psiModule = GetPsiModule(); var entityAttrs = entity.Attributes; var attrs = new IAttributeInstance[entityAttrs.Count]; for (var i = 0; i < attrs.Length; i++) { attrs[i] = new FSharpAttributeInstance(entityAttrs[i], psiModule); } return(attrs); }
private bool IsAttributeInstanceValid(IAttributeInstance attrib) { return attrib.Constructor != null && attrib.AttributeType != null; }
private IAttribute GetCSharpAttributeHack(IAttributeInstance attributeInstance) { if (attributeInstance.GetType().Name != "CSharpAttributeInstance") return null; if (CSharpAttributeInstanceMyAttributeField == null) CSharpAttributeInstanceMyAttributeField = attributeInstance.GetType().GetField("myAttribute", BindingFlags.Instance | BindingFlags.NonPublic); if (CSharpAttributeInstanceMyAttributeField == null) return null; return (IAttribute) CSharpAttributeInstanceMyAttributeField.GetValue(attributeInstance); }
private ConstantValue2 GetAttributeNamedParameterHack(IAttributeInstance attributeInstance, ITypeMember typeMember) { IAttribute attribute = GetCSharpAttributeHack(attributeInstance); if (attribute != null) { foreach (IPropertyAssignmentNode propertyAssignmentNode in attribute.ToTreeNode().PropertyAssignments) { IPropertyAssignment propertyAssignment = propertyAssignmentNode; if (propertyAssignment.Reference.Resolve().DeclaredElement == typeMember) { IType propertyType = ((ITypeOwner)typeMember).Type; ICSharpExpression expression = propertyAssignment.Source; return GetCSharpConstantValueHack(expression, propertyType); } } return ConstantValue2.BAD_VALUE; } return attributeInstance.NamedParameter(typeMember); }
private ConstantValue2 GetAttributePositionParameterHack(IAttributeInstance attributeInstance, int index) { IAttribute attribute = GetCSharpAttributeHack(attributeInstance); if (attribute != null) { IList<ICSharpArgument> arguments = attribute.Arguments; if (index >= arguments.Count) return ConstantValue2.BAD_VALUE; ICSharpExpression expression = arguments[index].Value; IList<IParameter> parameters = attributeInstance.Constructor.Parameters; int lastParameterIndex = parameters.Count - 1; if (index >= lastParameterIndex && parameters[lastParameterIndex].IsParameterArray) return GetCSharpConstantValueHack(expression, ((IArrayType)parameters[lastParameterIndex].Type).ElementType); return GetCSharpConstantValueHack(arguments[index].Value, parameters[index].Type); } return attributeInstance.PositionParameter(index); }
public static CommonAttribute ToCommon(this IAttributeInstance attributeInstance) { return(IntrospectionUtility.Instance.GetCommonAttribute(attributeInstance)); }
public static IAttributeInfo AsAttributeInfo(this IAttributeInstance attribute) { return(new PsiAttributeInfoAdapter(attribute)); }
public PsiAttributeInfoAdapter(IAttributeInstance attribute) { this.attribute = attribute; }
public AttributeInstanceWrapper(IAttributeInstance attribute) { this.attribute = attribute; }
private ConstantValue? GetAttributeNamedParameter(IAttributeInstance attributeHandle, ITypeMember memberHandle) { #if RESHARPER_31 ConstantValue2 rawValue = GetAttributeNamedParameterHack(attributeHandle, memberHandle); return rawValue.IsBadValue() ? (ConstantValue?)null : ConvertConstantValue(rawValue.Value); #else AttributeValue rawValue = attributeHandle.NamedParameter(memberHandle); return rawValue.IsBadValue ? (ConstantValue?) null : ConvertConstantValue(rawValue); #endif }
public static IDeclaredType GetAttributeType(this IAttributeInstance attribute) { return(attribute.AttributeType); }
private ConstantValue? GetAttributePositionParameter(IAttributeInstance attributeHandle, int index) { #if RESHARPER_31 ConstantValue2 rawValue = GetAttributePositionParameterHack(attributeHandle, index); return rawValue.IsBadValue() ? (ConstantValue?)null : ConvertConstantValue(rawValue.Value); #else AttributeValue rawValue = attributeHandle.PositionParameter(index); return rawValue.IsBadValue ? (ConstantValue?) null : ConvertConstantValue(rawValue); #endif }
internal static IAttributeInfo AsAttributeInfo(this IAttributeInstance attribute) { return(new AttributeInstanceWrapper(attribute)); }