choicestr.cpp

ncbi源码

                code.Methods(inl) <<
                    "    return (*m_"<<i->cName<<");\n"
                    "}\n"
                    "\n";
                code.MethodStart(inl) <<
                    "void "<<methodPrefix<<"Set"<<i->cName<<"("<<rType<<"& value)\n"
                    "{\n";
                code.Methods(inl) <<
                    "    m_"<<i->cName<<".Reset(&value);\n"
                    "}\n"
                    "\n";
            } else {
                inlineMethods <<
                    "inline\n"
                    "bool "<<methodPrefix<<"Is"<<i->cName<<"(void) const\n"
                    "{\n"
                    "    return "STATE_MEMBER" == "STATE_PREFIX<<i->cName<<";\n"
                    "}\n"
                    "\n";
                if (i->dataType && i->dataType->IsPrimitive()) {
                    code.MethodStart(inl) << rType;
                } else if (!isNull) {
                    code.MethodStart(inl) << "const "<<rType<<"&";
                }
                if (!isNull) {
                    code.Methods(inl) <<
                        " "<<methodPrefix<<"Get"<<i->cName<<"(void) const\n"
                        "{\n"
                        "    CheckSelected("STATE_PREFIX<<i->cName<<");\n";
                    if ( i->delayed ) {
                        code.Methods(inl) <<
                            "    "DELAY_MEMBER".Update();\n";
                    }
                    code.Methods(inl) <<
                        "    return "<<constMemberRef<<";\n"
                        "}\n"
                        "\n";
                }
                if (isNull) {
                    code.MethodStart(inl) <<
                        "void "<<methodPrefix<<"Set"<<i->cName<<"(void)\n";
                } else {
                    code.MethodStart(inl) <<
                        rType<<"& "<<methodPrefix<<"Set"<<i->cName<<"(void)\n";
                }
                code.Methods(inl) <<
                    "{\n"
                    "    Select("STATE_PREFIX<<i->cName<<", NCBI_NS_NCBI::eDoNotResetVariant);\n";
                if (!isNull) {
                    if ( i->delayed ) {
                        code.Methods(inl) <<
                            "    "DELAY_MEMBER".Update();\n";
                    }
                    if (isNullWithAtt) {
                        code.Methods(inl) <<
                            "    "<<rType<<"& value = "<<memberRef<<";\n" <<
                            "    value.Set"<<i->cName<<"();\n" <<
                            "    return value;\n";
                    } else {
                        code.Methods(inl) <<
                            "    return "<<memberRef<<";\n";
                    }
                }
                code.Methods(inl) <<
                    "}\n"
                    "\n";
                if ( i->type->CanBeCopied() ) {
                    bool set_inl = i->dataType && i->dataType->IsPrimitive();
                    if (!isNull) {
                        code.MethodStart(set_inl) <<
                            "void "<<methodPrefix<<"Set"<<i->cName<<"("
                            "const " << rType << "&" << " value)\n"
                            "{\n"
                            "    Select("STATE_PREFIX<<i->cName<<", NCBI_NS_NCBI::eDoNotResetVariant);\n";
                        if ( i->delayed ) {
                            code.Methods(set_inl) <<
                                "    "DELAY_MEMBER".Forget();\n";
                        }
                        code.Methods(set_inl) <<
                            "    "<<memberRef<<" = value;\n"
                            "}\n"
                            "\n";
                    }
                }
                if ( i->memberType == eObjectPointerMember  && !isNullWithAtt) {
                    methods <<
                        "void "<<methodPrefix<<"Set"<<i->cName<<"("<<rType<<"& value)\n"
                        "{\n"
                        "    T"<<i->cName<<"* ptr = &value;\n";
                    if ( i->delayed ) {
                        methods <<
                            "    if ( "STATE_MEMBER" != "STATE_PREFIX<<i->cName<<" || "DELAY_MEMBER" || "OBJECT_MEMBER" != ptr ) {\n";
                    }
                    else {
                        methods <<
                            "    if ( "STATE_MEMBER" != "STATE_PREFIX<<i->cName<<" || "OBJECT_MEMBER" != ptr ) {\n";
                    }
                    methods <<
                        "        Reset();\n"
                        "        ("OBJECT_MEMBER" = ptr)->AddReference();\n"
                        "        "STATE_MEMBER" = "STATE_PREFIX<<i->cName<<";\n"
                        "    }\n"
                        "}\n"
                        "\n";
                    if (i->dataType) {
                        const CDataType* resolved = i->dataType->Resolve();
                        if (resolved && resolved != i->dataType) {
                            CClassTypeStrings* typeStr = resolved->GetTypeStr();
                            if (typeStr) {
                                ITERATE ( TMembers, ir, typeStr->m_Members ) {
                                    if (ir->simple) {
                                        string ircType(ir->type->GetCType(
                                            code.GetNamespace()));
                                        if (CClassCode::GetDoxygenComments()) {
                                            setters <<
                                                "\n"
                                                "    /// Select the variant and set its data.\n"
                                                "    ///\n"
                                                "    /// @param value\n"
                                                "    ///   Reference to variant data.\n";
                                        }
                                        setters <<
                                            "    void Set"<<i->cName<<"(const "<<
                                            ircType<<"& value);\n";
                                        methods <<
                                            "void "<<methodPrefix<<"Set"<<
                                            i->cName<<"(const "<<ircType<<
                                            "& value)\n"
                                            "{\n";
                                        methods <<
                                            "    Set" << i->cName <<
                                            "() = value;\n"
                                            "}\n"
                                            "\n";
                                    }
                                }
                            }
                        }
                    }
                }
            }
            setters <<
                "\n";
        }
    }

    // generate variants data
    {
        code.ClassPrivate() <<
            "    // data\n";
        if (haveAttlist) {
            ITERATE ( TVariants, i, m_Variants ) {
                if (i->attlist) {
                    code.ClassPrivate() <<
                        "    "<<ncbiNamespace<<"CRef< T"<<i->cName<<" > m_"<<i->cName<<";\n";
                }
            }
        }
        if ( haveUnion ) {
            code.ClassPrivate() << "    union {\n";
            ITERATE ( TVariants, i, m_Variants ) {
                if ( i->memberType == eSimpleMember ) {
                    if (!x_IsNullType(i)) {
                        code.ClassPrivate() <<
                            "        T"<<i->cName<<" m_"<<i->cName<<";\n";
                    }
                }
                else if ( i->memberType == ePointerMember ) {
                    code.ClassPrivate() <<
                        "        T"<<i->cName<<" *m_"<<i->cName<<";\n";
                }
            }
            if ( haveString ) {
                code.ClassPrivate() <<
                    "        "STRING_TYPE_FULL" *"STRING_MEMBER";\n";
            }
            if ( haveObjectPointer ) {
                code.ClassPrivate() <<
                    "        "OBJECT_TYPE_FULL" *"OBJECT_MEMBER";\n";
            }
            code.ClassPrivate() <<
                "    };\n";
        }
        else if ( haveString ) {
            code.ClassPrivate() <<
                "    "STRING_TYPE_FULL" "STRING_MEMBER";\n";
        }
        else if ( haveObjectPointer ) {
            code.ClassPrivate() <<
                "    "OBJECT_TYPE_FULL" *"OBJECT_MEMBER";\n";
        }
        if ( delayed ) {
            code.ClassPrivate() <<
                "    mutable "DELAY_TYPE_FULL" "DELAY_MEMBER";\n";
        }
    }

    // generate type info
    methods <<
        "// helper methods\n"
        "\n"
        "// type info\n";
    if ( haveUserClass )
        methods << "BEGIN_NAMED_BASE_CHOICE_INFO";
    else
        methods << "BEGIN_NAMED_CHOICE_INFO";
    methods <<
        "(\""<<GetExternalName()<<"\", "<<classPrefix<<GetClassNameDT()<<")\n"
        "{\n";
    if ( !GetModuleName().empty() ) {
        methods <<
            "    SET_CHOICE_MODULE(\""<<GetModuleName()<<"\");\n";
    }
    if ( delayed ) {
        methods <<
            "    SET_CHOICE_DELAYED();\n";
    }
    {
        // All or none of the choices must be tagged
        bool useTags = false;
        bool hasUntagged = false;
        // All tags must be different
        map<int, bool> tag_map;

        ITERATE ( TVariants, i, m_Variants ) {
            // Save member info
            if ( i->memberTag >= 0 ) {
                if ( hasUntagged ) {
                    NCBI_THROW(CDatatoolException,eInvalidData,
                        "No explicit tag for some members in " +
                        GetModuleName());
                }
                if ( tag_map[i->memberTag] ) {
                    NCBI_THROW(CDatatoolException,eInvalidData,
                        "Duplicate tag: " + i->cName +
                        " [" + NStr::IntToString(i->memberTag) + "] in " +
                        GetModuleName());
                }
                tag_map[i->memberTag] = true;
                useTags = true;
            }
            else {
                hasUntagged = true;
                if ( useTags ) {
                    NCBI_THROW(CDatatoolException,eInvalidData,
                        "No explicit tag for " + i->cName + " in " +
                        GetModuleName());
                }
            }

            methods << "    ADD_NAMED_";
            bool isNull = x_IsNullType(i);
            if (isNull) {
                methods << "NULL_";
            }
            
            bool addNamespace = false;
            bool addCType = false;
            bool addEnum = false;
            bool addRef = false;

            switch ( i->memberType ) {
            case ePointerMember:
                methods << "PTR_";
                addRef = true;
                break;
            case eObjectPointerMember:
                methods << "REF_";
                addCType = true;
                break;
            case eSimpleMember:
                if ( i->type->GetKind() == eKindEnum ) {
                    methods << "ENUM_";
                    addEnum = true;
                    if ( !i->type->GetNamespace().IsEmpty() &&
                         code.GetNamespace() != i->type->GetNamespace() ) {
                        _TRACE("EnumNamespace: "<<i->type->GetNamespace()<<" from "<<code.GetNamespace());
                        methods << "IN_";
                        addNamespace = true;
                    }
                }
                else if ( i->type->HaveSpecialRef() ) {
                    addRef = true;
                }
                else {
                    methods << "STD_";
                }
                break;
            case eStringMember:
                if ( haveUnion ) {
                    methods << "PTR_";
                    addRef = true;
                }
                else if ( i->type->HaveSpecialRef() ) {
                    addRef = true;
                }
                else {
                    methods << "STD_";
                }
                break;
            }

            if (i->attlist) {
                methods << "MEMBER(\"";
            } else {
                methods << "CHOICE_VARIANT(\"";
            }
            methods <<i->externalName<<"\"";
            if (!isNull) {
                methods <<", ";
            }
            switch ( i->memberType ) {
            case eObjectPointerMember:
                if (i->attlist) {
                    methods << "m_" << i->cName;
                } else {
                    methods << OBJECT_MEMBER;
                }
                break;
            case eStringMember:
                methods << STRING_MEMBER;
                break;
            default:
                if (!isNull) {
                    methods << "m_"<<i->cName;
                }
                break;
            }
            if ( addNamespace )
                methods << ", "<<i->type->GetNamespace();
            if ( addCType )
                methods << ", "<<i->type->GetCType(code.GetNamespace());
            if ( addEnum )
                methods << ", "<<i->type->GetEnumName();
            if ( addRef )
                methods << ", "<<i->type->GetRef(code.GetNamespace());
            methods <<")";
            
            if ( i->delayed ) {
                methods << "->SetDelayBuffer(MEMBER_PTR(m_delayBuffer))";
            }
            if (i->noPrefix) {
                methods << "->SetNoPrefix()";
            }
            if (i->attlist) {
                methods << "->SetAttlist()";
            }
            if (i->noTag) {
                methods << "->SetNotag()";
            }
            if ( i->memberTag >= 0 ) {
                methods << "->GetId().SetTag(" << i->memberTag << ")";
            }
            methods << ";\n";
        }
    }
    methods <<
        "}\n"
        "END_CHOICE_INFO\n"
        "\n";
}

CChoiceRefTypeStrings::CChoiceRefTypeStrings(const string& className,
                                             const CNamespace& ns,
                                             const string& fileName)
    : CParent(className, ns, fileName)
{
}

END_NCBI_SCOPE