C# G25.GetName方法代码示例

        /// <summary>
        /// Determines whether this fgs is a converter with source 'type'/'FT'.
        /// </summary>
        public bool IsConverterSource(Specification S, G25.SMV smv, FloatType FT)
        {
            if (!IsConverter(S)) return false;

            if (!ArgumentTypeNames[0].Equals(smv.GetName())) return false;
            foreach (string floatName in FloatNames)
            {
                if (floatName.Equals(FT.type)) return true;
            }
            return false;
        }

        /// <summary>
        /// Writes all shortcuts for 'type'.
        /// </summary>
        /// <param name="SB">Where the code goes.</param>
        /// <param name="S">Used for namespace.</param>
        /// <param name="cgd">Not used yet.</param>
        /// <param name="FT">Float point type of 'type'.</param>
        /// <param name="type">The type for which the function should be written.</param>
        public static void WriteFunctionShortcuts(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.VariableType type)
        {
            Dictionary<string, List<G25.Operator>> operatorMap = S.GetOperatorMap();
            Dictionary<string, bool> boundOperators = new Dictionary<string, bool>();

            foreach (G25.fgs fgs in S.m_functions)
            {
                if ((type is G25.SMV) && fgs.IsConverter(S))
                {
                    G25.SMV smv = (G25.SMV)type;
                    if (fgs.IsConverterSource(S, (G25.SMV)type, FT))
                    {
                        // write converter here . . .
                        //SB.AppendLine("// converter source here!");
                    } else if (fgs.IsConverterDestination(S, smv, FT))
                    {
                        // write converter here . . .
                        Converter.WriteMemberConverter(SB, S, cgd, FT, fgs, (G25.SMV)S.GetType(fgs.ArgumentTypeNames[0]), smv);
                    }
                }
                else if (fgs.GetSupportedByPlugin() && (fgs.NbArguments >= 1) && (Array.IndexOf(fgs.FloatNames, FT.type) >= 0))
                {

                    // get function arguments
                    bool computeMultivectorValue = false;
                    G25.CG.Shared.FuncArgInfo[] FAI = null;
                    try
                    {
                        FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, fgs, fgs.NbArguments, FT, "not set", computeMultivectorValue);
                    }
                    catch (Exception ex)
                    {
                        if ((type is G25.GMV) && (FT == S.m_floatTypes[0])) // only warn once
                            Console.WriteLine("Warning: cannot generate shortcut to " + fgs.ToString());
                        continue;
                    }

                    // if type matches, write the shortcut, and possibly an operator
                    if (FAI[0].TypeName.Equals(type.GetName()))
                    {
                        WriteFunctionShortcut(SB, S, cgd, FT, type, fgs, FAI);
                        if (S.OutputCSharpOrJava())
                            removeMvInterfaces(FAI); // arguments to operators need to be of the multivector type, not the multivector interface type
                        WriteOperatorShortcut(SB, S, cgd, FT, type, fgs, FAI, operatorMap, boundOperators);
                    }

                }
            }
        }

        /// <summary>
        /// Determines whether this fgs is a converter for destination 'type'/'FT'.
        /// </summary>
        public bool IsConverterDestination(Specification S, G25.SMV smv, FloatType FT)
        {
            if (!IsConverter(S)) return false;

            if (!Name.Equals("_" + smv.GetName())) return false;
            foreach (string floatName in FloatNames)
            {
                if (floatName.Equals(FT.type)) return true;
            }
            return false;
        }

        private static void WriteOperatorShortcut(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.VariableType type,
            G25.fgs fgs, FuncArgInfo[] FAI, G25.Operator op)
        {
            // C# does not allow return type of ++ or -- to be different from input type
            if (S.OutputCSharp() &&
                (op.IsIncrement() || op.IsDecrement()) &&
                (fgs.ReturnTypeName != type.GetName()))
                return;

            string operatorCall = getOperatorCall(S, fgs, FAI);

            SB.AppendLine("");

            int nbTabs = 1;
            // output comment
            new Comment("operator for " + operatorCall).Write(SB, S, nbTabs);

            bool inline = false;
            bool staticFunc = true;
            string returnType = FT.GetMangledName(S, fgs.ReturnTypeName);
            FuncArgInfo returnArgument = null;

            SB.Append('\t', nbTabs);
            Functions.WriteDeclaration(SB, S, cgd,
                inline, staticFunc, returnType, "operator " + op.Symbol,
                returnArgument, FAI);
            SB.AppendLine(" {");

            SB.Append('\t', nbTabs+1);
            SB.Append("return ");
            SB.Append(operatorCall);
            SB.AppendLine(";");

            SB.Append('\t', nbTabs);
            SB.AppendLine("}");
        }