Note: This document covers API impact only. For more details, see the ABI compatibility page

Add an enum member

Overview

- init step 1 step 2 step 3
fidl link link
dart link link
go link link
hlcpp link link
llcpp link link
rust link link link

Initial State {#init}

FIDL {#fidl-init}

  1. flexible enum Color {
  2.     RED = 1;
  3.     BLUE = 2;
  4. };

Dart {#dart-init}

  1. fidllib.Color writer(String s) {
  2.   if (s == 'red') {
  3.     return fidllib.Color.red;
  4.   } else if (s == 'blue') {
  5.     return fidllib.Color.blue;
  6.   } else {
  7.     return fidllib.Color.$unknown;
  8.   }
  9. }
  11. String reader(fidllib.Color color) {
  12.   switch (color) {
  13.     case fidllib.Color.blue:
  14.       return 'blue';
  15.     case fidllib.Color.red:
  16.       return 'red';
  17.     default:
  18.       return '<unknown>';
  19.   }
  20. }

Go {#go-init}

  1. func writer(s string) lib.Color {
  2.     switch s {
  3.     case "blue":
  4.         return lib.ColorBlue
  5.     case "red":
  6.         return lib.ColorRed
  7.     default:
  8.         return lib.Color_Unknown
  9.     }
  10. }
  12. func reader(color lib.Color) string {
  13.     switch color {
  14.     case lib.ColorBlue:
  15.         return "blue"
  16.     case lib.ColorRed:
  17.         return "red"
  18.     default:
  19.         return "<unknown>"
  20.     }
  21. }

HLCPP {#hlcpp-init}

  1. fidl_test::Color writer(std::string s) {
  2.   if (s == "red") {
  3.     return fidl_test::Color::RED;
  4.   } else if (s == "blue") {
  5.     return fidl_test::Color::BLUE;
  6.   } else {
  7.     return fidl_test::Color::Unknown();
  8.   }
  9. }
  11. std::string reader(fidl_test::Color color) {
  12.   switch (color) {
  13.     case fidl_test::Color::RED:
  14.       return "red";
  15.     case fidl_test::Color::BLUE:
  16.       return "blue";
  17.     default:
  18.       return "<unknown>";
  19.   }
  20. }

LLCPP {#llcpp-init}

  1. fidl_test::Color writer(std::string s) {
  2.   if (s == "red") {
  3.     return fidl_test::Color::RED;
  4.   } else if (s == "blue") {
  5.     return fidl_test::Color::BLUE;
  6.   } else {
  7.     return fidl_test::Color::Unknown();
  8.   }
  9. }
  11. std::string reader(fidl_test::Color color) {
  12.   switch (color) {
  13.     case fidl_test::Color::RED:
  14.       return "red";
  15.     case fidl_test::Color::BLUE:
  16.       return "blue";
  17.     default:
  18.       return "<unknown>";
  19.   }
  20. }

Rust {#rust-init}

  1. fn writer(s: &str) -> fidl_lib::Color {
  2.     match s {
  3.         "red" => fidl_lib::Color::Red,
  4.         "blue" => fidl_lib::Color::Blue,
  5.         _ => fidl_lib::Color::unknown(),
  6.     }
  7. }
  9. fn reader(color: fidl_lib::Color) -> &'static str {
  10.     match color {
  11.         fidl_lib::Color::Red => "red",
  12.         fidl_lib::Color::Blue => "blue",
  13.         fidl_lib::ColorUnknown!() => "unknown",
  14.     }
  15. }

Update Source Code {#step-1}

Rust {#rust-1}

  • Replace any unknown match arm macros with a catch-all case to handle the soon-to-be-added variant.
  1.   fn writer(s: &str) -> fidl_lib::Color {
  2.       match s {
  3.           "red" => fidl_lib::Color::Red,
  4.           "blue" => fidl_lib::Color::Blue,
  5.           _ => fidl_lib::Color::unknown(),
  6.       }
  7.   }
  9.   fn reader(color: fidl_lib::Color) -> &'static str {
  10.       match color {
  11.           fidl_lib::Color::Red => "red",
  12.           fidl_lib::Color::Blue => "blue",
  13. -         fidl_lib::ColorUnknown!() => "unknown",
  14. +         _ => "unknown",
  15.       }
  16.   }

Update FIDL Library {#step-2}

  • Add the new member
  1.   flexible enum Color {
  2.       RED = 1;
  3.       BLUE = 2;
  4. +     YELLOW = 3;
  5.   };

Update Source Code {#step-3}

Dart {#dart-3}

  • Writers can now produce instances of the new enum member.
  1.   fidllib.Color writer(String s) {
  2.     if (s == 'red') {
  3.       return fidllib.Color.red;
  4.     } else if (s == 'blue') {
  5.       return fidllib.Color.blue;
  6. +   } else if (s == 'yellow') {
  7. +     return fidllib.Color.yellow;
  8.     } else {
  9.       return fidllib.Color.$unknown;
  10.     }
  11.   }
  13.   String reader(fidllib.Color color) {
  14.     switch (color) {
  15.       case fidllib.Color.blue:
  16.         return 'blue';
  17.       case fidllib.Color.red:
  18.         return 'red';
  19. +     case fidllib.Color.yellow:
  20. +       return 'yellow';
  21.       default:
  22.         return '<unknown>';
  23.     }
  24.   }

Go {#go-3}

  • Writers can now produce instances of the new enum member.
  1.   func writer(s string) lib.Color {
  2.       switch s {
  3.       case "blue":
  4.           return lib.ColorBlue
  5.       case "red":
  6.           return lib.ColorRed
  7. +     case "yellow":
  8. +         return lib.ColorYellow
  9.       default:
  10.           return lib.Color_Unknown
  11.       }
  12.   }
  14.   func reader(color lib.Color) string {
  15.       switch color {
  16.       case lib.ColorBlue:
  17.           return "blue"
  18.       case lib.ColorRed:
  19.           return "red"
  20. +     case lib.ColorYellow:
  21. +         return "yellow"
  22.       default:
  23.           return "<unknown>"
  24.       }
  25.   }

HLCPP {#hlcpp-3}

  • Writers can now produce instances of the new enum member.
  1.   fidl_test::Color writer(std::string s) {
  2.     if (s == "red") {
  3.       return fidl_test::Color::RED;
  4.     } else if (s == "blue") {
  5.       return fidl_test::Color::BLUE;
  6. +   } else if (s == "yellow") {
  7. +     return fidl_test::Color::YELLOW;
  8.     } else {
  9.       return fidl_test::Color::Unknown();
  10.     }
  11.   }
  13.   std::string reader(fidl_test::Color color) {
  14.     switch (color) {
  15.       case fidl_test::Color::RED:
  16.         return "red";
  17.       case fidl_test::Color::BLUE:
  18.         return "blue";
  19. +     case fidl_test::Color::YELLOW:
  20. +       return "yellow";
  21.       default:
  22.         return "<unknown>";
  23.     }
  24.   }

LLCPP {#llcpp-3}

  • Writers can now produce instances of the new enum member.
  1.   fidl_test::Color writer(std::string s) {
  2.     if (s == "red") {
  3.       return fidl_test::Color::RED;
  4.     } else if (s == "blue") {
  5.       return fidl_test::Color::BLUE;
  6. +   } else if (s == "yellow") {
  7. +     return fidl_test::Color::YELLOW;
  8.     } else {
  9.       return fidl_test::Color::Unknown();
  10.     }
  11.   }
  13.   std::string reader(fidl_test::Color color) {
  14.     switch (color) {
  15.       case fidl_test::Color::RED:
  16.         return "red";
  17.       case fidl_test::Color::BLUE:
  18.         return "blue";
  19. +     case fidl_test::Color::YELLOW:
  20. +       return "yellow";
  21.       default:
  22.         return "<unknown>";
  23.     }
  24.   }

Rust {#rust-3}

  • Writers can now produce instances of the new enum member.
  • Replace the catch-all case with the unknown macro.
  1.   fn writer(s: &str) -> fidl_lib::Color {
  2.       match s {
  3.           "red" => fidl_lib::Color::Red,
  4.           "blue" => fidl_lib::Color::Blue,
  5. +         "yellow" => fidl_lib::Color::Yellow,
  6.           _ => fidl_lib::Color::unknown(),
  7.       }
  8.   }
  10.   fn reader(color: fidl_lib::Color) -> &'static str {
  11.       match color {
  12.           fidl_lib::Color::Red => "red",
  13.           fidl_lib::Color::Blue => "blue",
  14. -         _ => "unknown",
  15. +         fidl_lib::Color::Yellow => "yellow",
  16. +         fidl_lib::ColorUnknown!() => "unknown",
  17.       }
  18.   }