diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright (c) 2016, Google Inc. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Google Inc. nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +import Data.ProtoLens.Setup + +main = defaultMainGeneratingProtos "proto-src" diff --git a/dist/build/autogen/Proto/Google/Protobuf/Any.hs b/dist/build/autogen/Proto/Google/Protobuf/Any.hs new file mode 100644 --- /dev/null +++ b/dist/build/autogen/Proto/Google/Protobuf/Any.hs @@ -0,0 +1,88 @@ +{- This file was auto-generated from google/protobuf/any.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, MultiParamTypeClasses, FlexibleContexts, + FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude + #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +module Proto.Google.Protobuf.Any where +import qualified Data.ProtoLens.Reexport.Prelude as Prelude +import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int +import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word +import qualified Data.ProtoLens.Reexport.Data.ProtoLens + as Data.ProtoLens +import qualified + Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum + as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Reexport.Lens.Family2 + as Lens.Family2 +import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked + as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Reexport.Data.Default.Class + as Data.Default.Class +import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text +import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map +import qualified Data.ProtoLens.Reexport.Data.ByteString + as Data.ByteString +import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels + +data Any = Any{_Any'typeUrl :: !Data.Text.Text, + _Any'value :: !Data.ByteString.ByteString} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Text.Text, b ~ Data.Text.Text, + Prelude.Functor f) => + Lens.Labels.HasLens "typeUrl" f Any Any a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Any'typeUrl + (\ x__ y__ -> x__{_Any'typeUrl = y__}) + +instance (a ~ Data.ByteString.ByteString, + b ~ Data.ByteString.ByteString, Prelude.Functor f) => + Lens.Labels.HasLens "value" f Any Any a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Any'value + (\ x__ y__ -> x__{_Any'value = y__}) + +instance Data.Default.Class.Default Any where + def + = Any{_Any'typeUrl = Data.ProtoLens.fieldDefault, + _Any'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message Any where + descriptor + = let typeUrl__field_descriptor + = Data.ProtoLens.FieldDescriptor "type_url" + (Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional typeUrl) + :: Data.ProtoLens.FieldDescriptor Any + value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.BytesField :: + Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor Any + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, typeUrl__field_descriptor), + (Data.ProtoLens.Tag 2, value__field_descriptor)]) + (Data.Map.fromList + [("type_url", typeUrl__field_descriptor), + ("value", value__field_descriptor)]) + +typeUrl :: + forall f s t a b . (Lens.Labels.HasLens "typeUrl" f s t a b) => + Lens.Family2.LensLike f s t a b +typeUrl + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "typeUrl") + +value :: + forall f s t a b . (Lens.Labels.HasLens "value" f s t a b) => + Lens.Family2.LensLike f s t a b +value + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value") diff --git a/dist/build/autogen/Proto/Google/Protobuf/Duration.hs b/dist/build/autogen/Proto/Google/Protobuf/Duration.hs new file mode 100644 --- /dev/null +++ b/dist/build/autogen/Proto/Google/Protobuf/Duration.hs @@ -0,0 +1,88 @@ +{- This file was auto-generated from google/protobuf/duration.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, MultiParamTypeClasses, FlexibleContexts, + FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude + #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +module Proto.Google.Protobuf.Duration where +import qualified Data.ProtoLens.Reexport.Prelude as Prelude +import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int +import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word +import qualified Data.ProtoLens.Reexport.Data.ProtoLens + as Data.ProtoLens +import qualified + Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum + as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Reexport.Lens.Family2 + as Lens.Family2 +import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked + as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Reexport.Data.Default.Class + as Data.Default.Class +import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text +import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map +import qualified Data.ProtoLens.Reexport.Data.ByteString + as Data.ByteString +import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels + +data Duration = Duration{_Duration'seconds :: !Data.Int.Int64, + _Duration'nanos :: !Data.Int.Int32} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64, + Prelude.Functor f) => + Lens.Labels.HasLens "seconds" f Duration Duration a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Duration'seconds + (\ x__ y__ -> x__{_Duration'seconds = y__}) + +instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32, + Prelude.Functor f) => + Lens.Labels.HasLens "nanos" f Duration Duration a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Duration'nanos + (\ x__ y__ -> x__{_Duration'nanos = y__}) + +instance Data.Default.Class.Default Duration where + def + = Duration{_Duration'seconds = Data.ProtoLens.fieldDefault, + _Duration'nanos = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message Duration where + descriptor + = let seconds__field_descriptor + = Data.ProtoLens.FieldDescriptor "seconds" + (Data.ProtoLens.Int64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional seconds) + :: Data.ProtoLens.FieldDescriptor Duration + nanos__field_descriptor + = Data.ProtoLens.FieldDescriptor "nanos" + (Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional nanos) + :: Data.ProtoLens.FieldDescriptor Duration + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, seconds__field_descriptor), + (Data.ProtoLens.Tag 2, nanos__field_descriptor)]) + (Data.Map.fromList + [("seconds", seconds__field_descriptor), + ("nanos", nanos__field_descriptor)]) + +nanos :: + forall f s t a b . (Lens.Labels.HasLens "nanos" f s t a b) => + Lens.Family2.LensLike f s t a b +nanos + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nanos") + +seconds :: + forall f s t a b . (Lens.Labels.HasLens "seconds" f s t a b) => + Lens.Family2.LensLike f s t a b +seconds + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "seconds") diff --git a/dist/build/autogen/Proto/Google/Protobuf/Wrappers.hs b/dist/build/autogen/Proto/Google/Protobuf/Wrappers.hs new file mode 100644 --- /dev/null +++ b/dist/build/autogen/Proto/Google/Protobuf/Wrappers.hs @@ -0,0 +1,289 @@ +{- This file was auto-generated from google/protobuf/wrappers.proto by the proto-lens-protoc program. -} +{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, + UndecidableInstances, MultiParamTypeClasses, FlexibleContexts, + FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude + #-} +{-# OPTIONS_GHC -fno-warn-unused-imports#-} +module Proto.Google.Protobuf.Wrappers where +import qualified Data.ProtoLens.Reexport.Prelude as Prelude +import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int +import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word +import qualified Data.ProtoLens.Reexport.Data.ProtoLens + as Data.ProtoLens +import qualified + Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum + as Data.ProtoLens.Message.Enum +import qualified Data.ProtoLens.Reexport.Lens.Family2 + as Lens.Family2 +import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked + as Lens.Family2.Unchecked +import qualified Data.ProtoLens.Reexport.Data.Default.Class + as Data.Default.Class +import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text +import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map +import qualified Data.ProtoLens.Reexport.Data.ByteString + as Data.ByteString +import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels + +data BoolValue = BoolValue{_BoolValue'value :: !Prelude.Bool} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Prelude.Bool, b ~ Prelude.Bool, Prelude.Functor f) => + Lens.Labels.HasLens "value" f BoolValue BoolValue a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _BoolValue'value + (\ x__ y__ -> x__{_BoolValue'value = y__}) + +instance Data.Default.Class.Default BoolValue where + def = BoolValue{_BoolValue'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message BoolValue where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.BoolField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Bool) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor BoolValue + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data BytesValue = BytesValue{_BytesValue'value :: + !Data.ByteString.ByteString} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.ByteString.ByteString, + b ~ Data.ByteString.ByteString, Prelude.Functor f) => + Lens.Labels.HasLens "value" f BytesValue BytesValue a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _BytesValue'value + (\ x__ y__ -> x__{_BytesValue'value = y__}) + +instance Data.Default.Class.Default BytesValue where + def = BytesValue{_BytesValue'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message BytesValue where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.BytesField :: + Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor BytesValue + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data DoubleValue = DoubleValue{_DoubleValue'value :: + !Prelude.Double} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Prelude.Double, b ~ Prelude.Double, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f DoubleValue DoubleValue a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _DoubleValue'value + (\ x__ y__ -> x__{_DoubleValue'value = y__}) + +instance Data.Default.Class.Default DoubleValue where + def = DoubleValue{_DoubleValue'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message DoubleValue where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.DoubleField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Double) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor DoubleValue + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data FloatValue = FloatValue{_FloatValue'value :: !Prelude.Float} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Prelude.Float, b ~ Prelude.Float, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f FloatValue FloatValue a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _FloatValue'value + (\ x__ y__ -> x__{_FloatValue'value = y__}) + +instance Data.Default.Class.Default FloatValue where + def = FloatValue{_FloatValue'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message FloatValue where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.FloatField :: + Data.ProtoLens.FieldTypeDescriptor Prelude.Float) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor FloatValue + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data Int32Value = Int32Value{_Int32Value'value :: !Data.Int.Int32} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Int.Int32, b ~ Data.Int.Int32, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f Int32Value Int32Value a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Int32Value'value + (\ x__ y__ -> x__{_Int32Value'value = y__}) + +instance Data.Default.Class.Default Int32Value where + def = Int32Value{_Int32Value'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message Int32Value where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.Int32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor Int32Value + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data Int64Value = Int64Value{_Int64Value'value :: !Data.Int.Int64} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f Int64Value Int64Value a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _Int64Value'value + (\ x__ y__ -> x__{_Int64Value'value = y__}) + +instance Data.Default.Class.Default Int64Value where + def = Int64Value{_Int64Value'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message Int64Value where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.Int64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor Int64Value + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data StringValue = StringValue{_StringValue'value :: + !Data.Text.Text} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Text.Text, b ~ Data.Text.Text, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f StringValue StringValue a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _StringValue'value + (\ x__ y__ -> x__{_StringValue'value = y__}) + +instance Data.Default.Class.Default StringValue where + def = StringValue{_StringValue'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message StringValue where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.StringField :: + Data.ProtoLens.FieldTypeDescriptor Data.Text.Text) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor StringValue + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data UInt32Value = UInt32Value{_UInt32Value'value :: + !Data.Word.Word32} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Word.Word32, b ~ Data.Word.Word32, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f UInt32Value UInt32Value a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _UInt32Value'value + (\ x__ y__ -> x__{_UInt32Value'value = y__}) + +instance Data.Default.Class.Default UInt32Value where + def = UInt32Value{_UInt32Value'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message UInt32Value where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.UInt32Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor UInt32Value + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +data UInt64Value = UInt64Value{_UInt64Value'value :: + !Data.Word.Word64} + deriving (Prelude.Show, Prelude.Eq) + +instance (a ~ Data.Word.Word64, b ~ Data.Word.Word64, + Prelude.Functor f) => + Lens.Labels.HasLens "value" f UInt64Value UInt64Value a b + where + lensOf _ + = Lens.Family2.Unchecked.lens _UInt64Value'value + (\ x__ y__ -> x__{_UInt64Value'value = y__}) + +instance Data.Default.Class.Default UInt64Value where + def = UInt64Value{_UInt64Value'value = Data.ProtoLens.fieldDefault} + +instance Data.ProtoLens.Message UInt64Value where + descriptor + = let value__field_descriptor + = Data.ProtoLens.FieldDescriptor "value" + (Data.ProtoLens.UInt64Field :: + Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64) + (Data.ProtoLens.PlainField Data.ProtoLens.Optional value) + :: Data.ProtoLens.FieldDescriptor UInt64Value + in + Data.ProtoLens.MessageDescriptor + (Data.Map.fromList + [(Data.ProtoLens.Tag 1, value__field_descriptor)]) + (Data.Map.fromList [("value", value__field_descriptor)]) + +value :: + forall f s t a b . (Lens.Labels.HasLens "value" f s t a b) => + Lens.Family2.LensLike f s t a b +value + = Lens.Labels.lensOf + ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value") diff --git a/proto-lens-protobuf-types.cabal b/proto-lens-protobuf-types.cabal new file mode 100644 --- /dev/null +++ b/proto-lens-protobuf-types.cabal @@ -0,0 +1,31 @@ +name: proto-lens-protobuf-types +version: 0.2.1.0 +synopsis: Basic protocol buffer message types. +description: + This package provides bindings standard protocol message types, + for use with the proto-lens library. + +homepage: https://github.com/google/proto-lens +license: BSD3 +license-file: LICENSE +author: Judah Jacobson +maintainer: proto-lens@googlegroups.com +copyright: Google Inc. +category: Data +build-type: Custom +cabal-version: >=1.8 +extra-source-files: + proto-src/google/protobuf/any.proto + proto-src/google/protobuf/duration.proto + proto-src/google/protobuf/wrappers.proto + +custom-setup + setup-depends: base >= 4.8 && < 4.10 + , Cabal + , proto-lens-protoc == 0.2.* + +library + exposed-modules: Proto.Google.Protobuf.Any + Proto.Google.Protobuf.Duration + Proto.Google.Protobuf.Wrappers + build-depends: proto-lens-protoc == 0.2.* diff --git a/proto-src/google/protobuf/any.proto b/proto-src/google/protobuf/any.proto new file mode 100644 --- /dev/null +++ b/proto-src/google/protobuf/any.proto @@ -0,0 +1,128 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "github.com/golang/protobuf/ptypes/any"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "AnyProto"; +option java_multiple_files = true; +option java_generate_equals_and_hash = true; +option objc_class_prefix = "GPB"; + +// `Any` contains an arbitrary serialized protocol buffer message along with a +// URL that describes the type of the serialized message. +// +// Protobuf library provides support to pack/unpack Any values in the form +// of utility functions or additional generated methods of the Any type. +// +// Example 1: Pack and unpack a message in C++. +// +// Foo foo = ...; +// Any any; +// any.PackFrom(foo); +// ... +// if (any.UnpackTo(&foo)) { +// ... +// } +// +// Example 2: Pack and unpack a message in Java. +// +// Foo foo = ...; +// Any any = Any.pack(foo); +// ... +// if (any.is(Foo.class)) { +// foo = any.unpack(Foo.class); +// } +// +// The pack methods provided by protobuf library will by default use +// 'type.googleapis.com/full.type.name' as the type URL and the unpack +// methods only use the fully qualified type name after the last '/' +// in the type URL, for example "foo.bar.com/x/y.z" will yield type +// name "y.z". +// +// +// JSON +// ==== +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the `@type` +// field. Example (for message [google.protobuf.Duration][]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +message Any { + // A URL/resource name whose content describes the type of the + // serialized protocol buffer message. + // + // For URLs which use the schema `http`, `https`, or no schema, the + // following restrictions and interpretations apply: + // + // * If no schema is provided, `https` is assumed. + // * The last segment of the URL's path must represent the fully + // qualified name of the type (as in `path/google.protobuf.Duration`). + // * An HTTP GET on the URL must yield a [google.protobuf.Type][] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Schemas other than `http`, `https` (or the empty schema) might be + // used with implementation specific semantics. + // + string type_url = 1; + + // Must be a valid serialized protocol buffer of the above specified type. + bytes value = 2; +} diff --git a/proto-src/google/protobuf/duration.proto b/proto-src/google/protobuf/duration.proto new file mode 100644 --- /dev/null +++ b/proto-src/google/protobuf/duration.proto @@ -0,0 +1,98 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "github.com/golang/protobuf/ptypes/duration"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DurationProto"; +option java_multiple_files = true; +option java_generate_equals_and_hash = true; +option objc_class_prefix = "GPB"; + +// 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 "day" +// or "month". 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. +// +// Example 1: Compute Duration from two Timestamps in 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 (durations.seconds > 0 && duration.nanos < 0) { +// duration.seconds -= 1; +// duration.nanos += 1000000000; +// } +// +// Example 2: Compute Timestamp from Timestamp + Duration in 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; +// } +// +// +message Duration { + + // Signed seconds of the span of time. Must be from -315,576,000,000 + // to +315,576,000,000 inclusive. + int64 seconds = 1; + + // Signed fractions of a second at nanosecond resolution of the span + // of time. Durations less than one second are represented with a 0 + // `seconds` field and a positive or negative `nanos` field. For durations + // of one second or more, a non-zero value for the `nanos` field must be + // of the same sign as the `seconds` field. Must be from -999,999,999 + // to +999,999,999 inclusive. + int32 nanos = 2; +} diff --git a/proto-src/google/protobuf/wrappers.proto b/proto-src/google/protobuf/wrappers.proto new file mode 100644 --- /dev/null +++ b/proto-src/google/protobuf/wrappers.proto @@ -0,0 +1,119 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Wrappers for primitive (non-message) types. These types are useful +// for embedding primitives in the `google.protobuf.Any` type and for places +// where we need to distinguish between the absence of a primitive +// typed field and its default value. + +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option cc_enable_arenas = true; +option go_package = "github.com/golang/protobuf/ptypes/wrappers"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "WrappersProto"; +option java_multiple_files = true; +option java_generate_equals_and_hash = true; +option objc_class_prefix = "GPB"; + +// Wrapper message for `double`. +// +// The JSON representation for `DoubleValue` is JSON number. +message DoubleValue { + // The double value. + double value = 1; +} + +// Wrapper message for `float`. +// +// The JSON representation for `FloatValue` is JSON number. +message FloatValue { + // The float value. + float value = 1; +} + +// Wrapper message for `int64`. +// +// The JSON representation for `Int64Value` is JSON string. +message Int64Value { + // The int64 value. + int64 value = 1; +} + +// Wrapper message for `uint64`. +// +// The JSON representation for `UInt64Value` is JSON string. +message UInt64Value { + // The uint64 value. + uint64 value = 1; +} + +// Wrapper message for `int32`. +// +// The JSON representation for `Int32Value` is JSON number. +message Int32Value { + // The int32 value. + int32 value = 1; +} + +// Wrapper message for `uint32`. +// +// The JSON representation for `UInt32Value` is JSON number. +message UInt32Value { + // The uint32 value. + uint32 value = 1; +} + +// Wrapper message for `bool`. +// +// The JSON representation for `BoolValue` is JSON `true` and `false`. +message BoolValue { + // The bool value. + bool value = 1; +} + +// Wrapper message for `string`. +// +// The JSON representation for `StringValue` is JSON string. +message StringValue { + // The string value. + string value = 1; +} + +// Wrapper message for `bytes`. +// +// The JSON representation for `BytesValue` is JSON string. +message BytesValue { + // The bytes value. + bytes value = 1; +}