Example #1
0
void UmlClass::write(QTextStream & f, const UmlTypeSpec & t,
                     bool with_formals, BooL * is_template)
{
    if (t.type != 0)
        t.type->write(f, with_formals, is_template);
    else {
        WrapperStr s = CppSettings::type(t.explicit_type);

        f << s;

        if (is_template != 0)
            *is_template = (!s.isEmpty() && (s.at(s.length() - 1) == QString('>')));
    }

}
Example #2
0
WrapperStr UmlItem::legalName(WrapperStr s)
{
    unsigned index;
    unsigned n = s.length();

    for (index = 0; index != n; index += 1) {
        char c = s.at(index);

        if (!(((c >= 'a') && (c <= 'z')) ||
              ((c >= 'A') && (c <= 'Z')) ||
              ((c >= '0') && (c <= '9')) ||
              (c == '_')))
            s.replace(index, 1, "_");
    }

    return s;
}
Example #3
0
WrapperStr UmlClass::decl()
{
    WrapperStr result;
    WrapperStr close_template;
    UmlArtifact * cp = associatedArtifact();
    WrapperStr nasp = ((UmlPackage *)
                      ((cp != 0) ? (UmlItem *) cp : (UmlItem *) this)->package())
                     ->cppNamespace();

    if (!nasp.isEmpty()) {
        int index =
            // bypass :: allowing ::a...
            ((nasp.at(0) == ":") && (nasp != QString("::"))) ? 2 : 0;
        int index2 = 0;

        while ((index2 = nasp.find("::", index)) != -1) {
            result += "namespace " + nasp.mid(index, index2 - index) + " { ";
            close_template += " } ";
            index = index2 + 2;
        }

        result += "namespace " + nasp.mid(index) + " { ";
        close_template += " } ";
    }

    WrapperStr template1;
    WrapperStr template2;

    get_template_prefixes(template1, template2);

    if (!template1.isEmpty())
        result += template1.left(template1.length() - 1) + ' ';

    result += cpp_stereotype() + ' ';

    return result + name() + ';' + close_template + '\n';
}
Example #4
0
bool UmlAttribute::new_one(Class * container, const WrapperStr & name,
                           UmlTypeSpec typespec, aVisibility visibility,
                           bool staticp, bool finalp, bool transientp,
                           bool volatilep, const WrapperStr & array,
                           const WrapperStr & value, WrapperStr comment,
                           WrapperStr description, WrapperStr annotation
#ifdef ROUNDTRIP
                           , bool roundtrip, QList<UmlItem *> & expected_order
#endif
                          )
{
#ifdef TRACE
    QLOG_INFO() << "ATTRIBUTE '" << name << "'\n";
#endif

    if (
#ifdef REVERSE
        container->from_libp() && (
#endif
                                   visibility == PrivateVisibility
#ifdef REVERSE
                                   )
#endif
        )
    {
        Lex::finish_line();
        Lex::clear_comments();
        return TRUE;
    }

    UmlClass * cl = container->get_uml();
    UmlAttribute * at;

#ifdef ROUNDTRIP
    bool created;

    if (!roundtrip ||
        ((at = search_attr(container, name)) == 0)) {
#endif
        at = UmlBaseAttribute::create(cl, name);

        if (at == 0) {
            JavaCatWindow::trace(WrapperStr("<font face=helvetica><b>cannot add attribute <i>")
                                 + name + "</i> in <i>" + cl->name()
                                 + "</i></b></font><br>");
            return FALSE;
        }

#ifdef REVERSE
# ifndef ROUNDTRIP
        Statistic::one_attribute_more();
# else

        if (roundtrip)
            container->set_updated();

        created = TRUE;
    }
    else
        created = FALSE;

# endif
#endif

        Lex::finish_line();

        comment = Lex::get_comments(comment);
        description = Lex::get_description(description);

        WrapperStr decl = JavaSettings::attributeDecl("");
        int index = decl.find("${type}");

        if ((index == -1) || (decl.find("${name}") == -1)) {
            decl = "  ${comment}${@}${visibility}${static}${final}${transient}${volatile}${type} ${name}${value};";
            index = decl.find("${type}");
        }

#ifdef ROUNDTRIP

        if (roundtrip && !created) {
            if (decl.find("${description}") != -1) {
                if (nequal(at->description(), description)) {
                    at->set_Description(description);
                    container->set_updated();
                }
            }
            else if (nequal(at->description(), Lex::simplify_comment(comment))) {
                at->set_Description(comment); // comment was set
                container->set_updated();
            }

            if (at->isReadOnly() != finalp) {
                at->set_isReadOnly(finalp);
                container->set_updated();
            }

            if (at->isJavaTransient() != transientp) {
                at->set_isJavaTransient(transientp);
                container->set_updated();
            }

            if (at->isVolatile() != volatilep) {
                at->set_isVolatile(volatilep);
                container->set_updated();
            }

            if (at->isClassMember() != staticp) {
                at->set_isClassMember(staticp);
                container->set_updated();
            }

            if (!array.isEmpty())
                decl.insert(index + 7, "${multiplicity}");

            if (neq(at->multiplicity(), array)) {
                at->set_Multiplicity(array);
                container->set_updated();
            }

            WrapperStr v = at->defaultValue();

            if (!v.isEmpty() && (((const char *) v)[0] == '='))
                v = v.mid(1);

            if (nequal(v, value)) {
                at->set_DefaultValue(value);
                container->set_updated();
            }

            if (nequal(at->javaAnnotations(), annotation)) {
                at->set_JavaAnnotations(annotation);
                container->set_updated();
            }

            WrapperStr stereotype;
            bool force_ste = FALSE;

            if (cl->stereotype() == "enum") {
                stereotype = "attribute";
                force_ste = TRUE;
            }
            else if (typespec.type == 0) {
                WrapperStr t = typespec.explicit_type;
                int index2;

                if (!t.isEmpty() &&
                    (t.at(t.length() - 1) == ">") &&
                    ((index2 = t.find('<')) > 0)) {
                    stereotype = t.left(index2);
                    typespec.explicit_type =
                        // may be a,b ...
                        t.mid(index2 + 1, t.length() - 2 - index2);
                    decl.replace(index, 7, "${stereotype}<${type}>");
                    force_ste = TRUE;
                }
            }

            if (at->visibility() != visibility) {
                at->set_Visibility(visibility);
                container->set_updated();
            }

            if (neq(at->stereotype(), stereotype)) {
                WrapperStr jst;

                if (! at->stereotype().isEmpty())
                    jst = JavaSettings::relationAttributeStereotype(at->stereotype());

                if ((force_ste) ? (jst != stereotype) : (jst == "attribute")) {
                    at->set_Stereotype(stereotype);
                    container->set_updated();
                }
            }

            if (neq(at->javaDecl(), decl)) {
                at->set_JavaDecl(decl);
                container->set_updated();
            }

            if (!at->type().equal(typespec)) {
                at->set_Type(typespec);
                container->set_updated();
            }

            at->set_usefull();

            expected_order.append(at);
        }
        else {
#endif

            if (!comment.isEmpty())
                at->set_Description((decl.find("${description}") != -1)
                                    ? description : Lex::simplify_comment(comment));

            if (finalp)
                at->set_isReadOnly(TRUE);

            if (transientp)
                at->set_isJavaTransient(TRUE);

            if (volatilep)
                at->set_isVolatile(TRUE);

            if (staticp)
                at->set_isClassMember(TRUE);

            if (!array.isEmpty()) {
                decl.insert(index + 7, "${multiplicity}");
                at->set_Multiplicity(array);
            }

            if (! value.isEmpty())
                at->set_DefaultValue(value);

            if (! annotation.isEmpty())
                at->set_JavaAnnotations(annotation);

            if ((typespec.type == 0) && (cl->stereotype() != "enum")) {
                WrapperStr t = typespec.explicit_type;
                int index2 = 0;

                if (!t.isEmpty() &&
                        (t.at(t.length() - 1) == ">") &&
                    ((index2 = t.find('<')) > 0))
                {
                    at->set_Stereotype(t.left(index2));
                    typespec.explicit_type =
                        // may be a,b ...
                        t.mid(index2 + 1, t.length() - 2 - index2);
                    decl.replace(index, 7, "${stereotype}<${type}>");
                }
            }

            at->set_Visibility(visibility);

            if (cl->stereotype() == "enum") {
                at->set_JavaDecl(decl);
                at->set_Stereotype("attribute");
            }
            else if (decl != JavaSettings::attributeDecl(""))
                at->set_JavaDecl(decl);

            at->set_Type(typespec);

#ifdef ROUNDTRIP

            if (roundtrip)
                expected_order.append(at);
        }

#endif

        return TRUE;
    }
Example #5
0
void UmlClass::write(QTextStream & f, bool with_formals, BooL * is_template,
                     const QList<UmlActualParameter> & actuals)
{
    if (! context.contains(this)) {
        if (parent()->kind() == aClass) {
            if (! context.contains((UmlClass *) parent())) {
                // parent cannot have formals, but may have actuals
                ((UmlClass *) parent())->write(f, FALSE, 0, actuals);
                f << "::";
            }
        }
        else {
            UmlArtifact * cp = associatedArtifact();
            WrapperStr nasp = ((UmlPackage *)
                              ((cp != 0) ? (UmlItem *) cp : (UmlItem *) this)->package())
                             ->cppNamespace();

            if (CppSettings::isForceNamespacePrefixGeneration() ||
                (nasp != UmlArtifact::generation_package()->cppNamespace()))
                f << nasp << "::";
        }
    }

    WrapperStr s;

    if (isCppExternal()) {
        s = cppDecl();

        int index = s.find('\n');

        s = (index == -1) ? s.stripWhiteSpace()
            : s.left(index).stripWhiteSpace();

        if ((index = s.find("${name}")) != -1)
            s.replace(index, 7, name());
        else if ((index = s.find("${Name}")) != -1)
            s.replace(index, 7, capitalize(name()));
        else if ((index = s.find("${NAME}")) != -1)
            s.replace(index, 7, name().upper().toLatin1().constData());
        else if ((index = s.find("${nAME}")) != -1)
            s.replace(index, 7, name().lower().toLatin1().constData());
    }
    else
        s = name();	// true_name

    if (! s.isEmpty()) {
        f << s;

        if (is_template != 0)
            *is_template = (s.at(s.length() - 1) == QString('>'));
    }
    else if (is_template != 0)
        *is_template = FALSE;

    if (with_formals) {
        QList<UmlFormalParameter> formals = this->formals();

        if (! formals.isEmpty()) {
            const char * sep = "<";
            QList<UmlFormalParameter>::ConstIterator it;

            for (it = formals.begin(); it != formals.end(); ++it) {
                f << sep << (*it).name();
                sep = ", ";
            }

            f << '>';

            if (is_template != 0)
                *is_template = TRUE;
        }
    }
    else if (!actuals.isEmpty()) {
        QList<UmlActualParameter>::ConstIterator ita;
        BooL need_space = FALSE;
        bool used = FALSE;

        for (ita = actuals.begin(); ita != actuals.end(); ++ita) {
            if ((*ita).superClass() == this) {
                used = TRUE;
                (*ita).generate(f, need_space);
            }
        }

        if (used) {
            if (need_space)
                f << " >";
            else
                f << '>';

            if (is_template != 0)
                *is_template = TRUE;
        }
    }
}
Example #6
0
bool UmlAttribute::new_one(Class * container, const WrapperStr & name,
                           const WrapperStr & type, const WrapperStr & modifier,
                           const WrapperStr & pretype, const WrapperStr & array,
                           aVisibility visibility, bool staticp, bool constp,
                           bool typenamep, bool mutablep, bool volatilep,
                           const WrapperStr & bitfield, const WrapperStr & value,
                           WrapperStr comment, WrapperStr description
#ifdef ROUNDTRIP
                           , bool roundtrip, QList<UmlItem *> & expected_order
#endif
                          )
{
#ifdef DEBUG_DOUML
    QLOG_INFO() << "ATTRIBUTE '" << name << "' type '" << type << "' modifier '" << modifier << "' array '" << array << "'\n";
#endif

    if (
#ifdef REVERSE
        container->from_libp() &&
#endif
        (visibility == PrivateVisibility)) {
        Lex::finish_line();
        Lex::clear_comments();
        return TRUE;
    }

    UmlClass * cl = container->get_uml();
    UmlAttribute * at;

#ifdef ROUNDTRIP
    bool created;

    if (!roundtrip ||
        ((at = search_attr(cl, name)) == 0)) {
#endif
        at = UmlBaseAttribute::create(cl, name);

        if (at == 0) {
            UmlCom::trace(WrapperStr("<font face=helvetica><b>cannot add attribute <i>")
                          + name + "</i> in <i>" + WrapperStr(cl->name())
                          + "</i></b></font><br><hr>");
            return FALSE;
        }

#ifdef REVERSE
# ifndef ROUNDTRIP
        Statistic::one_attribute_more();
# else

        if (roundtrip)
            container->set_updated();

        created = TRUE;
    }
    else
        created = FALSE;

# endif
#endif

        Lex::finish_line();

        comment = Lex::get_comments(comment);
        description = Lex::get_description(description);

        bool pfunc = (type.find('$') != -1);
        UmlTypeSpec typespec;
        WrapperStr typeform;
        WrapperStr stereotype;

        if (! pfunc) {
            typeform = (pretype.isEmpty())
                       ? WrapperStr("${type}")
                       : pretype + " ${type}";

            container->compute_type(type, typespec, typeform);
        }
        else {
            typespec.explicit_type = type.simplifyWhiteSpace();

            int index = typespec.explicit_type.find("${name}");

            if (index != -1)
                typespec.explicit_type.remove(index, 7);
        }

        WrapperStr decl = CppSettings::attributeDecl("");
        int index = decl.find("${type}");

        if ((index == -1) ||
            (decl.find("${const}") == -1) ||
            (decl.find("${name}") == -1) ||
            (decl.find("${mutable}") == -1) ||
            (decl.find("${volatile}") == -1) ||
            (decl.find(';') == -1)) {
            decl = "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};";
            index = decl.find("${type}");
        }

        if (pfunc)
            decl.replace(index, decl.find("${name}") + 7 - index, type);
        else {
            if (!modifier.isEmpty())
                decl.insert(index + 7, (const char *)(WrapperStr(" ") + modifier));

            if (typeform != "${type}")
                decl.replace(index, 7, typeform);
            else if (typespec.type == 0) {
                WrapperStr t = typespec.explicit_type;
                int index2 = 0;

                if (!t.isEmpty() && (t.at(t.length() - 1) == ">") && ((index2 = t.find('<')) > 0))
                {
                    stereotype = t.left(index2);
                    typespec.explicit_type =
                        // may be a,b ...
                        t.mid(index2 + 1, t.length() - 2 - index2);
                    decl.replace(index, 7, "${stereotype}<${type}>");
                }
            }

            if (!array.isEmpty())
                decl.insert(decl.find("${name}") + 7, "${multiplicity}");

            if (!bitfield.isEmpty())
                decl.insert(decl.find(';'), (const char *)(WrapperStr(" : ") + bitfield));
        }

        if (typenamep) {
            int index = decl.find("${const}") + 8; // find cannot return -1
            int index2 = decl.find("${mutable}") + 10; // find cannot return -1
            int index3 = decl.find("${volatile}") + 11; // find cannot return -1

            if (index2 > index) index = index2;

            if (index3 > index) index = index3;

            decl.insert(index, "typename ");
        }

        if (!value.isEmpty() && ((index = decl.find("${value}")) != -1))
            decl.insert(index + 2,  "h_");

#ifdef ROUNDTRIP

        if (roundtrip && !created) {
            if (decl.find("${description}") != -1) {
                if (nequal(at->description(), description)) {
                    at->set_Description(description);
                    container->set_updated();
                }
            }
            else if (nequal(at->description(), Lex::simplify_comment(comment))) {
                at->set_Description(comment); // comment was set
                container->set_updated();
            }

            if (at->isReadOnly() != constp) {
                at->set_isReadOnly(constp);
                container->set_updated();
            }

            if (at->isCppMutable() != mutablep) {
                at->set_isCppMutable(mutablep);
                container->set_updated();
            }

            if (at->isVolatile() != volatilep) {
                at->set_isVolatile(volatilep);
                container->set_updated();
            }

            if (at->isClassMember() != staticp) {
                at->set_isClassMember(staticp);
                container->set_updated();
            }

            if (neq(at->multiplicity(), array)) {
                at->set_Multiplicity(array);
                container->set_updated();
            }

            if (!staticp) {
                WrapperStr v = at->defaultValue();

                if (!v.isEmpty() && (((const char *) v)[0] == '='))
                    v = v.mid(1);

                if (nequal(v, value)) {
                    at->set_DefaultValue(value);
                    container->set_updated();
                }
            }

            if (at->visibility() != visibility) {
                at->set_Visibility(visibility);
                container->set_updated();
            }

            if (!stereotype.isEmpty()) {
                WrapperStr cppst;

                if (!at->stereotype().isEmpty())
                    cppst = CppSettings::relationAttributeStereotype(at->stereotype());

                if (cppst != stereotype) {
                    at->set_Stereotype(stereotype);
                    container->set_updated();
                }
            }

            if (!at->type().equal(typespec)) {
                at->set_Type(typespec);
                container->set_updated();
            }

            if (neq(at->cppDecl(), decl)) {
                at->set_CppDecl(decl);
                container->set_updated();
            }

            at->set_usefull();

            expected_order.append(at);
        }
        else {
#endif

            if (!comment.isEmpty())
                at->set_Description((decl.find("${description}") != -1)
                                    ? description : Lex::simplify_comment(comment));

            if (constp)
                at->set_isReadOnly(TRUE);

            if (mutablep)
                at->set_isCppMutable(TRUE);

            if (volatilep)
                at->set_isVolatile(TRUE);

            if (staticp)
                at->set_isClassMember(TRUE);

            if (!array.isEmpty())
                at->set_Multiplicity(array);

            if (! value.isEmpty())
                at->set_DefaultValue(value);

            at->set_Visibility(visibility);

            if (! stereotype.isEmpty())
                at->set_Stereotype(stereotype);

            at->set_Type(typespec);

            at->set_CppDecl(decl);

#ifdef ROUNDTRIP

            if (roundtrip)
                expected_order.append(at);
        }

#endif

        return TRUE;
    }