Esempio n. 1
0
 public void MergeFrom(RemoteTensorHandle other)
 {
     if (other == null)
     {
         return;
     }
     if (other.OpId != 0L)
     {
         OpId = other.OpId;
     }
     if (other.OutputNum != 0)
     {
         OutputNum = other.OutputNum;
     }
     if (other.Device.Length != 0)
     {
         Device = other.Device;
     }
     if (other.OpDevice.Length != 0)
     {
         OpDevice = other.OpDevice;
     }
     if (other.Dtype != 0)
     {
         Dtype = other.Dtype;
     }
     _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
 }
Esempio n. 2
0
                public void MergeFrom(pb::CodedInputStream input)
                {
                    uint tag;

                    while ((tag = input.ReadTag()) != 0)
                    {
                        switch (tag)
                        {
                        default:
                            input.SkipLastField();
                            break;

                        case 8: {
                            dtype_ = (global::Tensorflow.DataType)input.ReadEnum();
                            break;
                        }

                        case 18: {
                            if (shape_ == null)
                            {
                                shape_ = new global::Tensorflow.TensorShapeProto();
                            }
                            input.ReadMessage(shape_);
                            break;
                        }
                        }
                    }
                }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    dtype_ = (global::Tensorflow.DataType)input.ReadEnum();
                    break;
                }

                case 18: {
                    ValuesOutputTensorName = input.ReadString();
                    break;
                }

                case 26: {
                    IndicesOutputTensorName = input.ReadString();
                    break;
                }

                case 34: {
                    ShapesOutputTensorName = input.ReadString();
                    break;
                }
                }
            }
        }
Esempio n. 4
0
                public void MergeFrom(pb::CodedInputStream input)
                {
                    uint tag;

                    while ((tag = input.ReadTag()) != 0)
                    {
                        switch (tag)
                        {
                        default:
                            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                            break;

                        case 10: {
                            if (shape_ == null)
                            {
                                shape_ = new global::Tensorflow.TensorShapeProto();
                            }
                            input.ReadMessage(shape_);
                            break;
                        }

                        case 16: {
                            dtype_ = (global::Tensorflow.DataType)input.ReadEnum();
                            break;
                        }
                        }
                    }
                }
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    input.SkipLastField();
                    break;

                case 8: {
                    dtype_ = (global::Tensorflow.DataType)input.ReadEnum();
                    break;
                }

                case 18: {
                    if (shape_ == null)
                    {
                        shape_ = new global::Tensorflow.TensorShapeProto();
                    }
                    input.ReadMessage(shape_);
                    break;
                }

                case 24: {
                    ShardId = input.ReadInt32();
                    break;
                }

                case 32: {
                    Offset = input.ReadInt64();
                    break;
                }

                case 40: {
                    Size = input.ReadInt64();
                    break;
                }

                case 53: {
                    Crc32C = input.ReadFixed32();
                    break;
                }

                case 58: {
                    slices_.AddEntriesFrom(input, _repeated_slices_codec);
                    break;
                }
                }
            }
        }
Esempio n. 6
0
 public void MergeFrom(HandleShapeAndType other)
 {
     if (other == null)
     {
         return;
     }
     if (other.shape_ != null)
     {
         if (shape_ == null)
         {
             shape_ = new global::Tensorflow.TensorShapeProto();
         }
         Shape.MergeFrom(other.Shape);
     }
     if (other.Dtype != 0)
     {
         Dtype = other.Dtype;
     }
     _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
 }
Esempio n. 7
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    OpId = input.ReadInt64();
                    break;
                }

                case 16: {
                    OutputNum = input.ReadInt32();
                    break;
                }

                case 26: {
                    Device = input.ReadString();
                    break;
                }

                case 34: {
                    OpDevice = input.ReadString();
                    break;
                }

                case 40: {
                    Dtype = (global::Tensorflow.DataType)input.ReadEnum();
                    break;
                }
                }
            }
        }
Esempio n. 8
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8: {
                    dtype_ = (global::Tensorflow.DataType)input.ReadEnum();
                    break;
                }

                case 18: {
                    if (tensorShape_ == null)
                    {
                        tensorShape_ = new global::Tensorflow.TensorShapeProto();
                    }
                    input.ReadMessage(tensorShape_);
                    break;
                }

                case 24: {
                    VersionNumber = input.ReadInt32();
                    break;
                }

                case 34: {
                    TensorContent = input.ReadBytes();
                    break;
                }

                case 42:
                case 45: {
                    floatVal_.AddEntriesFrom(input, _repeated_floatVal_codec);
                    break;
                }

                case 50:
                case 49: {
                    doubleVal_.AddEntriesFrom(input, _repeated_doubleVal_codec);
                    break;
                }

                case 58:
                case 56: {
                    intVal_.AddEntriesFrom(input, _repeated_intVal_codec);
                    break;
                }

                case 66: {
                    stringVal_.AddEntriesFrom(input, _repeated_stringVal_codec);
                    break;
                }

                case 74:
                case 77: {
                    scomplexVal_.AddEntriesFrom(input, _repeated_scomplexVal_codec);
                    break;
                }

                case 82:
                case 80: {
                    int64Val_.AddEntriesFrom(input, _repeated_int64Val_codec);
                    break;
                }

                case 90:
                case 88: {
                    boolVal_.AddEntriesFrom(input, _repeated_boolVal_codec);
                    break;
                }

                case 98:
                case 97: {
                    dcomplexVal_.AddEntriesFrom(input, _repeated_dcomplexVal_codec);
                    break;
                }

                case 106:
                case 104: {
                    halfVal_.AddEntriesFrom(input, _repeated_halfVal_codec);
                    break;
                }

                case 114: {
                    resourceHandleVal_.AddEntriesFrom(input, _repeated_resourceHandleVal_codec);
                    break;
                }

                case 122: {
                    variantVal_.AddEntriesFrom(input, _repeated_variantVal_codec);
                    break;
                }

                case 130:
                case 128: {
                    uint32Val_.AddEntriesFrom(input, _repeated_uint32Val_codec);
                    break;
                }

                case 138:
                case 136: {
                    uint64Val_.AddEntriesFrom(input, _repeated_uint64Val_codec);
                    break;
                }
                }
            }
        }