Package google.protobuf

Any contient un message sérialisé arbitraire ainsi qu'une URL décrivant le type du message sérialisé.

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": <string>,
  "lastName": <string>
}

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}

L'API est un descripteur léger pour un service de tampon de protocole.

Message wrapper pour bool.

La représentation JSON de BoolValue est JSON true et false.

Message wrapper pour bytes.

La représentation JSON de BytesValue est une chaîne JSON.

Message wrapper pour double.

La représentation JSON de DoubleValue est un nombre JSON.

Une durée représente une période de durée signée signée, représentée par un nombre de secondes et des fractions de secondes à une résolution de l'ordre de la nanoseconde. Il est indépendant de tout calendrier et concept tels que "jour" ou "mois". Elle est liée à l'horodatage dans la mesure où la différence entre deux valeurs d'horodatage est une durée et peut être ajoutée ou soustraite d'un horodatage. La plage est d'environ +-10 000 ans.

Exemple 1: Calculer la durée à partir de deux horodatages en pseudo-code

Timestamp start = ...;
Timestamp end = ...;
Duration duration = ...;

duration.seconds = end.seconds - start.seconds;
duration.nanos = end.nanos - start.nanos;

if (duration.seconds < 0 && duration.nanos > 0) {
  duration.seconds += 1;
  duration.nanos -= 1000000000;
} else if (duration.seconds > 0 && duration.nanos < 0) {
  duration.seconds -= 1;
  duration.nanos += 1000000000;
}

Exemple 2: Calculer l'horodatage à partir de l'horodatage et de la durée en pseudo-code

Timestamp start = ...;
Duration duration = ...;
Timestamp end = ...;

end.seconds = start.seconds + duration.seconds;
end.nanos = start.nanos + duration.nanos;

if (end.nanos < 0) {
  end.seconds -= 1;
  end.nanos += 1000000000;
} else if (end.nanos >= 1000000000) {
  end.seconds += 1;
  end.nanos -= 1000000000;
}

La représentation JSON de Duration est une String qui se termine par s pour indiquer les secondes. Elle est précédée du nombre de secondes, la nanoseconde étant exprimée en fractions de secondes.

Message générique vide que vous pouvez réutiliser pour éviter de définir des messages vides en double dans vos API. Un exemple typique consiste à l'utiliser comme requête ou type de réponse d'une méthode API. Exemple :

service Foo {
  rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
}

La représentation JSON de Empty est un objet JSON vide {}.

Définition du type d'énumération.

Définition de la valeur d'énumération.

Champ unique d'un type de message.

Indique si un champ est facultatif, obligatoire ou répété.

Types de champs de base.

FieldMask représente un ensemble de chemins d'accès à des champs symboliques, par exemple:

paths: "f.a"
paths: "f.b.d"

Ici, f représente un champ dans un message racine, a et b dans le message trouvé dans f, et d un champ dans le message dans f.b.

Les masques de champ permettent de spécifier un sous-ensemble de champs devant être renvoyés par une opération "get" (une projection) ou modifiés par une opération de mise à jour. Les masques de champ possèdent également un encodage JSON personnalisé (voir ci-dessous).

f {
  a : 22
  b {
    d : 1
    x : 2
  }
  y : 13
}
z: 8

f {
  a : 22
  b {
    d : 1
  }
}

message Profile {
  User user = 1;
  Photo photo = 2;
}
message User {
  string display_name = 1;
  string address = 2;
}

mask {
  paths: "user.display_name"
  paths: "photo"
}

{
  mask: "user.displayName,photo"
}

Message wrapper pour float.

La représentation JSON de FloatValue est un nombre JSON.

Message wrapper pour int32.

La représentation JSON de Int32Value est un nombre JSON.

Message wrapper pour int64.

La représentation JSON de Int64Value est une chaîne JSON.

ListValue est un wrapper autour d'un champ répété de valeurs.

La représentation JSON de ListValue est un tableau JSON.

Method représente une méthode d'API.

Déclare une API à inclure dans cette API. L'API d'inclusion doit redéclarer toutes les méthodes de l'API incluse, mais la documentation et les options sont héritées comme suit:

• Si, après suppression des commentaires et des espaces, la chaîne de documentation de la méthode redéclarée est vide, elle est héritée de la méthode d'origine.

• Chaque annotation appartenant à la configuration de service (http, visibilité) qui n'est pas définie dans la méthode redéclarée est héritée.

• Si une annotation HTTP est héritée, le format de chemin est modifié comme suit. Tout préfixe de version sera remplacé par la version de l'API, y compris le chemin d'accès root si spécifié.

Exemple de mixin simple:

package google.acl.v1;
service AccessControl {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v1/{resource=**}:getAcl";
  }
}

package google.storage.v2;
service Storage {
  //       rpc GetAcl(GetAclRequest) returns (Acl);

  // Get a data record.
  rpc GetData(GetDataRequest) returns (Data) {
    option (google.api.http).get = "/v2/{resource=**}";
  }
}

Exemple de configuration d'une combinaison:

apis:
- name: google.storage.v2.Storage
  mixins:
  - name: google.acl.v1.AccessControl

La construction mixin implique que toutes les méthodes de AccessControl sont également déclarées avec le même nom et les mêmes types de requêtes/réponses dans Storage. Un générateur de documentation ou un processeur d'annotations verra la méthode Storage.GetAcl effective après avoir intégré la documentation et les annotations, comme suit:

service Storage {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v2/{resource=**}:getAcl";
  }
  ...
}

Notez que la version du format de chemin est passée de v1 à v2.

Si le champ root du mixin est spécifié, il doit s'agir d'un chemin d'accès relatif sous lequel les chemins HTTP hérités sont placés. Exemple :

apis:
- name: google.storage.v2.Storage
  mixins:
  - name: google.acl.v1.AccessControl
    root: acls

Cela implique l'annotation HTTP héritée suivante:

service Storage {
  // Get the underlying ACL object.
  rpc GetAcl(GetAclRequest) returns (Acl) {
    option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
  }
  ...
}

NullValue est une énumération unique qui représente la valeur nulle pour l'union de type Value.

La représentation JSON de NullValue est JSON null.

Option de tampon de protocole, qui peut être associée à un message, un champ, une énumération, etc.

SourceContext représente les informations sur la source d'un élément protobuf, comme le fichier dans lequel il est défini.

Message wrapper pour string.

La représentation JSON de StringValue est une chaîne JSON.

Struct représente une valeur de données structurées, composée de champs qui correspondent à des valeurs de type dynamique. Dans certaines langues, Struct peut être compatible avec une représentation native. Par exemple, dans les langages de script comme JS, une structure est représentée en tant qu'objet. Les détails de cette représentation sont décrits avec la compatibilité du proto pour le langage.

La représentation JSON de Struct est un objet JSON.

Syntaxe dans laquelle un élément de tampon de protocole est défini.

Un objet Timestamp représente un moment indépendant de tout fuseau horaire ou calendrier, représenté par des secondes et des fractions de secondes avec une précision de l'ordre de la nanoseconde dans l'epoch UTC. Il est encodé à l'aide du calendrier grégorien proleptique, qui étend le calendrier grégorien à la première année. L'objet est encodé en supposant que toutes les minutes durent 60 secondes, c'est-à-dire que les secondes intercalaires sont "lissées" de sorte qu'aucune table de secondes intercalaires n'est nécessaire pour l'interprétation. La plage va de 0001-01-01T00:00:00Z à 9999-12-31T23:59:59.999999999Z. En nous limitant à cette plage, nous nous assurons que nous pouvons convertir des chaînes de date au format RFC 3339. Consultez la page https://www.ietf.org/rfc/rfc3339.txt.

Exemple 1 : Calculer l'horodatage à partir du paramètre POSIX time()

Timestamp timestamp;
timestamp.set_seconds(time(NULL));
timestamp.set_nanos(0);

Exemple 2 : Calculer l'horodatage à partir du paramètre POSIX gettimeofday()

struct timeval tv;
gettimeofday(&tv, NULL);

Timestamp timestamp;
timestamp.set_seconds(tv.tv_sec);
timestamp.set_nanos(tv.tv_usec * 1000);

Exemple 3 : Calculer l'horodatage à partir du paramètre Win32 GetSystemTimeAsFileTime()

FILETIME ft;
GetSystemTimeAsFileTime(&ft);
UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

// A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
Timestamp timestamp;
timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

Exemple 4 : Calculer l'horodatage à partir du paramètre Java System.currentTimeMillis()

long millis = System.currentTimeMillis();

Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
    .setNanos((int) ((millis % 1000) * 1000000)).build();

Exemple 5 : Calculer l'horodatage à partir de l'heure actuelle en Python

now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
timestamp = Timestamp(seconds=seconds, nanos=nanos)

Type de message de tampon de protocole.

Message wrapper pour uint32.

La représentation JSON de UInt32Value est un nombre JSON.

Message wrapper pour uint64.

La représentation JSON de UInt64Value est une chaîne JSON.

Value représente une valeur de type dynamique qui peut être une valeur nulle, un nombre, une chaîne, une valeur booléenne, une valeur de structure récursive ou une liste de valeurs. Un producteur de valeur doit définir l'une de ces variantes. L'absence de variante indique une erreur.

La représentation JSON de Value est une valeur JSON.