internal void UpdateFunctionDescriptor(FunctionDescriptor funcDesc) { Function = funcDesc; // Setting 'summary' to 'null' so its value is retrieved later // when 'Summary' property is invoked. See 'Summary' for details. summary = null; }
public void DescriptionTest() { var assembly = System.Reflection.Assembly.UnsafeLoadFrom("FFITarget.dll"); var testClass = assembly.GetType("FFITarget.DummyZeroTouchClass"); MethodInfo methodWithDesc = testClass.GetMethod("FunctionWithDescription"); MethodInfo methodWithoutDesc = testClass.GetMethod("FunctionWithoutDescription"); NodeDescriptionAttribute atr = new NodeDescriptionAttribute(""); IEnumerable<TypedParameter> arguments; FunctionDescriptor fucDescriptor; // 1 case. Method with description. var attributes = methodWithDesc.GetCustomAttributes(typeof(NodeDescriptionAttribute), false); Assert.IsNotNull(attributes); Assert.Greater(attributes.Length, 0); atr = attributes[0] as NodeDescriptionAttribute; arguments = methodWithDesc.GetParameters().Select( arg => { var type = new ProtoCore.Type(); type.Name = arg.ParameterType.ToString(); return new TypedParameter(arg.Name, type); }); fucDescriptor = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = methodWithDesc.Name, Summary = atr.ElementDescription, Parameters = arguments }); NodeModel node = new DSFunction(fucDescriptor); Assert.AreEqual(atr.ElementDescription + "\n\n" + fucDescriptor.Signature, node.Description); // 2 case. Method without description. atr = new NodeDescriptionAttribute(""); attributes = methodWithoutDesc.GetCustomAttributes(typeof(NodeDescriptionAttribute), false); Assert.IsNotNull(attributes); Assert.AreEqual(attributes.Length, 0); arguments = methodWithoutDesc.GetParameters().Select( arg => { var type = new ProtoCore.Type(); type.Name = arg.ParameterType.ToString(); return new TypedParameter(arg.Name, type); }); fucDescriptor = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = methodWithDesc.Name, Summary = atr.ElementDescription, Parameters = arguments }); node = new DSFunction(fucDescriptor); Assert.AreEqual(fucDescriptor.Signature, node.Description); }
private FunctionDescriptor GetConstructorMethod() { var funcDesc = new FunctionDescriptor(new FunctionDescriptorParams { Assembly = "MyAssembly.dll", ClassName = "MyNamespace.MyClass", FunctionName = "MyClass", ReturnType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar), FunctionType = FunctionType.Constructor }); return funcDesc; }
/// <summary> /// Add a function descriptor to the group /// </summary> /// <param name="function"></param> /// <returns></returns> internal bool AddFunctionDescriptor(FunctionDescriptor function) { if (!QualifiedName.Equals(function.QualifiedName) || functions.Contains(function)) return false; functions.Add(function); if (functions.Count > 1) { functions[0].IsOverloaded = true; functions[functions.Count - 1].IsOverloaded = true; } return true; }
private FunctionDescriptor GetMyMethod() { var parms = new List<TypedParameter>() { new TypedParameter("a", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeDouble, 0)), new TypedParameter("b", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeDouble, 0)), new TypedParameter("c", TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeDouble, 0)) }; var funcDesc = new FunctionDescriptor(new FunctionDescriptorParams { Assembly = "MyAssembly.dll", ClassName = "MyNamespace.MyClass", FunctionName = "MyMethod", Parameters = parms, ReturnType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar), FunctionType = FunctionType.InstanceMethod }); parms.ForEach(x => x.UpdateFunctionDescriptor(funcDesc)); return funcDesc; }
public void TypedParametersToStringTest() { //1. Foo(x: double, y : double) -> Foo.double-double //2. Foo(point : Point) -> Foo.Point //3. Foo(a : bool [ ] [ ] , b : var[], c : double[][]) -> Foo.bool2-var1-double2 //4. Foo(arr : var[]..[], a : int) -> Foo.varN-int //5. Foo(a: Autodesk.DesignScript.Geometry.Circle, b: Xxxx.Yyy.Curve) //6. Empty string(a: int) // 1 case var parameters1 = new List<TypedParameter>(); parameters1.Add(new TypedParameter("x", new ProtoCore.Type { Name = "double" })); parameters1.Add(new TypedParameter("y", new ProtoCore.Type { Name = "double" })); var functionItem1 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "Foo", Parameters = parameters1, FunctionType = FunctionType.GenericFunction }); System.Console.WriteLine(functionItem1.Parameters.Count()); Assert.AreEqual("Foo.double-double", Utils.TypedParametersToString(functionItem1)); //2 case var parameters2 = new List<TypedParameter>(); parameters2.Add(new TypedParameter("point", new ProtoCore.Type { Name = "Point" })); var functionItem2 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "Foo", Parameters = parameters2, FunctionType = FunctionType.GenericFunction }); Assert.AreEqual("Foo.Point", Utils.TypedParametersToString(functionItem2)); //3 case var parameters3 = new List<TypedParameter>(); parameters3.Add(new TypedParameter("a", new ProtoCore.Type { Name = "bool [ ] [ ] " })); parameters3.Add(new TypedParameter("b", new ProtoCore.Type { Name = "var[]" })); parameters3.Add(new TypedParameter("c", new ProtoCore.Type { Name = "double[][]" })); var functionItem3 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "Foo", Parameters = parameters3, FunctionType = FunctionType.GenericFunction }); Assert.AreEqual("Foo.bool2-var1-double2", Utils.TypedParametersToString(functionItem3)); //4 case var parameters4 = new List<TypedParameter>(); parameters4.Add(new TypedParameter("arr", new ProtoCore.Type { Name = "var[]..[]" })); parameters4.Add(new TypedParameter("a", new ProtoCore.Type { Name = "int" })); var functionItem4 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "Foo", Parameters = parameters4, FunctionType = FunctionType.GenericFunction }); Assert.AreEqual("Foo.varN-int", Utils.TypedParametersToString(functionItem4)); //5 case var parameters5 = new List<TypedParameter>(); parameters5.Add(new TypedParameter("a", new ProtoCore.Type { Name = "Autodesk.DesignScript.Geometry.Circle" })); parameters5.Add(new TypedParameter("b", new ProtoCore.Type { Name = "Xxxx.Yyy.Curve" })); var functionItem5 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "Foo", Parameters = parameters5, FunctionType = FunctionType.GenericFunction }); Assert.AreEqual("Foo.Circle-Curve", Utils.TypedParametersToString(functionItem5)); //6 case var parameters6 = new List<TypedParameter>(); parameters6.Add(new TypedParameter("a", new ProtoCore.Type { Name = "int" })); var functionItem6 = new FunctionDescriptor(new FunctionDescriptorParams { FunctionName = "", Parameters = parameters6, FunctionType = FunctionType.GenericFunction }); Assert.AreEqual(".int", Utils.TypedParametersToString(functionItem6)); }
/// <summary> /// Initializes a new instance of the <see cref="DSFunction"/> class. /// </summary> /// <param name="description">Function descritor.</param> public DSFunction(FunctionDescriptor functionDescription) : base(new ZeroTouchNodeController<FunctionDescriptor>(functionDescription)) { }
/// <summary> /// Initializes a new instance of the <see cref="DSFunction"/> class. /// </summary> /// <param name="descriptor">Function descritor.</param> public DSFunction(FunctionDescriptor descriptor) : base(new ZeroTouchNodeController<FunctionDescriptor>(descriptor)) { }
private void ImportProcedure(string library, ProcedureNode proc) { string procName = proc.Name; if (proc.IsAutoGeneratedThisProc || CoreUtils.IsSetter(procName) || CoreUtils.IsDisposeMethod(procName) || CoreUtils.StartsWithDoubleUnderscores(procName)) { return; } string obsoleteMessage = ""; int classScope = proc.ClassID; string className = string.Empty; MethodAttributes methodAttribute = proc.MethodAttribute; ClassAttributes classAttribute = null; if (classScope != Constants.kGlobalScope) { var classNode = LibraryManagementCore.ClassTable.ClassNodes[classScope]; classAttribute = classNode.ClassAttributes; className = classNode.Name; } // MethodAttribute's HiddenInLibrary has higher priority than // ClassAttribute's HiddenInLibrary var isVisible = true; var canUpdatePeriodically = false; if (methodAttribute != null) { isVisible = !methodAttribute.HiddenInLibrary; canUpdatePeriodically = methodAttribute.CanUpdatePeriodically; } else { if (classAttribute != null) { isVisible = !classAttribute.HiddenInLibrary; } } FunctionType type; if (classScope == Constants.kGlobalScope) { type = FunctionType.GenericFunction; } else { if (CoreUtils.IsGetter(procName)) { type = proc.IsStatic ? FunctionType.StaticProperty : FunctionType.InstanceProperty; string property; if (CoreUtils.TryGetPropertyName(procName, out property)) { procName = property; } } else { if (proc.IsConstructor) { type = FunctionType.Constructor; } else if (proc.IsStatic) { type = FunctionType.StaticMethod; } else { type = FunctionType.InstanceMethod; } } } List <TypedParameter> arguments = proc.ArgumentInfos.Zip( proc.ArgumentTypes, (arg, argType) => { AssociativeNode defaultArgumentNode; // Default argument specified by DefaultArgumentAttribute // takes higher priority if (!TryGetDefaultArgumentFromAttribute(arg, out defaultArgumentNode) && arg.IsDefault) { var binaryExpr = arg.DefaultExpression as BinaryExpressionNode; if (binaryExpr != null) { defaultArgumentNode = binaryExpr.RightNode; } } string shortName = null; if (defaultArgumentNode != null) { shortName = defaultArgumentNode.ToString(); var rewriter = new ElementRewriter(LibraryManagementCore.ClassTable, LibraryManagementCore.BuildStatus.LogSymbolConflictWarning); defaultArgumentNode = defaultArgumentNode.Accept(rewriter); } return(new TypedParameter(arg.Name, argType, defaultArgumentNode, shortName)); }).ToList(); IEnumerable <string> returnKeys = null; if (proc.MethodAttribute != null) { if (proc.MethodAttribute.ReturnKeys != null) { returnKeys = proc.MethodAttribute.ReturnKeys; } if (proc.MethodAttribute.IsObsolete) { obsoleteMessage = proc.MethodAttribute.ObsoleteMessage; } } var function = new FunctionDescriptor(new FunctionDescriptorParams { Assembly = library, ClassName = className, FunctionName = procName, Parameters = arguments, ReturnType = proc.ReturnType, FunctionType = type, IsVisibleInLibrary = isVisible, ReturnKeys = returnKeys, PathManager = pathManager, IsVarArg = proc.IsVarArg, ObsoleteMsg = obsoleteMessage, CanUpdatePeriodically = canUpdatePeriodically, IsBuiltIn = pathManager.PreloadedLibraries.Contains(library), IsPackageMember = packagedLibraries.Contains(library) }); AddImportedFunctions(library, new[] { function }); }
private static MemberDocumentNode GetMemberDocumentNode( FunctionDescriptor function, XmlReader xml ) { //customNodeDefinitions typedParameters don't have functionDescriptors if (function == null) { return null; } var assemblyName = function.Assembly; if (string.IsNullOrEmpty(assemblyName)) return null; var fullyQualifiedName = MemberDocumentNode.MakeFullyQualifiedName (assemblyName, GetMemberElementName(function)); if (!documentNodes.ContainsKey(fullyQualifiedName)) { if (xml == null) xml = DocumentationServices.GetForAssembly(function.Assembly, function.PathManager); LoadDataFromXml(xml, assemblyName); } MemberDocumentNode documentNode = null; if (documentNodes.ContainsKey(fullyQualifiedName)) documentNode = documentNodes[fullyQualifiedName]; else { var overloadedName = documentNodes.Keys. Where(key => key.Contains(function.ClassName + "." + function.FunctionName)).FirstOrDefault(); if (overloadedName == null) return null; if (documentNodes.ContainsKey(overloadedName)) documentNode = documentNodes[overloadedName]; } return documentNode; }
private static string GetMemberElementName(FunctionDescriptor member) { char prefixCode; string memberName = member.FunctionName; if (!string.IsNullOrEmpty(member.ClassName)) { memberName = member.ClassName + "." + member.FunctionName; } switch (member.Type) { case FunctionType.Constructor: // XML documentation uses slightly different constructor names int lastPoint = member.ClassName.LastIndexOf("."); if (lastPoint == -1) { goto case FunctionType.InstanceMethod; } string classNameWithoutNamespace = member.ClassName.Substring(lastPoint + 1); // If classname is the same as function name, then it's usual constructor. // Otherwise it's static method which return type is the same as class. if (classNameWithoutNamespace == member.FunctionName) { memberName = member.ClassName + ".#ctor"; } goto case FunctionType.InstanceMethod; case FunctionType.InstanceMethod: prefixCode = 'M'; // parameters are listed according to their type, not their name string paramTypesList = String.Join( ",", member.Parameters.Select(x => x.Type.ToString()).Select(PrimitiveMap).ToArray() ); if (!String.IsNullOrEmpty(paramTypesList)) { memberName += "(" + paramTypesList + ")"; } break; case FunctionType.StaticMethod: goto case FunctionType.InstanceMethod; break; case FunctionType.InstanceProperty: prefixCode = 'P'; break; case FunctionType.StaticProperty: goto case FunctionType.InstanceProperty; break; case FunctionType.GenericFunction: return(member.FunctionName); break; default: throw new ArgumentException("Unknown member type", "member"); } // elements are of the form "M:Namespace.Class.Method" return(String.Format("{0}:{1}", prefixCode, memberName)); }
/// <summary> /// Initializes a new instance of the <see cref="ZeroTouchSearchElement"/> class /// with the DesignScript function description /// </summary> /// <param name="functionDescriptor"><see cref="FunctionDescriptor"/> object /// describing DesignScript function.</param> public ZeroTouchSearchElement(FunctionDescriptor functionDescriptor) { this.functionDescriptor = functionDescriptor; Name = functionDescriptor.UserFriendlyName; if (functionDescriptor.IsOverloaded) { var parameters = new StringBuilder(); parameters.Append("("); parameters.Append(String.Join(", ", functionDescriptor.Parameters.Select(x => x.Name))); parameters.Append(")"); Parameters = parameters.ToString(); } FullCategoryName = functionDescriptor.Category; Description = functionDescriptor.Description; Assembly = functionDescriptor.Assembly; ElementType = ElementTypes.ZeroTouch; if (functionDescriptor.IsBuiltIn) ElementType |= ElementTypes.BuiltIn; if (functionDescriptor.IsPackageMember) ElementType |= ElementTypes.Packaged; inputParameters = new List<Tuple<string, string>>(functionDescriptor.InputParameters); outputParameters = new List<string>() { functionDescriptor.ReturnType.ToShortString() }; foreach (var tag in functionDescriptor.GetSearchTags()) SearchKeywords.Add(tag); var weights = functionDescriptor.GetSearchTagWeights(); foreach (var weight in weights) { // Search tag weight can't be more then 1. if (weight <= 1) keywordWeights.Add(weight); } int weightsCount = weights.Count(); // If there weren't added weights for search tags, then add default value - 0.5 if (weightsCount != SearchKeywords.Count) { int numberOfLackingWeights = SearchKeywords.Count - weightsCount; // Number of lacking weights should be more than 0. // It can be less then 0 only if there was some mistake in xml file. if (numberOfLackingWeights > 0) { for (int i = 0; i < numberOfLackingWeights; i++) { keywordWeights.Add(0.5); } } } iconName = GetIconName(); }
private static string GetMemberElementName(FunctionDescriptor member) { char prefixCode; string memberName = member.FunctionName; if (!string.IsNullOrEmpty(member.ClassName)) memberName = member.ClassName + "." + member.FunctionName; switch (member.Type) { case FunctionType.Constructor: // XML documentation uses slightly different constructor names int lastPoint = member.ClassName.LastIndexOf("."); if (lastPoint == -1) goto case FunctionType.InstanceMethod; string classNameWithoutNamespace = member.ClassName.Substring(lastPoint + 1); // If classname is the same as function name, then it's usual constructor. // Otherwise it's static method which return type is the same as class. if (classNameWithoutNamespace == member.FunctionName) memberName = member.ClassName + ".#ctor"; goto case FunctionType.InstanceMethod; case FunctionType.InstanceMethod: prefixCode = 'M'; // parameters are listed according to their type, not their name string paramTypesList = String.Join( ",", member.Parameters.Select(x => x.Type.ToString()).Select(PrimitiveMap).ToArray() ); if (!String.IsNullOrEmpty(paramTypesList)) memberName += "(" + paramTypesList + ")"; break; case FunctionType.StaticMethod: goto case FunctionType.InstanceMethod; break; case FunctionType.InstanceProperty: prefixCode = 'P'; break; case FunctionType.StaticProperty: goto case FunctionType.InstanceProperty; break; case FunctionType.GenericFunction: return member.FunctionName; break; default: throw new ArgumentException("Unknown member type", "member"); } // elements are of the form "M:Namespace.Class.Method" return String.Format("{0}:{1}", prefixCode, memberName); }
private static string GetMemberElement( FunctionDescriptor function, XmlReader xml, DocumentElementType property, string paramName = "") { var documentNode = GetMemberDocumentNode(function, xml); if (documentNode == null) return String.Empty; if (property.Equals(DocumentElementType.Description) && !documentNode.Parameters.ContainsKey(paramName)) return String.Empty; switch (property) { case DocumentElementType.Summary: return documentNode.Summary; case DocumentElementType.Description: return documentNode.Parameters[paramName]; case DocumentElementType.SearchTags: return documentNode.SearchTags; case DocumentElementType.SearchTagWeights: return documentNode.SearchTagWeights; default: throw new ArgumentException("property"); } }
/// <summary> /// This method returns a name for the icon based on name of the node. /// </summary> /// <param name="descriptor">Function descriptor, that contains all info about node.</param> /// <param name="overridePrefix"> /// overridePrefix is used as default value for generating node icon name. /// If overridePrefix is empty, it uses QualifiedName property. /// e.g. Autodesk.DesignScript.Geometry.CoordinateSystem.ByOrigin /// </param> internal static string TypedParametersToString(FunctionDescriptor descriptor, string overridePrefix = "") { var builder = new StringBuilder(); foreach (TypedParameter tp in descriptor.Parameters) { string typeOfParameter = tp.Type.ToString(); // Check to see if there is array indexer symbols '[]', if so turn their // dimensionality into a number (e.g. 'bool[][]' turned into 'bool2'). int squareBrackets = typeOfParameter.Count(x => x == '['); if (squareBrackets > 0) { if (typeOfParameter.Contains("[]..[]")) { // Remove square brackets. typeOfParameter = typeOfParameter.Replace("[]..[]", ""); // Add number of them. typeOfParameter = String.Concat(typeOfParameter, "N"); } else { // Remove square brackets. int index = typeOfParameter.IndexOf('['); typeOfParameter = typeOfParameter.Substring(0, index).TrimEnd(); // Add number of them. typeOfParameter = String.Concat(typeOfParameter, squareBrackets.ToString()); } } if (builder.Length > 0) builder.Append("-"); typeOfParameter = typeOfParameter.Split('.').Last(); builder.Append(typeOfParameter); } // If the caller does not supply a prefix, use default logic to generate one. if (string.IsNullOrEmpty(overridePrefix)) overridePrefix = NormalizeAsResourceName(descriptor.QualifiedName); return overridePrefix + "." + builder.ToString(); }
private void AddZeroTouchNodeToSearch(FunctionDescriptor functionDescriptor) { if (functionDescriptor.IsVisibleInLibrary) { SearchModel.Add(new ZeroTouchSearchElement(functionDescriptor)); } }
/// <summary> /// Get a summary of a method from its documentation xml, /// using the corresponding FunctionDescriptor object. /// </summary> /// <param name="member">The FunctionDescriptor object corresponding to the method.</param> /// <param name="xml"></param> /// <returns>The contents of the documentation summary tag.</returns> internal static string GetSummary(this FunctionDescriptor member, XmlReader xml = null) { return(GetMemberElement(member, xml, DocumentElementType.Summary)); }