string t_java_deprecated_generator::render_const_value()

in thrift/compiler/generate/t_java_deprecated_generator.cc [406:527]

• 120 lines of code
• 27 McCabe index (conditional complexity)

string t_java_deprecated_generator::render_const_value(
    ostream& out,
    string /* unused */,
    const t_type* type,
    const t_const_value* value) {
  type = type->get_true_type();
  std::ostringstream render;
  if (type->is_base_type()) {
    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
    switch (tbase) {
      case t_base_type::TYPE_STRING:
      case t_base_type::TYPE_BINARY: {
        render << '"';
        auto& rawValue = value->get_string();
        for (std::string::size_type i = 0; i < rawValue.size();) {
          switch (rawValue[i]) {
            case '\\': {
              render << rawValue[i];
              ++i;
              assert(i <= rawValue.size());
              if (i == rawValue.size()) {
                throw std::string(
                    "compiler error: leading backslash missing "
                    "escape sequence: ") +
                    rawValue;
              }
              if (rawValue[i] == 'x') {
                auto end =
                    rawValue.find_first_not_of("0123456789abcdefABCDEF", ++i);
                if (end == std::string::npos) {
                  end = rawValue.size();
                }
                if (end == i) {
                  throw std::string(
                      "compiler error: missing hexadecimal "
                      "character code in escape sequence: ") +
                      rawValue;
                }
                assert(i < end);
                if (end > i + 2) {
                  end = i + 2;
                }
                render << 'u';
                for (auto n = 4 - (end - i); n--;) {
                  render << '0';
                }
                render.write(std::next(rawValue.data(), i), end - i);
                i = end;
              } else {
                render << rawValue[i++];
              }
              break;
            }
            case '"':
              render << '\\';
              // intentional fallback
            default:
              render << rawValue[i];
              ++i;
          }
        }
        render << '"';
        if (tbase == t_base_type::TYPE_BINARY) {
          render << ".getBytes()";
        }
        break;
      }
      case t_base_type::TYPE_BOOL:
        render << ((value->get_integer() > 0) ? "true" : "false");
        break;
      case t_base_type::TYPE_BYTE:
        render << "(byte)" << value->get_integer();
        break;
      case t_base_type::TYPE_I16:
        render << "(short)" << value->get_integer();
        break;
      case t_base_type::TYPE_I32:
        render << value->get_integer();
        break;
      case t_base_type::TYPE_I64:
        render << value->get_integer() << "L";
        break;
      case t_base_type::TYPE_DOUBLE:
        if (value->get_type() == t_const_value::CV_INTEGER) {
          render << "(double)" << value->get_integer();
        } else {
          render << value->get_double();
        }
        break;
      case t_base_type::TYPE_FLOAT:
        if (value->get_type() == t_const_value::CV_INTEGER) {
          render << "(float)" << value->get_integer();
        } else {
          render << "(float)" << value->get_double();
        }
        break;
      default:
        throw std::runtime_error(
            "compiler error: no const of base type " +
            t_base_type::t_base_name(tbase));
    }
  } else if (type->is_enum()) {
    std::string namespace_prefix =
        type->program()->get_namespace(namespace_key_);
    if (namespace_prefix.length() > 0) {
      namespace_prefix += ".";
    }
    if (value->get_enum() == nullptr) {
      render << namespace_prefix << type->get_name() << ".findByValue("
             << value->get_integer() << ")";
    } else {
      render << namespace_prefix << value->get_enum()->get_name() << "."
             << value->get_enum_value()->get_name();
    }
  } else {
    string t = tmp("tmp");
    print_const_value(out, t, type, value, true);
    render << t;
  }

  return render.str();
}