Example #1
0
 public void MergeFrom(pb::CodedInputStream input) {
   uint tag;
   while ((tag = input.ReadTag()) != 0) {
     switch(tag) {
       default:
         input.SkipLastField();
         break;
       case 8: {
         Size = input.ReadInt64();
         break;
       }
       case 16: {
         AliasInputPort = input.ReadInt64();
         break;
       }
       case 26: {
         if (shape_ == null) {
           shape_ = new global::Vision.Tensorflow.Proto.TensorShapeProto();
         }
         input.ReadMessage(shape_);
         break;
       }
       case 32: {
         dtype_ = (global::Vision.Tensorflow.Proto.DataType) input.ReadEnum();
         break;
       }
     }
   }
 }
Example #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::Vision.Tensorflow.Proto.DataType)input.ReadEnum();
                    break;
                }

                case 18: {
                    if (shape_ == null)
                    {
                        shape_ = new global::Vision.Tensorflow.Proto.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;
                }
                }
            }
        }
Example #3
0
 public void MergeFrom(OutputInfo other) {
   if (other == null) {
     return;
   }
   if (other.Size != 0L) {
     Size = other.Size;
   }
   if (other.AliasInputPort != 0L) {
     AliasInputPort = other.AliasInputPort;
   }
   if (other.shape_ != null) {
     if (shape_ == null) {
       shape_ = new global::Vision.Tensorflow.Proto.TensorShapeProto();
     }
     Shape.MergeFrom(other.Shape);
   }
   if (other.Dtype != 0) {
     Dtype = other.Dtype;
   }
 }
Example #4
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

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

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

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

                case 34: {
                    if (allocationDescription_ == null)
                    {
                        allocationDescription_ = new global::Vision.Tensorflow.Proto.AllocationDescription();
                    }
                    input.ReadMessage(allocationDescription_);
                    break;
                }
                }
            }
        }
Example #5
0
        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

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

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

                case 18: {
                    if (tensorShape_ == null)
                    {
                        tensorShape_ = new global::Vision.Tensorflow.Proto.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;
                }
                }
            }
        }