Source file duration.ml

(********************************************************)
(*           AUTOGENERATED FILE - DO NOT EDIT!          *)
(********************************************************)
(* Generated by: ocaml-protoc-plugin                    *)
(* https://github.com/andersfugmann/ocaml-protoc-plugin *)
(********************************************************)
(*
  Source: google/protobuf/duration.proto
  Syntax: proto3
  Parameters:
    debug=false
    annot=''
    opens=[]
    int64_as_int=true
    int32_as_int=true
    fixed_as_int=false
    singleton_record=false
    prefix_output_with_package=false
*)
[@@@ocaml.alert "-protobuf"] (* Disable deprecation warnings for protobuf*)
(**/**)
module Runtime' = Ocaml_protoc_plugin [@@warning "-33"]
module Imported'modules = struct
end
(**/**)
module rec Google : sig
  module rec Protobuf : sig

    (**
{%html:
<p>A Duration represents a signed, fixed-length span of time represented
as a count of seconds and fractions of seconds at nanosecond
resolution. It is independent of any calendar and concepts like &quot;day&quot;
or &quot;month&quot;. It is related to Timestamp in that the difference between
two Timestamp values is a Duration and it can be added or subtracted
from a Timestamp. Range is approximately +-10,000 years.</p>
<h1 id="examples">Examples</h1>
<p>Example 1: Compute Duration from two Timestamps in pseudo code.</p>
<pre><code> Timestamp start = ...;
 Timestamp end = ...;
 Duration duration = ...;

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

 if (duration.seconds &lt; 0 &amp;&amp; duration.nanos &gt; 0) {
   duration.seconds += 1;
   duration.nanos -= 1000000000;
 } else if (duration.seconds &gt; 0 &amp;&amp; duration.nanos &lt; 0) {
   duration.seconds -= 1;
   duration.nanos += 1000000000;
 }
</code></pre>
<p>Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.</p>
<pre><code> Timestamp start = ...;
 Duration duration = ...;
 Timestamp end = ...;

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

 if (end.nanos &lt; 0) {
   end.seconds -= 1;
   end.nanos += 1000000000;
 } else if (end.nanos &gt;= 1000000000) {
   end.seconds += 1;
   end.nanos -= 1000000000;
 }
</code></pre>
<p>Example 3: Compute Duration from datetime.timedelta in Python.</p>
<pre><code> td = datetime.timedelta(days=3, minutes=10)
 duration = Duration()
 duration.FromTimedelta(td)
</code></pre>
<h1 id="json-mapping">JSON Mapping</h1>
<p>In JSON format, the Duration type is encoded as a string rather than an
object, where the string ends in the suffix &quot;s&quot; (indicating seconds) and
is preceded by the number of seconds, with nanoseconds expressed as
fractional seconds. For example, 3 seconds with 0 nanoseconds should be
encoded in JSON format as &quot;3s&quot;, while 3 seconds and 1 nanosecond should
be expressed in JSON format as &quot;3.000000001s&quot;, and 3 seconds and 1
microsecond should be expressed in JSON format as &quot;3.000001s&quot;.</p>
%}
    *)
    module rec Duration : sig
      type t = {
        seconds:int;
        (**
{%html:
<p>Signed seconds of the span of time. Must be from -315,576,000,000
to +315,576,000,000 inclusive. Note: these bounds are computed from:
60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years</p>
%}
        *)

        nanos:int;
        (**
{%html:
<p>Signed fractions of a second at nanosecond resolution of the span
of time. Durations less than one second are represented with a 0
<code>seconds</code> field and a positive or negative <code>nanos</code> field. For durations
of one second or more, a non-zero value for the <code>nanos</code> field must be
of the same sign as the <code>seconds</code> field. Must be from -999,999,999
to +999,999,999 inclusive.</p>
%}
        *)

      }
      val make: ?seconds:int -> ?nanos:int -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?seconds:int -> ?nanos:int -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

  end
end = struct
  module rec Protobuf : sig

    (**
{%html:
<p>A Duration represents a signed, fixed-length span of time represented
as a count of seconds and fractions of seconds at nanosecond
resolution. It is independent of any calendar and concepts like &quot;day&quot;
or &quot;month&quot;. It is related to Timestamp in that the difference between
two Timestamp values is a Duration and it can be added or subtracted
from a Timestamp. Range is approximately +-10,000 years.</p>
<h1 id="examples">Examples</h1>
<p>Example 1: Compute Duration from two Timestamps in pseudo code.</p>
<pre><code> Timestamp start = ...;
 Timestamp end = ...;
 Duration duration = ...;

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

 if (duration.seconds &lt; 0 &amp;&amp; duration.nanos &gt; 0) {
   duration.seconds += 1;
   duration.nanos -= 1000000000;
 } else if (duration.seconds &gt; 0 &amp;&amp; duration.nanos &lt; 0) {
   duration.seconds -= 1;
   duration.nanos += 1000000000;
 }
</code></pre>
<p>Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.</p>
<pre><code> Timestamp start = ...;
 Duration duration = ...;
 Timestamp end = ...;

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

 if (end.nanos &lt; 0) {
   end.seconds -= 1;
   end.nanos += 1000000000;
 } else if (end.nanos &gt;= 1000000000) {
   end.seconds += 1;
   end.nanos -= 1000000000;
 }
</code></pre>
<p>Example 3: Compute Duration from datetime.timedelta in Python.</p>
<pre><code> td = datetime.timedelta(days=3, minutes=10)
 duration = Duration()
 duration.FromTimedelta(td)
</code></pre>
<h1 id="json-mapping">JSON Mapping</h1>
<p>In JSON format, the Duration type is encoded as a string rather than an
object, where the string ends in the suffix &quot;s&quot; (indicating seconds) and
is preceded by the number of seconds, with nanoseconds expressed as
fractional seconds. For example, 3 seconds with 0 nanoseconds should be
encoded in JSON format as &quot;3s&quot;, while 3 seconds and 1 nanosecond should
be expressed in JSON format as &quot;3.000000001s&quot;, and 3 seconds and 1
microsecond should be expressed in JSON format as &quot;3.000001s&quot;.</p>
%}
    *)
    module rec Duration : sig
      type t = {
        seconds:int;
        (**
{%html:
<p>Signed seconds of the span of time. Must be from -315,576,000,000
to +315,576,000,000 inclusive. Note: these bounds are computed from:
60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years</p>
%}
        *)

        nanos:int;
        (**
{%html:
<p>Signed fractions of a second at nanosecond resolution of the span
of time. Durations less than one second are represented with a 0
<code>seconds</code> field and a positive or negative <code>nanos</code> field. For durations
of one second or more, a non-zero value for the <code>nanos</code> field must be
of the same sign as the <code>seconds</code> field. Must be from -999,999,999
to +999,999,999 inclusive.</p>
%}
        *)

      }
      val make: ?seconds:int -> ?nanos:int -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?seconds:int -> ?nanos:int -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end

  end = struct
    module rec Duration : sig
      type t = {
        seconds:int;
        (**
{%html:
<p>Signed seconds of the span of time. Must be from -315,576,000,000
to +315,576,000,000 inclusive. Note: these bounds are computed from:
60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years</p>
%}
        *)

        nanos:int;
        (**
{%html:
<p>Signed fractions of a second at nanosecond resolution of the span
of time. Durations less than one second are represented with a 0
<code>seconds</code> field and a positive or negative <code>nanos</code> field. For durations
of one second or more, a non-zero value for the <code>nanos</code> field must be
of the same sign as the <code>seconds</code> field. Must be from -999,999,999
to +999,999,999 inclusive.</p>
%}
        *)

      }
      val make: ?seconds:int -> ?nanos:int -> unit -> t
      (** Helper function to generate a message using default values *)

      val to_proto: t -> Runtime'.Writer.t
      (** Serialize the message to binary format *)

      val from_proto: Runtime'.Reader.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from binary format *)

      val to_json: Runtime'.Json_options.t -> t -> Runtime'.Json.t
      (** Serialize to Json (compatible with Yojson.Basic.t) *)

      val from_json: Runtime'.Json.t -> (t, [> Runtime'.Result.error]) result
      (** Deserialize from Json (compatible with Yojson.Basic.t) *)

      val name: unit -> string
      (** Fully qualified protobuf name of this message *)

      (**/**)
      type make_t = ?seconds:int -> ?nanos:int -> unit -> t
      val merge: t -> t -> t
      val to_proto': Runtime'.Writer.t -> t -> unit
      val from_proto_exn: Runtime'.Reader.t -> t
      val from_json_exn: Runtime'.Json.t -> t
      (**/**)
    end = struct
      module This'_ = Duration
      let name () = ".google.protobuf.Duration"
      type t = {
        seconds:int;
        nanos:int;
      }
      type make_t = ?seconds:int -> ?nanos:int -> unit -> t
      let make ?(seconds = 0) ?(nanos = 0) () = { seconds; nanos }
      let merge =
      let merge_seconds = Runtime'.Merge.merge Runtime'.Spec.( basic ((1, "seconds", "seconds"), int64_int, (0)) ) in
      let merge_nanos = Runtime'.Merge.merge Runtime'.Spec.( basic ((2, "nanos", "nanos"), int32_int, (0)) ) in
      fun t1 t2 -> {
      	seconds = (merge_seconds t1.seconds t2.seconds);
      	nanos = (merge_nanos t1.nanos t2.nanos);
       }
      let spec () = Runtime'.Spec.( basic ((1, "seconds", "seconds"), int64_int, (0)) ^:: basic ((2, "nanos", "nanos"), int32_int, (0)) ^:: nil )
      let to_proto' =
        let serialize = Runtime'.apply_lazy (fun () -> Runtime'.Serialize.serialize (spec ())) in
        fun writer { seconds; nanos } -> serialize writer seconds nanos

      let to_proto t = let writer = Runtime'.Writer.init () in to_proto' writer t; writer
      let from_proto_exn =
        let constructor seconds nanos = { seconds; nanos } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize.deserialize (spec ()) constructor)
      let from_proto writer = Runtime'.Result.catch (fun () -> from_proto_exn writer)
      let to_json options =
        let serialize = Runtime'.Serialize_json.serialize ~message_name:(name ()) (spec ()) options in
        fun { seconds; nanos } -> serialize seconds nanos
      let from_json_exn =
        let constructor seconds nanos = { seconds; nanos } in
        Runtime'.apply_lazy (fun () -> Runtime'.Deserialize_json.deserialize ~message_name:(name ()) (spec ()) constructor)
      let from_json json = Runtime'.Result.catch (fun () -> from_json_exn json)
    end

  end
end