F# Record Serialization about froto HOT 3 CLOSED

module SampleNamespace =
    open System
    open Froto.Serialization
    open Froto.Serialization.Serializer
    open Froto.Serialization.Encoding

    type ETest =
        | Nada = 0
        | One = 1
        | Two = 2

    let ETestDefault = ETest.One  // NOTE: Non-zero default is only supported in Proto2

    type InnerSample = {
        id : int32
        name : string
        option : bool
        test : ETest
        packedFixed32 : uint32 list
        repeatedInt32 : int32 list
        _unknownFields : RawField list
        _foundFields : Set<FieldNum>
        }
        with
            static member Default = {
                id=0
                name=""
                option=false
                test=ETest.Nada
                packedFixed32=[]
                repeatedInt32=[]
                _unknownFields=List.empty
                _foundFields=Set.empty
            }

            static member Serializer (m, zcb) =
                (m.id             |> Encode.fromVarint 1) >>
                (m.name           |> Encode.fromString 2) >>
                (m.option         |> Encode.fromBool 3) >>
                (m.test           |> Encode.fromDefaultedVarint ETestDefault 4) >>
                (m.packedFixed32  |> Encode.fromPackedFixed32 5) >>
                (m.repeatedInt32  |> Encode.fromRepeated Encode.fromVarint 6) >>
                (m._unknownFields |> Encode.fromRawFields )
                <| zcb

            static member DecoderRing =
                [
                    0, fun m rawField -> { m with _unknownFields = rawField :: m._unknownFields }
                    1, fun m rawField -> { m with id = rawField |> Decode.toInt32 } : InnerSample
                    2, fun m rawField -> { m with name = rawField |> Decode.toString } : InnerSample
                    3, fun m rawField -> { m with option = rawField |> Decode.toBool } : InnerSample
                    4, fun m rawField -> { m with test = rawField |> Decode.toEnum } : InnerSample
                    5, fun m rawField -> { m with packedFixed32 = rawField |> Decode.toPackedFixed32 } : InnerSample
                    6, fun m rawField -> { m with repeatedInt32 = (rawField |> Decode.toInt32) :: m.repeatedInt32 } : InnerSample
                ]
                |> Map.ofList

            static member RememberFound (m,found) =
                { m with _foundFields = m._foundFields |> Set.add found }

            static member DecodeFixup m =
                { m with
                    packedFixed32 = List.rev m.packedFixed32
                    repeatedInt32 = List.rev m.repeatedInt32
                    _unknownFields = List.rev m._unknownFields }

            static member RequiredFields =
                [ 1; 2 ] |> Set.ofList

            static member FoundFields m =
                m._foundFields

            static member UnknownFields m =
                m._unknownFields