scisharp
/
TensorFlow.NET
Not watched
1
0
Fork 0
Code
Releases 21 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 71fef9ac14
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '71fef9ac14'
${ noResults }
TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/AttrValue.cs

1031 lines
38 kB
Raw Blame History 

  1. // <auto-generated>

  2. //     Generated by the protocol buffer compiler.  DO NOT EDIT!

  3. //     source: tensorflow/core/framework/attr_value.proto

  4. // </auto-generated>

  5. #pragma warning disable 1591, 0612, 3021

  6. #region Designer generated code

  7. 

  8. using pb = global::Google.Protobuf;

  9. using pbc = global::Google.Protobuf.Collections;

  10. using pbr = global::Google.Protobuf.Reflection;

  11. using scg = global::System.Collections.Generic;

  12. namespace Tensorflow {

  13. 

  14.   /// <summary>Holder for reflection information generated from tensorflow/core/framework/attr_value.proto</summary>

  15.   public static partial class AttrValueReflection {

  16. 

  17.     #region Descriptor

  18.     /// <summary>File descriptor for tensorflow/core/framework/attr_value.proto</summary>

  19.     public static pbr::FileDescriptor Descriptor {

  20.       get { return descriptor; }

  21.     }

  22.     private static pbr::FileDescriptor descriptor;

  23. 

  24.     static AttrValueReflection() {

  25.       byte[] descriptorData = global::System.Convert.FromBase64String(

  26.           string.Concat(

  27.             "Cip0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL2F0dHJfdmFsdWUucHJvdG8S",

  28.             "CnRlbnNvcmZsb3caJnRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvdGVuc29y",

  29.             "LnByb3RvGix0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3RlbnNvcl9zaGFw",

  30.             "ZS5wcm90bxoldGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay90eXBlcy5wcm90",

  31.             "byKmBAoJQXR0clZhbHVlEgsKAXMYAiABKAxIABILCgFpGAMgASgDSAASCwoB",

  32.             "ZhgEIAEoAkgAEgsKAWIYBSABKAhIABIkCgR0eXBlGAYgASgOMhQudGVuc29y",

  33.             "Zmxvdy5EYXRhVHlwZUgAEi0KBXNoYXBlGAcgASgLMhwudGVuc29yZmxvdy5U",

  34.             "ZW5zb3JTaGFwZVByb3RvSAASKQoGdGVuc29yGAggASgLMhcudGVuc29yZmxv",

  35.             "dy5UZW5zb3JQcm90b0gAEi8KBGxpc3QYASABKAsyHy50ZW5zb3JmbG93LkF0",

  36.             "dHJWYWx1ZS5MaXN0VmFsdWVIABIoCgRmdW5jGAogASgLMhgudGVuc29yZmxv",

  37.             "dy5OYW1lQXR0ckxpc3RIABIVCgtwbGFjZWhvbGRlchgJIAEoCUgAGukBCglM",

  38.             "aXN0VmFsdWUSCQoBcxgCIAMoDBINCgFpGAMgAygDQgIQARINCgFmGAQgAygC",

  39.             "QgIQARINCgFiGAUgAygIQgIQARImCgR0eXBlGAYgAygOMhQudGVuc29yZmxv",

  40.             "dy5EYXRhVHlwZUICEAESKwoFc2hhcGUYByADKAsyHC50ZW5zb3JmbG93LlRl",

  41.             "bnNvclNoYXBlUHJvdG8SJwoGdGVuc29yGAggAygLMhcudGVuc29yZmxvdy5U",

  42.             "ZW5zb3JQcm90bxImCgRmdW5jGAkgAygLMhgudGVuc29yZmxvdy5OYW1lQXR0",

  43.             "ckxpc3RCBwoFdmFsdWUikgEKDE5hbWVBdHRyTGlzdBIMCgRuYW1lGAEgASgJ",

  44.             "EjAKBGF0dHIYAiADKAsyIi50ZW5zb3JmbG93Lk5hbWVBdHRyTGlzdC5BdHRy",

  45.             "RW50cnkaQgoJQXR0ckVudHJ5EgsKA2tleRgBIAEoCRIkCgV2YWx1ZRgCIAEo",

  46.             "CzIVLnRlbnNvcmZsb3cuQXR0clZhbHVlOgI4AUJvChhvcmcudGVuc29yZmxv",

  47.             "dy5mcmFtZXdvcmtCD0F0dHJWYWx1ZVByb3Rvc1ABWj1naXRodWIuY29tL3Rl",

  48.             "bnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3",

  49.             "b3Jr+AEBYgZwcm90bzM="));

  50.       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

  51.           new pbr::FileDescriptor[] { global::Tensorflow.TensorReflection.Descriptor, global::Tensorflow.TensorShapeReflection.Descriptor, global::Tensorflow.TypesReflection.Descriptor, },

  52.           new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {

  53.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.AttrValue), global::Tensorflow.AttrValue.Parser, new[]{ "S", "I", "F", "B", "Type", "Shape", "Tensor", "List", "Func", "Placeholder" }, new[]{ "Value" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.AttrValue.Types.ListValue), global::Tensorflow.AttrValue.Types.ListValue.Parser, new[]{ "S", "I", "F", "B", "Type", "Shape", "Tensor", "Func" }, null, null, null, null)}),

  54.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NameAttrList), global::Tensorflow.NameAttrList.Parser, new[]{ "Name", "Attr" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, })

  55.           }));

  56.     }

  57.     #endregion

  58. 

  59.   }

  60.   #region Messages

  61.   /// <summary>

  62.   /// Protocol buffer representing the value for an attr used to configure an Op.

  63.   /// Comment indicates the corresponding attr type.  Only the field matching the

  64.   /// attr type may be filled.

  65.   /// </summary>

  66.   public sealed partial class AttrValue : pb::IMessage<AttrValue> {

  67.     private static readonly pb::MessageParser<AttrValue> _parser = new pb::MessageParser<AttrValue>(() => new AttrValue());

  68.     private pb::UnknownFieldSet _unknownFields;

  69.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  70.     public static pb::MessageParser<AttrValue> Parser { get { return _parser; } }

  71. 

  72.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  73.     public static pbr::MessageDescriptor Descriptor {

  74.       get { return global::Tensorflow.AttrValueReflection.Descriptor.MessageTypes[0]; }

  75.     }

  76. 

  77.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  78.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  79.       get { return Descriptor; }

  80.     }

  81. 

  82.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  83.     public AttrValue() {

  84.       OnConstruction();

  85.     }

  86. 

  87.     partial void OnConstruction();

  88. 

  89.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  90.     public AttrValue(AttrValue other) : this() {

  91.       switch (other.ValueCase) {

  92.         case ValueOneofCase.S:

  93.           S = other.S;

  94.           break;

  95.         case ValueOneofCase.I:

  96.           I = other.I;

  97.           break;

  98.         case ValueOneofCase.F:

  99.           F = other.F;

  100.           break;

  101.         case ValueOneofCase.B:

  102.           B = other.B;

  103.           break;

  104.         case ValueOneofCase.Type:

  105.           Type = other.Type;

  106.           break;

  107.         case ValueOneofCase.Shape:

  108.           Shape = other.Shape.Clone();

  109.           break;

  110.         case ValueOneofCase.Tensor:

  111.           Tensor = other.Tensor.Clone();

  112.           break;

  113.         case ValueOneofCase.List:

  114.           List = other.List.Clone();

  115.           break;

  116.         case ValueOneofCase.Func:

  117.           Func = other.Func.Clone();

  118.           break;

  119.         case ValueOneofCase.Placeholder:

  120.           Placeholder = other.Placeholder;

  121.           break;

  122.       }

  123. 

  124.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  125.     }

  126. 

  127.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  128.     public AttrValue Clone() {

  129.       return new AttrValue(this);

  130.     }

  131. 

  132.     /// <summary>Field number for the "s" field.</summary>

  133.     public const int SFieldNumber = 2;

  134.     /// <summary>

  135.     /// "string"

  136.     /// </summary>

  137.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  138.     public pb::ByteString S {

  139.       get { return valueCase_ == ValueOneofCase.S ? (pb::ByteString) value_ : pb::ByteString.Empty; }

  140.       set {

  141.         value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  142.         valueCase_ = ValueOneofCase.S;

  143.       }

  144.     }

  145. 

  146.     /// <summary>Field number for the "i" field.</summary>

  147.     public const int IFieldNumber = 3;

  148.     /// <summary>

  149.     /// "int"

  150.     /// </summary>

  151.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  152.     public long I {

  153.       get { return valueCase_ == ValueOneofCase.I ? (long) value_ : 0L; }

  154.       set {

  155.         value_ = value;

  156.         valueCase_ = ValueOneofCase.I;

  157.       }

  158.     }

  159. 

  160.     /// <summary>Field number for the "f" field.</summary>

  161.     public const int FFieldNumber = 4;

  162.     /// <summary>

  163.     /// "float"

  164.     /// </summary>

  165.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  166.     public float F {

  167.       get { return valueCase_ == ValueOneofCase.F ? (float) value_ : 0F; }

  168.       set {

  169.         value_ = value;

  170.         valueCase_ = ValueOneofCase.F;

  171.       }

  172.     }

  173. 

  174.     /// <summary>Field number for the "b" field.</summary>

  175.     public const int BFieldNumber = 5;

  176.     /// <summary>

  177.     /// "bool"

  178.     /// </summary>

  179.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  180.     public bool B {

  181.       get { return valueCase_ == ValueOneofCase.B ? (bool) value_ : false; }

  182.       set {

  183.         value_ = value;

  184.         valueCase_ = ValueOneofCase.B;

  185.       }

  186.     }

  187. 

  188.     /// <summary>Field number for the "type" field.</summary>

  189.     public const int TypeFieldNumber = 6;

  190.     /// <summary>

  191.     /// "type"

  192.     /// </summary>

  193.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  194.     public global::Tensorflow.DataType Type {

  195.       get { return valueCase_ == ValueOneofCase.Type ? (global::Tensorflow.DataType) value_ : global::Tensorflow.DataType.DtInvalid; }

  196.       set {

  197.         value_ = value;

  198.         valueCase_ = ValueOneofCase.Type;

  199.       }

  200.     }

  201. 

  202.     /// <summary>Field number for the "shape" field.</summary>

  203.     public const int ShapeFieldNumber = 7;

  204.     /// <summary>

  205.     /// "shape"

  206.     /// </summary>

  207.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  208.     public global::Tensorflow.TensorShapeProto Shape {

  209.       get { return valueCase_ == ValueOneofCase.Shape ? (global::Tensorflow.TensorShapeProto) value_ : null; }

  210.       set {

  211.         value_ = value;

  212.         valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.Shape;

  213.       }

  214.     }

  215. 

  216.     /// <summary>Field number for the "tensor" field.</summary>

  217.     public const int TensorFieldNumber = 8;

  218.     /// <summary>

  219.     /// "tensor"

  220.     /// </summary>

  221.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  222.     public global::Tensorflow.TensorProto Tensor {

  223.       get { return valueCase_ == ValueOneofCase.Tensor ? (global::Tensorflow.TensorProto) value_ : null; }

  224.       set {

  225.         value_ = value;

  226.         valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.Tensor;

  227.       }

  228.     }

  229. 

  230.     /// <summary>Field number for the "list" field.</summary>

  231.     public const int ListFieldNumber = 1;

  232.     /// <summary>

  233.     /// any "list(...)"

  234.     /// </summary>

  235.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  236.     public global::Tensorflow.AttrValue.Types.ListValue List {

  237.       get { return valueCase_ == ValueOneofCase.List ? (global::Tensorflow.AttrValue.Types.ListValue) value_ : null; }

  238.       set {

  239.         value_ = value;

  240.         valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.List;

  241.       }

  242.     }

  243. 

  244.     /// <summary>Field number for the "func" field.</summary>

  245.     public const int FuncFieldNumber = 10;

  246.     /// <summary>

  247.     /// "func" represents a function. func.name is a function's name or

  248.     /// a primitive op's name. func.attr.first is the name of an attr

  249.     /// defined for that function. func.attr.second is the value for

  250.     /// that attr in the instantiation.

  251.     /// </summary>

  252.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  253.     public global::Tensorflow.NameAttrList Func {

  254.       get { return valueCase_ == ValueOneofCase.Func ? (global::Tensorflow.NameAttrList) value_ : null; }

  255.       set {

  256.         value_ = value;

  257.         valueCase_ = value == null ? ValueOneofCase.None : ValueOneofCase.Func;

  258.       }

  259.     }

  260. 

  261.     /// <summary>Field number for the "placeholder" field.</summary>

  262.     public const int PlaceholderFieldNumber = 9;

  263.     /// <summary>

  264.     /// This is a placeholder only used in nodes defined inside a

  265.     /// function.  It indicates the attr value will be supplied when

  266.     /// the function is instantiated.  For example, let us suppose a

  267.     /// node "N" in function "FN". "N" has an attr "A" with value

  268.     /// placeholder = "foo". When FN is instantiated with attr "foo"

  269.     /// set to "bar", the instantiated node N's attr A will have been

  270.     /// given the value "bar".

  271.     /// </summary>

  272.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  273.     public string Placeholder {

  274.       get { return valueCase_ == ValueOneofCase.Placeholder ? (string) value_ : ""; }

  275.       set {

  276.         value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  277.         valueCase_ = ValueOneofCase.Placeholder;

  278.       }

  279.     }

  280. 

  281.     private object value_;

  282.     /// <summary>Enum of possible cases for the "value" oneof.</summary>

  283.     public enum ValueOneofCase {

  284.       None = 0,

  285.       S = 2,

  286.       I = 3,

  287.       F = 4,

  288.       B = 5,

  289.       Type = 6,

  290.       Shape = 7,

  291.       Tensor = 8,

  292.       List = 1,

  293.       Func = 10,

  294.       Placeholder = 9,

  295.     }

  296.     private ValueOneofCase valueCase_ = ValueOneofCase.None;

  297.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  298.     public ValueOneofCase ValueCase {

  299.       get { return valueCase_; }

  300.     }

  301. 

  302.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  303.     public void ClearValue() {

  304.       valueCase_ = ValueOneofCase.None;

  305.       value_ = null;

  306.     }

  307. 

  308.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  309.     public override bool Equals(object other) {

  310.       return Equals(other as AttrValue);

  311.     }

  312. 

  313.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  314.     public bool Equals(AttrValue other) {

  315.       if (ReferenceEquals(other, null)) {

  316.         return false;

  317.       }

  318.       if (ReferenceEquals(other, this)) {

  319.         return true;

  320.       }

  321.       if (S != other.S) return false;

  322.       if (I != other.I) return false;

  323.       if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(F, other.F)) return false;

  324.       if (B != other.B) return false;

  325.       if (Type != other.Type) return false;

  326.       if (!object.Equals(Shape, other.Shape)) return false;

  327.       if (!object.Equals(Tensor, other.Tensor)) return false;

  328.       if (!object.Equals(List, other.List)) return false;

  329.       if (!object.Equals(Func, other.Func)) return false;

  330.       if (Placeholder != other.Placeholder) return false;

  331.       if (ValueCase != other.ValueCase) return false;

  332.       return Equals(_unknownFields, other._unknownFields);

  333.     }

  334. 

  335.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  336.     public override int GetHashCode() {

  337.       int hash = 1;

  338.       if (valueCase_ == ValueOneofCase.S) hash ^= S.GetHashCode();

  339.       if (valueCase_ == ValueOneofCase.I) hash ^= I.GetHashCode();

  340.       if (valueCase_ == ValueOneofCase.F) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(F);

  341.       if (valueCase_ == ValueOneofCase.B) hash ^= B.GetHashCode();

  342.       if (valueCase_ == ValueOneofCase.Type) hash ^= Type.GetHashCode();

  343.       if (valueCase_ == ValueOneofCase.Shape) hash ^= Shape.GetHashCode();

  344.       if (valueCase_ == ValueOneofCase.Tensor) hash ^= Tensor.GetHashCode();

  345.       if (valueCase_ == ValueOneofCase.List) hash ^= List.GetHashCode();

  346.       if (valueCase_ == ValueOneofCase.Func) hash ^= Func.GetHashCode();

  347.       if (valueCase_ == ValueOneofCase.Placeholder) hash ^= Placeholder.GetHashCode();

  348.       hash ^= (int) valueCase_;

  349.       if (_unknownFields != null) {

  350.         hash ^= _unknownFields.GetHashCode();

  351.       }

  352.       return hash;

  353.     }

  354. 

  355.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  356.     public override string ToString() {

  357.       return pb::JsonFormatter.ToDiagnosticString(this);

  358.     }

  359. 

  360.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  361.     public void WriteTo(pb::CodedOutputStream output) {

  362.       if (valueCase_ == ValueOneofCase.List) {

  363.         output.WriteRawTag(10);

  364.         output.WriteMessage(List);

  365.       }

  366.       if (valueCase_ == ValueOneofCase.S) {

  367.         output.WriteRawTag(18);

  368.         output.WriteBytes(S);

  369.       }

  370.       if (valueCase_ == ValueOneofCase.I) {

  371.         output.WriteRawTag(24);

  372.         output.WriteInt64(I);

  373.       }

  374.       if (valueCase_ == ValueOneofCase.F) {

  375.         output.WriteRawTag(37);

  376.         output.WriteFloat(F);

  377.       }

  378.       if (valueCase_ == ValueOneofCase.B) {

  379.         output.WriteRawTag(40);

  380.         output.WriteBool(B);

  381.       }

  382.       if (valueCase_ == ValueOneofCase.Type) {

  383.         output.WriteRawTag(48);

  384.         output.WriteEnum((int) Type);

  385.       }

  386.       if (valueCase_ == ValueOneofCase.Shape) {

  387.         output.WriteRawTag(58);

  388.         output.WriteMessage(Shape);

  389.       }

  390.       if (valueCase_ == ValueOneofCase.Tensor) {

  391.         output.WriteRawTag(66);

  392.         output.WriteMessage(Tensor);

  393.       }

  394.       if (valueCase_ == ValueOneofCase.Placeholder) {

  395.         output.WriteRawTag(74);

  396.         output.WriteString(Placeholder);

  397.       }

  398.       if (valueCase_ == ValueOneofCase.Func) {

  399.         output.WriteRawTag(82);

  400.         output.WriteMessage(Func);

  401.       }

  402.       if (_unknownFields != null) {

  403.         _unknownFields.WriteTo(output);

  404.       }

  405.     }

  406. 

  407.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  408.     public int CalculateSize() {

  409.       int size = 0;

  410.       if (valueCase_ == ValueOneofCase.S) {

  411.         size += 1 + pb::CodedOutputStream.ComputeBytesSize(S);

  412.       }

  413.       if (valueCase_ == ValueOneofCase.I) {

  414.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(I);

  415.       }

  416.       if (valueCase_ == ValueOneofCase.F) {

  417.         size += 1 + 4;

  418.       }

  419.       if (valueCase_ == ValueOneofCase.B) {

  420.         size += 1 + 1;

  421.       }

  422.       if (valueCase_ == ValueOneofCase.Type) {

  423.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type);

  424.       }

  425.       if (valueCase_ == ValueOneofCase.Shape) {

  426.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape);

  427.       }

  428.       if (valueCase_ == ValueOneofCase.Tensor) {

  429.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Tensor);

  430.       }

  431.       if (valueCase_ == ValueOneofCase.List) {

  432.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(List);

  433.       }

  434.       if (valueCase_ == ValueOneofCase.Func) {

  435.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Func);

  436.       }

  437.       if (valueCase_ == ValueOneofCase.Placeholder) {

  438.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Placeholder);

  439.       }

  440.       if (_unknownFields != null) {

  441.         size += _unknownFields.CalculateSize();

  442.       }

  443.       return size;

  444.     }

  445. 

  446.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  447.     public void MergeFrom(AttrValue other) {

  448.       if (other == null) {

  449.         return;

  450.       }

  451.       switch (other.ValueCase) {

  452.         case ValueOneofCase.S:

  453.           S = other.S;

  454.           break;

  455.         case ValueOneofCase.I:

  456.           I = other.I;

  457.           break;

  458.         case ValueOneofCase.F:

  459.           F = other.F;

  460.           break;

  461.         case ValueOneofCase.B:

  462.           B = other.B;

  463.           break;

  464.         case ValueOneofCase.Type:

  465.           Type = other.Type;

  466.           break;

  467.         case ValueOneofCase.Shape:

  468.           if (Shape == null) {

  469.             Shape = new global::Tensorflow.TensorShapeProto();

  470.           }

  471.           Shape.MergeFrom(other.Shape);

  472.           break;

  473.         case ValueOneofCase.Tensor:

  474.           if (Tensor == null) {

  475.             Tensor = new global::Tensorflow.TensorProto();

  476.           }

  477.           Tensor.MergeFrom(other.Tensor);

  478.           break;

  479.         case ValueOneofCase.List:

  480.           if (List == null) {

  481.             List = new global::Tensorflow.AttrValue.Types.ListValue();

  482.           }

  483.           List.MergeFrom(other.List);

  484.           break;

  485.         case ValueOneofCase.Func:

  486.           if (Func == null) {

  487.             Func = new global::Tensorflow.NameAttrList();

  488.           }

  489.           Func.MergeFrom(other.Func);

  490.           break;

  491.         case ValueOneofCase.Placeholder:

  492.           Placeholder = other.Placeholder;

  493.           break;

  494.       }

  495. 

  496.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  497.     }

  498. 

  499.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  500.     public void MergeFrom(pb::CodedInputStream input) {

  501.       uint tag;

  502.       while ((tag = input.ReadTag()) != 0) {

  503.         switch(tag) {

  504.           default:

  505.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  506.             break;

  507.           case 10: {

  508.             global::Tensorflow.AttrValue.Types.ListValue subBuilder = new global::Tensorflow.AttrValue.Types.ListValue();

  509.             if (valueCase_ == ValueOneofCase.List) {

  510.               subBuilder.MergeFrom(List);

  511.             }

  512.             input.ReadMessage(subBuilder);

  513.             List = subBuilder;

  514.             break;

  515.           }

  516.           case 18: {

  517.             S = input.ReadBytes();

  518.             break;

  519.           }

  520.           case 24: {

  521.             I = input.ReadInt64();

  522.             break;

  523.           }

  524.           case 37: {

  525.             F = input.ReadFloat();

  526.             break;

  527.           }

  528.           case 40: {

  529.             B = input.ReadBool();

  530.             break;

  531.           }

  532.           case 48: {

  533.             value_ = input.ReadEnum();

  534.             valueCase_ = ValueOneofCase.Type;

  535.             break;

  536.           }

  537.           case 58: {

  538.             global::Tensorflow.TensorShapeProto subBuilder = new global::Tensorflow.TensorShapeProto();

  539.             if (valueCase_ == ValueOneofCase.Shape) {

  540.               subBuilder.MergeFrom(Shape);

  541.             }

  542.             input.ReadMessage(subBuilder);

  543.             Shape = subBuilder;

  544.             break;

  545.           }

  546.           case 66: {

  547.             global::Tensorflow.TensorProto subBuilder = new global::Tensorflow.TensorProto();

  548.             if (valueCase_ == ValueOneofCase.Tensor) {

  549.               subBuilder.MergeFrom(Tensor);

  550.             }

  551.             input.ReadMessage(subBuilder);

  552.             Tensor = subBuilder;

  553.             break;

  554.           }

  555.           case 74: {

  556.             Placeholder = input.ReadString();

  557.             break;

  558.           }

  559.           case 82: {

  560.             global::Tensorflow.NameAttrList subBuilder = new global::Tensorflow.NameAttrList();

  561.             if (valueCase_ == ValueOneofCase.Func) {

  562.               subBuilder.MergeFrom(Func);

  563.             }

  564.             input.ReadMessage(subBuilder);

  565.             Func = subBuilder;

  566.             break;

  567.           }

  568.         }

  569.       }

  570.     }

  571. 

  572.     #region Nested types

  573.     /// <summary>Container for nested types declared in the AttrValue message type.</summary>

  574.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  575.     public static partial class Types {

  576.       /// <summary>

  577.       /// LINT.IfChange

  578.       /// </summary>

  579.       public sealed partial class ListValue : pb::IMessage<ListValue> {

  580.         private static readonly pb::MessageParser<ListValue> _parser = new pb::MessageParser<ListValue>(() => new ListValue());

  581.         private pb::UnknownFieldSet _unknownFields;

  582.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  583.         public static pb::MessageParser<ListValue> Parser { get { return _parser; } }

  584. 

  585.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  586.         public static pbr::MessageDescriptor Descriptor {

  587.           get { return global::Tensorflow.AttrValue.Descriptor.NestedTypes[0]; }

  588.         }

  589. 

  590.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  591.         pbr::MessageDescriptor pb::IMessage.Descriptor {

  592.           get { return Descriptor; }

  593.         }

  594. 

  595.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  596.         public ListValue() {

  597.           OnConstruction();

  598.         }

  599. 

  600.         partial void OnConstruction();

  601. 

  602.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  603.         public ListValue(ListValue other) : this() {

  604.           s_ = other.s_.Clone();

  605.           i_ = other.i_.Clone();

  606.           f_ = other.f_.Clone();

  607.           b_ = other.b_.Clone();

  608.           type_ = other.type_.Clone();

  609.           shape_ = other.shape_.Clone();

  610.           tensor_ = other.tensor_.Clone();

  611.           func_ = other.func_.Clone();

  612.           _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  613.         }

  614. 

  615.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  616.         public ListValue Clone() {

  617.           return new ListValue(this);

  618.         }

  619. 

  620.         /// <summary>Field number for the "s" field.</summary>

  621.         public const int SFieldNumber = 2;

  622.         private static readonly pb::FieldCodec<pb::ByteString> _repeated_s_codec

  623.             = pb::FieldCodec.ForBytes(18);

  624.         private readonly pbc::RepeatedField<pb::ByteString> s_ = new pbc::RepeatedField<pb::ByteString>();

  625.         /// <summary>

  626.         /// "list(string)"

  627.         /// </summary>

  628.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  629.         public pbc::RepeatedField<pb::ByteString> S {

  630.           get { return s_; }

  631.         }

  632. 

  633.         /// <summary>Field number for the "i" field.</summary>

  634.         public const int IFieldNumber = 3;

  635.         private static readonly pb::FieldCodec<long> _repeated_i_codec

  636.             = pb::FieldCodec.ForInt64(26);

  637.         private readonly pbc::RepeatedField<long> i_ = new pbc::RepeatedField<long>();

  638.         /// <summary>

  639.         /// "list(int)"

  640.         /// </summary>

  641.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  642.         public pbc::RepeatedField<long> I {

  643.           get { return i_; }

  644.         }

  645. 

  646.         /// <summary>Field number for the "f" field.</summary>

  647.         public const int FFieldNumber = 4;

  648.         private static readonly pb::FieldCodec<float> _repeated_f_codec

  649.             = pb::FieldCodec.ForFloat(34);

  650.         private readonly pbc::RepeatedField<float> f_ = new pbc::RepeatedField<float>();

  651.         /// <summary>

  652.         /// "list(float)"

  653.         /// </summary>

  654.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  655.         public pbc::RepeatedField<float> F {

  656.           get { return f_; }

  657.         }

  658. 

  659.         /// <summary>Field number for the "b" field.</summary>

  660.         public const int BFieldNumber = 5;

  661.         private static readonly pb::FieldCodec<bool> _repeated_b_codec

  662.             = pb::FieldCodec.ForBool(42);

  663.         private readonly pbc::RepeatedField<bool> b_ = new pbc::RepeatedField<bool>();

  664.         /// <summary>

  665.         /// "list(bool)"

  666.         /// </summary>

  667.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  668.         public pbc::RepeatedField<bool> B {

  669.           get { return b_; }

  670.         }

  671. 

  672.         /// <summary>Field number for the "type" field.</summary>

  673.         public const int TypeFieldNumber = 6;

  674.         private static readonly pb::FieldCodec<global::Tensorflow.DataType> _repeated_type_codec

  675.             = pb::FieldCodec.ForEnum(50, x => (int) x, x => (global::Tensorflow.DataType) x);

  676.         private readonly pbc::RepeatedField<global::Tensorflow.DataType> type_ = new pbc::RepeatedField<global::Tensorflow.DataType>();

  677.         /// <summary>

  678.         /// "list(type)"

  679.         /// </summary>

  680.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  681.         public pbc::RepeatedField<global::Tensorflow.DataType> Type {

  682.           get { return type_; }

  683.         }

  684. 

  685.         /// <summary>Field number for the "shape" field.</summary>

  686.         public const int ShapeFieldNumber = 7;

  687.         private static readonly pb::FieldCodec<global::Tensorflow.TensorShapeProto> _repeated_shape_codec

  688.             = pb::FieldCodec.ForMessage(58, global::Tensorflow.TensorShapeProto.Parser);

  689.         private readonly pbc::RepeatedField<global::Tensorflow.TensorShapeProto> shape_ = new pbc::RepeatedField<global::Tensorflow.TensorShapeProto>();

  690.         /// <summary>

  691.         /// "list(shape)"

  692.         /// </summary>

  693.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  694.         public pbc::RepeatedField<global::Tensorflow.TensorShapeProto> Shape {

  695.           get { return shape_; }

  696.         }

  697. 

  698.         /// <summary>Field number for the "tensor" field.</summary>

  699.         public const int TensorFieldNumber = 8;

  700.         private static readonly pb::FieldCodec<global::Tensorflow.TensorProto> _repeated_tensor_codec

  701.             = pb::FieldCodec.ForMessage(66, global::Tensorflow.TensorProto.Parser);

  702.         private readonly pbc::RepeatedField<global::Tensorflow.TensorProto> tensor_ = new pbc::RepeatedField<global::Tensorflow.TensorProto>();

  703.         /// <summary>

  704.         /// "list(tensor)"

  705.         /// </summary>

  706.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  707.         public pbc::RepeatedField<global::Tensorflow.TensorProto> Tensor {

  708.           get { return tensor_; }

  709.         }

  710. 

  711.         /// <summary>Field number for the "func" field.</summary>

  712.         public const int FuncFieldNumber = 9;

  713.         private static readonly pb::FieldCodec<global::Tensorflow.NameAttrList> _repeated_func_codec

  714.             = pb::FieldCodec.ForMessage(74, global::Tensorflow.NameAttrList.Parser);

  715.         private readonly pbc::RepeatedField<global::Tensorflow.NameAttrList> func_ = new pbc::RepeatedField<global::Tensorflow.NameAttrList>();

  716.         /// <summary>

  717.         /// "list(attr)"

  718.         /// </summary>

  719.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  720.         public pbc::RepeatedField<global::Tensorflow.NameAttrList> Func {

  721.           get { return func_; }

  722.         }

  723. 

  724.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  725.         public override bool Equals(object other) {

  726.           return Equals(other as ListValue);

  727.         }

  728. 

  729.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  730.         public bool Equals(ListValue other) {

  731.           if (ReferenceEquals(other, null)) {

  732.             return false;

  733.           }

  734.           if (ReferenceEquals(other, this)) {

  735.             return true;

  736.           }

  737.           if(!s_.Equals(other.s_)) return false;

  738.           if(!i_.Equals(other.i_)) return false;

  739.           if(!f_.Equals(other.f_)) return false;

  740.           if(!b_.Equals(other.b_)) return false;

  741.           if(!type_.Equals(other.type_)) return false;

  742.           if(!shape_.Equals(other.shape_)) return false;

  743.           if(!tensor_.Equals(other.tensor_)) return false;

  744.           if(!func_.Equals(other.func_)) return false;

  745.           return Equals(_unknownFields, other._unknownFields);

  746.         }

  747. 

  748.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  749.         public override int GetHashCode() {

  750.           int hash = 1;

  751.           hash ^= s_.GetHashCode();

  752.           hash ^= i_.GetHashCode();

  753.           hash ^= f_.GetHashCode();

  754.           hash ^= b_.GetHashCode();

  755.           hash ^= type_.GetHashCode();

  756.           hash ^= shape_.GetHashCode();

  757.           hash ^= tensor_.GetHashCode();

  758.           hash ^= func_.GetHashCode();

  759.           if (_unknownFields != null) {

  760.             hash ^= _unknownFields.GetHashCode();

  761.           }

  762.           return hash;

  763.         }

  764. 

  765.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  766.         public override string ToString() {

  767.           return pb::JsonFormatter.ToDiagnosticString(this);

  768.         }

  769. 

  770.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  771.         public void WriteTo(pb::CodedOutputStream output) {

  772.           s_.WriteTo(output, _repeated_s_codec);

  773.           i_.WriteTo(output, _repeated_i_codec);

  774.           f_.WriteTo(output, _repeated_f_codec);

  775.           b_.WriteTo(output, _repeated_b_codec);

  776.           type_.WriteTo(output, _repeated_type_codec);

  777.           shape_.WriteTo(output, _repeated_shape_codec);

  778.           tensor_.WriteTo(output, _repeated_tensor_codec);

  779.           func_.WriteTo(output, _repeated_func_codec);

  780.           if (_unknownFields != null) {

  781.             _unknownFields.WriteTo(output);

  782.           }

  783.         }

  784. 

  785.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  786.         public int CalculateSize() {

  787.           int size = 0;

  788.           size += s_.CalculateSize(_repeated_s_codec);

  789.           size += i_.CalculateSize(_repeated_i_codec);

  790.           size += f_.CalculateSize(_repeated_f_codec);

  791.           size += b_.CalculateSize(_repeated_b_codec);

  792.           size += type_.CalculateSize(_repeated_type_codec);

  793.           size += shape_.CalculateSize(_repeated_shape_codec);

  794.           size += tensor_.CalculateSize(_repeated_tensor_codec);

  795.           size += func_.CalculateSize(_repeated_func_codec);

  796.           if (_unknownFields != null) {

  797.             size += _unknownFields.CalculateSize();

  798.           }

  799.           return size;

  800.         }

  801. 

  802.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  803.         public void MergeFrom(ListValue other) {

  804.           if (other == null) {

  805.             return;

  806.           }

  807.           s_.Add(other.s_);

  808.           i_.Add(other.i_);

  809.           f_.Add(other.f_);

  810.           b_.Add(other.b_);

  811.           type_.Add(other.type_);

  812.           shape_.Add(other.shape_);

  813.           tensor_.Add(other.tensor_);

  814.           func_.Add(other.func_);

  815.           _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  816.         }

  817. 

  818.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  819.         public void MergeFrom(pb::CodedInputStream input) {

  820.           uint tag;

  821.           while ((tag = input.ReadTag()) != 0) {

  822.             switch(tag) {

  823.               default:

  824.                 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  825.                 break;

  826.               case 18: {

  827.                 s_.AddEntriesFrom(input, _repeated_s_codec);

  828.                 break;

  829.               }

  830.               case 26:

  831.               case 24: {

  832.                 i_.AddEntriesFrom(input, _repeated_i_codec);

  833.                 break;

  834.               }

  835.               case 34:

  836.               case 37: {

  837.                 f_.AddEntriesFrom(input, _repeated_f_codec);

  838.                 break;

  839.               }

  840.               case 42:

  841.               case 40: {

  842.                 b_.AddEntriesFrom(input, _repeated_b_codec);

  843.                 break;

  844.               }

  845.               case 50:

  846.               case 48: {

  847.                 type_.AddEntriesFrom(input, _repeated_type_codec);

  848.                 break;

  849.               }

  850.               case 58: {

  851.                 shape_.AddEntriesFrom(input, _repeated_shape_codec);

  852.                 break;

  853.               }

  854.               case 66: {

  855.                 tensor_.AddEntriesFrom(input, _repeated_tensor_codec);

  856.                 break;

  857.               }

  858.               case 74: {

  859.                 func_.AddEntriesFrom(input, _repeated_func_codec);

  860.                 break;

  861.               }

  862.             }

  863.           }

  864.         }

  865. 

  866.       }

  867. 

  868.     }

  869.     #endregion

  870. 

  871.   }

  872. 

  873.   /// <summary>

  874.   /// A list of attr names and their values. The whole list is attached

  875.   /// with a string name.  E.g., MatMul[T=float].

  876.   /// </summary>

  877.   public sealed partial class NameAttrList : pb::IMessage<NameAttrList> {

  878.     private static readonly pb::MessageParser<NameAttrList> _parser = new pb::MessageParser<NameAttrList>(() => new NameAttrList());

  879.     private pb::UnknownFieldSet _unknownFields;

  880.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  881.     public static pb::MessageParser<NameAttrList> Parser { get { return _parser; } }

  882. 

  883.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  884.     public static pbr::MessageDescriptor Descriptor {

  885.       get { return global::Tensorflow.AttrValueReflection.Descriptor.MessageTypes[1]; }

  886.     }

  887. 

  888.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  889.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  890.       get { return Descriptor; }

  891.     }

  892. 

  893.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  894.     public NameAttrList() {

  895.       OnConstruction();

  896.     }

  897. 

  898.     partial void OnConstruction();

  899. 

  900.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  901.     public NameAttrList(NameAttrList other) : this() {

  902.       name_ = other.name_;

  903.       attr_ = other.attr_.Clone();

  904.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  905.     }

  906. 

  907.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  908.     public NameAttrList Clone() {

  909.       return new NameAttrList(this);

  910.     }

  911. 

  912.     /// <summary>Field number for the "name" field.</summary>

  913.     public const int NameFieldNumber = 1;

  914.     private string name_ = "";

  915.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  916.     public string Name {

  917.       get { return name_; }

  918.       set {

  919.         name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  920.       }

  921.     }

  922. 

  923.     /// <summary>Field number for the "attr" field.</summary>

  924.     public const int AttrFieldNumber = 2;

  925.     private static readonly pbc::MapField<string, global::Tensorflow.AttrValue>.Codec _map_attr_codec

  926.         = new pbc::MapField<string, global::Tensorflow.AttrValue>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Tensorflow.AttrValue.Parser), 18);

  927.     private readonly pbc::MapField<string, global::Tensorflow.AttrValue> attr_ = new pbc::MapField<string, global::Tensorflow.AttrValue>();

  928.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  929.     public pbc::MapField<string, global::Tensorflow.AttrValue> Attr {

  930.       get { return attr_; }

  931.     }

  932. 

  933.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  934.     public override bool Equals(object other) {

  935.       return Equals(other as NameAttrList);

  936.     }

  937. 

  938.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  939.     public bool Equals(NameAttrList other) {

  940.       if (ReferenceEquals(other, null)) {

  941.         return false;

  942.       }

  943.       if (ReferenceEquals(other, this)) {

  944.         return true;

  945.       }

  946.       if (Name != other.Name) return false;

  947.       if (!Attr.Equals(other.Attr)) return false;

  948.       return Equals(_unknownFields, other._unknownFields);

  949.     }

  950. 

  951.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  952.     public override int GetHashCode() {

  953.       int hash = 1;

  954.       if (Name.Length != 0) hash ^= Name.GetHashCode();

  955.       hash ^= Attr.GetHashCode();

  956.       if (_unknownFields != null) {

  957.         hash ^= _unknownFields.GetHashCode();

  958.       }

  959.       return hash;

  960.     }

  961. 

  962.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  963.     public override string ToString() {

  964.       return pb::JsonFormatter.ToDiagnosticString(this);

  965.     }

  966. 

  967.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  968.     public void WriteTo(pb::CodedOutputStream output) {

  969.       if (Name.Length != 0) {

  970.         output.WriteRawTag(10);

  971.         output.WriteString(Name);

  972.       }

  973.       attr_.WriteTo(output, _map_attr_codec);

  974.       if (_unknownFields != null) {

  975.         _unknownFields.WriteTo(output);

  976.       }

  977.     }

  978. 

  979.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  980.     public int CalculateSize() {

  981.       int size = 0;

  982.       if (Name.Length != 0) {

  983.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);

  984.       }

  985.       size += attr_.CalculateSize(_map_attr_codec);

  986.       if (_unknownFields != null) {

  987.         size += _unknownFields.CalculateSize();

  988.       }

  989.       return size;

  990.     }

  991. 

  992.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  993.     public void MergeFrom(NameAttrList other) {

  994.       if (other == null) {

  995.         return;

  996.       }

  997.       if (other.Name.Length != 0) {

  998.         Name = other.Name;

  999.       }

  1000.       attr_.Add(other.attr_);

  1001.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1002.     }

  1003. 

  1004.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1005.     public void MergeFrom(pb::CodedInputStream input) {

  1006.       uint tag;

  1007.       while ((tag = input.ReadTag()) != 0) {

  1008.         switch(tag) {

  1009.           default:

  1010.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1011.             break;

  1012.           case 10: {

  1013.             Name = input.ReadString();

  1014.             break;

  1015.           }

  1016.           case 18: {

  1017.             attr_.AddEntriesFrom(input, _map_attr_codec);

  1018.             break;

  1019.           }

  1020.         }

  1021.       }

  1022.     }

  1023. 

  1024.   }

  1025. 

  1026.   #endregion

  1027. 

  1028. }

  1029. 

  1030. #endregion Designer generated code