protected void createEnum(CompounddefType compounddefType, INamedElement element)
     throws InvalidEditingException {
   List<SectiondefType> sectiondefTypes = compounddefType.getSectiondef();
   for (SectiondefType sectiondefType : sectiondefTypes) {
     List<MemberdefType> memberdefTypes = sectiondefType.getMemberdef();
     for (MemberdefType memberdefType : memberdefTypes) {
       if (memberdefType.getKind() != DoxMemberKind.ENUM) {
         continue;
       }
       Type type = this.typeUtil.createEnumType(memberdefType);
       IClass enumClass = null;
       try {
         if (element instanceof IPackage) {
           enumClass = this.basicModelEditor.createClass((IPackage) element, type.getName());
         } else if (element instanceof IClass) {
           enumClass = this.basicModelEditor.createClass((IClass) element, type.getName());
         }
       } catch (InvalidEditingException e) {
         // グローバルで同名は存在するので無視する
         if (!e.getKey().equals(InvalidEditingException.NAME_DOUBLE_ERROR_KEY)) {
           throw e;
         }
       }
       if (enumClass == null) {
         break;
       }
       enumClass.addStereotype(STEREOTYPE_ENUM);
       enumClass.setVisibility(type.getVisiblity());
       List<EnumvalueType> enumvalues = memberdefType.getEnumvalue();
       if (enumvalues == null) {
         break;
       }
       for (EnumvalueType enumvalue : enumvalues) {
         Type enumtype = this.typeUtil.createEnumType(enumvalue);
         try {
           IAttribute enumAttribute =
               this.basicModelEditor.createAttribute(enumClass, enumtype.getName(), enumClass);
           enumAttribute.setVisibility(enumtype.getVisiblity());
           enumAttribute.setInitialValue(enumtype.getInitialValue());
           // enum なので static とする
           enumAttribute.setStatic(true);
         } catch (InvalidEditingException e) {
           // 同じネームスペース名で同じ名前のEnumの中に同じ名前の定数を宣言しているときは例外を出したくない
           if (!e.getKey().equals(InvalidEditingException.NAME_DOUBLE_ERROR_KEY)) {
             throw e;
           }
         }
       }
     }
   }
 }
 protected void createAttribute(
     IClass clazz, Type type, MemberdefType memberdefType, IClass findClass, boolean isAssociation)
     throws InvalidEditingException {
   IAttribute attribute = null;
   boolean memberEnd = false;
   if (LanguageManager.PRIMITIVE_TYPE.contains(type.getNamespaceClass().clazz)) {
     attribute =
         this.basicModelEditor.createAttribute(
             clazz, type.getName(), type.getNamespaceClass().clazz);
   } else if (!isEmpty(type.getTemplates())) {
     attribute =
         this.basicModelEditor.createAttribute(
             clazz, type.getName(), astahModelUtil.clearNamespace(type.getTemplateParameter()));
   } else {
     if (findClass == null) {
       if (type.getNamespaceClass() != null && !isEmpty(type.getNamespaceClass().clazz)) {
         IPackage pkg =
             this.astahModelUtil.getModelWithPath(
                 IPackage.class, project, type.getNamespaceClass().namespace);
         if (pkg == null) {
           pkg = project;
         }
         findClass = this.basicModelEditor.createClass(pkg, type.getNamespaceClass().clazz);
         if (isAssociation) {
           attribute = this.createAssosiation(clazz, type, findClass);
           memberEnd = true;
         } else {
           attribute = this.basicModelEditor.createAttribute(clazz, type.getName(), findClass);
         }
       }
     } else {
       if (isAssociation) {
         attribute = this.createAssosiation(clazz, type, findClass);
         memberEnd = true;
       } else {
         attribute = this.basicModelEditor.createAttribute(clazz, type.getName(), findClass);
       }
     }
   }
   if (attribute == null) {
     return;
   }
   this.setLanguage(CPLUS_ATTRIBUTE, attribute);
   // 属性のその他属性を作成
   attribute.setStatic(type.isStatic());
   attribute.setVisibility(type.getVisiblity());
   attribute.setDefinition(this.parseDescription(memberdefType.getDetaileddescription()));
   if (!isEmpty(type.getTypeModifier())) {
     attribute.setTypeModifier(type.getTypeModifier());
   }
   if (!memberEnd && type.isConst()) {
     this.createTaggedValue(attribute, "jude.c_plus.const", "true");
   }
   if (!memberEnd && type.isVolatile()) {
     this.createTaggedValue(attribute, "jude.c_plus.volatile", "true");
   }
   if (!memberEnd && type.isMutable()) {
     this.createTaggedValue(attribute, "jude.c_plus.mutable", "true");
   }
 }
 private void createInheritanceFromBaseCompoundDef(CompounddefType compounddefType, IClass clazz)
     throws ProjectNotFoundException, InvalidEditingException {
   List<CompoundRefType> basecompoundrefs = compounddefType.getBasecompoundref();
   // 2つ同名の親が設定されているxmlがあるので、同じものは親としないためのチェック用。
   Set<String> generalizations = new HashSet<>();
   for (CompoundRefType basecompoundref : basecompoundrefs) {
     Type type = this.typeUtil.createType(basecompoundref);
     IGeneralization generalization = null;
     try {
       IClass baseClass = this.findClass(type);
       if (baseClass == null) {
         if (type.getNamespaceClass() != null || !isEmpty(type.getNamespaceClass().clazz)) {
           IClass generalizationClass =
               this.basicModelEditor.createClass(
                   createPackage(type), type.getNamespaceClass().clazz);
           generalization =
               this.basicModelEditor.createGeneralization(clazz, generalizationClass, "");
           generalizations.add(type.getNamespaceClass().getFullName());
         } else {
           LOG.info(
               "not created generalization. clazz:{}, type:{}", clazz.getName(), type.getName());
           continue;
         }
       } else {
         if (!generalizations.contains(type.getNamespaceClass().getFullName())) {
           generalization = this.basicModelEditor.createGeneralization(clazz, baseClass, "");
           generalizations.add(type.getNamespaceClass().getFullName());
         } else {
           LOG.info(
               "generalization already exists. generalization:{}, clazz:{}, baseClass:{}",
               type.getNamespaceClass().getFullName(),
               clazz,
               baseClass);
           continue;
         }
       }
       if (!isEmpty(type.getVisiblity())) {
         generalization.setVisibility(type.getVisiblity());
       }
     } catch (InvalidEditingException e) {
       if (!e.getKey().equals(InvalidEditingException.NAME_DOUBLE_ERROR_KEY)) {
         throw e;
       }
       LOG.info("invalid editing {},{}", clazz.getName(), type.getName());
     }
   }
 }
 protected void createOperation(
     IClass clazz, Type type, MemberdefType memberdefType, IClass findClass)
     throws InvalidEditingException, ProjectNotFoundException {
   IOperation operation = null;
   if (LanguageManager.PRIMITIVE_TYPE.contains(type.getNamespaceClass().clazz)) {
     operation =
         this.basicModelEditor.createOperation(
             clazz, type.getName(), type.getNamespaceClass().clazz);
   } else {
     if (findClass == null) {
       if (clazz.getName().equals(type.getName())
           || format("~%s", clazz.getName()).equals(type.getName())) {
         operation = this.basicModelEditor.createOperation(clazz, type.getName(), "");
       } else if (type.getNamespaceClass() != null && !isEmpty(type.getNamespaceClass().clazz)) {
         operation =
             this.basicModelEditor.createOperation(
                 clazz, type.getName(), type.getNamespaceClass().clazz);
       }
     } else {
       operation =
           this.basicModelEditor.createOperation(clazz, type.getName(), (IClass) findClass);
     }
   }
   if (operation == null) {
     return;
   }
   // 操作のその他属性を作成
   this.setLanguage(CPLUS_OPERATION, operation);
   this.createParameter(operation, memberdefType.getParam());
   operation.setDefinition(this.parseDescription(memberdefType.getDetaileddescription()));
   operation.setVisibility(type.getVisiblity());
   if (type.isConst()) {
     this.createTaggedValue(operation, "jude.c_plus.const", "true");
   }
   if (type.getVirt().equals(DoxVirtualKind.VIRTUAL.value())
       || type.getVirt().equals(DoxVirtualKind.PURE_VIRTUAL.value())) {
     this.createTaggedValue(operation, "jude.c_plus.virtual", "true");
   }
   if (type.isExplicit()) {
     this.createTaggedValue(operation, "jude.c_plus.explicit", "true");
   }
   if (type.isInline()) {
     this.createTaggedValue(operation, "jude.c_plus.inline", "true");
   }
   if (type.isFriend()) {
     this.createTaggedValue(operation, "jude.c_plus.friend", "true");
   }
 }