include/codegen/idl_namer.h

#ifndef FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_
#define FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_

#include "codegen/namer.h"
#include "flatbuffers/idl.h"

namespace flatbuffers {

// Provides Namer capabilities to types defined in the flatbuffers IDL.
class IdlNamer : public Namer {
 public:
  explicit IdlNamer(Config config, std::set<std::string> keywords)
      : Namer(config, std::move(keywords)) {}

  using Namer::Constant;
  using Namer::Directories;
  using Namer::Field;
  using Namer::File;
  using Namer::Function;
  using Namer::Method;
  using Namer::Namespace;
  using Namer::NamespacedType;
  using Namer::ObjectType;
  using Namer::Type;
  using Namer::Variable;
  using Namer::Variant;

  std::string Constant(const FieldDef& d) const { return Constant(d.name); }

  // Types are always structs or enums so we can only expose these two
  // overloads.
  std::string Type(const StructDef& d) const { return Type(d.name); }
  std::string Type(const EnumDef& d) const { return Type(d.name); }

  std::string Function(const Definition& s) const { return Function(s.name); }
  std::string Function(const std::string& prefix, const Definition& s) const {
    return Function(prefix + s.name);
  }

  std::string Field(const FieldDef& s) const { return Field(s.name); }
  std::string Field(const FieldDef& d, const std::string& s) const {
    return Field(d.name + "_" + s);
  }

  std::string Variable(const FieldDef& s) const { return Variable(s.name); }

  std::string Variable(const StructDef& s) const { return Variable(s.name); }

  std::string Variant(const EnumVal& s) const { return Variant(s.name); }

  std::string EnumVariant(const EnumDef& e, const EnumVal& v) const {
    return Type(e) + config_.enum_variant_seperator + Variant(v);
  }

  std::string ObjectType(const StructDef& d) const {
    return ObjectType(d.name);
  }
  std::string ObjectType(const EnumDef& d) const { return ObjectType(d.name); }

  std::string Method(const FieldDef& d, const std::string& suffix) const {
    return Method(d.name, suffix);
  }
  std::string Method(const std::string& prefix, const StructDef& d) const {
    return Method(prefix, d.name);
  }
  std::string Method(const std::string& prefix, const FieldDef& d) const {
    return Method(prefix, d.name);
  }
  std::string Method(const std::string& prefix, const FieldDef& d,
                     const std::string& suffix) const {
    return Method(prefix, d.name, suffix);
  }

  std::string Namespace(const struct Namespace& ns) const {
    return Namespace(ns.components);
  }

  std::string NamespacedEnumVariant(const EnumDef& e, const EnumVal& v) const {
    return NamespacedString(e.defined_namespace, EnumVariant(e, v));
  }

  std::string NamespacedType(const Definition& def) const {
    return NamespacedString(def.defined_namespace, Type(def.name));
  }

  std::string NamespacedObjectType(const Definition& def) const {
    return NamespacedString(def.defined_namespace, ObjectType(def.name));
  }

  std::string Directories(const struct Namespace& ns,
                          SkipDir skips = SkipDir::None,
                          Case input_case = Case::kUpperCamel) const {
    return Directories(ns.components, skips, input_case);
  }

  // Legacy fields do not really follow the usual config and should be
  // considered for deprecation.

  std::string LegacyRustNativeVariant(const EnumVal& v) const {
    return ConvertCase(EscapeKeyword(v.name), Case::kUpperCamel);
  }

  std::string LegacyRustFieldOffsetName(const FieldDef& field) const {
    return "VT_" + ConvertCase(EscapeKeyword(field.name), Case::kAllUpper);
  }
  std::string LegacyRustUnionTypeOffsetName(const FieldDef& field) const {
    return "VT_" +
           ConvertCase(EscapeKeyword(field.name + "_type"), Case::kAllUpper);
  }

  std::string LegacySwiftVariant(const EnumVal& ev) const {
    auto name = ev.name;
    if (isupper(name.front())) {
      std::transform(name.begin(), name.end(), name.begin(), CharToLower);
    }
    return EscapeKeyword(ConvertCase(name, Case::kLowerCamel));
  }

  // Also used by Kotlin, lol.
  std::string LegacyJavaMethod2(const std::string& prefix, const StructDef& sd,
                                const std::string& suffix) const {
    return prefix + sd.name + suffix;
  }

  std::string LegacyKotlinVariant(EnumVal& ev) const {
    // Namer assumes the input case is snake case which is wrong...
    return ConvertCase(EscapeKeyword(ev.name), Case::kLowerCamel);
  }
  // Kotlin methods escapes keywords after case conversion but before
  // prefixing and suffixing.
  std::string LegacyKotlinMethod(const std::string& prefix, const FieldDef& d,
                                 const std::string& suffix) const {
    return prefix + ConvertCase(EscapeKeyword(d.name), Case::kUpperCamel) +
           suffix;
  }
  std::string LegacyKotlinMethod(const std::string& prefix, const StructDef& d,
                                 const std::string& suffix) const {
    return prefix + ConvertCase(EscapeKeyword(d.name), Case::kUpperCamel) +
           suffix;
  }

  // This is a mix of snake case and keep casing, when Ts should be using
  // lower camel case.
  std::string LegacyTsMutateMethod(const FieldDef& d) {
    return "mutate_" + d.name;
  }

  std::string LegacyRustUnionTypeMethod(const FieldDef& d) {
    // assert d is a union
    // d should convert case but not escape keywords due to historical reasons
    return ConvertCase(d.name, config_.fields, Case::kLowerCamel) + "_type";
  }

 private:
  std::string NamespacedString(const struct Namespace* ns,
                               const std::string& str) const {
    std::string ret;
    if (ns != nullptr) {
      ret += Namespace(ns->components);
    }
    if (!ret.empty()) ret += config_.namespace_seperator;
    return ret + str;
  }
};

// This is a temporary helper function for code generators to call until all
// flag-overriding logic into flatc.cpp
inline Namer::Config WithFlagOptions(const Namer::Config& input,
                                     const IDLOptions& opts,
                                     const std::string& path) {
  Namer::Config result = input;
  result.object_prefix = opts.object_prefix;
  result.object_suffix = opts.object_suffix;
  result.output_path = path;
  result.filename_suffix = opts.filename_suffix;
  return result;
}

}  // namespace flatbuffers

#endif  // FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_