docs: private static Map<String, IDLProxyObject> doCreatePro(List<ProtoFile> protoFiles, boolean multi, boolean debug,
              File path, boolean generateSouceOnly, File sourceOutputDir, List<CodeDependent> cds,
              Set<String> compiledClass, Map<String, String> mappedUniName, boolean isUniName) throws IOException {
  
          int count = 0;
  
          Map<String, EnumElement> enumTypes = new HashMap<String, EnumElement>();
          // package mapping
          Map<String, String> packageMapping = new HashMap<String, String>();
  
          Set<String> packages = new HashSet<String>();
          for (ProtoFile protoFile : protoFiles) {
  
              List<TypeElement> types = protoFile.typeElements();
              if (types == null || types.isEmpty()) {
                  continue;
              }
  
              String packageName = protoFile.packageName();
              // to check if option has "java_package"
              List<OptionElement> options = protoFile.options();
              if (options != null) {
                  for (OptionElement option : options) {
                      if (option.name().equals(JAVA_PACKAGE_OPTION)) {
                          packageName = option.value().toString();
                      }
                  }
              }
              packages.add(packageName);
  
              for (TypeElement type : types) {
                  packageMapping.put(type.name(), packageName);
                  packageMapping.put(type.qualifiedName(), packageName);
  
                  if (type instanceof MessageElement) {
                      count++;
                  } else {
                      enumTypes.put(type.name(), (EnumElement) type);
                      enumTypes.put(type.qualifiedName(), (EnumElement) type);
                  }
              }
          }
  
          if (!multi && count != 1) {
              throw new RuntimeException("Only one message defined allowed in '.proto' IDL");
          }
  
          // create enum type classes
          List<Class<?>> clsList = createEnumClasses(enumTypes, packageMapping, generateSouceOnly, sourceOutputDir,
                  compiledClass, mappedUniName, isUniName);
  
          for (ProtoFile protoFile : protoFiles) {
              // create message type classes
              List<Class<?>> messageClasses =
                      createMessageClass(protoFile, multi, debug, generateSouceOnly, sourceOutputDir, cds, compiledClass,
                              new HashSet<String>(enumTypes.keySet()), packages, mappedUniName, isUniName);
              clsList.addAll(messageClasses);
  
          }
  
          Map<String, IDLProxyObject> ret = new HashMap<String, IDLProxyObject>();
          for (Class cls : clsList) {
              Object newInstance;
              try {
                  if (Enum.class.isAssignableFrom(cls)) {
                      continue;
                  }
                  newInstance = cls.newInstance();
              } catch (Exception e) {
                  throw new RuntimeException(e.getMessage(), e);
              }
  
              ProtobufProxy.enableCache(false);
              try {
                  Codec codec = ProtobufProxy.create(cls, debug, path);
                  IDLProxyObject idlProxyObject = new IDLProxyObject(codec, newInstance, cls);
                  String name = cls.getSimpleName();
                  if (name.indexOf(DEFAULT_SUFFIX_CLASSNAME) != -1) {
                      name = StringUtils.substringBefore(name, DEFAULT_SUFFIX_CLASSNAME);
                  }
                  ret.put(name, idlProxyObject);
              } finally {
                  ProtobufProxy.enableCache(true);
              }
          }
  
          return ret;
      }