UnitTestImportLiteProtoFile.cs 10.1 KB
Newer Older
1
// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
2
#pragma warning disable 1591, 0612, 3021
3
#region Designer generated code
4 5 6 7 8 9 10

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
  
11
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
  public static partial class UnitTestImportLiteProtoFile {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
    }
    #endregion
    #region Static variables
    #endregion
    #region Extensions
    internal static readonly object Descriptor;
    static UnitTestImportLiteProtoFile() {
      Descriptor = null;
    }
    #endregion
    
  }
  #region Enums
  public enum ImportEnumLite {
    IMPORT_LITE_FOO = 7,
    IMPORT_LITE_BAR = 8,
    IMPORT_LITE_BAZ = 9,
  }
  
  #endregion
  
  #region Messages
38
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
39
  public sealed partial class ImportMessageLite : pb::GeneratedMessageLite<ImportMessageLite, ImportMessageLite.Builder> {
40
    private ImportMessageLite() { }
41
    private static readonly ImportMessageLite defaultInstance = new ImportMessageLite().MakeReadOnly();
42 43
    private static readonly string[] _importMessageLiteFieldNames = new string[] { "d" };
    private static readonly uint[] _importMessageLiteFieldTags = new uint[] { 8 };
44 45 46 47 48
    public static ImportMessageLite DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override ImportMessageLite DefaultInstanceForType {
49
      get { return DefaultInstance; }
50 51 52 53 54 55 56 57
    }
    
    protected override ImportMessageLite ThisMessage {
      get { return this; }
    }
    
    public const int DFieldNumber = 1;
    private bool hasD;
csharptest's avatar
csharptest committed
58
    private int d_;
59 60 61 62 63 64 65 66 67 68 69 70 71
    public bool HasD {
      get { return hasD; }
    }
    public int D {
      get { return d_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
72
    public override void WriteTo(pb::ICodedOutputStream output) {
73
      int size = SerializedSize;
74
      string[] field_names = _importMessageLiteFieldNames;
75
      if (hasD) {
76
        output.WriteInt32(1, field_names[0], D);
77 78 79 80 81 82 83 84 85 86
      }
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
87
        if (hasD) {
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
          size += pb::CodedOutputStream.ComputeInt32Size(1, D);
        }
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    #region Lite runtime methods
    public override int GetHashCode() {
      int hash = GetType().GetHashCode();
      if (hasD) hash ^= d_.GetHashCode();
      return hash;
    }
    
    public override bool Equals(object obj) {
      ImportMessageLite other = obj as ImportMessageLite;
      if (other == null) return false;
      if (hasD != other.hasD || (hasD && !d_.Equals(other.d_))) return false;
      return true;
    }
    
    public override void PrintTo(global::System.IO.TextWriter writer) {
      PrintField("d", hasD, d_, writer);
    }
    #endregion
    
    public static ImportMessageLite ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static ImportMessageLite ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static ImportMessageLite ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static ImportMessageLite ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static ImportMessageLite ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static ImportMessageLite ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static ImportMessageLite ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static ImportMessageLite ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
138
    public static ImportMessageLite ParseFrom(pb::ICodedInputStream input) {
139 140
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
141
    public static ImportMessageLite ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
142 143
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
144 145 146 147
    private ImportMessageLite MakeReadOnly() {
      return this;
    }
    
148 149 150 151
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(ImportMessageLite prototype) {
152
      return new Builder(prototype);
153 154
    }
    
155
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
156 157 158 159
    public sealed partial class Builder : pb::GeneratedBuilderLite<ImportMessageLite, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
160
      public Builder() {
161 162
        result = DefaultInstance;
        resultIsReadOnly = true;
163 164 165
      }
      internal Builder(ImportMessageLite cloneFrom) {
        result = cloneFrom;
166
        resultIsReadOnly = true;
167 168
      }
      
169 170
      private bool resultIsReadOnly;
      private ImportMessageLite result;
171
      
172
      private ImportMessageLite PrepareBuilder() {
173
        if (resultIsReadOnly) {
174 175
          ImportMessageLite original = result;
          result = new ImportMessageLite();
176
          resultIsReadOnly = false;
177 178 179 180 181 182 183 184
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
185 186
      
      protected override ImportMessageLite MessageBeingBuilt {
187
        get { return PrepareBuilder(); }
188 189 190
      }
      
      public override Builder Clear() {
191 192
        result = DefaultInstance;
        resultIsReadOnly = true;
193 194 195 196
        return this;
      }
      
      public override Builder Clone() {
197
        if (resultIsReadOnly) {
198 199 200 201
          return new Builder(result);
        } else {
          return new Builder().MergeFrom(result);
        }
202 203 204 205 206 207 208
      }
      
      public override ImportMessageLite DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.TestProtos.ImportMessageLite.DefaultInstance; }
      }
      
      public override ImportMessageLite BuildPartial() {
209
        if (resultIsReadOnly) {
210
          return result;
211
        }
212 213
        resultIsReadOnly = true;
        return result.MakeReadOnly();
214 215 216 217 218 219 220 221 222 223 224 225 226
      }
      
      public override Builder MergeFrom(pb::IMessageLite other) {
        if (other is ImportMessageLite) {
          return MergeFrom((ImportMessageLite) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(ImportMessageLite other) {
        if (other == global::Google.ProtocolBuffers.TestProtos.ImportMessageLite.DefaultInstance) return this;
227
        PrepareBuilder();
228 229 230 231 232 233
        if (other.HasD) {
          D = other.D;
        }
        return this;
      }
      
234
      public override Builder MergeFrom(pb::ICodedInputStream input) {
235 236 237
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
238
      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
239
        PrepareBuilder();
240 241 242
        uint tag;
        string field_name;
        while (input.ReadTag(out tag, out field_name)) {
243 244 245 246 247 248 249 250 251
          if(tag == 0 && field_name != null) {
            int field_ordinal = global::System.Array.BinarySearch(_importMessageLiteFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _importMessageLiteFieldTags[field_ordinal];
            else {
              ParseUnknownField(input, extensionRegistry, tag, field_name);
              continue;
            }
          }
252 253
          switch (tag) {
            case 0: {
254
              throw pb::InvalidProtocolBufferException.InvalidTag();
255 256 257 258 259
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                return this;
              }
260
              ParseUnknownField(input, extensionRegistry, tag, field_name);
261 262 263
              break;
            }
            case 8: {
264
              result.hasD = input.ReadInt32(ref result.d_);
265 266 267 268
              break;
            }
          }
        }
269 270
        
        return this;
271 272 273 274
      }
      
      
      public bool HasD {
275
        get { return result.hasD; }
276 277 278 279 280 281
      }
      public int D {
        get { return result.D; }
        set { SetD(value); }
      }
      public Builder SetD(int value) {
282
        PrepareBuilder();
283 284 285 286 287
        result.hasD = true;
        result.d_ = value;
        return this;
      }
      public Builder ClearD() {
288
        PrepareBuilder();
289 290 291 292 293 294 295 296 297 298 299 300 301
        result.hasD = false;
        result.d_ = 0;
        return this;
      }
    }
    static ImportMessageLite() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestImportLiteProtoFile.Descriptor, null);
    }
  }
  
  #endregion
  
}
302 303

#endregion Designer generated code