DotNet Reference

.Net Reference

CpModel.pb.cs
Go to the documentation of this file.
1 // <auto-generated>
2 // Generated by the protocol buffer compiler. DO NOT EDIT!
3 // source: ortools/sat/cp_model.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 Google.OrTools.Sat {
13 
15  public static partial class CpModelReflection {
16 
17  #region Descriptor
18  public static pbr::FileDescriptor Descriptor {
20  get { return descriptor; }
21  }
22  private static pbr::FileDescriptor descriptor;
23 
24  static CpModelReflection() {
25  byte[] descriptorData = global::System.Convert.FromBase64String(
26  string.Concat(
27  "ChpvcnRvb2xzL3NhdC9jcF9tb2RlbC5wcm90bxIXb3BlcmF0aW9uc19yZXNl",
28  "YXJjaC5zYXQiNAoUSW50ZWdlclZhcmlhYmxlUHJvdG8SDAoEbmFtZRgBIAEo",
29  "CRIOCgZkb21haW4YAiADKAMiJQoRQm9vbEFyZ3VtZW50UHJvdG8SEAoIbGl0",
30  "ZXJhbHMYASADKAUiNAoUSW50ZWdlckFyZ3VtZW50UHJvdG8SDgoGdGFyZ2V0",
31  "GAEgASgFEgwKBHZhcnMYAiADKAUiRQoVTGluZWFyRXhwcmVzc2lvblByb3Rv",
32  "EgwKBHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBm9mZnNldBgDIAEo",
33  "AyKUAQoTTGluZWFyQXJndW1lbnRQcm90bxI+CgZ0YXJnZXQYASABKAsyLi5v",
34  "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5lYXJFeHByZXNzaW9uUHJvdG8S",
35  "PQoFZXhwcnMYAiADKAsyLi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5l",
36  "YXJFeHByZXNzaW9uUHJvdG8iKwobQWxsRGlmZmVyZW50Q29uc3RyYWludFBy",
37  "b3RvEgwKBHZhcnMYASADKAUiRQoVTGluZWFyQ29uc3RyYWludFByb3RvEgwK",
38  "BHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBmRvbWFpbhgDIAMoAyJF",
39  "ChZFbGVtZW50Q29uc3RyYWludFByb3RvEg0KBWluZGV4GAEgASgFEg4KBnRh",
40  "cmdldBgCIAEoBRIMCgR2YXJzGAMgAygFIkMKF0ludGVydmFsQ29uc3RyYWlu",
41  "dFByb3RvEg0KBXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBRIMCgRzaXplGAMg",
42  "ASgFIi0KGE5vT3ZlcmxhcENvbnN0cmFpbnRQcm90bxIRCglpbnRlcnZhbHMY",
43  "ASADKAUicAoaTm9PdmVybGFwMkRDb25zdHJhaW50UHJvdG8SEwoLeF9pbnRl",
44  "cnZhbHMYASADKAUSEwoLeV9pbnRlcnZhbHMYAiADKAUSKAogYm94ZXNfd2l0",
45  "aF9udWxsX2FyZWFfY2FuX292ZXJsYXAYAyABKAgiUQoZQ3VtdWxhdGl2ZUNv",
46  "bnN0cmFpbnRQcm90bxIQCghjYXBhY2l0eRgBIAEoBRIRCglpbnRlcnZhbHMY",
47  "AiADKAUSDwoHZGVtYW5kcxgDIAMoBSJxChhSZXNlcnZvaXJDb25zdHJhaW50",
48  "UHJvdG8SEQoJbWluX2xldmVsGAEgASgDEhEKCW1heF9sZXZlbBgCIAEoAxIN",
49  "CgV0aW1lcxgDIAMoBRIPCgdkZW1hbmRzGAQgAygDEg8KB2FjdGl2ZXMYBSAD",
50  "KAUiSAoWQ2lyY3VpdENvbnN0cmFpbnRQcm90bxINCgV0YWlscxgDIAMoBRIN",
51  "CgVoZWFkcxgEIAMoBRIQCghsaXRlcmFscxgFIAMoBSJqChVSb3V0ZXNDb25z",
52  "dHJhaW50UHJvdG8SDQoFdGFpbHMYASADKAUSDQoFaGVhZHMYAiADKAUSEAoI",
53  "bGl0ZXJhbHMYAyADKAUSDwoHZGVtYW5kcxgEIAMoBRIQCghjYXBhY2l0eRgF",
54  "IAEoAyJMCh5DaXJjdWl0Q292ZXJpbmdDb25zdHJhaW50UHJvdG8SDQoFbmV4",
55  "dHMYASADKAUSGwoTZGlzdGluZ3Vpc2hlZF9ub2RlcxgCIAMoAyJFChRUYWJs",
56  "ZUNvbnN0cmFpbnRQcm90bxIMCgR2YXJzGAEgAygFEg4KBnZhbHVlcxgCIAMo",
57  "AxIPCgduZWdhdGVkGAMgASgIIj0KFkludmVyc2VDb25zdHJhaW50UHJvdG8S",
58  "EAoIZl9kaXJlY3QYASADKAUSEQoJZl9pbnZlcnNlGAIgAygFIqIBChhBdXRv",
59  "bWF0b25Db25zdHJhaW50UHJvdG8SFgoOc3RhcnRpbmdfc3RhdGUYAiABKAMS",
60  "FAoMZmluYWxfc3RhdGVzGAMgAygDEhcKD3RyYW5zaXRpb25fdGFpbBgEIAMo",
61  "AxIXCg90cmFuc2l0aW9uX2hlYWQYBSADKAMSGAoQdHJhbnNpdGlvbl9sYWJl",
62  "bBgGIAMoAxIMCgR2YXJzGAcgAygFIv8NCg9Db25zdHJhaW50UHJvdG8SDAoE",
63  "bmFtZRgBIAEoCRIbChNlbmZvcmNlbWVudF9saXRlcmFsGAIgAygFEj0KB2Jv",
64  "b2xfb3IYAyABKAsyKi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5Cb29sQXJn",
65  "dW1lbnRQcm90b0gAEj4KCGJvb2xfYW5kGAQgASgLMioub3BlcmF0aW9uc19y",
66  "ZXNlYXJjaC5zYXQuQm9vbEFyZ3VtZW50UHJvdG9IABJBCgthdF9tb3N0X29u",
67  "ZRgaIAEoCzIqLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkJvb2xBcmd1bWVu",
68  "dFByb3RvSAASPgoIYm9vbF94b3IYBSABKAsyKi5vcGVyYXRpb25zX3Jlc2Vh",
69  "cmNoLnNhdC5Cb29sQXJndW1lbnRQcm90b0gAEkAKB2ludF9kaXYYByABKAsy",
70  "LS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90",
71  "b0gAEkAKB2ludF9tb2QYCCABKAsyLS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNh",
72  "dC5JbnRlZ2VyQXJndW1lbnRQcm90b0gAEkAKB2ludF9tYXgYCSABKAsyLS5v",
73  "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90b0gA",
74  "Ej8KB2xpbl9tYXgYGyABKAsyLC5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5M",
75  "aW5lYXJBcmd1bWVudFByb3RvSAASQAoHaW50X21pbhgKIAEoCzItLm9wZXJh",
76  "dGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASPwoH",
77  "bGluX21pbhgcIAEoCzIsLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkxpbmVh",
78  "ckFyZ3VtZW50UHJvdG9IABJBCghpbnRfcHJvZBgLIAEoCzItLm9wZXJhdGlv",
79  "bnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASQAoGbGlu",
80  "ZWFyGAwgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuTGluZWFyQ29u",
81  "c3RyYWludFByb3RvSAASSAoIYWxsX2RpZmYYDSABKAsyNC5vcGVyYXRpb25z",
82  "X3Jlc2VhcmNoLnNhdC5BbGxEaWZmZXJlbnRDb25zdHJhaW50UHJvdG9IABJC",
83  "CgdlbGVtZW50GA4gASgLMi8ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRWxl",
84  "bWVudENvbnN0cmFpbnRQcm90b0gAEkIKB2NpcmN1aXQYDyABKAsyLy5vcGVy",
85  "YXRpb25zX3Jlc2VhcmNoLnNhdC5DaXJjdWl0Q29uc3RyYWludFByb3RvSAAS",
86  "QAoGcm91dGVzGBcgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuUm91",
87  "dGVzQ29uc3RyYWludFByb3RvSAASUwoQY2lyY3VpdF9jb3ZlcmluZxgZIAEo",
88  "CzI3Lm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNpcmN1aXRDb3ZlcmluZ0Nv",
89  "bnN0cmFpbnRQcm90b0gAEj4KBXRhYmxlGBAgASgLMi0ub3BlcmF0aW9uc19y",
90  "ZXNlYXJjaC5zYXQuVGFibGVDb25zdHJhaW50UHJvdG9IABJGCglhdXRvbWF0",
91  "b24YESABKAsyMS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5BdXRvbWF0b25D",
92  "b25zdHJhaW50UHJvdG9IABJCCgdpbnZlcnNlGBIgASgLMi8ub3BlcmF0aW9u",
93  "c19yZXNlYXJjaC5zYXQuSW52ZXJzZUNvbnN0cmFpbnRQcm90b0gAEkYKCXJl",
94  "c2Vydm9pchgYIAEoCzIxLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LlJlc2Vy",
95  "dm9pckNvbnN0cmFpbnRQcm90b0gAEkQKCGludGVydmFsGBMgASgLMjAub3Bl",
96  "cmF0aW9uc19yZXNlYXJjaC5zYXQuSW50ZXJ2YWxDb25zdHJhaW50UHJvdG9I",
97  "ABJHCgpub19vdmVybGFwGBQgASgLMjEub3BlcmF0aW9uc19yZXNlYXJjaC5z",
98  "YXQuTm9PdmVybGFwQ29uc3RyYWludFByb3RvSAASTAoNbm9fb3ZlcmxhcF8y",
99  "ZBgVIAEoCzIzLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0Lk5vT3ZlcmxhcDJE",
100  "Q29uc3RyYWludFByb3RvSAASSAoKY3VtdWxhdGl2ZRgWIAEoCzIyLm9wZXJh",
101  "dGlvbnNfcmVzZWFyY2guc2F0LkN1bXVsYXRpdmVDb25zdHJhaW50UHJvdG9I",
102  "AEIMCgpjb25zdHJhaW50ImgKEENwT2JqZWN0aXZlUHJvdG8SDAoEdmFycxgB",
103  "IAMoBRIOCgZjb2VmZnMYBCADKAMSDgoGb2Zmc2V0GAIgASgBEhYKDnNjYWxp",
104  "bmdfZmFjdG9yGAMgASgBEg4KBmRvbWFpbhgFIAMoAyLVBQoVRGVjaXNpb25T",
105  "dHJhdGVneVByb3RvEhEKCXZhcmlhYmxlcxgBIAMoBRJtCht2YXJpYWJsZV9z",
106  "ZWxlY3Rpb25fc3RyYXRlZ3kYAiABKA4ySC5vcGVyYXRpb25zX3Jlc2VhcmNo",
107  "LnNhdC5EZWNpc2lvblN0cmF0ZWd5UHJvdG8uVmFyaWFibGVTZWxlY3Rpb25T",
108  "dHJhdGVneRJpChlkb21haW5fcmVkdWN0aW9uX3N0cmF0ZWd5GAMgASgOMkYu",
109  "b3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3Rv",
110  "LkRvbWFpblJlZHVjdGlvblN0cmF0ZWd5ElwKD3RyYW5zZm9ybWF0aW9ucxgE",
111  "IAMoCzJDLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkRlY2lzaW9uU3RyYXRl",
112  "Z3lQcm90by5BZmZpbmVUcmFuc2Zvcm1hdGlvbhpLChRBZmZpbmVUcmFuc2Zv",
113  "cm1hdGlvbhILCgN2YXIYASABKAUSDgoGb2Zmc2V0GAIgASgDEhYKDnBvc2l0",
114  "aXZlX2NvZWZmGAMgASgDIpQBChlWYXJpYWJsZVNlbGVjdGlvblN0cmF0ZWd5",
115  "EhAKDENIT09TRV9GSVJTVBAAEhUKEUNIT09TRV9MT1dFU1RfTUlOEAESFgoS",
116  "Q0hPT1NFX0hJR0hFU1RfTUFYEAISGgoWQ0hPT1NFX01JTl9ET01BSU5fU0la",
117  "RRADEhoKFkNIT09TRV9NQVhfRE9NQUlOX1NJWkUQBCKMAQoXRG9tYWluUmVk",
118  "dWN0aW9uU3RyYXRlZ3kSFAoQU0VMRUNUX01JTl9WQUxVRRAAEhQKEFNFTEVD",
119  "VF9NQVhfVkFMVUUQARIVChFTRUxFQ1RfTE9XRVJfSEFMRhACEhUKEVNFTEVD",
120  "VF9VUFBFUl9IQUxGEAMSFwoTU0VMRUNUX01FRElBTl9WQUxVRRAEIjkKGVBh",
121  "cnRpYWxWYXJpYWJsZUFzc2lnbm1lbnQSDAoEdmFycxgBIAMoBRIOCgZ2YWx1",
122  "ZXMYAiADKAMihAMKDENwTW9kZWxQcm90bxIMCgRuYW1lGAEgASgJEkAKCXZh",
123  "cmlhYmxlcxgCIAMoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVn",
124  "ZXJWYXJpYWJsZVByb3RvEj0KC2NvbnN0cmFpbnRzGAMgAygLMigub3BlcmF0",
125  "aW9uc19yZXNlYXJjaC5zYXQuQ29uc3RyYWludFByb3RvEjwKCW9iamVjdGl2",
126  "ZRgEIAEoCzIpLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNwT2JqZWN0aXZl",
127  "UHJvdG8SRwoPc2VhcmNoX3N0cmF0ZWd5GAUgAygLMi4ub3BlcmF0aW9uc19y",
128  "ZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3RvEkkKDXNvbHV0aW9u",
129  "X2hpbnQYBiABKAsyMi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5QYXJ0aWFs",
130  "VmFyaWFibGVBc3NpZ25tZW50EhMKC2Fzc3VtcHRpb25zGAcgAygFIuoEChBD",
131  "cFNvbHZlclJlc3BvbnNlEjcKBnN0YXR1cxgBIAEoDjInLm9wZXJhdGlvbnNf",
132  "cmVzZWFyY2guc2F0LkNwU29sdmVyU3RhdHVzEhAKCHNvbHV0aW9uGAIgAygD",
133  "EhcKD29iamVjdGl2ZV92YWx1ZRgDIAEoARIcChRiZXN0X29iamVjdGl2ZV9i",
134  "b3VuZBgEIAEoARIdChVzb2x1dGlvbl9sb3dlcl9ib3VuZHMYEiADKAMSHQoV",
135  "c29sdXRpb25fdXBwZXJfYm91bmRzGBMgAygDEkoKE3RpZ2h0ZW5lZF92YXJp",
136  "YWJsZXMYFSADKAsyLS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2Vy",
137  "VmFyaWFibGVQcm90bxIwCihzdWZmaWNpZW50X2Fzc3VtcHRpb25zX2Zvcl9p",
138  "bmZlYXNpYmlsaXR5GBcgAygFEiAKGGFsbF9zb2x1dGlvbnNfd2VyZV9mb3Vu",
139  "ZBgFIAEoCBIUCgxudW1fYm9vbGVhbnMYCiABKAMSFQoNbnVtX2NvbmZsaWN0",
140  "cxgLIAEoAxIUCgxudW1fYnJhbmNoZXMYDCABKAMSHwoXbnVtX2JpbmFyeV9w",
141  "cm9wYWdhdGlvbnMYDSABKAMSIAoYbnVtX2ludGVnZXJfcHJvcGFnYXRpb25z",
142  "GA4gASgDEhEKCXdhbGxfdGltZRgPIAEoARIRCgl1c2VyX3RpbWUYECABKAES",
143  "GgoSZGV0ZXJtaW5pc3RpY190aW1lGBEgASgBEhcKD3ByaW1hbF9pbnRlZ3Jh",
144  "bBgWIAEoARIVCg1zb2x1dGlvbl9pbmZvGBQgASgJKlsKDkNwU29sdmVyU3Rh",
145  "dHVzEgsKB1VOS05PV04QABIRCg1NT0RFTF9JTlZBTElEEAESDAoIRkVBU0lC",
146  "TEUQAhIOCgpJTkZFQVNJQkxFEAMSCwoHT1BUSU1BTBAEQkAKFmNvbS5nb29n",
147  "bGUub3J0b29scy5zYXRCD0NwTW9kZWxQcm90b2J1ZlABqgISR29vZ2xlLk9y",
148  "VG9vbHMuU2F0YgZwcm90bzM="));
149  descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
150  new pbr::FileDescriptor[] { },
151  new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Google.OrTools.Sat.CpSolverStatus), }, null, new pbr::GeneratedClrTypeInfo[] {
152  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerVariableProto), global::Google.OrTools.Sat.IntegerVariableProto.Parser, new[]{ "Name", "Domain" }, null, null, null, null),
153  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.BoolArgumentProto), global::Google.OrTools.Sat.BoolArgumentProto.Parser, new[]{ "Literals" }, null, null, null, null),
154  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerArgumentProto), global::Google.OrTools.Sat.IntegerArgumentProto.Parser, new[]{ "Target", "Vars" }, null, null, null, null),
155  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearExpressionProto), global::Google.OrTools.Sat.LinearExpressionProto.Parser, new[]{ "Vars", "Coeffs", "Offset" }, null, null, null, null),
156  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearArgumentProto), global::Google.OrTools.Sat.LinearArgumentProto.Parser, new[]{ "Target", "Exprs" }, null, null, null, null),
157  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AllDifferentConstraintProto), global::Google.OrTools.Sat.AllDifferentConstraintProto.Parser, new[]{ "Vars" }, null, null, null, null),
158  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearConstraintProto), global::Google.OrTools.Sat.LinearConstraintProto.Parser, new[]{ "Vars", "Coeffs", "Domain" }, null, null, null, null),
159  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ElementConstraintProto), global::Google.OrTools.Sat.ElementConstraintProto.Parser, new[]{ "Index", "Target", "Vars" }, null, null, null, null),
160  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntervalConstraintProto), global::Google.OrTools.Sat.IntervalConstraintProto.Parser, new[]{ "Start", "End", "Size" }, null, null, null, null),
161  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlapConstraintProto), global::Google.OrTools.Sat.NoOverlapConstraintProto.Parser, new[]{ "Intervals" }, null, null, null, null),
162  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlap2DConstraintProto), global::Google.OrTools.Sat.NoOverlap2DConstraintProto.Parser, new[]{ "XIntervals", "YIntervals", "BoxesWithNullAreaCanOverlap" }, null, null, null, null),
163  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CumulativeConstraintProto), global::Google.OrTools.Sat.CumulativeConstraintProto.Parser, new[]{ "Capacity", "Intervals", "Demands" }, null, null, null, null),
164  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ReservoirConstraintProto), global::Google.OrTools.Sat.ReservoirConstraintProto.Parser, new[]{ "MinLevel", "MaxLevel", "Times", "Demands", "Actives" }, null, null, null, null),
165  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitConstraintProto), global::Google.OrTools.Sat.CircuitConstraintProto.Parser, new[]{ "Tails", "Heads", "Literals" }, null, null, null, null),
166  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.RoutesConstraintProto), global::Google.OrTools.Sat.RoutesConstraintProto.Parser, new[]{ "Tails", "Heads", "Literals", "Demands", "Capacity" }, null, null, null, null),
167  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitCoveringConstraintProto), global::Google.OrTools.Sat.CircuitCoveringConstraintProto.Parser, new[]{ "Nexts", "DistinguishedNodes" }, null, null, null, null),
168  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.TableConstraintProto), global::Google.OrTools.Sat.TableConstraintProto.Parser, new[]{ "Vars", "Values", "Negated" }, null, null, null, null),
169  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.InverseConstraintProto), global::Google.OrTools.Sat.InverseConstraintProto.Parser, new[]{ "FDirect", "FInverse" }, null, null, null, null),
170  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AutomatonConstraintProto), global::Google.OrTools.Sat.AutomatonConstraintProto.Parser, new[]{ "StartingState", "FinalStates", "TransitionTail", "TransitionHead", "TransitionLabel", "Vars" }, null, null, null, null),
171  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ConstraintProto), global::Google.OrTools.Sat.ConstraintProto.Parser, new[]{ "Name", "EnforcementLiteral", "BoolOr", "BoolAnd", "AtMostOne", "BoolXor", "IntDiv", "IntMod", "IntMax", "LinMax", "IntMin", "LinMin", "IntProd", "Linear", "AllDiff", "Element", "Circuit", "Routes", "CircuitCovering", "Table", "Automaton", "Inverse", "Reservoir", "Interval", "NoOverlap", "NoOverlap2D", "Cumulative" }, new[]{ "Constraint" }, null, null, null),
172  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpObjectiveProto), global::Google.OrTools.Sat.CpObjectiveProto.Parser, new[]{ "Vars", "Coeffs", "Offset", "ScalingFactor", "Domain" }, null, null, null, null),
173  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto), global::Google.OrTools.Sat.DecisionStrategyProto.Parser, new[]{ "Variables", "VariableSelectionStrategy", "DomainReductionStrategy", "Transformations" }, null, new[]{ typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy), typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation), global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser, new[]{ "Var", "Offset", "PositiveCoeff" }, null, null, null, null)}),
174  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.PartialVariableAssignment), global::Google.OrTools.Sat.PartialVariableAssignment.Parser, new[]{ "Vars", "Values" }, null, null, null, null),
175  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpModelProto), global::Google.OrTools.Sat.CpModelProto.Parser, new[]{ "Name", "Variables", "Constraints", "Objective", "SearchStrategy", "SolutionHint", "Assumptions" }, null, null, null, null),
176  new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpSolverResponse), global::Google.OrTools.Sat.CpSolverResponse.Parser, new[]{ "Status", "Solution", "ObjectiveValue", "BestObjectiveBound", "SolutionLowerBounds", "SolutionUpperBounds", "TightenedVariables", "SufficientAssumptionsForInfeasibility", "AllSolutionsWereFound", "NumBooleans", "NumConflicts", "NumBranches", "NumBinaryPropagations", "NumIntegerPropagations", "WallTime", "UserTime", "DeterministicTime", "PrimalIntegral", "SolutionInfo" }, null, null, null, null)
177  }));
178  }
179  #endregion
180 
181  }
182  #region Enums
183  public enum CpSolverStatus {
191  [pbr::OriginalName("UNKNOWN")] Unknown = 0,
196  [pbr::OriginalName("MODEL_INVALID")] ModelInvalid = 1,
202  [pbr::OriginalName("FEASIBLE")] Feasible = 2,
206  [pbr::OriginalName("INFEASIBLE")] Infeasible = 3,
217  [pbr::OriginalName("OPTIMAL")] Optimal = 4,
218  }
219 
220  #endregion
221 
222  #region Messages
223  public sealed partial class IntegerVariableProto : pb::IMessage<IntegerVariableProto>
245  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
246  , pb::IBufferMessage
247  #endif
248  {
249  private static readonly pb::MessageParser<IntegerVariableProto> _parser = new pb::MessageParser<IntegerVariableProto>(() => new IntegerVariableProto());
250  private pb::UnknownFieldSet _unknownFields;
251  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
252  public static pb::MessageParser<IntegerVariableProto> Parser { get { return _parser; } }
253 
254  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
255  public static pbr::MessageDescriptor Descriptor {
256  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[0]; }
257  }
258 
259  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
260  pbr::MessageDescriptor pb::IMessage.Descriptor {
261  get { return Descriptor; }
262  }
263 
264  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
265  public IntegerVariableProto() {
266  OnConstruction();
267  }
268 
269  partial void OnConstruction();
270 
271  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
272  public IntegerVariableProto(IntegerVariableProto other) : this() {
273  name_ = other.name_;
274  domain_ = other.domain_.Clone();
275  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
276  }
277 
278  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
279  public IntegerVariableProto Clone() {
280  return new IntegerVariableProto(this);
281  }
282 
284  public const int NameFieldNumber = 1;
285  private string name_ = "";
289  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
290  public string Name {
291  get { return name_; }
292  set {
293  name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
294  }
295  }
296 
298  public const int DomainFieldNumber = 2;
299  private static readonly pb::FieldCodec<long> _repeated_domain_codec
300  = pb::FieldCodec.ForInt64(18);
301  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
321  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
322  public pbc::RepeatedField<long> Domain {
323  get { return domain_; }
324  }
325 
326  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
327  public override bool Equals(object other) {
328  return Equals(other as IntegerVariableProto);
329  }
330 
331  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
332  public bool Equals(IntegerVariableProto other) {
333  if (ReferenceEquals(other, null)) {
334  return false;
335  }
336  if (ReferenceEquals(other, this)) {
337  return true;
338  }
339  if (Name != other.Name) return false;
340  if(!domain_.Equals(other.domain_)) return false;
341  return Equals(_unknownFields, other._unknownFields);
342  }
343 
344  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
345  public override int GetHashCode() {
346  int hash = 1;
347  if (Name.Length != 0) hash ^= Name.GetHashCode();
348  hash ^= domain_.GetHashCode();
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 !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
363  output.WriteRawMessage(this);
364  #else
365  if (Name.Length != 0) {
366  output.WriteRawTag(10);
367  output.WriteString(Name);
368  }
369  domain_.WriteTo(output, _repeated_domain_codec);
370  if (_unknownFields != null) {
371  _unknownFields.WriteTo(output);
372  }
373  #endif
374  }
375 
376  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
377  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
378  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
379  if (Name.Length != 0) {
380  output.WriteRawTag(10);
381  output.WriteString(Name);
382  }
383  domain_.WriteTo(ref output, _repeated_domain_codec);
384  if (_unknownFields != null) {
385  _unknownFields.WriteTo(ref output);
386  }
387  }
388  #endif
389 
390  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
391  public int CalculateSize() {
392  int size = 0;
393  if (Name.Length != 0) {
394  size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
395  }
396  size += domain_.CalculateSize(_repeated_domain_codec);
397  if (_unknownFields != null) {
398  size += _unknownFields.CalculateSize();
399  }
400  return size;
401  }
402 
403  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
404  public void MergeFrom(IntegerVariableProto other) {
405  if (other == null) {
406  return;
407  }
408  if (other.Name.Length != 0) {
409  Name = other.Name;
410  }
411  domain_.Add(other.domain_);
412  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
413  }
414 
415  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
416  public void MergeFrom(pb::CodedInputStream input) {
417  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
418  input.ReadRawMessage(this);
419  #else
420  uint tag;
421  while ((tag = input.ReadTag()) != 0) {
422  switch(tag) {
423  default:
424  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
425  break;
426  case 10: {
427  Name = input.ReadString();
428  break;
429  }
430  case 18:
431  case 16: {
432  domain_.AddEntriesFrom(input, _repeated_domain_codec);
433  break;
434  }
435  }
436  }
437  #endif
438  }
439 
440  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
441  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
442  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
443  uint tag;
444  while ((tag = input.ReadTag()) != 0) {
445  switch(tag) {
446  default:
447  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
448  break;
449  case 10: {
450  Name = input.ReadString();
451  break;
452  }
453  case 18:
454  case 16: {
455  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
456  break;
457  }
458  }
459  }
460  }
461  #endif
462 
463  }
464 
468  public sealed partial class BoolArgumentProto : pb::IMessage<BoolArgumentProto>
469  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
470  , pb::IBufferMessage
471  #endif
472  {
473  private static readonly pb::MessageParser<BoolArgumentProto> _parser = new pb::MessageParser<BoolArgumentProto>(() => new BoolArgumentProto());
474  private pb::UnknownFieldSet _unknownFields;
475  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
476  public static pb::MessageParser<BoolArgumentProto> Parser { get { return _parser; } }
477 
478  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
479  public static pbr::MessageDescriptor Descriptor {
480  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[1]; }
481  }
482 
483  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
484  pbr::MessageDescriptor pb::IMessage.Descriptor {
485  get { return Descriptor; }
486  }
487 
488  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
489  public BoolArgumentProto() {
490  OnConstruction();
491  }
492 
493  partial void OnConstruction();
494 
495  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
496  public BoolArgumentProto(BoolArgumentProto other) : this() {
497  literals_ = other.literals_.Clone();
498  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
499  }
500 
501  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
502  public BoolArgumentProto Clone() {
503  return new BoolArgumentProto(this);
504  }
505 
507  public const int LiteralsFieldNumber = 1;
508  private static readonly pb::FieldCodec<int> _repeated_literals_codec
509  = pb::FieldCodec.ForInt32(10);
510  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
511  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
512  public pbc::RepeatedField<int> Literals {
513  get { return literals_; }
514  }
515 
516  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
517  public override bool Equals(object other) {
518  return Equals(other as BoolArgumentProto);
519  }
520 
521  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
522  public bool Equals(BoolArgumentProto other) {
523  if (ReferenceEquals(other, null)) {
524  return false;
525  }
526  if (ReferenceEquals(other, this)) {
527  return true;
528  }
529  if(!literals_.Equals(other.literals_)) return false;
530  return Equals(_unknownFields, other._unknownFields);
531  }
532 
533  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
534  public override int GetHashCode() {
535  int hash = 1;
536  hash ^= literals_.GetHashCode();
537  if (_unknownFields != null) {
538  hash ^= _unknownFields.GetHashCode();
539  }
540  return hash;
541  }
542 
543  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
544  public override string ToString() {
545  return pb::JsonFormatter.ToDiagnosticString(this);
546  }
547 
548  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
549  public void WriteTo(pb::CodedOutputStream output) {
550  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
551  output.WriteRawMessage(this);
552  #else
553  literals_.WriteTo(output, _repeated_literals_codec);
554  if (_unknownFields != null) {
555  _unknownFields.WriteTo(output);
556  }
557  #endif
558  }
559 
560  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
562  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
563  literals_.WriteTo(ref output, _repeated_literals_codec);
564  if (_unknownFields != null) {
565  _unknownFields.WriteTo(ref output);
566  }
567  }
568  #endif
569 
570  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
571  public int CalculateSize() {
572  int size = 0;
573  size += literals_.CalculateSize(_repeated_literals_codec);
574  if (_unknownFields != null) {
575  size += _unknownFields.CalculateSize();
576  }
577  return size;
578  }
579 
580  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
581  public void MergeFrom(BoolArgumentProto other) {
582  if (other == null) {
583  return;
584  }
585  literals_.Add(other.literals_);
586  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
587  }
588 
589  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
590  public void MergeFrom(pb::CodedInputStream input) {
591  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
592  input.ReadRawMessage(this);
593  #else
594  uint tag;
595  while ((tag = input.ReadTag()) != 0) {
596  switch(tag) {
597  default:
598  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
599  break;
600  case 10:
601  case 8: {
602  literals_.AddEntriesFrom(input, _repeated_literals_codec);
603  break;
604  }
605  }
606  }
607  #endif
608  }
609 
610  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
611  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
612  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
613  uint tag;
614  while ((tag = input.ReadTag()) != 0) {
615  switch(tag) {
616  default:
617  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
618  break;
619  case 10:
620  case 8: {
621  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
622  break;
623  }
624  }
625  }
626  }
627  #endif
628 
629  }
630 
634  public sealed partial class IntegerArgumentProto : pb::IMessage<IntegerArgumentProto>
635  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
636  , pb::IBufferMessage
637  #endif
638  {
639  private static readonly pb::MessageParser<IntegerArgumentProto> _parser = new pb::MessageParser<IntegerArgumentProto>(() => new IntegerArgumentProto());
640  private pb::UnknownFieldSet _unknownFields;
641  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
642  public static pb::MessageParser<IntegerArgumentProto> Parser { get { return _parser; } }
643 
644  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
645  public static pbr::MessageDescriptor Descriptor {
646  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[2]; }
647  }
648 
649  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
650  pbr::MessageDescriptor pb::IMessage.Descriptor {
651  get { return Descriptor; }
652  }
653 
654  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
655  public IntegerArgumentProto() {
656  OnConstruction();
657  }
658 
659  partial void OnConstruction();
660 
661  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
662  public IntegerArgumentProto(IntegerArgumentProto other) : this() {
663  target_ = other.target_;
664  vars_ = other.vars_.Clone();
665  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
666  }
667 
668  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
669  public IntegerArgumentProto Clone() {
670  return new IntegerArgumentProto(this);
671  }
672 
674  public const int TargetFieldNumber = 1;
675  private int target_;
676  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
677  public int Target {
678  get { return target_; }
679  set {
680  target_ = value;
681  }
682  }
683 
685  public const int VarsFieldNumber = 2;
686  private static readonly pb::FieldCodec<int> _repeated_vars_codec
687  = pb::FieldCodec.ForInt32(18);
688  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
689  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
690  public pbc::RepeatedField<int> Vars {
691  get { return vars_; }
692  }
693 
694  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
695  public override bool Equals(object other) {
696  return Equals(other as IntegerArgumentProto);
697  }
698 
699  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
700  public bool Equals(IntegerArgumentProto other) {
701  if (ReferenceEquals(other, null)) {
702  return false;
703  }
704  if (ReferenceEquals(other, this)) {
705  return true;
706  }
707  if (Target != other.Target) return false;
708  if(!vars_.Equals(other.vars_)) return false;
709  return Equals(_unknownFields, other._unknownFields);
710  }
711 
712  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
713  public override int GetHashCode() {
714  int hash = 1;
715  if (Target != 0) hash ^= Target.GetHashCode();
716  hash ^= vars_.GetHashCode();
717  if (_unknownFields != null) {
718  hash ^= _unknownFields.GetHashCode();
719  }
720  return hash;
721  }
722 
723  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
724  public override string ToString() {
725  return pb::JsonFormatter.ToDiagnosticString(this);
726  }
727 
728  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
729  public void WriteTo(pb::CodedOutputStream output) {
730  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
731  output.WriteRawMessage(this);
732  #else
733  if (Target != 0) {
734  output.WriteRawTag(8);
735  output.WriteInt32(Target);
736  }
737  vars_.WriteTo(output, _repeated_vars_codec);
738  if (_unknownFields != null) {
739  _unknownFields.WriteTo(output);
740  }
741  #endif
742  }
743 
744  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
745  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
746  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
747  if (Target != 0) {
748  output.WriteRawTag(8);
749  output.WriteInt32(Target);
750  }
751  vars_.WriteTo(ref output, _repeated_vars_codec);
752  if (_unknownFields != null) {
753  _unknownFields.WriteTo(ref output);
754  }
755  }
756  #endif
757 
758  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
759  public int CalculateSize() {
760  int size = 0;
761  if (Target != 0) {
762  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
763  }
764  size += vars_.CalculateSize(_repeated_vars_codec);
765  if (_unknownFields != null) {
766  size += _unknownFields.CalculateSize();
767  }
768  return size;
769  }
770 
771  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
772  public void MergeFrom(IntegerArgumentProto other) {
773  if (other == null) {
774  return;
775  }
776  if (other.Target != 0) {
777  Target = other.Target;
778  }
779  vars_.Add(other.vars_);
780  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
781  }
782 
783  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
784  public void MergeFrom(pb::CodedInputStream input) {
785  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
786  input.ReadRawMessage(this);
787  #else
788  uint tag;
789  while ((tag = input.ReadTag()) != 0) {
790  switch(tag) {
791  default:
792  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
793  break;
794  case 8: {
795  Target = input.ReadInt32();
796  break;
797  }
798  case 18:
799  case 16: {
800  vars_.AddEntriesFrom(input, _repeated_vars_codec);
801  break;
802  }
803  }
804  }
805  #endif
806  }
807 
808  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
809  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
810  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
811  uint tag;
812  while ((tag = input.ReadTag()) != 0) {
813  switch(tag) {
814  default:
815  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
816  break;
817  case 8: {
818  Target = input.ReadInt32();
819  break;
820  }
821  case 18:
822  case 16: {
823  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
824  break;
825  }
826  }
827  }
828  }
829  #endif
830 
831  }
832 
833  public sealed partial class LinearExpressionProto : pb::IMessage<LinearExpressionProto>
834  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
835  , pb::IBufferMessage
836  #endif
837  {
838  private static readonly pb::MessageParser<LinearExpressionProto> _parser = new pb::MessageParser<LinearExpressionProto>(() => new LinearExpressionProto());
839  private pb::UnknownFieldSet _unknownFields;
840  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
841  public static pb::MessageParser<LinearExpressionProto> Parser { get { return _parser; } }
842 
843  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
844  public static pbr::MessageDescriptor Descriptor {
845  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[3]; }
846  }
847 
848  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
849  pbr::MessageDescriptor pb::IMessage.Descriptor {
850  get { return Descriptor; }
851  }
852 
853  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
854  public LinearExpressionProto() {
855  OnConstruction();
856  }
857 
858  partial void OnConstruction();
859 
860  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
861  public LinearExpressionProto(LinearExpressionProto other) : this() {
862  vars_ = other.vars_.Clone();
863  coeffs_ = other.coeffs_.Clone();
864  offset_ = other.offset_;
865  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
866  }
867 
868  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
869  public LinearExpressionProto Clone() {
870  return new LinearExpressionProto(this);
871  }
872 
874  public const int VarsFieldNumber = 1;
875  private static readonly pb::FieldCodec<int> _repeated_vars_codec
876  = pb::FieldCodec.ForInt32(10);
877  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
878  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
879  public pbc::RepeatedField<int> Vars {
880  get { return vars_; }
881  }
882 
884  public const int CoeffsFieldNumber = 2;
885  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
886  = pb::FieldCodec.ForInt64(18);
887  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
888  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
889  public pbc::RepeatedField<long> Coeffs {
890  get { return coeffs_; }
891  }
892 
894  public const int OffsetFieldNumber = 3;
895  private long offset_;
896  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
897  public long Offset {
898  get { return offset_; }
899  set {
900  offset_ = value;
901  }
902  }
903 
904  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
905  public override bool Equals(object other) {
906  return Equals(other as LinearExpressionProto);
907  }
908 
909  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
910  public bool Equals(LinearExpressionProto other) {
911  if (ReferenceEquals(other, null)) {
912  return false;
913  }
914  if (ReferenceEquals(other, this)) {
915  return true;
916  }
917  if(!vars_.Equals(other.vars_)) return false;
918  if(!coeffs_.Equals(other.coeffs_)) return false;
919  if (Offset != other.Offset) return false;
920  return Equals(_unknownFields, other._unknownFields);
921  }
922 
923  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
924  public override int GetHashCode() {
925  int hash = 1;
926  hash ^= vars_.GetHashCode();
927  hash ^= coeffs_.GetHashCode();
928  if (Offset != 0L) hash ^= Offset.GetHashCode();
929  if (_unknownFields != null) {
930  hash ^= _unknownFields.GetHashCode();
931  }
932  return hash;
933  }
934 
935  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
936  public override string ToString() {
937  return pb::JsonFormatter.ToDiagnosticString(this);
938  }
939 
940  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
941  public void WriteTo(pb::CodedOutputStream output) {
942  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
943  output.WriteRawMessage(this);
944  #else
945  vars_.WriteTo(output, _repeated_vars_codec);
946  coeffs_.WriteTo(output, _repeated_coeffs_codec);
947  if (Offset != 0L) {
948  output.WriteRawTag(24);
949  output.WriteInt64(Offset);
950  }
951  if (_unknownFields != null) {
952  _unknownFields.WriteTo(output);
953  }
954  #endif
955  }
956 
957  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
958  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
959  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
960  vars_.WriteTo(ref output, _repeated_vars_codec);
961  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
962  if (Offset != 0L) {
963  output.WriteRawTag(24);
964  output.WriteInt64(Offset);
965  }
966  if (_unknownFields != null) {
967  _unknownFields.WriteTo(ref output);
968  }
969  }
970  #endif
971 
972  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
973  public int CalculateSize() {
974  int size = 0;
975  size += vars_.CalculateSize(_repeated_vars_codec);
976  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
977  if (Offset != 0L) {
978  size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
979  }
980  if (_unknownFields != null) {
981  size += _unknownFields.CalculateSize();
982  }
983  return size;
984  }
985 
986  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
987  public void MergeFrom(LinearExpressionProto other) {
988  if (other == null) {
989  return;
990  }
991  vars_.Add(other.vars_);
992  coeffs_.Add(other.coeffs_);
993  if (other.Offset != 0L) {
994  Offset = other.Offset;
995  }
996  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
997  }
998 
999  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1000  public void MergeFrom(pb::CodedInputStream input) {
1001  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1002  input.ReadRawMessage(this);
1003  #else
1004  uint tag;
1005  while ((tag = input.ReadTag()) != 0) {
1006  switch(tag) {
1007  default:
1008  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1009  break;
1010  case 10:
1011  case 8: {
1012  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1013  break;
1014  }
1015  case 18:
1016  case 16: {
1017  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
1018  break;
1019  }
1020  case 24: {
1021  Offset = input.ReadInt64();
1022  break;
1023  }
1024  }
1025  }
1026  #endif
1027  }
1028 
1029  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1030  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1031  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1032  uint tag;
1033  while ((tag = input.ReadTag()) != 0) {
1034  switch(tag) {
1035  default:
1036  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1037  break;
1038  case 10:
1039  case 8: {
1040  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1041  break;
1042  }
1043  case 18:
1044  case 16: {
1045  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
1046  break;
1047  }
1048  case 24: {
1049  Offset = input.ReadInt64();
1050  break;
1051  }
1052  }
1053  }
1054  }
1055  #endif
1056 
1057  }
1058 
1059  public sealed partial class LinearArgumentProto : pb::IMessage<LinearArgumentProto>
1060  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1061  , pb::IBufferMessage
1062  #endif
1063  {
1064  private static readonly pb::MessageParser<LinearArgumentProto> _parser = new pb::MessageParser<LinearArgumentProto>(() => new LinearArgumentProto());
1065  private pb::UnknownFieldSet _unknownFields;
1066  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1067  public static pb::MessageParser<LinearArgumentProto> Parser { get { return _parser; } }
1068 
1069  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1070  public static pbr::MessageDescriptor Descriptor {
1071  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[4]; }
1072  }
1073 
1074  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1075  pbr::MessageDescriptor pb::IMessage.Descriptor {
1076  get { return Descriptor; }
1077  }
1078 
1079  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1080  public LinearArgumentProto() {
1081  OnConstruction();
1082  }
1083 
1084  partial void OnConstruction();
1085 
1086  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1087  public LinearArgumentProto(LinearArgumentProto other) : this() {
1088  target_ = other.target_ != null ? other.target_.Clone() : null;
1089  exprs_ = other.exprs_.Clone();
1090  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1091  }
1092 
1093  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1094  public LinearArgumentProto Clone() {
1095  return new LinearArgumentProto(this);
1096  }
1097 
1099  public const int TargetFieldNumber = 1;
1100  private global::Google.OrTools.Sat.LinearExpressionProto target_;
1101  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1102  public global::Google.OrTools.Sat.LinearExpressionProto Target {
1103  get { return target_; }
1104  set {
1105  target_ = value;
1106  }
1107  }
1108 
1110  public const int ExprsFieldNumber = 2;
1111  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.LinearExpressionProto> _repeated_exprs_codec
1112  = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.LinearExpressionProto.Parser);
1113  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> exprs_ = new pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto>();
1114  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1115  public pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> Exprs {
1116  get { return exprs_; }
1117  }
1118 
1119  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1120  public override bool Equals(object other) {
1121  return Equals(other as LinearArgumentProto);
1122  }
1123 
1124  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1125  public bool Equals(LinearArgumentProto other) {
1126  if (ReferenceEquals(other, null)) {
1127  return false;
1128  }
1129  if (ReferenceEquals(other, this)) {
1130  return true;
1131  }
1132  if (!object.Equals(Target, other.Target)) return false;
1133  if(!exprs_.Equals(other.exprs_)) return false;
1134  return Equals(_unknownFields, other._unknownFields);
1135  }
1136 
1137  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1138  public override int GetHashCode() {
1139  int hash = 1;
1140  if (target_ != null) hash ^= Target.GetHashCode();
1141  hash ^= exprs_.GetHashCode();
1142  if (_unknownFields != null) {
1143  hash ^= _unknownFields.GetHashCode();
1144  }
1145  return hash;
1146  }
1147 
1148  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1149  public override string ToString() {
1150  return pb::JsonFormatter.ToDiagnosticString(this);
1151  }
1152 
1153  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1154  public void WriteTo(pb::CodedOutputStream output) {
1155  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1156  output.WriteRawMessage(this);
1157  #else
1158  if (target_ != null) {
1159  output.WriteRawTag(10);
1160  output.WriteMessage(Target);
1161  }
1162  exprs_.WriteTo(output, _repeated_exprs_codec);
1163  if (_unknownFields != null) {
1164  _unknownFields.WriteTo(output);
1165  }
1166  #endif
1167  }
1168 
1169  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1170  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1171  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1172  if (target_ != null) {
1173  output.WriteRawTag(10);
1174  output.WriteMessage(Target);
1175  }
1176  exprs_.WriteTo(ref output, _repeated_exprs_codec);
1177  if (_unknownFields != null) {
1178  _unknownFields.WriteTo(ref output);
1179  }
1180  }
1181  #endif
1182 
1183  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1184  public int CalculateSize() {
1185  int size = 0;
1186  if (target_ != null) {
1187  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Target);
1188  }
1189  size += exprs_.CalculateSize(_repeated_exprs_codec);
1190  if (_unknownFields != null) {
1191  size += _unknownFields.CalculateSize();
1192  }
1193  return size;
1194  }
1195 
1196  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1197  public void MergeFrom(LinearArgumentProto other) {
1198  if (other == null) {
1199  return;
1200  }
1201  if (other.target_ != null) {
1202  if (target_ == null) {
1203  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1204  }
1205  Target.MergeFrom(other.Target);
1206  }
1207  exprs_.Add(other.exprs_);
1208  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1209  }
1210 
1211  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1212  public void MergeFrom(pb::CodedInputStream input) {
1213  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1214  input.ReadRawMessage(this);
1215  #else
1216  uint tag;
1217  while ((tag = input.ReadTag()) != 0) {
1218  switch(tag) {
1219  default:
1220  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1221  break;
1222  case 10: {
1223  if (target_ == null) {
1224  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1225  }
1226  input.ReadMessage(Target);
1227  break;
1228  }
1229  case 18: {
1230  exprs_.AddEntriesFrom(input, _repeated_exprs_codec);
1231  break;
1232  }
1233  }
1234  }
1235  #endif
1236  }
1237 
1238  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1239  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1240  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1241  uint tag;
1242  while ((tag = input.ReadTag()) != 0) {
1243  switch(tag) {
1244  default:
1245  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1246  break;
1247  case 10: {
1248  if (target_ == null) {
1249  Target = new global::Google.OrTools.Sat.LinearExpressionProto();
1250  }
1251  input.ReadMessage(Target);
1252  break;
1253  }
1254  case 18: {
1255  exprs_.AddEntriesFrom(ref input, _repeated_exprs_codec);
1256  break;
1257  }
1258  }
1259  }
1260  }
1261  #endif
1262 
1263  }
1264 
1268  public sealed partial class AllDifferentConstraintProto : pb::IMessage<AllDifferentConstraintProto>
1269  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1270  , pb::IBufferMessage
1271  #endif
1272  {
1273  private static readonly pb::MessageParser<AllDifferentConstraintProto> _parser = new pb::MessageParser<AllDifferentConstraintProto>(() => new AllDifferentConstraintProto());
1274  private pb::UnknownFieldSet _unknownFields;
1275  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1276  public static pb::MessageParser<AllDifferentConstraintProto> Parser { get { return _parser; } }
1277 
1278  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1279  public static pbr::MessageDescriptor Descriptor {
1280  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[5]; }
1281  }
1282 
1283  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1284  pbr::MessageDescriptor pb::IMessage.Descriptor {
1285  get { return Descriptor; }
1286  }
1287 
1288  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1289  public AllDifferentConstraintProto() {
1290  OnConstruction();
1291  }
1292 
1293  partial void OnConstruction();
1294 
1295  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1296  public AllDifferentConstraintProto(AllDifferentConstraintProto other) : this() {
1297  vars_ = other.vars_.Clone();
1298  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1299  }
1300 
1301  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1302  public AllDifferentConstraintProto Clone() {
1303  return new AllDifferentConstraintProto(this);
1304  }
1305 
1307  public const int VarsFieldNumber = 1;
1308  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1309  = pb::FieldCodec.ForInt32(10);
1310  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1311  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1312  public pbc::RepeatedField<int> Vars {
1313  get { return vars_; }
1314  }
1315 
1316  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1317  public override bool Equals(object other) {
1318  return Equals(other as AllDifferentConstraintProto);
1319  }
1320 
1321  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1322  public bool Equals(AllDifferentConstraintProto other) {
1323  if (ReferenceEquals(other, null)) {
1324  return false;
1325  }
1326  if (ReferenceEquals(other, this)) {
1327  return true;
1328  }
1329  if(!vars_.Equals(other.vars_)) return false;
1330  return Equals(_unknownFields, other._unknownFields);
1331  }
1332 
1333  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1334  public override int GetHashCode() {
1335  int hash = 1;
1336  hash ^= vars_.GetHashCode();
1337  if (_unknownFields != null) {
1338  hash ^= _unknownFields.GetHashCode();
1339  }
1340  return hash;
1341  }
1342 
1343  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1344  public override string ToString() {
1345  return pb::JsonFormatter.ToDiagnosticString(this);
1346  }
1347 
1348  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1349  public void WriteTo(pb::CodedOutputStream output) {
1350  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1351  output.WriteRawMessage(this);
1352  #else
1353  vars_.WriteTo(output, _repeated_vars_codec);
1354  if (_unknownFields != null) {
1355  _unknownFields.WriteTo(output);
1356  }
1357  #endif
1358  }
1359 
1360  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1361  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1362  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1363  vars_.WriteTo(ref output, _repeated_vars_codec);
1364  if (_unknownFields != null) {
1365  _unknownFields.WriteTo(ref output);
1366  }
1367  }
1368  #endif
1369 
1370  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1371  public int CalculateSize() {
1372  int size = 0;
1373  size += vars_.CalculateSize(_repeated_vars_codec);
1374  if (_unknownFields != null) {
1375  size += _unknownFields.CalculateSize();
1376  }
1377  return size;
1378  }
1379 
1380  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1381  public void MergeFrom(AllDifferentConstraintProto other) {
1382  if (other == null) {
1383  return;
1384  }
1385  vars_.Add(other.vars_);
1386  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1387  }
1388 
1389  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1390  public void MergeFrom(pb::CodedInputStream input) {
1391  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1392  input.ReadRawMessage(this);
1393  #else
1394  uint tag;
1395  while ((tag = input.ReadTag()) != 0) {
1396  switch(tag) {
1397  default:
1398  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1399  break;
1400  case 10:
1401  case 8: {
1402  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1403  break;
1404  }
1405  }
1406  }
1407  #endif
1408  }
1409 
1410  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1411  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1412  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1413  uint tag;
1414  while ((tag = input.ReadTag()) != 0) {
1415  switch(tag) {
1416  default:
1417  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1418  break;
1419  case 10:
1420  case 8: {
1421  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1422  break;
1423  }
1424  }
1425  }
1426  }
1427  #endif
1428 
1429  }
1430 
1439  public sealed partial class LinearConstraintProto : pb::IMessage<LinearConstraintProto>
1440  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1441  , pb::IBufferMessage
1442  #endif
1443  {
1444  private static readonly pb::MessageParser<LinearConstraintProto> _parser = new pb::MessageParser<LinearConstraintProto>(() => new LinearConstraintProto());
1445  private pb::UnknownFieldSet _unknownFields;
1446  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1447  public static pb::MessageParser<LinearConstraintProto> Parser { get { return _parser; } }
1448 
1449  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1450  public static pbr::MessageDescriptor Descriptor {
1451  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[6]; }
1452  }
1453 
1454  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1455  pbr::MessageDescriptor pb::IMessage.Descriptor {
1456  get { return Descriptor; }
1457  }
1458 
1459  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1460  public LinearConstraintProto() {
1461  OnConstruction();
1462  }
1463 
1464  partial void OnConstruction();
1465 
1466  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1467  public LinearConstraintProto(LinearConstraintProto other) : this() {
1468  vars_ = other.vars_.Clone();
1469  coeffs_ = other.coeffs_.Clone();
1470  domain_ = other.domain_.Clone();
1471  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1472  }
1473 
1474  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1475  public LinearConstraintProto Clone() {
1476  return new LinearConstraintProto(this);
1477  }
1478 
1480  public const int VarsFieldNumber = 1;
1481  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1482  = pb::FieldCodec.ForInt32(10);
1483  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1484  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1485  public pbc::RepeatedField<int> Vars {
1486  get { return vars_; }
1487  }
1488 
1490  public const int CoeffsFieldNumber = 2;
1491  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
1492  = pb::FieldCodec.ForInt64(18);
1493  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
1497  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1498  public pbc::RepeatedField<long> Coeffs {
1499  get { return coeffs_; }
1500  }
1501 
1503  public const int DomainFieldNumber = 3;
1504  private static readonly pb::FieldCodec<long> _repeated_domain_codec
1505  = pb::FieldCodec.ForInt64(26);
1506  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
1507  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1508  public pbc::RepeatedField<long> Domain {
1509  get { return domain_; }
1510  }
1511 
1512  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1513  public override bool Equals(object other) {
1514  return Equals(other as LinearConstraintProto);
1515  }
1516 
1517  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1518  public bool Equals(LinearConstraintProto other) {
1519  if (ReferenceEquals(other, null)) {
1520  return false;
1521  }
1522  if (ReferenceEquals(other, this)) {
1523  return true;
1524  }
1525  if(!vars_.Equals(other.vars_)) return false;
1526  if(!coeffs_.Equals(other.coeffs_)) return false;
1527  if(!domain_.Equals(other.domain_)) return false;
1528  return Equals(_unknownFields, other._unknownFields);
1529  }
1530 
1531  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1532  public override int GetHashCode() {
1533  int hash = 1;
1534  hash ^= vars_.GetHashCode();
1535  hash ^= coeffs_.GetHashCode();
1536  hash ^= domain_.GetHashCode();
1537  if (_unknownFields != null) {
1538  hash ^= _unknownFields.GetHashCode();
1539  }
1540  return hash;
1541  }
1542 
1543  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1544  public override string ToString() {
1545  return pb::JsonFormatter.ToDiagnosticString(this);
1546  }
1547 
1548  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1549  public void WriteTo(pb::CodedOutputStream output) {
1550  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1551  output.WriteRawMessage(this);
1552  #else
1553  vars_.WriteTo(output, _repeated_vars_codec);
1554  coeffs_.WriteTo(output, _repeated_coeffs_codec);
1555  domain_.WriteTo(output, _repeated_domain_codec);
1556  if (_unknownFields != null) {
1557  _unknownFields.WriteTo(output);
1558  }
1559  #endif
1560  }
1561 
1562  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1563  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1564  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1565  vars_.WriteTo(ref output, _repeated_vars_codec);
1566  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
1567  domain_.WriteTo(ref output, _repeated_domain_codec);
1568  if (_unknownFields != null) {
1569  _unknownFields.WriteTo(ref output);
1570  }
1571  }
1572  #endif
1573 
1574  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1575  public int CalculateSize() {
1576  int size = 0;
1577  size += vars_.CalculateSize(_repeated_vars_codec);
1578  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
1579  size += domain_.CalculateSize(_repeated_domain_codec);
1580  if (_unknownFields != null) {
1581  size += _unknownFields.CalculateSize();
1582  }
1583  return size;
1584  }
1585 
1586  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1587  public void MergeFrom(LinearConstraintProto other) {
1588  if (other == null) {
1589  return;
1590  }
1591  vars_.Add(other.vars_);
1592  coeffs_.Add(other.coeffs_);
1593  domain_.Add(other.domain_);
1594  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1595  }
1596 
1597  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1598  public void MergeFrom(pb::CodedInputStream input) {
1599  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1600  input.ReadRawMessage(this);
1601  #else
1602  uint tag;
1603  while ((tag = input.ReadTag()) != 0) {
1604  switch(tag) {
1605  default:
1606  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1607  break;
1608  case 10:
1609  case 8: {
1610  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1611  break;
1612  }
1613  case 18:
1614  case 16: {
1615  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
1616  break;
1617  }
1618  case 26:
1619  case 24: {
1620  domain_.AddEntriesFrom(input, _repeated_domain_codec);
1621  break;
1622  }
1623  }
1624  }
1625  #endif
1626  }
1627 
1628  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1629  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1630  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1631  uint tag;
1632  while ((tag = input.ReadTag()) != 0) {
1633  switch(tag) {
1634  default:
1635  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1636  break;
1637  case 10:
1638  case 8: {
1639  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1640  break;
1641  }
1642  case 18:
1643  case 16: {
1644  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
1645  break;
1646  }
1647  case 26:
1648  case 24: {
1649  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
1650  break;
1651  }
1652  }
1653  }
1654  }
1655  #endif
1656 
1657  }
1658 
1663  public sealed partial class ElementConstraintProto : pb::IMessage<ElementConstraintProto>
1664  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1665  , pb::IBufferMessage
1666  #endif
1667  {
1668  private static readonly pb::MessageParser<ElementConstraintProto> _parser = new pb::MessageParser<ElementConstraintProto>(() => new ElementConstraintProto());
1669  private pb::UnknownFieldSet _unknownFields;
1670  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1671  public static pb::MessageParser<ElementConstraintProto> Parser { get { return _parser; } }
1672 
1673  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1674  public static pbr::MessageDescriptor Descriptor {
1675  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[7]; }
1676  }
1677 
1678  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1679  pbr::MessageDescriptor pb::IMessage.Descriptor {
1680  get { return Descriptor; }
1681  }
1682 
1683  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1684  public ElementConstraintProto() {
1685  OnConstruction();
1686  }
1687 
1688  partial void OnConstruction();
1689 
1690  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1691  public ElementConstraintProto(ElementConstraintProto other) : this() {
1692  index_ = other.index_;
1693  target_ = other.target_;
1694  vars_ = other.vars_.Clone();
1695  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1696  }
1697 
1698  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1699  public ElementConstraintProto Clone() {
1700  return new ElementConstraintProto(this);
1701  }
1702 
1704  public const int IndexFieldNumber = 1;
1705  private int index_;
1706  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1707  public int Index {
1708  get { return index_; }
1709  set {
1710  index_ = value;
1711  }
1712  }
1713 
1715  public const int TargetFieldNumber = 2;
1716  private int target_;
1717  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1718  public int Target {
1719  get { return target_; }
1720  set {
1721  target_ = value;
1722  }
1723  }
1724 
1726  public const int VarsFieldNumber = 3;
1727  private static readonly pb::FieldCodec<int> _repeated_vars_codec
1728  = pb::FieldCodec.ForInt32(26);
1729  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
1730  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1731  public pbc::RepeatedField<int> Vars {
1732  get { return vars_; }
1733  }
1734 
1735  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1736  public override bool Equals(object other) {
1737  return Equals(other as ElementConstraintProto);
1738  }
1739 
1740  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1741  public bool Equals(ElementConstraintProto other) {
1742  if (ReferenceEquals(other, null)) {
1743  return false;
1744  }
1745  if (ReferenceEquals(other, this)) {
1746  return true;
1747  }
1748  if (Index != other.Index) return false;
1749  if (Target != other.Target) return false;
1750  if(!vars_.Equals(other.vars_)) return false;
1751  return Equals(_unknownFields, other._unknownFields);
1752  }
1753 
1754  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1755  public override int GetHashCode() {
1756  int hash = 1;
1757  if (Index != 0) hash ^= Index.GetHashCode();
1758  if (Target != 0) hash ^= Target.GetHashCode();
1759  hash ^= vars_.GetHashCode();
1760  if (_unknownFields != null) {
1761  hash ^= _unknownFields.GetHashCode();
1762  }
1763  return hash;
1764  }
1765 
1766  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1767  public override string ToString() {
1768  return pb::JsonFormatter.ToDiagnosticString(this);
1769  }
1770 
1771  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1772  public void WriteTo(pb::CodedOutputStream output) {
1773  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1774  output.WriteRawMessage(this);
1775  #else
1776  if (Index != 0) {
1777  output.WriteRawTag(8);
1778  output.WriteInt32(Index);
1779  }
1780  if (Target != 0) {
1781  output.WriteRawTag(16);
1782  output.WriteInt32(Target);
1783  }
1784  vars_.WriteTo(output, _repeated_vars_codec);
1785  if (_unknownFields != null) {
1786  _unknownFields.WriteTo(output);
1787  }
1788  #endif
1789  }
1790 
1791  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1792  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1793  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
1794  if (Index != 0) {
1795  output.WriteRawTag(8);
1796  output.WriteInt32(Index);
1797  }
1798  if (Target != 0) {
1799  output.WriteRawTag(16);
1800  output.WriteInt32(Target);
1801  }
1802  vars_.WriteTo(ref output, _repeated_vars_codec);
1803  if (_unknownFields != null) {
1804  _unknownFields.WriteTo(ref output);
1805  }
1806  }
1807  #endif
1808 
1809  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1810  public int CalculateSize() {
1811  int size = 0;
1812  if (Index != 0) {
1813  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Index);
1814  }
1815  if (Target != 0) {
1816  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
1817  }
1818  size += vars_.CalculateSize(_repeated_vars_codec);
1819  if (_unknownFields != null) {
1820  size += _unknownFields.CalculateSize();
1821  }
1822  return size;
1823  }
1824 
1825  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1826  public void MergeFrom(ElementConstraintProto other) {
1827  if (other == null) {
1828  return;
1829  }
1830  if (other.Index != 0) {
1831  Index = other.Index;
1832  }
1833  if (other.Target != 0) {
1834  Target = other.Target;
1835  }
1836  vars_.Add(other.vars_);
1837  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1838  }
1839 
1840  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1841  public void MergeFrom(pb::CodedInputStream input) {
1842  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1843  input.ReadRawMessage(this);
1844  #else
1845  uint tag;
1846  while ((tag = input.ReadTag()) != 0) {
1847  switch(tag) {
1848  default:
1849  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1850  break;
1851  case 8: {
1852  Index = input.ReadInt32();
1853  break;
1854  }
1855  case 16: {
1856  Target = input.ReadInt32();
1857  break;
1858  }
1859  case 26:
1860  case 24: {
1861  vars_.AddEntriesFrom(input, _repeated_vars_codec);
1862  break;
1863  }
1864  }
1865  }
1866  #endif
1867  }
1868 
1869  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1870  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1871  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
1872  uint tag;
1873  while ((tag = input.ReadTag()) != 0) {
1874  switch(tag) {
1875  default:
1876  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
1877  break;
1878  case 8: {
1879  Index = input.ReadInt32();
1880  break;
1881  }
1882  case 16: {
1883  Target = input.ReadInt32();
1884  break;
1885  }
1886  case 26:
1887  case 24: {
1888  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
1889  break;
1890  }
1891  }
1892  }
1893  }
1894  #endif
1895 
1896  }
1897 
1902  public sealed partial class IntervalConstraintProto : pb::IMessage<IntervalConstraintProto>
1903  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
1904  , pb::IBufferMessage
1905  #endif
1906  {
1907  private static readonly pb::MessageParser<IntervalConstraintProto> _parser = new pb::MessageParser<IntervalConstraintProto>(() => new IntervalConstraintProto());
1908  private pb::UnknownFieldSet _unknownFields;
1909  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1910  public static pb::MessageParser<IntervalConstraintProto> Parser { get { return _parser; } }
1911 
1912  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1913  public static pbr::MessageDescriptor Descriptor {
1914  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[8]; }
1915  }
1916 
1917  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1918  pbr::MessageDescriptor pb::IMessage.Descriptor {
1919  get { return Descriptor; }
1920  }
1921 
1922  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1923  public IntervalConstraintProto() {
1924  OnConstruction();
1925  }
1926 
1927  partial void OnConstruction();
1928 
1929  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1930  public IntervalConstraintProto(IntervalConstraintProto other) : this() {
1931  start_ = other.start_;
1932  end_ = other.end_;
1933  size_ = other.size_;
1934  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1935  }
1936 
1937  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1938  public IntervalConstraintProto Clone() {
1939  return new IntervalConstraintProto(this);
1940  }
1941 
1943  public const int StartFieldNumber = 1;
1944  private int start_;
1945  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1946  public int Start {
1947  get { return start_; }
1948  set {
1949  start_ = value;
1950  }
1951  }
1952 
1954  public const int EndFieldNumber = 2;
1955  private int end_;
1956  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1957  public int End {
1958  get { return end_; }
1959  set {
1960  end_ = value;
1961  }
1962  }
1963 
1965  public const int SizeFieldNumber = 3;
1966  private int size_;
1967  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1968  public int Size {
1969  get { return size_; }
1970  set {
1971  size_ = value;
1972  }
1973  }
1974 
1975  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1976  public override bool Equals(object other) {
1977  return Equals(other as IntervalConstraintProto);
1978  }
1979 
1980  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1981  public bool Equals(IntervalConstraintProto other) {
1982  if (ReferenceEquals(other, null)) {
1983  return false;
1984  }
1985  if (ReferenceEquals(other, this)) {
1986  return true;
1987  }
1988  if (Start != other.Start) return false;
1989  if (End != other.End) return false;
1990  if (Size != other.Size) return false;
1991  return Equals(_unknownFields, other._unknownFields);
1992  }
1993 
1994  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1995  public override int GetHashCode() {
1996  int hash = 1;
1997  if (Start != 0) hash ^= Start.GetHashCode();
1998  if (End != 0) hash ^= End.GetHashCode();
1999  if (Size != 0) hash ^= Size.GetHashCode();
2000  if (_unknownFields != null) {
2001  hash ^= _unknownFields.GetHashCode();
2002  }
2003  return hash;
2004  }
2005 
2006  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2007  public override string ToString() {
2008  return pb::JsonFormatter.ToDiagnosticString(this);
2009  }
2010 
2011  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2012  public void WriteTo(pb::CodedOutputStream output) {
2013  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2014  output.WriteRawMessage(this);
2015  #else
2016  if (Start != 0) {
2017  output.WriteRawTag(8);
2018  output.WriteInt32(Start);
2019  }
2020  if (End != 0) {
2021  output.WriteRawTag(16);
2022  output.WriteInt32(End);
2023  }
2024  if (Size != 0) {
2025  output.WriteRawTag(24);
2026  output.WriteInt32(Size);
2027  }
2028  if (_unknownFields != null) {
2029  _unknownFields.WriteTo(output);
2030  }
2031  #endif
2032  }
2033 
2034  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2035  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2036  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2037  if (Start != 0) {
2038  output.WriteRawTag(8);
2039  output.WriteInt32(Start);
2040  }
2041  if (End != 0) {
2042  output.WriteRawTag(16);
2043  output.WriteInt32(End);
2044  }
2045  if (Size != 0) {
2046  output.WriteRawTag(24);
2047  output.WriteInt32(Size);
2048  }
2049  if (_unknownFields != null) {
2050  _unknownFields.WriteTo(ref output);
2051  }
2052  }
2053  #endif
2054 
2055  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2056  public int CalculateSize() {
2057  int size = 0;
2058  if (Start != 0) {
2059  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
2060  }
2061  if (End != 0) {
2062  size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
2063  }
2064  if (Size != 0) {
2065  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Size);
2066  }
2067  if (_unknownFields != null) {
2068  size += _unknownFields.CalculateSize();
2069  }
2070  return size;
2071  }
2072 
2073  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2074  public void MergeFrom(IntervalConstraintProto other) {
2075  if (other == null) {
2076  return;
2077  }
2078  if (other.Start != 0) {
2079  Start = other.Start;
2080  }
2081  if (other.End != 0) {
2082  End = other.End;
2083  }
2084  if (other.Size != 0) {
2085  Size = other.Size;
2086  }
2087  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2088  }
2089 
2090  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2091  public void MergeFrom(pb::CodedInputStream input) {
2092  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2093  input.ReadRawMessage(this);
2094  #else
2095  uint tag;
2096  while ((tag = input.ReadTag()) != 0) {
2097  switch(tag) {
2098  default:
2099  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2100  break;
2101  case 8: {
2102  Start = input.ReadInt32();
2103  break;
2104  }
2105  case 16: {
2106  End = input.ReadInt32();
2107  break;
2108  }
2109  case 24: {
2110  Size = input.ReadInt32();
2111  break;
2112  }
2113  }
2114  }
2115  #endif
2116  }
2117 
2118  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2119  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2120  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2121  uint tag;
2122  while ((tag = input.ReadTag()) != 0) {
2123  switch(tag) {
2124  default:
2125  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2126  break;
2127  case 8: {
2128  Start = input.ReadInt32();
2129  break;
2130  }
2131  case 16: {
2132  End = input.ReadInt32();
2133  break;
2134  }
2135  case 24: {
2136  Size = input.ReadInt32();
2137  break;
2138  }
2139  }
2140  }
2141  }
2142  #endif
2143 
2144  }
2145 
2153  public sealed partial class NoOverlapConstraintProto : pb::IMessage<NoOverlapConstraintProto>
2154  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2155  , pb::IBufferMessage
2156  #endif
2157  {
2158  private static readonly pb::MessageParser<NoOverlapConstraintProto> _parser = new pb::MessageParser<NoOverlapConstraintProto>(() => new NoOverlapConstraintProto());
2159  private pb::UnknownFieldSet _unknownFields;
2160  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2161  public static pb::MessageParser<NoOverlapConstraintProto> Parser { get { return _parser; } }
2162 
2163  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2164  public static pbr::MessageDescriptor Descriptor {
2165  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[9]; }
2166  }
2167 
2168  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2169  pbr::MessageDescriptor pb::IMessage.Descriptor {
2170  get { return Descriptor; }
2171  }
2172 
2173  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2174  public NoOverlapConstraintProto() {
2175  OnConstruction();
2176  }
2177 
2178  partial void OnConstruction();
2179 
2180  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2181  public NoOverlapConstraintProto(NoOverlapConstraintProto other) : this() {
2182  intervals_ = other.intervals_.Clone();
2183  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2184  }
2185 
2186  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2187  public NoOverlapConstraintProto Clone() {
2188  return new NoOverlapConstraintProto(this);
2189  }
2190 
2192  public const int IntervalsFieldNumber = 1;
2193  private static readonly pb::FieldCodec<int> _repeated_intervals_codec
2194  = pb::FieldCodec.ForInt32(10);
2195  private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
2196  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2197  public pbc::RepeatedField<int> Intervals {
2198  get { return intervals_; }
2199  }
2200 
2201  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2202  public override bool Equals(object other) {
2203  return Equals(other as NoOverlapConstraintProto);
2204  }
2205 
2206  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2207  public bool Equals(NoOverlapConstraintProto other) {
2208  if (ReferenceEquals(other, null)) {
2209  return false;
2210  }
2211  if (ReferenceEquals(other, this)) {
2212  return true;
2213  }
2214  if(!intervals_.Equals(other.intervals_)) return false;
2215  return Equals(_unknownFields, other._unknownFields);
2216  }
2217 
2218  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2219  public override int GetHashCode() {
2220  int hash = 1;
2221  hash ^= intervals_.GetHashCode();
2222  if (_unknownFields != null) {
2223  hash ^= _unknownFields.GetHashCode();
2224  }
2225  return hash;
2226  }
2227 
2228  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2229  public override string ToString() {
2230  return pb::JsonFormatter.ToDiagnosticString(this);
2231  }
2232 
2233  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2234  public void WriteTo(pb::CodedOutputStream output) {
2235  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2236  output.WriteRawMessage(this);
2237  #else
2238  intervals_.WriteTo(output, _repeated_intervals_codec);
2239  if (_unknownFields != null) {
2240  _unknownFields.WriteTo(output);
2241  }
2242  #endif
2243  }
2244 
2245  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2246  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2247  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2248  intervals_.WriteTo(ref output, _repeated_intervals_codec);
2249  if (_unknownFields != null) {
2250  _unknownFields.WriteTo(ref output);
2251  }
2252  }
2253  #endif
2254 
2255  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2256  public int CalculateSize() {
2257  int size = 0;
2258  size += intervals_.CalculateSize(_repeated_intervals_codec);
2259  if (_unknownFields != null) {
2260  size += _unknownFields.CalculateSize();
2261  }
2262  return size;
2263  }
2264 
2265  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2266  public void MergeFrom(NoOverlapConstraintProto other) {
2267  if (other == null) {
2268  return;
2269  }
2270  intervals_.Add(other.intervals_);
2271  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2272  }
2273 
2274  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2275  public void MergeFrom(pb::CodedInputStream input) {
2276  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2277  input.ReadRawMessage(this);
2278  #else
2279  uint tag;
2280  while ((tag = input.ReadTag()) != 0) {
2281  switch(tag) {
2282  default:
2283  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2284  break;
2285  case 10:
2286  case 8: {
2287  intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
2288  break;
2289  }
2290  }
2291  }
2292  #endif
2293  }
2294 
2295  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2296  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2297  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2298  uint tag;
2299  while ((tag = input.ReadTag()) != 0) {
2300  switch(tag) {
2301  default:
2302  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2303  break;
2304  case 10:
2305  case 8: {
2306  intervals_.AddEntriesFrom(ref input, _repeated_intervals_codec);
2307  break;
2308  }
2309  }
2310  }
2311  }
2312  #endif
2313 
2314  }
2315 
2319  public sealed partial class NoOverlap2DConstraintProto : pb::IMessage<NoOverlap2DConstraintProto>
2320  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2321  , pb::IBufferMessage
2322  #endif
2323  {
2324  private static readonly pb::MessageParser<NoOverlap2DConstraintProto> _parser = new pb::MessageParser<NoOverlap2DConstraintProto>(() => new NoOverlap2DConstraintProto());
2325  private pb::UnknownFieldSet _unknownFields;
2326  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2327  public static pb::MessageParser<NoOverlap2DConstraintProto> Parser { get { return _parser; } }
2328 
2329  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2330  public static pbr::MessageDescriptor Descriptor {
2331  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[10]; }
2332  }
2333 
2334  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2335  pbr::MessageDescriptor pb::IMessage.Descriptor {
2336  get { return Descriptor; }
2337  }
2338 
2339  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2340  public NoOverlap2DConstraintProto() {
2341  OnConstruction();
2342  }
2343 
2344  partial void OnConstruction();
2345 
2346  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2347  public NoOverlap2DConstraintProto(NoOverlap2DConstraintProto other) : this() {
2348  xIntervals_ = other.xIntervals_.Clone();
2349  yIntervals_ = other.yIntervals_.Clone();
2350  boxesWithNullAreaCanOverlap_ = other.boxesWithNullAreaCanOverlap_;
2351  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2352  }
2353 
2354  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2355  public NoOverlap2DConstraintProto Clone() {
2356  return new NoOverlap2DConstraintProto(this);
2357  }
2358 
2360  public const int XIntervalsFieldNumber = 1;
2361  private static readonly pb::FieldCodec<int> _repeated_xIntervals_codec
2362  = pb::FieldCodec.ForInt32(10);
2363  private readonly pbc::RepeatedField<int> xIntervals_ = new pbc::RepeatedField<int>();
2364  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2365  public pbc::RepeatedField<int> XIntervals {
2366  get { return xIntervals_; }
2367  }
2368 
2370  public const int YIntervalsFieldNumber = 2;
2371  private static readonly pb::FieldCodec<int> _repeated_yIntervals_codec
2372  = pb::FieldCodec.ForInt32(18);
2373  private readonly pbc::RepeatedField<int> yIntervals_ = new pbc::RepeatedField<int>();
2377  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2378  public pbc::RepeatedField<int> YIntervals {
2379  get { return yIntervals_; }
2380  }
2381 
2383  public const int BoxesWithNullAreaCanOverlapFieldNumber = 3;
2384  private bool boxesWithNullAreaCanOverlap_;
2385  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2386  public bool BoxesWithNullAreaCanOverlap {
2387  get { return boxesWithNullAreaCanOverlap_; }
2388  set {
2389  boxesWithNullAreaCanOverlap_ = value;
2390  }
2391  }
2392 
2393  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2394  public override bool Equals(object other) {
2395  return Equals(other as NoOverlap2DConstraintProto);
2396  }
2397 
2398  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2399  public bool Equals(NoOverlap2DConstraintProto other) {
2400  if (ReferenceEquals(other, null)) {
2401  return false;
2402  }
2403  if (ReferenceEquals(other, this)) {
2404  return true;
2405  }
2406  if(!xIntervals_.Equals(other.xIntervals_)) return false;
2407  if(!yIntervals_.Equals(other.yIntervals_)) return false;
2408  if (BoxesWithNullAreaCanOverlap != other.BoxesWithNullAreaCanOverlap) return false;
2409  return Equals(_unknownFields, other._unknownFields);
2410  }
2411 
2412  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2413  public override int GetHashCode() {
2414  int hash = 1;
2415  hash ^= xIntervals_.GetHashCode();
2416  hash ^= yIntervals_.GetHashCode();
2417  if (BoxesWithNullAreaCanOverlap != false) hash ^= BoxesWithNullAreaCanOverlap.GetHashCode();
2418  if (_unknownFields != null) {
2419  hash ^= _unknownFields.GetHashCode();
2420  }
2421  return hash;
2422  }
2423 
2424  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2425  public override string ToString() {
2426  return pb::JsonFormatter.ToDiagnosticString(this);
2427  }
2428 
2429  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2430  public void WriteTo(pb::CodedOutputStream output) {
2431  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2432  output.WriteRawMessage(this);
2433  #else
2434  xIntervals_.WriteTo(output, _repeated_xIntervals_codec);
2435  yIntervals_.WriteTo(output, _repeated_yIntervals_codec);
2436  if (BoxesWithNullAreaCanOverlap != false) {
2437  output.WriteRawTag(24);
2438  output.WriteBool(BoxesWithNullAreaCanOverlap);
2439  }
2440  if (_unknownFields != null) {
2441  _unknownFields.WriteTo(output);
2442  }
2443  #endif
2444  }
2445 
2446  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2447  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2448  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2449  xIntervals_.WriteTo(ref output, _repeated_xIntervals_codec);
2450  yIntervals_.WriteTo(ref output, _repeated_yIntervals_codec);
2451  if (BoxesWithNullAreaCanOverlap != false) {
2452  output.WriteRawTag(24);
2453  output.WriteBool(BoxesWithNullAreaCanOverlap);
2454  }
2455  if (_unknownFields != null) {
2456  _unknownFields.WriteTo(ref output);
2457  }
2458  }
2459  #endif
2460 
2461  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2462  public int CalculateSize() {
2463  int size = 0;
2464  size += xIntervals_.CalculateSize(_repeated_xIntervals_codec);
2465  size += yIntervals_.CalculateSize(_repeated_yIntervals_codec);
2466  if (BoxesWithNullAreaCanOverlap != false) {
2467  size += 1 + 1;
2468  }
2469  if (_unknownFields != null) {
2470  size += _unknownFields.CalculateSize();
2471  }
2472  return size;
2473  }
2474 
2475  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2476  public void MergeFrom(NoOverlap2DConstraintProto other) {
2477  if (other == null) {
2478  return;
2479  }
2480  xIntervals_.Add(other.xIntervals_);
2481  yIntervals_.Add(other.yIntervals_);
2482  if (other.BoxesWithNullAreaCanOverlap != false) {
2483  BoxesWithNullAreaCanOverlap = other.BoxesWithNullAreaCanOverlap;
2484  }
2485  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2486  }
2487 
2488  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2489  public void MergeFrom(pb::CodedInputStream input) {
2490  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2491  input.ReadRawMessage(this);
2492  #else
2493  uint tag;
2494  while ((tag = input.ReadTag()) != 0) {
2495  switch(tag) {
2496  default:
2497  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2498  break;
2499  case 10:
2500  case 8: {
2501  xIntervals_.AddEntriesFrom(input, _repeated_xIntervals_codec);
2502  break;
2503  }
2504  case 18:
2505  case 16: {
2506  yIntervals_.AddEntriesFrom(input, _repeated_yIntervals_codec);
2507  break;
2508  }
2509  case 24: {
2510  BoxesWithNullAreaCanOverlap = input.ReadBool();
2511  break;
2512  }
2513  }
2514  }
2515  #endif
2516  }
2517 
2518  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2519  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2520  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2521  uint tag;
2522  while ((tag = input.ReadTag()) != 0) {
2523  switch(tag) {
2524  default:
2525  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2526  break;
2527  case 10:
2528  case 8: {
2529  xIntervals_.AddEntriesFrom(ref input, _repeated_xIntervals_codec);
2530  break;
2531  }
2532  case 18:
2533  case 16: {
2534  yIntervals_.AddEntriesFrom(ref input, _repeated_yIntervals_codec);
2535  break;
2536  }
2537  case 24: {
2538  BoxesWithNullAreaCanOverlap = input.ReadBool();
2539  break;
2540  }
2541  }
2542  }
2543  }
2544  #endif
2545 
2546  }
2547 
2554  public sealed partial class CumulativeConstraintProto : pb::IMessage<CumulativeConstraintProto>
2555  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2556  , pb::IBufferMessage
2557  #endif
2558  {
2559  private static readonly pb::MessageParser<CumulativeConstraintProto> _parser = new pb::MessageParser<CumulativeConstraintProto>(() => new CumulativeConstraintProto());
2560  private pb::UnknownFieldSet _unknownFields;
2561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2562  public static pb::MessageParser<CumulativeConstraintProto> Parser { get { return _parser; } }
2563 
2564  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2565  public static pbr::MessageDescriptor Descriptor {
2566  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[11]; }
2567  }
2568 
2569  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2570  pbr::MessageDescriptor pb::IMessage.Descriptor {
2571  get { return Descriptor; }
2572  }
2573 
2574  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2575  public CumulativeConstraintProto() {
2576  OnConstruction();
2577  }
2578 
2579  partial void OnConstruction();
2580 
2581  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2582  public CumulativeConstraintProto(CumulativeConstraintProto other) : this() {
2583  capacity_ = other.capacity_;
2584  intervals_ = other.intervals_.Clone();
2585  demands_ = other.demands_.Clone();
2586  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2587  }
2588 
2589  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2590  public CumulativeConstraintProto Clone() {
2591  return new CumulativeConstraintProto(this);
2592  }
2593 
2595  public const int CapacityFieldNumber = 1;
2596  private int capacity_;
2597  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2598  public int Capacity {
2599  get { return capacity_; }
2600  set {
2601  capacity_ = value;
2602  }
2603  }
2604 
2606  public const int IntervalsFieldNumber = 2;
2607  private static readonly pb::FieldCodec<int> _repeated_intervals_codec
2608  = pb::FieldCodec.ForInt32(18);
2609  private readonly pbc::RepeatedField<int> intervals_ = new pbc::RepeatedField<int>();
2610  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2611  public pbc::RepeatedField<int> Intervals {
2612  get { return intervals_; }
2613  }
2614 
2616  public const int DemandsFieldNumber = 3;
2617  private static readonly pb::FieldCodec<int> _repeated_demands_codec
2618  = pb::FieldCodec.ForInt32(26);
2619  private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
2623  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2624  public pbc::RepeatedField<int> Demands {
2625  get { return demands_; }
2626  }
2627 
2628  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2629  public override bool Equals(object other) {
2630  return Equals(other as CumulativeConstraintProto);
2631  }
2632 
2633  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2634  public bool Equals(CumulativeConstraintProto other) {
2635  if (ReferenceEquals(other, null)) {
2636  return false;
2637  }
2638  if (ReferenceEquals(other, this)) {
2639  return true;
2640  }
2641  if (Capacity != other.Capacity) return false;
2642  if(!intervals_.Equals(other.intervals_)) return false;
2643  if(!demands_.Equals(other.demands_)) return false;
2644  return Equals(_unknownFields, other._unknownFields);
2645  }
2646 
2647  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2648  public override int GetHashCode() {
2649  int hash = 1;
2650  if (Capacity != 0) hash ^= Capacity.GetHashCode();
2651  hash ^= intervals_.GetHashCode();
2652  hash ^= demands_.GetHashCode();
2653  if (_unknownFields != null) {
2654  hash ^= _unknownFields.GetHashCode();
2655  }
2656  return hash;
2657  }
2658 
2659  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2660  public override string ToString() {
2661  return pb::JsonFormatter.ToDiagnosticString(this);
2662  }
2663 
2664  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2665  public void WriteTo(pb::CodedOutputStream output) {
2666  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2667  output.WriteRawMessage(this);
2668  #else
2669  if (Capacity != 0) {
2670  output.WriteRawTag(8);
2671  output.WriteInt32(Capacity);
2672  }
2673  intervals_.WriteTo(output, _repeated_intervals_codec);
2674  demands_.WriteTo(output, _repeated_demands_codec);
2675  if (_unknownFields != null) {
2676  _unknownFields.WriteTo(output);
2677  }
2678  #endif
2679  }
2680 
2681  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2682  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2683  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2684  if (Capacity != 0) {
2685  output.WriteRawTag(8);
2686  output.WriteInt32(Capacity);
2687  }
2688  intervals_.WriteTo(ref output, _repeated_intervals_codec);
2689  demands_.WriteTo(ref output, _repeated_demands_codec);
2690  if (_unknownFields != null) {
2691  _unknownFields.WriteTo(ref output);
2692  }
2693  }
2694  #endif
2695 
2696  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2697  public int CalculateSize() {
2698  int size = 0;
2699  if (Capacity != 0) {
2700  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Capacity);
2701  }
2702  size += intervals_.CalculateSize(_repeated_intervals_codec);
2703  size += demands_.CalculateSize(_repeated_demands_codec);
2704  if (_unknownFields != null) {
2705  size += _unknownFields.CalculateSize();
2706  }
2707  return size;
2708  }
2709 
2710  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2711  public void MergeFrom(CumulativeConstraintProto other) {
2712  if (other == null) {
2713  return;
2714  }
2715  if (other.Capacity != 0) {
2716  Capacity = other.Capacity;
2717  }
2718  intervals_.Add(other.intervals_);
2719  demands_.Add(other.demands_);
2720  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2721  }
2722 
2723  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2724  public void MergeFrom(pb::CodedInputStream input) {
2725  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2726  input.ReadRawMessage(this);
2727  #else
2728  uint tag;
2729  while ((tag = input.ReadTag()) != 0) {
2730  switch(tag) {
2731  default:
2732  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2733  break;
2734  case 8: {
2735  Capacity = input.ReadInt32();
2736  break;
2737  }
2738  case 18:
2739  case 16: {
2740  intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
2741  break;
2742  }
2743  case 26:
2744  case 24: {
2745  demands_.AddEntriesFrom(input, _repeated_demands_codec);
2746  break;
2747  }
2748  }
2749  }
2750  #endif
2751  }
2752 
2753  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2754  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2755  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
2756  uint tag;
2757  while ((tag = input.ReadTag()) != 0) {
2758  switch(tag) {
2759  default:
2760  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
2761  break;
2762  case 8: {
2763  Capacity = input.ReadInt32();
2764  break;
2765  }
2766  case 18:
2767  case 16: {
2768  intervals_.AddEntriesFrom(ref input, _repeated_intervals_codec);
2769  break;
2770  }
2771  case 26:
2772  case 24: {
2773  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
2774  break;
2775  }
2776  }
2777  }
2778  }
2779  #endif
2780 
2781  }
2782 
2799  public sealed partial class ReservoirConstraintProto : pb::IMessage<ReservoirConstraintProto>
2800  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2801  , pb::IBufferMessage
2802  #endif
2803  {
2804  private static readonly pb::MessageParser<ReservoirConstraintProto> _parser = new pb::MessageParser<ReservoirConstraintProto>(() => new ReservoirConstraintProto());
2805  private pb::UnknownFieldSet _unknownFields;
2806  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2807  public static pb::MessageParser<ReservoirConstraintProto> Parser { get { return _parser; } }
2808 
2809  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2810  public static pbr::MessageDescriptor Descriptor {
2811  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[12]; }
2812  }
2813 
2814  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2815  pbr::MessageDescriptor pb::IMessage.Descriptor {
2816  get { return Descriptor; }
2817  }
2818 
2819  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2820  public ReservoirConstraintProto() {
2821  OnConstruction();
2822  }
2823 
2824  partial void OnConstruction();
2825 
2826  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2827  public ReservoirConstraintProto(ReservoirConstraintProto other) : this() {
2828  minLevel_ = other.minLevel_;
2829  maxLevel_ = other.maxLevel_;
2830  times_ = other.times_.Clone();
2831  demands_ = other.demands_.Clone();
2832  actives_ = other.actives_.Clone();
2833  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2834  }
2835 
2836  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2837  public ReservoirConstraintProto Clone() {
2838  return new ReservoirConstraintProto(this);
2839  }
2840 
2842  public const int MinLevelFieldNumber = 1;
2843  private long minLevel_;
2844  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2845  public long MinLevel {
2846  get { return minLevel_; }
2847  set {
2848  minLevel_ = value;
2849  }
2850  }
2851 
2853  public const int MaxLevelFieldNumber = 2;
2854  private long maxLevel_;
2855  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2856  public long MaxLevel {
2857  get { return maxLevel_; }
2858  set {
2859  maxLevel_ = value;
2860  }
2861  }
2862 
2864  public const int TimesFieldNumber = 3;
2865  private static readonly pb::FieldCodec<int> _repeated_times_codec
2866  = pb::FieldCodec.ForInt32(26);
2867  private readonly pbc::RepeatedField<int> times_ = new pbc::RepeatedField<int>();
2871  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2872  public pbc::RepeatedField<int> Times {
2873  get { return times_; }
2874  }
2875 
2877  public const int DemandsFieldNumber = 4;
2878  private static readonly pb::FieldCodec<long> _repeated_demands_codec
2879  = pb::FieldCodec.ForInt64(34);
2880  private readonly pbc::RepeatedField<long> demands_ = new pbc::RepeatedField<long>();
2884  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2885  public pbc::RepeatedField<long> Demands {
2886  get { return demands_; }
2887  }
2888 
2890  public const int ActivesFieldNumber = 5;
2891  private static readonly pb::FieldCodec<int> _repeated_actives_codec
2892  = pb::FieldCodec.ForInt32(42);
2893  private readonly pbc::RepeatedField<int> actives_ = new pbc::RepeatedField<int>();
2897  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2898  public pbc::RepeatedField<int> Actives {
2899  get { return actives_; }
2900  }
2901 
2902  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2903  public override bool Equals(object other) {
2904  return Equals(other as ReservoirConstraintProto);
2905  }
2906 
2907  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2908  public bool Equals(ReservoirConstraintProto other) {
2909  if (ReferenceEquals(other, null)) {
2910  return false;
2911  }
2912  if (ReferenceEquals(other, this)) {
2913  return true;
2914  }
2915  if (MinLevel != other.MinLevel) return false;
2916  if (MaxLevel != other.MaxLevel) return false;
2917  if(!times_.Equals(other.times_)) return false;
2918  if(!demands_.Equals(other.demands_)) return false;
2919  if(!actives_.Equals(other.actives_)) return false;
2920  return Equals(_unknownFields, other._unknownFields);
2921  }
2922 
2923  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2924  public override int GetHashCode() {
2925  int hash = 1;
2926  if (MinLevel != 0L) hash ^= MinLevel.GetHashCode();
2927  if (MaxLevel != 0L) hash ^= MaxLevel.GetHashCode();
2928  hash ^= times_.GetHashCode();
2929  hash ^= demands_.GetHashCode();
2930  hash ^= actives_.GetHashCode();
2931  if (_unknownFields != null) {
2932  hash ^= _unknownFields.GetHashCode();
2933  }
2934  return hash;
2935  }
2936 
2937  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2938  public override string ToString() {
2939  return pb::JsonFormatter.ToDiagnosticString(this);
2940  }
2941 
2942  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2943  public void WriteTo(pb::CodedOutputStream output) {
2944  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2945  output.WriteRawMessage(this);
2946  #else
2947  if (MinLevel != 0L) {
2948  output.WriteRawTag(8);
2949  output.WriteInt64(MinLevel);
2950  }
2951  if (MaxLevel != 0L) {
2952  output.WriteRawTag(16);
2953  output.WriteInt64(MaxLevel);
2954  }
2955  times_.WriteTo(output, _repeated_times_codec);
2956  demands_.WriteTo(output, _repeated_demands_codec);
2957  actives_.WriteTo(output, _repeated_actives_codec);
2958  if (_unknownFields != null) {
2959  _unknownFields.WriteTo(output);
2960  }
2961  #endif
2962  }
2963 
2964  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2965  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2966  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2967  if (MinLevel != 0L) {
2968  output.WriteRawTag(8);
2969  output.WriteInt64(MinLevel);
2970  }
2971  if (MaxLevel != 0L) {
2972  output.WriteRawTag(16);
2973  output.WriteInt64(MaxLevel);
2974  }
2975  times_.WriteTo(ref output, _repeated_times_codec);
2976  demands_.WriteTo(ref output, _repeated_demands_codec);
2977  actives_.WriteTo(ref output, _repeated_actives_codec);
2978  if (_unknownFields != null) {
2979  _unknownFields.WriteTo(ref output);
2980  }
2981  }
2982  #endif
2983 
2984  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2985  public int CalculateSize() {
2986  int size = 0;
2987  if (MinLevel != 0L) {
2988  size += 1 + pb::CodedOutputStream.ComputeInt64Size(MinLevel);
2989  }
2990  if (MaxLevel != 0L) {
2991  size += 1 + pb::CodedOutputStream.ComputeInt64Size(MaxLevel);
2992  }
2993  size += times_.CalculateSize(_repeated_times_codec);
2994  size += demands_.CalculateSize(_repeated_demands_codec);
2995  size += actives_.CalculateSize(_repeated_actives_codec);
2996  if (_unknownFields != null) {
2997  size += _unknownFields.CalculateSize();
2998  }
2999  return size;
3000  }
3001 
3002  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3003  public void MergeFrom(ReservoirConstraintProto other) {
3004  if (other == null) {
3005  return;
3006  }
3007  if (other.MinLevel != 0L) {
3008  MinLevel = other.MinLevel;
3009  }
3010  if (other.MaxLevel != 0L) {
3011  MaxLevel = other.MaxLevel;
3012  }
3013  times_.Add(other.times_);
3014  demands_.Add(other.demands_);
3015  actives_.Add(other.actives_);
3016  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3017  }
3018 
3019  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3020  public void MergeFrom(pb::CodedInputStream input) {
3021  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3022  input.ReadRawMessage(this);
3023  #else
3024  uint tag;
3025  while ((tag = input.ReadTag()) != 0) {
3026  switch(tag) {
3027  default:
3028  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3029  break;
3030  case 8: {
3031  MinLevel = input.ReadInt64();
3032  break;
3033  }
3034  case 16: {
3035  MaxLevel = input.ReadInt64();
3036  break;
3037  }
3038  case 26:
3039  case 24: {
3040  times_.AddEntriesFrom(input, _repeated_times_codec);
3041  break;
3042  }
3043  case 34:
3044  case 32: {
3045  demands_.AddEntriesFrom(input, _repeated_demands_codec);
3046  break;
3047  }
3048  case 42:
3049  case 40: {
3050  actives_.AddEntriesFrom(input, _repeated_actives_codec);
3051  break;
3052  }
3053  }
3054  }
3055  #endif
3056  }
3057 
3058  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3059  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3060  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3061  uint tag;
3062  while ((tag = input.ReadTag()) != 0) {
3063  switch(tag) {
3064  default:
3065  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3066  break;
3067  case 8: {
3068  MinLevel = input.ReadInt64();
3069  break;
3070  }
3071  case 16: {
3072  MaxLevel = input.ReadInt64();
3073  break;
3074  }
3075  case 26:
3076  case 24: {
3077  times_.AddEntriesFrom(ref input, _repeated_times_codec);
3078  break;
3079  }
3080  case 34:
3081  case 32: {
3082  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
3083  break;
3084  }
3085  case 42:
3086  case 40: {
3087  actives_.AddEntriesFrom(ref input, _repeated_actives_codec);
3088  break;
3089  }
3090  }
3091  }
3092  }
3093  #endif
3094 
3095  }
3096 
3108  public sealed partial class CircuitConstraintProto : pb::IMessage<CircuitConstraintProto>
3109  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3110  , pb::IBufferMessage
3111  #endif
3112  {
3113  private static readonly pb::MessageParser<CircuitConstraintProto> _parser = new pb::MessageParser<CircuitConstraintProto>(() => new CircuitConstraintProto());
3114  private pb::UnknownFieldSet _unknownFields;
3115  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3116  public static pb::MessageParser<CircuitConstraintProto> Parser { get { return _parser; } }
3117 
3118  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3119  public static pbr::MessageDescriptor Descriptor {
3120  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[13]; }
3121  }
3122 
3123  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3124  pbr::MessageDescriptor pb::IMessage.Descriptor {
3125  get { return Descriptor; }
3126  }
3127 
3128  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3129  public CircuitConstraintProto() {
3130  OnConstruction();
3131  }
3132 
3133  partial void OnConstruction();
3134 
3135  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3136  public CircuitConstraintProto(CircuitConstraintProto other) : this() {
3137  tails_ = other.tails_.Clone();
3138  heads_ = other.heads_.Clone();
3139  literals_ = other.literals_.Clone();
3140  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3141  }
3142 
3143  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3144  public CircuitConstraintProto Clone() {
3145  return new CircuitConstraintProto(this);
3146  }
3147 
3149  public const int TailsFieldNumber = 3;
3150  private static readonly pb::FieldCodec<int> _repeated_tails_codec
3151  = pb::FieldCodec.ForInt32(26);
3152  private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
3153  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3154  public pbc::RepeatedField<int> Tails {
3155  get { return tails_; }
3156  }
3157 
3159  public const int HeadsFieldNumber = 4;
3160  private static readonly pb::FieldCodec<int> _repeated_heads_codec
3161  = pb::FieldCodec.ForInt32(34);
3162  private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
3163  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3164  public pbc::RepeatedField<int> Heads {
3165  get { return heads_; }
3166  }
3167 
3169  public const int LiteralsFieldNumber = 5;
3170  private static readonly pb::FieldCodec<int> _repeated_literals_codec
3171  = pb::FieldCodec.ForInt32(42);
3172  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
3173  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3174  public pbc::RepeatedField<int> Literals {
3175  get { return literals_; }
3176  }
3177 
3178  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3179  public override bool Equals(object other) {
3180  return Equals(other as CircuitConstraintProto);
3181  }
3182 
3183  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3184  public bool Equals(CircuitConstraintProto other) {
3185  if (ReferenceEquals(other, null)) {
3186  return false;
3187  }
3188  if (ReferenceEquals(other, this)) {
3189  return true;
3190  }
3191  if(!tails_.Equals(other.tails_)) return false;
3192  if(!heads_.Equals(other.heads_)) return false;
3193  if(!literals_.Equals(other.literals_)) return false;
3194  return Equals(_unknownFields, other._unknownFields);
3195  }
3196 
3197  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3198  public override int GetHashCode() {
3199  int hash = 1;
3200  hash ^= tails_.GetHashCode();
3201  hash ^= heads_.GetHashCode();
3202  hash ^= literals_.GetHashCode();
3203  if (_unknownFields != null) {
3204  hash ^= _unknownFields.GetHashCode();
3205  }
3206  return hash;
3207  }
3208 
3209  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3210  public override string ToString() {
3211  return pb::JsonFormatter.ToDiagnosticString(this);
3212  }
3213 
3214  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3215  public void WriteTo(pb::CodedOutputStream output) {
3216  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3217  output.WriteRawMessage(this);
3218  #else
3219  tails_.WriteTo(output, _repeated_tails_codec);
3220  heads_.WriteTo(output, _repeated_heads_codec);
3221  literals_.WriteTo(output, _repeated_literals_codec);
3222  if (_unknownFields != null) {
3223  _unknownFields.WriteTo(output);
3224  }
3225  #endif
3226  }
3227 
3228  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3229  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3230  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3231  tails_.WriteTo(ref output, _repeated_tails_codec);
3232  heads_.WriteTo(ref output, _repeated_heads_codec);
3233  literals_.WriteTo(ref output, _repeated_literals_codec);
3234  if (_unknownFields != null) {
3235  _unknownFields.WriteTo(ref output);
3236  }
3237  }
3238  #endif
3239 
3240  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3241  public int CalculateSize() {
3242  int size = 0;
3243  size += tails_.CalculateSize(_repeated_tails_codec);
3244  size += heads_.CalculateSize(_repeated_heads_codec);
3245  size += literals_.CalculateSize(_repeated_literals_codec);
3246  if (_unknownFields != null) {
3247  size += _unknownFields.CalculateSize();
3248  }
3249  return size;
3250  }
3251 
3252  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3253  public void MergeFrom(CircuitConstraintProto other) {
3254  if (other == null) {
3255  return;
3256  }
3257  tails_.Add(other.tails_);
3258  heads_.Add(other.heads_);
3259  literals_.Add(other.literals_);
3260  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3261  }
3262 
3263  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3264  public void MergeFrom(pb::CodedInputStream input) {
3265  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3266  input.ReadRawMessage(this);
3267  #else
3268  uint tag;
3269  while ((tag = input.ReadTag()) != 0) {
3270  switch(tag) {
3271  default:
3272  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3273  break;
3274  case 26:
3275  case 24: {
3276  tails_.AddEntriesFrom(input, _repeated_tails_codec);
3277  break;
3278  }
3279  case 34:
3280  case 32: {
3281  heads_.AddEntriesFrom(input, _repeated_heads_codec);
3282  break;
3283  }
3284  case 42:
3285  case 40: {
3286  literals_.AddEntriesFrom(input, _repeated_literals_codec);
3287  break;
3288  }
3289  }
3290  }
3291  #endif
3292  }
3293 
3294  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3295  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3296  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3297  uint tag;
3298  while ((tag = input.ReadTag()) != 0) {
3299  switch(tag) {
3300  default:
3301  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3302  break;
3303  case 26:
3304  case 24: {
3305  tails_.AddEntriesFrom(ref input, _repeated_tails_codec);
3306  break;
3307  }
3308  case 34:
3309  case 32: {
3310  heads_.AddEntriesFrom(ref input, _repeated_heads_codec);
3311  break;
3312  }
3313  case 42:
3314  case 40: {
3315  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
3316  break;
3317  }
3318  }
3319  }
3320  }
3321  #endif
3322 
3323  }
3324 
3342  public sealed partial class RoutesConstraintProto : pb::IMessage<RoutesConstraintProto>
3343  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3344  , pb::IBufferMessage
3345  #endif
3346  {
3347  private static readonly pb::MessageParser<RoutesConstraintProto> _parser = new pb::MessageParser<RoutesConstraintProto>(() => new RoutesConstraintProto());
3348  private pb::UnknownFieldSet _unknownFields;
3349  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3350  public static pb::MessageParser<RoutesConstraintProto> Parser { get { return _parser; } }
3351 
3352  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3353  public static pbr::MessageDescriptor Descriptor {
3354  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[14]; }
3355  }
3356 
3357  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3358  pbr::MessageDescriptor pb::IMessage.Descriptor {
3359  get { return Descriptor; }
3360  }
3361 
3362  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3363  public RoutesConstraintProto() {
3364  OnConstruction();
3365  }
3366 
3367  partial void OnConstruction();
3368 
3369  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3370  public RoutesConstraintProto(RoutesConstraintProto other) : this() {
3371  tails_ = other.tails_.Clone();
3372  heads_ = other.heads_.Clone();
3373  literals_ = other.literals_.Clone();
3374  demands_ = other.demands_.Clone();
3375  capacity_ = other.capacity_;
3376  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3377  }
3378 
3379  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3380  public RoutesConstraintProto Clone() {
3381  return new RoutesConstraintProto(this);
3382  }
3383 
3385  public const int TailsFieldNumber = 1;
3386  private static readonly pb::FieldCodec<int> _repeated_tails_codec
3387  = pb::FieldCodec.ForInt32(10);
3388  private readonly pbc::RepeatedField<int> tails_ = new pbc::RepeatedField<int>();
3389  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3390  public pbc::RepeatedField<int> Tails {
3391  get { return tails_; }
3392  }
3393 
3395  public const int HeadsFieldNumber = 2;
3396  private static readonly pb::FieldCodec<int> _repeated_heads_codec
3397  = pb::FieldCodec.ForInt32(18);
3398  private readonly pbc::RepeatedField<int> heads_ = new pbc::RepeatedField<int>();
3399  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3400  public pbc::RepeatedField<int> Heads {
3401  get { return heads_; }
3402  }
3403 
3405  public const int LiteralsFieldNumber = 3;
3406  private static readonly pb::FieldCodec<int> _repeated_literals_codec
3407  = pb::FieldCodec.ForInt32(26);
3408  private readonly pbc::RepeatedField<int> literals_ = new pbc::RepeatedField<int>();
3409  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3410  public pbc::RepeatedField<int> Literals {
3411  get { return literals_; }
3412  }
3413 
3415  public const int DemandsFieldNumber = 4;
3416  private static readonly pb::FieldCodec<int> _repeated_demands_codec
3417  = pb::FieldCodec.ForInt32(34);
3418  private readonly pbc::RepeatedField<int> demands_ = new pbc::RepeatedField<int>();
3424  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3425  public pbc::RepeatedField<int> Demands {
3426  get { return demands_; }
3427  }
3428 
3430  public const int CapacityFieldNumber = 5;
3431  private long capacity_;
3432  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3433  public long Capacity {
3434  get { return capacity_; }
3435  set {
3436  capacity_ = value;
3437  }
3438  }
3439 
3440  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3441  public override bool Equals(object other) {
3442  return Equals(other as RoutesConstraintProto);
3443  }
3444 
3445  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3446  public bool Equals(RoutesConstraintProto other) {
3447  if (ReferenceEquals(other, null)) {
3448  return false;
3449  }
3450  if (ReferenceEquals(other, this)) {
3451  return true;
3452  }
3453  if(!tails_.Equals(other.tails_)) return false;
3454  if(!heads_.Equals(other.heads_)) return false;
3455  if(!literals_.Equals(other.literals_)) return false;
3456  if(!demands_.Equals(other.demands_)) return false;
3457  if (Capacity != other.Capacity) return false;
3458  return Equals(_unknownFields, other._unknownFields);
3459  }
3460 
3461  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3462  public override int GetHashCode() {
3463  int hash = 1;
3464  hash ^= tails_.GetHashCode();
3465  hash ^= heads_.GetHashCode();
3466  hash ^= literals_.GetHashCode();
3467  hash ^= demands_.GetHashCode();
3468  if (Capacity != 0L) hash ^= Capacity.GetHashCode();
3469  if (_unknownFields != null) {
3470  hash ^= _unknownFields.GetHashCode();
3471  }
3472  return hash;
3473  }
3474 
3475  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3476  public override string ToString() {
3477  return pb::JsonFormatter.ToDiagnosticString(this);
3478  }
3479 
3480  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3481  public void WriteTo(pb::CodedOutputStream output) {
3482  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3483  output.WriteRawMessage(this);
3484  #else
3485  tails_.WriteTo(output, _repeated_tails_codec);
3486  heads_.WriteTo(output, _repeated_heads_codec);
3487  literals_.WriteTo(output, _repeated_literals_codec);
3488  demands_.WriteTo(output, _repeated_demands_codec);
3489  if (Capacity != 0L) {
3490  output.WriteRawTag(40);
3491  output.WriteInt64(Capacity);
3492  }
3493  if (_unknownFields != null) {
3494  _unknownFields.WriteTo(output);
3495  }
3496  #endif
3497  }
3498 
3499  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3500  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3501  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3502  tails_.WriteTo(ref output, _repeated_tails_codec);
3503  heads_.WriteTo(ref output, _repeated_heads_codec);
3504  literals_.WriteTo(ref output, _repeated_literals_codec);
3505  demands_.WriteTo(ref output, _repeated_demands_codec);
3506  if (Capacity != 0L) {
3507  output.WriteRawTag(40);
3508  output.WriteInt64(Capacity);
3509  }
3510  if (_unknownFields != null) {
3511  _unknownFields.WriteTo(ref output);
3512  }
3513  }
3514  #endif
3515 
3516  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3517  public int CalculateSize() {
3518  int size = 0;
3519  size += tails_.CalculateSize(_repeated_tails_codec);
3520  size += heads_.CalculateSize(_repeated_heads_codec);
3521  size += literals_.CalculateSize(_repeated_literals_codec);
3522  size += demands_.CalculateSize(_repeated_demands_codec);
3523  if (Capacity != 0L) {
3524  size += 1 + pb::CodedOutputStream.ComputeInt64Size(Capacity);
3525  }
3526  if (_unknownFields != null) {
3527  size += _unknownFields.CalculateSize();
3528  }
3529  return size;
3530  }
3531 
3532  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3533  public void MergeFrom(RoutesConstraintProto other) {
3534  if (other == null) {
3535  return;
3536  }
3537  tails_.Add(other.tails_);
3538  heads_.Add(other.heads_);
3539  literals_.Add(other.literals_);
3540  demands_.Add(other.demands_);
3541  if (other.Capacity != 0L) {
3542  Capacity = other.Capacity;
3543  }
3544  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3545  }
3546 
3547  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3548  public void MergeFrom(pb::CodedInputStream input) {
3549  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3550  input.ReadRawMessage(this);
3551  #else
3552  uint tag;
3553  while ((tag = input.ReadTag()) != 0) {
3554  switch(tag) {
3555  default:
3556  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3557  break;
3558  case 10:
3559  case 8: {
3560  tails_.AddEntriesFrom(input, _repeated_tails_codec);
3561  break;
3562  }
3563  case 18:
3564  case 16: {
3565  heads_.AddEntriesFrom(input, _repeated_heads_codec);
3566  break;
3567  }
3568  case 26:
3569  case 24: {
3570  literals_.AddEntriesFrom(input, _repeated_literals_codec);
3571  break;
3572  }
3573  case 34:
3574  case 32: {
3575  demands_.AddEntriesFrom(input, _repeated_demands_codec);
3576  break;
3577  }
3578  case 40: {
3579  Capacity = input.ReadInt64();
3580  break;
3581  }
3582  }
3583  }
3584  #endif
3585  }
3586 
3587  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3588  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3589  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3590  uint tag;
3591  while ((tag = input.ReadTag()) != 0) {
3592  switch(tag) {
3593  default:
3594  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3595  break;
3596  case 10:
3597  case 8: {
3598  tails_.AddEntriesFrom(ref input, _repeated_tails_codec);
3599  break;
3600  }
3601  case 18:
3602  case 16: {
3603  heads_.AddEntriesFrom(ref input, _repeated_heads_codec);
3604  break;
3605  }
3606  case 26:
3607  case 24: {
3608  literals_.AddEntriesFrom(ref input, _repeated_literals_codec);
3609  break;
3610  }
3611  case 34:
3612  case 32: {
3613  demands_.AddEntriesFrom(ref input, _repeated_demands_codec);
3614  break;
3615  }
3616  case 40: {
3617  Capacity = input.ReadInt64();
3618  break;
3619  }
3620  }
3621  }
3622  }
3623  #endif
3624 
3625  }
3626 
3632  public sealed partial class CircuitCoveringConstraintProto : pb::IMessage<CircuitCoveringConstraintProto>
3633  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3634  , pb::IBufferMessage
3635  #endif
3636  {
3637  private static readonly pb::MessageParser<CircuitCoveringConstraintProto> _parser = new pb::MessageParser<CircuitCoveringConstraintProto>(() => new CircuitCoveringConstraintProto());
3638  private pb::UnknownFieldSet _unknownFields;
3639  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3640  public static pb::MessageParser<CircuitCoveringConstraintProto> Parser { get { return _parser; } }
3641 
3642  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3643  public static pbr::MessageDescriptor Descriptor {
3644  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[15]; }
3645  }
3646 
3647  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3648  pbr::MessageDescriptor pb::IMessage.Descriptor {
3649  get { return Descriptor; }
3650  }
3651 
3652  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3653  public CircuitCoveringConstraintProto() {
3654  OnConstruction();
3655  }
3656 
3657  partial void OnConstruction();
3658 
3659  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3660  public CircuitCoveringConstraintProto(CircuitCoveringConstraintProto other) : this() {
3661  nexts_ = other.nexts_.Clone();
3662  distinguishedNodes_ = other.distinguishedNodes_.Clone();
3663  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3664  }
3665 
3666  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3667  public CircuitCoveringConstraintProto Clone() {
3668  return new CircuitCoveringConstraintProto(this);
3669  }
3670 
3672  public const int NextsFieldNumber = 1;
3673  private static readonly pb::FieldCodec<int> _repeated_nexts_codec
3674  = pb::FieldCodec.ForInt32(10);
3675  private readonly pbc::RepeatedField<int> nexts_ = new pbc::RepeatedField<int>();
3676  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3677  public pbc::RepeatedField<int> Nexts {
3678  get { return nexts_; }
3679  }
3680 
3682  public const int DistinguishedNodesFieldNumber = 2;
3683  private static readonly pb::FieldCodec<long> _repeated_distinguishedNodes_codec
3684  = pb::FieldCodec.ForInt64(18);
3685  private readonly pbc::RepeatedField<long> distinguishedNodes_ = new pbc::RepeatedField<long>();
3686  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3687  public pbc::RepeatedField<long> DistinguishedNodes {
3688  get { return distinguishedNodes_; }
3689  }
3690 
3691  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3692  public override bool Equals(object other) {
3693  return Equals(other as CircuitCoveringConstraintProto);
3694  }
3695 
3696  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3697  public bool Equals(CircuitCoveringConstraintProto other) {
3698  if (ReferenceEquals(other, null)) {
3699  return false;
3700  }
3701  if (ReferenceEquals(other, this)) {
3702  return true;
3703  }
3704  if(!nexts_.Equals(other.nexts_)) return false;
3705  if(!distinguishedNodes_.Equals(other.distinguishedNodes_)) return false;
3706  return Equals(_unknownFields, other._unknownFields);
3707  }
3708 
3709  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3710  public override int GetHashCode() {
3711  int hash = 1;
3712  hash ^= nexts_.GetHashCode();
3713  hash ^= distinguishedNodes_.GetHashCode();
3714  if (_unknownFields != null) {
3715  hash ^= _unknownFields.GetHashCode();
3716  }
3717  return hash;
3718  }
3719 
3720  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3721  public override string ToString() {
3722  return pb::JsonFormatter.ToDiagnosticString(this);
3723  }
3724 
3725  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3726  public void WriteTo(pb::CodedOutputStream output) {
3727  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3728  output.WriteRawMessage(this);
3729  #else
3730  nexts_.WriteTo(output, _repeated_nexts_codec);
3731  distinguishedNodes_.WriteTo(output, _repeated_distinguishedNodes_codec);
3732  if (_unknownFields != null) {
3733  _unknownFields.WriteTo(output);
3734  }
3735  #endif
3736  }
3737 
3738  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3739  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3740  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3741  nexts_.WriteTo(ref output, _repeated_nexts_codec);
3742  distinguishedNodes_.WriteTo(ref output, _repeated_distinguishedNodes_codec);
3743  if (_unknownFields != null) {
3744  _unknownFields.WriteTo(ref output);
3745  }
3746  }
3747  #endif
3748 
3749  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3750  public int CalculateSize() {
3751  int size = 0;
3752  size += nexts_.CalculateSize(_repeated_nexts_codec);
3753  size += distinguishedNodes_.CalculateSize(_repeated_distinguishedNodes_codec);
3754  if (_unknownFields != null) {
3755  size += _unknownFields.CalculateSize();
3756  }
3757  return size;
3758  }
3759 
3760  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3761  public void MergeFrom(CircuitCoveringConstraintProto other) {
3762  if (other == null) {
3763  return;
3764  }
3765  nexts_.Add(other.nexts_);
3766  distinguishedNodes_.Add(other.distinguishedNodes_);
3767  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3768  }
3769 
3770  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3771  public void MergeFrom(pb::CodedInputStream input) {
3772  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3773  input.ReadRawMessage(this);
3774  #else
3775  uint tag;
3776  while ((tag = input.ReadTag()) != 0) {
3777  switch(tag) {
3778  default:
3779  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3780  break;
3781  case 10:
3782  case 8: {
3783  nexts_.AddEntriesFrom(input, _repeated_nexts_codec);
3784  break;
3785  }
3786  case 18:
3787  case 16: {
3788  distinguishedNodes_.AddEntriesFrom(input, _repeated_distinguishedNodes_codec);
3789  break;
3790  }
3791  }
3792  }
3793  #endif
3794  }
3795 
3796  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3797  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3798  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3799  uint tag;
3800  while ((tag = input.ReadTag()) != 0) {
3801  switch(tag) {
3802  default:
3803  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3804  break;
3805  case 10:
3806  case 8: {
3807  nexts_.AddEntriesFrom(ref input, _repeated_nexts_codec);
3808  break;
3809  }
3810  case 18:
3811  case 16: {
3812  distinguishedNodes_.AddEntriesFrom(ref input, _repeated_distinguishedNodes_codec);
3813  break;
3814  }
3815  }
3816  }
3817  }
3818  #endif
3819 
3820  }
3821 
3827  public sealed partial class TableConstraintProto : pb::IMessage<TableConstraintProto>
3828  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3829  , pb::IBufferMessage
3830  #endif
3831  {
3832  private static readonly pb::MessageParser<TableConstraintProto> _parser = new pb::MessageParser<TableConstraintProto>(() => new TableConstraintProto());
3833  private pb::UnknownFieldSet _unknownFields;
3834  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3835  public static pb::MessageParser<TableConstraintProto> Parser { get { return _parser; } }
3836 
3837  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3838  public static pbr::MessageDescriptor Descriptor {
3839  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[16]; }
3840  }
3841 
3842  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3843  pbr::MessageDescriptor pb::IMessage.Descriptor {
3844  get { return Descriptor; }
3845  }
3846 
3847  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3848  public TableConstraintProto() {
3849  OnConstruction();
3850  }
3851 
3852  partial void OnConstruction();
3853 
3854  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3855  public TableConstraintProto(TableConstraintProto other) : this() {
3856  vars_ = other.vars_.Clone();
3857  values_ = other.values_.Clone();
3858  negated_ = other.negated_;
3859  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3860  }
3861 
3862  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3863  public TableConstraintProto Clone() {
3864  return new TableConstraintProto(this);
3865  }
3866 
3868  public const int VarsFieldNumber = 1;
3869  private static readonly pb::FieldCodec<int> _repeated_vars_codec
3870  = pb::FieldCodec.ForInt32(10);
3871  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
3872  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3873  public pbc::RepeatedField<int> Vars {
3874  get { return vars_; }
3875  }
3876 
3878  public const int ValuesFieldNumber = 2;
3879  private static readonly pb::FieldCodec<long> _repeated_values_codec
3880  = pb::FieldCodec.ForInt64(18);
3881  private readonly pbc::RepeatedField<long> values_ = new pbc::RepeatedField<long>();
3882  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3883  public pbc::RepeatedField<long> Values {
3884  get { return values_; }
3885  }
3886 
3888  public const int NegatedFieldNumber = 3;
3889  private bool negated_;
3894  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3895  public bool Negated {
3896  get { return negated_; }
3897  set {
3898  negated_ = value;
3899  }
3900  }
3901 
3902  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3903  public override bool Equals(object other) {
3904  return Equals(other as TableConstraintProto);
3905  }
3906 
3907  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3908  public bool Equals(TableConstraintProto other) {
3909  if (ReferenceEquals(other, null)) {
3910  return false;
3911  }
3912  if (ReferenceEquals(other, this)) {
3913  return true;
3914  }
3915  if(!vars_.Equals(other.vars_)) return false;
3916  if(!values_.Equals(other.values_)) return false;
3917  if (Negated != other.Negated) return false;
3918  return Equals(_unknownFields, other._unknownFields);
3919  }
3920 
3921  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3922  public override int GetHashCode() {
3923  int hash = 1;
3924  hash ^= vars_.GetHashCode();
3925  hash ^= values_.GetHashCode();
3926  if (Negated != false) hash ^= Negated.GetHashCode();
3927  if (_unknownFields != null) {
3928  hash ^= _unknownFields.GetHashCode();
3929  }
3930  return hash;
3931  }
3932 
3933  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3934  public override string ToString() {
3935  return pb::JsonFormatter.ToDiagnosticString(this);
3936  }
3937 
3938  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3939  public void WriteTo(pb::CodedOutputStream output) {
3940  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3941  output.WriteRawMessage(this);
3942  #else
3943  vars_.WriteTo(output, _repeated_vars_codec);
3944  values_.WriteTo(output, _repeated_values_codec);
3945  if (Negated != false) {
3946  output.WriteRawTag(24);
3947  output.WriteBool(Negated);
3948  }
3949  if (_unknownFields != null) {
3950  _unknownFields.WriteTo(output);
3951  }
3952  #endif
3953  }
3954 
3955  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3956  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3957  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
3958  vars_.WriteTo(ref output, _repeated_vars_codec);
3959  values_.WriteTo(ref output, _repeated_values_codec);
3960  if (Negated != false) {
3961  output.WriteRawTag(24);
3962  output.WriteBool(Negated);
3963  }
3964  if (_unknownFields != null) {
3965  _unknownFields.WriteTo(ref output);
3966  }
3967  }
3968  #endif
3969 
3970  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3971  public int CalculateSize() {
3972  int size = 0;
3973  size += vars_.CalculateSize(_repeated_vars_codec);
3974  size += values_.CalculateSize(_repeated_values_codec);
3975  if (Negated != false) {
3976  size += 1 + 1;
3977  }
3978  if (_unknownFields != null) {
3979  size += _unknownFields.CalculateSize();
3980  }
3981  return size;
3982  }
3983 
3984  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3985  public void MergeFrom(TableConstraintProto other) {
3986  if (other == null) {
3987  return;
3988  }
3989  vars_.Add(other.vars_);
3990  values_.Add(other.values_);
3991  if (other.Negated != false) {
3992  Negated = other.Negated;
3993  }
3994  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3995  }
3996 
3997  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3998  public void MergeFrom(pb::CodedInputStream input) {
3999  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4000  input.ReadRawMessage(this);
4001  #else
4002  uint tag;
4003  while ((tag = input.ReadTag()) != 0) {
4004  switch(tag) {
4005  default:
4006  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4007  break;
4008  case 10:
4009  case 8: {
4010  vars_.AddEntriesFrom(input, _repeated_vars_codec);
4011  break;
4012  }
4013  case 18:
4014  case 16: {
4015  values_.AddEntriesFrom(input, _repeated_values_codec);
4016  break;
4017  }
4018  case 24: {
4019  Negated = input.ReadBool();
4020  break;
4021  }
4022  }
4023  }
4024  #endif
4025  }
4026 
4027  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4028  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4029  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4030  uint tag;
4031  while ((tag = input.ReadTag()) != 0) {
4032  switch(tag) {
4033  default:
4034  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4035  break;
4036  case 10:
4037  case 8: {
4038  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
4039  break;
4040  }
4041  case 18:
4042  case 16: {
4043  values_.AddEntriesFrom(ref input, _repeated_values_codec);
4044  break;
4045  }
4046  case 24: {
4047  Negated = input.ReadBool();
4048  break;
4049  }
4050  }
4051  }
4052  }
4053  #endif
4054 
4055  }
4056 
4061  public sealed partial class InverseConstraintProto : pb::IMessage<InverseConstraintProto>
4062  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4063  , pb::IBufferMessage
4064  #endif
4065  {
4066  private static readonly pb::MessageParser<InverseConstraintProto> _parser = new pb::MessageParser<InverseConstraintProto>(() => new InverseConstraintProto());
4067  private pb::UnknownFieldSet _unknownFields;
4068  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4069  public static pb::MessageParser<InverseConstraintProto> Parser { get { return _parser; } }
4070 
4071  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4072  public static pbr::MessageDescriptor Descriptor {
4073  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[17]; }
4074  }
4075 
4076  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4077  pbr::MessageDescriptor pb::IMessage.Descriptor {
4078  get { return Descriptor; }
4079  }
4080 
4081  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4082  public InverseConstraintProto() {
4083  OnConstruction();
4084  }
4085 
4086  partial void OnConstruction();
4087 
4088  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4089  public InverseConstraintProto(InverseConstraintProto other) : this() {
4090  fDirect_ = other.fDirect_.Clone();
4091  fInverse_ = other.fInverse_.Clone();
4092  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4093  }
4094 
4095  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4096  public InverseConstraintProto Clone() {
4097  return new InverseConstraintProto(this);
4098  }
4099 
4101  public const int FDirectFieldNumber = 1;
4102  private static readonly pb::FieldCodec<int> _repeated_fDirect_codec
4103  = pb::FieldCodec.ForInt32(10);
4104  private readonly pbc::RepeatedField<int> fDirect_ = new pbc::RepeatedField<int>();
4105  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4106  public pbc::RepeatedField<int> FDirect {
4107  get { return fDirect_; }
4108  }
4109 
4111  public const int FInverseFieldNumber = 2;
4112  private static readonly pb::FieldCodec<int> _repeated_fInverse_codec
4113  = pb::FieldCodec.ForInt32(18);
4114  private readonly pbc::RepeatedField<int> fInverse_ = new pbc::RepeatedField<int>();
4115  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4116  public pbc::RepeatedField<int> FInverse {
4117  get { return fInverse_; }
4118  }
4119 
4120  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4121  public override bool Equals(object other) {
4122  return Equals(other as InverseConstraintProto);
4123  }
4124 
4125  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4126  public bool Equals(InverseConstraintProto other) {
4127  if (ReferenceEquals(other, null)) {
4128  return false;
4129  }
4130  if (ReferenceEquals(other, this)) {
4131  return true;
4132  }
4133  if(!fDirect_.Equals(other.fDirect_)) return false;
4134  if(!fInverse_.Equals(other.fInverse_)) return false;
4135  return Equals(_unknownFields, other._unknownFields);
4136  }
4137 
4138  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4139  public override int GetHashCode() {
4140  int hash = 1;
4141  hash ^= fDirect_.GetHashCode();
4142  hash ^= fInverse_.GetHashCode();
4143  if (_unknownFields != null) {
4144  hash ^= _unknownFields.GetHashCode();
4145  }
4146  return hash;
4147  }
4148 
4149  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4150  public override string ToString() {
4151  return pb::JsonFormatter.ToDiagnosticString(this);
4152  }
4153 
4154  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4155  public void WriteTo(pb::CodedOutputStream output) {
4156  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4157  output.WriteRawMessage(this);
4158  #else
4159  fDirect_.WriteTo(output, _repeated_fDirect_codec);
4160  fInverse_.WriteTo(output, _repeated_fInverse_codec);
4161  if (_unknownFields != null) {
4162  _unknownFields.WriteTo(output);
4163  }
4164  #endif
4165  }
4166 
4167  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4168  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4169  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
4170  fDirect_.WriteTo(ref output, _repeated_fDirect_codec);
4171  fInverse_.WriteTo(ref output, _repeated_fInverse_codec);
4172  if (_unknownFields != null) {
4173  _unknownFields.WriteTo(ref output);
4174  }
4175  }
4176  #endif
4177 
4178  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4179  public int CalculateSize() {
4180  int size = 0;
4181  size += fDirect_.CalculateSize(_repeated_fDirect_codec);
4182  size += fInverse_.CalculateSize(_repeated_fInverse_codec);
4183  if (_unknownFields != null) {
4184  size += _unknownFields.CalculateSize();
4185  }
4186  return size;
4187  }
4188 
4189  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4190  public void MergeFrom(InverseConstraintProto other) {
4191  if (other == null) {
4192  return;
4193  }
4194  fDirect_.Add(other.fDirect_);
4195  fInverse_.Add(other.fInverse_);
4196  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
4197  }
4198 
4199  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4200  public void MergeFrom(pb::CodedInputStream input) {
4201  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4202  input.ReadRawMessage(this);
4203  #else
4204  uint tag;
4205  while ((tag = input.ReadTag()) != 0) {
4206  switch(tag) {
4207  default:
4208  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4209  break;
4210  case 10:
4211  case 8: {
4212  fDirect_.AddEntriesFrom(input, _repeated_fDirect_codec);
4213  break;
4214  }
4215  case 18:
4216  case 16: {
4217  fInverse_.AddEntriesFrom(input, _repeated_fInverse_codec);
4218  break;
4219  }
4220  }
4221  }
4222  #endif
4223  }
4224 
4225  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4226  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4227  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4228  uint tag;
4229  while ((tag = input.ReadTag()) != 0) {
4230  switch(tag) {
4231  default:
4232  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4233  break;
4234  case 10:
4235  case 8: {
4236  fDirect_.AddEntriesFrom(ref input, _repeated_fDirect_codec);
4237  break;
4238  }
4239  case 18:
4240  case 16: {
4241  fInverse_.AddEntriesFrom(ref input, _repeated_fInverse_codec);
4242  break;
4243  }
4244  }
4245  }
4246  }
4247  #endif
4248 
4249  }
4250 
4255  public sealed partial class AutomatonConstraintProto : pb::IMessage<AutomatonConstraintProto>
4256  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4257  , pb::IBufferMessage
4258  #endif
4259  {
4260  private static readonly pb::MessageParser<AutomatonConstraintProto> _parser = new pb::MessageParser<AutomatonConstraintProto>(() => new AutomatonConstraintProto());
4261  private pb::UnknownFieldSet _unknownFields;
4262  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4263  public static pb::MessageParser<AutomatonConstraintProto> Parser { get { return _parser; } }
4264 
4265  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4266  public static pbr::MessageDescriptor Descriptor {
4267  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[18]; }
4268  }
4269 
4270  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4271  pbr::MessageDescriptor pb::IMessage.Descriptor {
4272  get { return Descriptor; }
4273  }
4274 
4275  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4276  public AutomatonConstraintProto() {
4277  OnConstruction();
4278  }
4279 
4280  partial void OnConstruction();
4281 
4282  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4283  public AutomatonConstraintProto(AutomatonConstraintProto other) : this() {
4284  startingState_ = other.startingState_;
4285  finalStates_ = other.finalStates_.Clone();
4286  transitionTail_ = other.transitionTail_.Clone();
4287  transitionHead_ = other.transitionHead_.Clone();
4288  transitionLabel_ = other.transitionLabel_.Clone();
4289  vars_ = other.vars_.Clone();
4290  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4291  }
4292 
4293  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4294  public AutomatonConstraintProto Clone() {
4295  return new AutomatonConstraintProto(this);
4296  }
4297 
4299  public const int StartingStateFieldNumber = 2;
4300  private long startingState_;
4306  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4307  public long StartingState {
4308  get { return startingState_; }
4309  set {
4310  startingState_ = value;
4311  }
4312  }
4313 
4315  public const int FinalStatesFieldNumber = 3;
4316  private static readonly pb::FieldCodec<long> _repeated_finalStates_codec
4317  = pb::FieldCodec.ForInt64(26);
4318  private readonly pbc::RepeatedField<long> finalStates_ = new pbc::RepeatedField<long>();
4319  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4320  public pbc::RepeatedField<long> FinalStates {
4321  get { return finalStates_; }
4322  }
4323 
4325  public const int TransitionTailFieldNumber = 4;
4326  private static readonly pb::FieldCodec<long> _repeated_transitionTail_codec
4327  = pb::FieldCodec.ForInt64(34);
4328  private readonly pbc::RepeatedField<long> transitionTail_ = new pbc::RepeatedField<long>();
4334  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4335  public pbc::RepeatedField<long> TransitionTail {
4336  get { return transitionTail_; }
4337  }
4338 
4340  public const int TransitionHeadFieldNumber = 5;
4341  private static readonly pb::FieldCodec<long> _repeated_transitionHead_codec
4342  = pb::FieldCodec.ForInt64(42);
4343  private readonly pbc::RepeatedField<long> transitionHead_ = new pbc::RepeatedField<long>();
4344  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4345  public pbc::RepeatedField<long> TransitionHead {
4346  get { return transitionHead_; }
4347  }
4348 
4350  public const int TransitionLabelFieldNumber = 6;
4351  private static readonly pb::FieldCodec<long> _repeated_transitionLabel_codec
4352  = pb::FieldCodec.ForInt64(50);
4353  private readonly pbc::RepeatedField<long> transitionLabel_ = new pbc::RepeatedField<long>();
4354  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4355  public pbc::RepeatedField<long> TransitionLabel {
4356  get { return transitionLabel_; }
4357  }
4358 
4360  public const int VarsFieldNumber = 7;
4361  private static readonly pb::FieldCodec<int> _repeated_vars_codec
4362  = pb::FieldCodec.ForInt32(58);
4363  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
4368  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4369  public pbc::RepeatedField<int> Vars {
4370  get { return vars_; }
4371  }
4372 
4373  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4374  public override bool Equals(object other) {
4375  return Equals(other as AutomatonConstraintProto);
4376  }
4377 
4378  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4379  public bool Equals(AutomatonConstraintProto other) {
4380  if (ReferenceEquals(other, null)) {
4381  return false;
4382  }
4383  if (ReferenceEquals(other, this)) {
4384  return true;
4385  }
4386  if (StartingState != other.StartingState) return false;
4387  if(!finalStates_.Equals(other.finalStates_)) return false;
4388  if(!transitionTail_.Equals(other.transitionTail_)) return false;
4389  if(!transitionHead_.Equals(other.transitionHead_)) return false;
4390  if(!transitionLabel_.Equals(other.transitionLabel_)) return false;
4391  if(!vars_.Equals(other.vars_)) return false;
4392  return Equals(_unknownFields, other._unknownFields);
4393  }
4394 
4395  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4396  public override int GetHashCode() {
4397  int hash = 1;
4398  if (StartingState != 0L) hash ^= StartingState.GetHashCode();
4399  hash ^= finalStates_.GetHashCode();
4400  hash ^= transitionTail_.GetHashCode();
4401  hash ^= transitionHead_.GetHashCode();
4402  hash ^= transitionLabel_.GetHashCode();
4403  hash ^= vars_.GetHashCode();
4404  if (_unknownFields != null) {
4405  hash ^= _unknownFields.GetHashCode();
4406  }
4407  return hash;
4408  }
4409 
4410  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4411  public override string ToString() {
4412  return pb::JsonFormatter.ToDiagnosticString(this);
4413  }
4414 
4415  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4416  public void WriteTo(pb::CodedOutputStream output) {
4417  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4418  output.WriteRawMessage(this);
4419  #else
4420  if (StartingState != 0L) {
4421  output.WriteRawTag(16);
4422  output.WriteInt64(StartingState);
4423  }
4424  finalStates_.WriteTo(output, _repeated_finalStates_codec);
4425  transitionTail_.WriteTo(output, _repeated_transitionTail_codec);
4426  transitionHead_.WriteTo(output, _repeated_transitionHead_codec);
4427  transitionLabel_.WriteTo(output, _repeated_transitionLabel_codec);
4428  vars_.WriteTo(output, _repeated_vars_codec);
4429  if (_unknownFields != null) {
4430  _unknownFields.WriteTo(output);
4431  }
4432  #endif
4433  }
4434 
4435  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4436  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4437  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
4438  if (StartingState != 0L) {
4439  output.WriteRawTag(16);
4440  output.WriteInt64(StartingState);
4441  }
4442  finalStates_.WriteTo(ref output, _repeated_finalStates_codec);
4443  transitionTail_.WriteTo(ref output, _repeated_transitionTail_codec);
4444  transitionHead_.WriteTo(ref output, _repeated_transitionHead_codec);
4445  transitionLabel_.WriteTo(ref output, _repeated_transitionLabel_codec);
4446  vars_.WriteTo(ref output, _repeated_vars_codec);
4447  if (_unknownFields != null) {
4448  _unknownFields.WriteTo(ref output);
4449  }
4450  }
4451  #endif
4452 
4453  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4454  public int CalculateSize() {
4455  int size = 0;
4456  if (StartingState != 0L) {
4457  size += 1 + pb::CodedOutputStream.ComputeInt64Size(StartingState);
4458  }
4459  size += finalStates_.CalculateSize(_repeated_finalStates_codec);
4460  size += transitionTail_.CalculateSize(_repeated_transitionTail_codec);
4461  size += transitionHead_.CalculateSize(_repeated_transitionHead_codec);
4462  size += transitionLabel_.CalculateSize(_repeated_transitionLabel_codec);
4463  size += vars_.CalculateSize(_repeated_vars_codec);
4464  if (_unknownFields != null) {
4465  size += _unknownFields.CalculateSize();
4466  }
4467  return size;
4468  }
4469 
4470  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4471  public void MergeFrom(AutomatonConstraintProto other) {
4472  if (other == null) {
4473  return;
4474  }
4475  if (other.StartingState != 0L) {
4476  StartingState = other.StartingState;
4477  }
4478  finalStates_.Add(other.finalStates_);
4479  transitionTail_.Add(other.transitionTail_);
4480  transitionHead_.Add(other.transitionHead_);
4481  transitionLabel_.Add(other.transitionLabel_);
4482  vars_.Add(other.vars_);
4483  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
4484  }
4485 
4486  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4487  public void MergeFrom(pb::CodedInputStream input) {
4488  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4489  input.ReadRawMessage(this);
4490  #else
4491  uint tag;
4492  while ((tag = input.ReadTag()) != 0) {
4493  switch(tag) {
4494  default:
4495  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4496  break;
4497  case 16: {
4498  StartingState = input.ReadInt64();
4499  break;
4500  }
4501  case 26:
4502  case 24: {
4503  finalStates_.AddEntriesFrom(input, _repeated_finalStates_codec);
4504  break;
4505  }
4506  case 34:
4507  case 32: {
4508  transitionTail_.AddEntriesFrom(input, _repeated_transitionTail_codec);
4509  break;
4510  }
4511  case 42:
4512  case 40: {
4513  transitionHead_.AddEntriesFrom(input, _repeated_transitionHead_codec);
4514  break;
4515  }
4516  case 50:
4517  case 48: {
4518  transitionLabel_.AddEntriesFrom(input, _repeated_transitionLabel_codec);
4519  break;
4520  }
4521  case 58:
4522  case 56: {
4523  vars_.AddEntriesFrom(input, _repeated_vars_codec);
4524  break;
4525  }
4526  }
4527  }
4528  #endif
4529  }
4530 
4531  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4532  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4533  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
4534  uint tag;
4535  while ((tag = input.ReadTag()) != 0) {
4536  switch(tag) {
4537  default:
4538  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
4539  break;
4540  case 16: {
4541  StartingState = input.ReadInt64();
4542  break;
4543  }
4544  case 26:
4545  case 24: {
4546  finalStates_.AddEntriesFrom(ref input, _repeated_finalStates_codec);
4547  break;
4548  }
4549  case 34:
4550  case 32: {
4551  transitionTail_.AddEntriesFrom(ref input, _repeated_transitionTail_codec);
4552  break;
4553  }
4554  case 42:
4555  case 40: {
4556  transitionHead_.AddEntriesFrom(ref input, _repeated_transitionHead_codec);
4557  break;
4558  }
4559  case 50:
4560  case 48: {
4561  transitionLabel_.AddEntriesFrom(ref input, _repeated_transitionLabel_codec);
4562  break;
4563  }
4564  case 58:
4565  case 56: {
4566  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
4567  break;
4568  }
4569  }
4570  }
4571  }
4572  #endif
4573 
4574  }
4575 
4579  public sealed partial class ConstraintProto : pb::IMessage<ConstraintProto>
4580  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
4581  , pb::IBufferMessage
4582  #endif
4583  {
4584  private static readonly pb::MessageParser<ConstraintProto> _parser = new pb::MessageParser<ConstraintProto>(() => new ConstraintProto());
4585  private pb::UnknownFieldSet _unknownFields;
4586  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4587  public static pb::MessageParser<ConstraintProto> Parser { get { return _parser; } }
4588 
4589  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4590  public static pbr::MessageDescriptor Descriptor {
4591  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[19]; }
4592  }
4593 
4594  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4595  pbr::MessageDescriptor pb::IMessage.Descriptor {
4596  get { return Descriptor; }
4597  }
4598 
4599  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4600  public ConstraintProto() {
4601  OnConstruction();
4602  }
4603 
4604  partial void OnConstruction();
4605 
4606  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4607  public ConstraintProto(ConstraintProto other) : this() {
4608  name_ = other.name_;
4609  enforcementLiteral_ = other.enforcementLiteral_.Clone();
4610  switch (other.ConstraintCase) {
4611  case ConstraintOneofCase.BoolOr:
4612  BoolOr = other.BoolOr.Clone();
4613  break;
4614  case ConstraintOneofCase.BoolAnd:
4615  BoolAnd = other.BoolAnd.Clone();
4616  break;
4617  case ConstraintOneofCase.AtMostOne:
4618  AtMostOne = other.AtMostOne.Clone();
4619  break;
4620  case ConstraintOneofCase.BoolXor:
4621  BoolXor = other.BoolXor.Clone();
4622  break;
4623  case ConstraintOneofCase.IntDiv:
4624  IntDiv = other.IntDiv.Clone();
4625  break;
4626  case ConstraintOneofCase.IntMod:
4627  IntMod = other.IntMod.Clone();
4628  break;
4629  case ConstraintOneofCase.IntMax:
4630  IntMax = other.IntMax.Clone();
4631  break;
4632  case ConstraintOneofCase.LinMax:
4633  LinMax = other.LinMax.Clone();
4634  break;
4635  case ConstraintOneofCase.IntMin:
4636  IntMin = other.IntMin.Clone();
4637  break;
4638  case ConstraintOneofCase.LinMin:
4639  LinMin = other.LinMin.Clone();
4640  break;
4641  case ConstraintOneofCase.IntProd:
4642  IntProd = other.IntProd.Clone();
4643  break;
4644  case ConstraintOneofCase.Linear:
4645  Linear = other.Linear.Clone();
4646  break;
4647  case ConstraintOneofCase.AllDiff:
4648  AllDiff = other.AllDiff.Clone();
4649  break;
4650  case ConstraintOneofCase.Element:
4651  Element = other.Element.Clone();
4652  break;
4653  case ConstraintOneofCase.Circuit:
4654  Circuit = other.Circuit.Clone();
4655  break;
4656  case ConstraintOneofCase.Routes:
4657  Routes = other.Routes.Clone();
4658  break;
4659  case ConstraintOneofCase.CircuitCovering:
4660  CircuitCovering = other.CircuitCovering.Clone();
4661  break;
4662  case ConstraintOneofCase.Table:
4663  Table = other.Table.Clone();
4664  break;
4665  case ConstraintOneofCase.Automaton:
4666  Automaton = other.Automaton.Clone();
4667  break;
4668  case ConstraintOneofCase.Inverse:
4669  Inverse = other.Inverse.Clone();
4670  break;
4671  case ConstraintOneofCase.Reservoir:
4672  Reservoir = other.Reservoir.Clone();
4673  break;
4674  case ConstraintOneofCase.Interval:
4675  Interval = other.Interval.Clone();
4676  break;
4677  case ConstraintOneofCase.NoOverlap:
4678  NoOverlap = other.NoOverlap.Clone();
4679  break;
4680  case ConstraintOneofCase.NoOverlap2D:
4681  NoOverlap2D = other.NoOverlap2D.Clone();
4682  break;
4683  case ConstraintOneofCase.Cumulative:
4684  Cumulative = other.Cumulative.Clone();
4685  break;
4686  }
4687 
4688  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4689  }
4690 
4691  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4692  public ConstraintProto Clone() {
4693  return new ConstraintProto(this);
4694  }
4695 
4697  public const int NameFieldNumber = 1;
4698  private string name_ = "";
4702  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4703  public string Name {
4704  get { return name_; }
4705  set {
4706  name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
4707  }
4708  }
4709 
4711  public const int EnforcementLiteralFieldNumber = 2;
4712  private static readonly pb::FieldCodec<int> _repeated_enforcementLiteral_codec
4713  = pb::FieldCodec.ForInt32(18);
4714  private readonly pbc::RepeatedField<int> enforcementLiteral_ = new pbc::RepeatedField<int>();
4731  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4732  public pbc::RepeatedField<int> EnforcementLiteral {
4733  get { return enforcementLiteral_; }
4734  }
4735 
4737  public const int BoolOrFieldNumber = 3;
4741  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4742  public global::Google.OrTools.Sat.BoolArgumentProto BoolOr {
4743  get { return constraintCase_ == ConstraintOneofCase.BoolOr ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4744  set {
4745  constraint_ = value;
4746  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolOr;
4747  }
4748  }
4749 
4751  public const int BoolAndFieldNumber = 4;
4759  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4760  public global::Google.OrTools.Sat.BoolArgumentProto BoolAnd {
4761  get { return constraintCase_ == ConstraintOneofCase.BoolAnd ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4762  set {
4763  constraint_ = value;
4764  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolAnd;
4765  }
4766  }
4767 
4769  public const int AtMostOneFieldNumber = 26;
4777  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4778  public global::Google.OrTools.Sat.BoolArgumentProto AtMostOne {
4779  get { return constraintCase_ == ConstraintOneofCase.AtMostOne ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4780  set {
4781  constraint_ = value;
4782  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AtMostOne;
4783  }
4784  }
4785 
4787  public const int BoolXorFieldNumber = 5;
4791  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4792  public global::Google.OrTools.Sat.BoolArgumentProto BoolXor {
4793  get { return constraintCase_ == ConstraintOneofCase.BoolXor ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ : null; }
4794  set {
4795  constraint_ = value;
4796  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.BoolXor;
4797  }
4798  }
4799 
4801  public const int IntDivFieldNumber = 7;
4805  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4806  public global::Google.OrTools.Sat.IntegerArgumentProto IntDiv {
4807  get { return constraintCase_ == ConstraintOneofCase.IntDiv ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4808  set {
4809  constraint_ = value;
4810  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntDiv;
4811  }
4812  }
4813 
4815  public const int IntModFieldNumber = 8;
4819  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4820  public global::Google.OrTools.Sat.IntegerArgumentProto IntMod {
4821  get { return constraintCase_ == ConstraintOneofCase.IntMod ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4822  set {
4823  constraint_ = value;
4824  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMod;
4825  }
4826  }
4827 
4829  public const int IntMaxFieldNumber = 9;
4835  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4836  public global::Google.OrTools.Sat.IntegerArgumentProto IntMax {
4837  get { return constraintCase_ == ConstraintOneofCase.IntMax ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4838  set {
4839  constraint_ = value;
4840  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMax;
4841  }
4842  }
4843 
4845  public const int LinMaxFieldNumber = 27;
4850  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4851  public global::Google.OrTools.Sat.LinearArgumentProto LinMax {
4852  get { return constraintCase_ == ConstraintOneofCase.LinMax ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
4853  set {
4854  constraint_ = value;
4855  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMax;
4856  }
4857  }
4858 
4860  public const int IntMinFieldNumber = 10;
4866  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4867  public global::Google.OrTools.Sat.IntegerArgumentProto IntMin {
4868  get { return constraintCase_ == ConstraintOneofCase.IntMin ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4869  set {
4870  constraint_ = value;
4871  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntMin;
4872  }
4873  }
4874 
4876  public const int LinMinFieldNumber = 28;
4881  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4882  public global::Google.OrTools.Sat.LinearArgumentProto LinMin {
4883  get { return constraintCase_ == ConstraintOneofCase.LinMin ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ : null; }
4884  set {
4885  constraint_ = value;
4886  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.LinMin;
4887  }
4888  }
4889 
4891  public const int IntProdFieldNumber = 11;
4896  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4897  public global::Google.OrTools.Sat.IntegerArgumentProto IntProd {
4898  get { return constraintCase_ == ConstraintOneofCase.IntProd ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ : null; }
4899  set {
4900  constraint_ = value;
4901  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.IntProd;
4902  }
4903  }
4904 
4906  public const int LinearFieldNumber = 12;
4911  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4912  public global::Google.OrTools.Sat.LinearConstraintProto Linear {
4913  get { return constraintCase_ == ConstraintOneofCase.Linear ? (global::Google.OrTools.Sat.LinearConstraintProto) constraint_ : null; }
4914  set {
4915  constraint_ = value;
4916  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Linear;
4917  }
4918  }
4919 
4921  public const int AllDiffFieldNumber = 13;
4925  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4926  public global::Google.OrTools.Sat.AllDifferentConstraintProto AllDiff {
4927  get { return constraintCase_ == ConstraintOneofCase.AllDiff ? (global::Google.OrTools.Sat.AllDifferentConstraintProto) constraint_ : null; }
4928  set {
4929  constraint_ = value;
4930  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.AllDiff;
4931  }
4932  }
4933 
4935  public const int ElementFieldNumber = 14;
4940  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4941  public global::Google.OrTools.Sat.ElementConstraintProto Element {
4942  get { return constraintCase_ == ConstraintOneofCase.Element ? (global::Google.OrTools.Sat.ElementConstraintProto) constraint_ : null; }
4943  set {
4944  constraint_ = value;
4945  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Element;
4946  }
4947  }
4948 
4950  public const int CircuitFieldNumber = 15;
4955  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4956  public global::Google.OrTools.Sat.CircuitConstraintProto Circuit {
4957  get { return constraintCase_ == ConstraintOneofCase.Circuit ? (global::Google.OrTools.Sat.CircuitConstraintProto) constraint_ : null; }
4958  set {
4959  constraint_ = value;
4960  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Circuit;
4961  }
4962  }
4963 
4965  public const int RoutesFieldNumber = 23;
4969  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4970  public global::Google.OrTools.Sat.RoutesConstraintProto Routes {
4971  get { return constraintCase_ == ConstraintOneofCase.Routes ? (global::Google.OrTools.Sat.RoutesConstraintProto) constraint_ : null; }
4972  set {
4973  constraint_ = value;
4974  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Routes;
4975  }
4976  }
4977 
4979  public const int CircuitCoveringFieldNumber = 25;
4984  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4985  public global::Google.OrTools.Sat.CircuitCoveringConstraintProto CircuitCovering {
4986  get { return constraintCase_ == ConstraintOneofCase.CircuitCovering ? (global::Google.OrTools.Sat.CircuitCoveringConstraintProto) constraint_ : null; }
4987  set {
4988  constraint_ = value;
4989  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.CircuitCovering;
4990  }
4991  }
4992 
4994  public const int TableFieldNumber = 16;
4999  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5000  public global::Google.OrTools.Sat.TableConstraintProto Table {
5001  get { return constraintCase_ == ConstraintOneofCase.Table ? (global::Google.OrTools.Sat.TableConstraintProto) constraint_ : null; }
5002  set {
5003  constraint_ = value;
5004  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Table;
5005  }
5006  }
5007 
5009  public const int AutomatonFieldNumber = 17;
5014  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5015  public global::Google.OrTools.Sat.AutomatonConstraintProto Automaton {
5016  get { return constraintCase_ == ConstraintOneofCase.Automaton ? (global::Google.OrTools.Sat.AutomatonConstraintProto) constraint_ : null; }
5017  set {
5018  constraint_ = value;
5019  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Automaton;
5020  }
5021  }
5022 
5024  public const int InverseFieldNumber = 18;
5029  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5030  public global::Google.OrTools.Sat.InverseConstraintProto Inverse {
5031  get { return constraintCase_ == ConstraintOneofCase.Inverse ? (global::Google.OrTools.Sat.InverseConstraintProto) constraint_ : null; }
5032  set {
5033  constraint_ = value;
5034  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Inverse;
5035  }
5036  }
5037 
5039  public const int ReservoirFieldNumber = 24;
5045  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5046  public global::Google.OrTools.Sat.ReservoirConstraintProto Reservoir {
5047  get { return constraintCase_ == ConstraintOneofCase.Reservoir ? (global::Google.OrTools.Sat.ReservoirConstraintProto) constraint_ : null; }
5048  set {
5049  constraint_ = value;
5050  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Reservoir;
5051  }
5052  }
5053 
5055  public const int IntervalFieldNumber = 19;
5060  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5061  public global::Google.OrTools.Sat.IntervalConstraintProto Interval {
5062  get { return constraintCase_ == ConstraintOneofCase.Interval ? (global::Google.OrTools.Sat.IntervalConstraintProto) constraint_ : null; }
5063  set {
5064  constraint_ = value;
5065  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Interval;
5066  }
5067  }
5068 
5070  public const int NoOverlapFieldNumber = 20;
5076  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5077  public global::Google.OrTools.Sat.NoOverlapConstraintProto NoOverlap {
5078  get { return constraintCase_ == ConstraintOneofCase.NoOverlap ? (global::Google.OrTools.Sat.NoOverlapConstraintProto) constraint_ : null; }
5079  set {
5080  constraint_ = value;
5081  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap;
5082  }
5083  }
5084 
5086  public const int NoOverlap2DFieldNumber = 21;
5090  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5091  public global::Google.OrTools.Sat.NoOverlap2DConstraintProto NoOverlap2D {
5092  get { return constraintCase_ == ConstraintOneofCase.NoOverlap2D ? (global::Google.OrTools.Sat.NoOverlap2DConstraintProto) constraint_ : null; }
5093  set {
5094  constraint_ = value;
5095  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.NoOverlap2D;
5096  }
5097  }
5098 
5100  public const int CumulativeFieldNumber = 22;
5106  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5107  public global::Google.OrTools.Sat.CumulativeConstraintProto Cumulative {
5108  get { return constraintCase_ == ConstraintOneofCase.Cumulative ? (global::Google.OrTools.Sat.CumulativeConstraintProto) constraint_ : null; }
5109  set {
5110  constraint_ = value;
5111  constraintCase_ = value == null ? ConstraintOneofCase.None : ConstraintOneofCase.Cumulative;
5112  }
5113  }
5114 
5115  private object constraint_;
5117  public enum ConstraintOneofCase {
5118  None = 0,
5119  BoolOr = 3,
5120  BoolAnd = 4,
5121  AtMostOne = 26,
5122  BoolXor = 5,
5123  IntDiv = 7,
5124  IntMod = 8,
5125  IntMax = 9,
5126  LinMax = 27,
5127  IntMin = 10,
5128  LinMin = 28,
5129  IntProd = 11,
5130  Linear = 12,
5131  AllDiff = 13,
5132  Element = 14,
5133  Circuit = 15,
5134  Routes = 23,
5135  CircuitCovering = 25,
5136  Table = 16,
5137  Automaton = 17,
5138  Inverse = 18,
5139  Reservoir = 24,
5140  Interval = 19,
5141  NoOverlap = 20,
5142  NoOverlap2D = 21,
5143  Cumulative = 22,
5144  }
5145  private ConstraintOneofCase constraintCase_ = ConstraintOneofCase.None;
5146  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5147  public ConstraintOneofCase ConstraintCase {
5148  get { return constraintCase_; }
5149  }
5150 
5151  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5152  public void ClearConstraint() {
5153  constraintCase_ = ConstraintOneofCase.None;
5154  constraint_ = null;
5155  }
5156 
5157  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5158  public override bool Equals(object other) {
5159  return Equals(other as ConstraintProto);
5160  }
5161 
5162  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5163  public bool Equals(ConstraintProto other) {
5164  if (ReferenceEquals(other, null)) {
5165  return false;
5166  }
5167  if (ReferenceEquals(other, this)) {
5168  return true;
5169  }
5170  if (Name != other.Name) return false;
5171  if(!enforcementLiteral_.Equals(other.enforcementLiteral_)) return false;
5172  if (!object.Equals(BoolOr, other.BoolOr)) return false;
5173  if (!object.Equals(BoolAnd, other.BoolAnd)) return false;
5174  if (!object.Equals(AtMostOne, other.AtMostOne)) return false;
5175  if (!object.Equals(BoolXor, other.BoolXor)) return false;
5176  if (!object.Equals(IntDiv, other.IntDiv)) return false;
5177  if (!object.Equals(IntMod, other.IntMod)) return false;
5178  if (!object.Equals(IntMax, other.IntMax)) return false;
5179  if (!object.Equals(LinMax, other.LinMax)) return false;
5180  if (!object.Equals(IntMin, other.IntMin)) return false;
5181  if (!object.Equals(LinMin, other.LinMin)) return false;
5182  if (!object.Equals(IntProd, other.IntProd)) return false;
5183  if (!object.Equals(Linear, other.Linear)) return false;
5184  if (!object.Equals(AllDiff, other.AllDiff)) return false;
5185  if (!object.Equals(Element, other.Element)) return false;
5186  if (!object.Equals(Circuit, other.Circuit)) return false;
5187  if (!object.Equals(Routes, other.Routes)) return false;
5188  if (!object.Equals(CircuitCovering, other.CircuitCovering)) return false;
5189  if (!object.Equals(Table, other.Table)) return false;
5190  if (!object.Equals(Automaton, other.Automaton)) return false;
5191  if (!object.Equals(Inverse, other.Inverse)) return false;
5192  if (!object.Equals(Reservoir, other.Reservoir)) return false;
5193  if (!object.Equals(Interval, other.Interval)) return false;
5194  if (!object.Equals(NoOverlap, other.NoOverlap)) return false;
5195  if (!object.Equals(NoOverlap2D, other.NoOverlap2D)) return false;
5196  if (!object.Equals(Cumulative, other.Cumulative)) return false;
5197  if (ConstraintCase != other.ConstraintCase) return false;
5198  return Equals(_unknownFields, other._unknownFields);
5199  }
5200 
5201  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5202  public override int GetHashCode() {
5203  int hash = 1;
5204  if (Name.Length != 0) hash ^= Name.GetHashCode();
5205  hash ^= enforcementLiteral_.GetHashCode();
5206  if (constraintCase_ == ConstraintOneofCase.BoolOr) hash ^= BoolOr.GetHashCode();
5207  if (constraintCase_ == ConstraintOneofCase.BoolAnd) hash ^= BoolAnd.GetHashCode();
5208  if (constraintCase_ == ConstraintOneofCase.AtMostOne) hash ^= AtMostOne.GetHashCode();
5209  if (constraintCase_ == ConstraintOneofCase.BoolXor) hash ^= BoolXor.GetHashCode();
5210  if (constraintCase_ == ConstraintOneofCase.IntDiv) hash ^= IntDiv.GetHashCode();
5211  if (constraintCase_ == ConstraintOneofCase.IntMod) hash ^= IntMod.GetHashCode();
5212  if (constraintCase_ == ConstraintOneofCase.IntMax) hash ^= IntMax.GetHashCode();
5213  if (constraintCase_ == ConstraintOneofCase.LinMax) hash ^= LinMax.GetHashCode();
5214  if (constraintCase_ == ConstraintOneofCase.IntMin) hash ^= IntMin.GetHashCode();
5215  if (constraintCase_ == ConstraintOneofCase.LinMin) hash ^= LinMin.GetHashCode();
5216  if (constraintCase_ == ConstraintOneofCase.IntProd) hash ^= IntProd.GetHashCode();
5217  if (constraintCase_ == ConstraintOneofCase.Linear) hash ^= Linear.GetHashCode();
5218  if (constraintCase_ == ConstraintOneofCase.AllDiff) hash ^= AllDiff.GetHashCode();
5219  if (constraintCase_ == ConstraintOneofCase.Element) hash ^= Element.GetHashCode();
5220  if (constraintCase_ == ConstraintOneofCase.Circuit) hash ^= Circuit.GetHashCode();
5221  if (constraintCase_ == ConstraintOneofCase.Routes) hash ^= Routes.GetHashCode();
5222  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) hash ^= CircuitCovering.GetHashCode();
5223  if (constraintCase_ == ConstraintOneofCase.Table) hash ^= Table.GetHashCode();
5224  if (constraintCase_ == ConstraintOneofCase.Automaton) hash ^= Automaton.GetHashCode();
5225  if (constraintCase_ == ConstraintOneofCase.Inverse) hash ^= Inverse.GetHashCode();
5226  if (constraintCase_ == ConstraintOneofCase.Reservoir) hash ^= Reservoir.GetHashCode();
5227  if (constraintCase_ == ConstraintOneofCase.Interval) hash ^= Interval.GetHashCode();
5228  if (constraintCase_ == ConstraintOneofCase.NoOverlap) hash ^= NoOverlap.GetHashCode();
5229  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) hash ^= NoOverlap2D.GetHashCode();
5230  if (constraintCase_ == ConstraintOneofCase.Cumulative) hash ^= Cumulative.GetHashCode();
5231  hash ^= (int) constraintCase_;
5232  if (_unknownFields != null) {
5233  hash ^= _unknownFields.GetHashCode();
5234  }
5235  return hash;
5236  }
5237 
5238  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5239  public override string ToString() {
5240  return pb::JsonFormatter.ToDiagnosticString(this);
5241  }
5242 
5243  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5244  public void WriteTo(pb::CodedOutputStream output) {
5245  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5246  output.WriteRawMessage(this);
5247  #else
5248  if (Name.Length != 0) {
5249  output.WriteRawTag(10);
5250  output.WriteString(Name);
5251  }
5252  enforcementLiteral_.WriteTo(output, _repeated_enforcementLiteral_codec);
5253  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5254  output.WriteRawTag(26);
5255  output.WriteMessage(BoolOr);
5256  }
5257  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5258  output.WriteRawTag(34);
5259  output.WriteMessage(BoolAnd);
5260  }
5261  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5262  output.WriteRawTag(42);
5263  output.WriteMessage(BoolXor);
5264  }
5265  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5266  output.WriteRawTag(58);
5267  output.WriteMessage(IntDiv);
5268  }
5269  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5270  output.WriteRawTag(66);
5271  output.WriteMessage(IntMod);
5272  }
5273  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5274  output.WriteRawTag(74);
5275  output.WriteMessage(IntMax);
5276  }
5277  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5278  output.WriteRawTag(82);
5279  output.WriteMessage(IntMin);
5280  }
5281  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5282  output.WriteRawTag(90);
5283  output.WriteMessage(IntProd);
5284  }
5285  if (constraintCase_ == ConstraintOneofCase.Linear) {
5286  output.WriteRawTag(98);
5287  output.WriteMessage(Linear);
5288  }
5289  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5290  output.WriteRawTag(106);
5291  output.WriteMessage(AllDiff);
5292  }
5293  if (constraintCase_ == ConstraintOneofCase.Element) {
5294  output.WriteRawTag(114);
5295  output.WriteMessage(Element);
5296  }
5297  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5298  output.WriteRawTag(122);
5299  output.WriteMessage(Circuit);
5300  }
5301  if (constraintCase_ == ConstraintOneofCase.Table) {
5302  output.WriteRawTag(130, 1);
5303  output.WriteMessage(Table);
5304  }
5305  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5306  output.WriteRawTag(138, 1);
5307  output.WriteMessage(Automaton);
5308  }
5309  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5310  output.WriteRawTag(146, 1);
5311  output.WriteMessage(Inverse);
5312  }
5313  if (constraintCase_ == ConstraintOneofCase.Interval) {
5314  output.WriteRawTag(154, 1);
5315  output.WriteMessage(Interval);
5316  }
5317  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5318  output.WriteRawTag(162, 1);
5319  output.WriteMessage(NoOverlap);
5320  }
5321  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5322  output.WriteRawTag(170, 1);
5323  output.WriteMessage(NoOverlap2D);
5324  }
5325  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5326  output.WriteRawTag(178, 1);
5327  output.WriteMessage(Cumulative);
5328  }
5329  if (constraintCase_ == ConstraintOneofCase.Routes) {
5330  output.WriteRawTag(186, 1);
5331  output.WriteMessage(Routes);
5332  }
5333  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5334  output.WriteRawTag(194, 1);
5335  output.WriteMessage(Reservoir);
5336  }
5337  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
5338  output.WriteRawTag(202, 1);
5339  output.WriteMessage(CircuitCovering);
5340  }
5341  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5342  output.WriteRawTag(210, 1);
5343  output.WriteMessage(AtMostOne);
5344  }
5345  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5346  output.WriteRawTag(218, 1);
5347  output.WriteMessage(LinMax);
5348  }
5349  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5350  output.WriteRawTag(226, 1);
5351  output.WriteMessage(LinMin);
5352  }
5353  if (_unknownFields != null) {
5354  _unknownFields.WriteTo(output);
5355  }
5356  #endif
5357  }
5358 
5359  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5360  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5361  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
5362  if (Name.Length != 0) {
5363  output.WriteRawTag(10);
5364  output.WriteString(Name);
5365  }
5366  enforcementLiteral_.WriteTo(ref output, _repeated_enforcementLiteral_codec);
5367  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5368  output.WriteRawTag(26);
5369  output.WriteMessage(BoolOr);
5370  }
5371  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5372  output.WriteRawTag(34);
5373  output.WriteMessage(BoolAnd);
5374  }
5375  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5376  output.WriteRawTag(42);
5377  output.WriteMessage(BoolXor);
5378  }
5379  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5380  output.WriteRawTag(58);
5381  output.WriteMessage(IntDiv);
5382  }
5383  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5384  output.WriteRawTag(66);
5385  output.WriteMessage(IntMod);
5386  }
5387  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5388  output.WriteRawTag(74);
5389  output.WriteMessage(IntMax);
5390  }
5391  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5392  output.WriteRawTag(82);
5393  output.WriteMessage(IntMin);
5394  }
5395  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5396  output.WriteRawTag(90);
5397  output.WriteMessage(IntProd);
5398  }
5399  if (constraintCase_ == ConstraintOneofCase.Linear) {
5400  output.WriteRawTag(98);
5401  output.WriteMessage(Linear);
5402  }
5403  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5404  output.WriteRawTag(106);
5405  output.WriteMessage(AllDiff);
5406  }
5407  if (constraintCase_ == ConstraintOneofCase.Element) {
5408  output.WriteRawTag(114);
5409  output.WriteMessage(Element);
5410  }
5411  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5412  output.WriteRawTag(122);
5413  output.WriteMessage(Circuit);
5414  }
5415  if (constraintCase_ == ConstraintOneofCase.Table) {
5416  output.WriteRawTag(130, 1);
5417  output.WriteMessage(Table);
5418  }
5419  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5420  output.WriteRawTag(138, 1);
5421  output.WriteMessage(Automaton);
5422  }
5423  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5424  output.WriteRawTag(146, 1);
5425  output.WriteMessage(Inverse);
5426  }
5427  if (constraintCase_ == ConstraintOneofCase.Interval) {
5428  output.WriteRawTag(154, 1);
5429  output.WriteMessage(Interval);
5430  }
5431  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5432  output.WriteRawTag(162, 1);
5433  output.WriteMessage(NoOverlap);
5434  }
5435  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5436  output.WriteRawTag(170, 1);
5437  output.WriteMessage(NoOverlap2D);
5438  }
5439  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5440  output.WriteRawTag(178, 1);
5441  output.WriteMessage(Cumulative);
5442  }
5443  if (constraintCase_ == ConstraintOneofCase.Routes) {
5444  output.WriteRawTag(186, 1);
5445  output.WriteMessage(Routes);
5446  }
5447  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5448  output.WriteRawTag(194, 1);
5449  output.WriteMessage(Reservoir);
5450  }
5451  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
5452  output.WriteRawTag(202, 1);
5453  output.WriteMessage(CircuitCovering);
5454  }
5455  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5456  output.WriteRawTag(210, 1);
5457  output.WriteMessage(AtMostOne);
5458  }
5459  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5460  output.WriteRawTag(218, 1);
5461  output.WriteMessage(LinMax);
5462  }
5463  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5464  output.WriteRawTag(226, 1);
5465  output.WriteMessage(LinMin);
5466  }
5467  if (_unknownFields != null) {
5468  _unknownFields.WriteTo(ref output);
5469  }
5470  }
5471  #endif
5472 
5473  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5474  public int CalculateSize() {
5475  int size = 0;
5476  if (Name.Length != 0) {
5477  size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
5478  }
5479  size += enforcementLiteral_.CalculateSize(_repeated_enforcementLiteral_codec);
5480  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5481  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolOr);
5482  }
5483  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5484  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolAnd);
5485  }
5486  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5487  size += 2 + pb::CodedOutputStream.ComputeMessageSize(AtMostOne);
5488  }
5489  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5490  size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolXor);
5491  }
5492  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5493  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntDiv);
5494  }
5495  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5496  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMod);
5497  }
5498  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5499  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMax);
5500  }
5501  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5502  size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMax);
5503  }
5504  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5505  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMin);
5506  }
5507  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5508  size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMin);
5509  }
5510  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5511  size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntProd);
5512  }
5513  if (constraintCase_ == ConstraintOneofCase.Linear) {
5514  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Linear);
5515  }
5516  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5517  size += 1 + pb::CodedOutputStream.ComputeMessageSize(AllDiff);
5518  }
5519  if (constraintCase_ == ConstraintOneofCase.Element) {
5520  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Element);
5521  }
5522  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5523  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Circuit);
5524  }
5525  if (constraintCase_ == ConstraintOneofCase.Routes) {
5526  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Routes);
5527  }
5528  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
5529  size += 2 + pb::CodedOutputStream.ComputeMessageSize(CircuitCovering);
5530  }
5531  if (constraintCase_ == ConstraintOneofCase.Table) {
5532  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Table);
5533  }
5534  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5535  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Automaton);
5536  }
5537  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5538  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Inverse);
5539  }
5540  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5541  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Reservoir);
5542  }
5543  if (constraintCase_ == ConstraintOneofCase.Interval) {
5544  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Interval);
5545  }
5546  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5547  size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap);
5548  }
5549  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5550  size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap2D);
5551  }
5552  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5553  size += 2 + pb::CodedOutputStream.ComputeMessageSize(Cumulative);
5554  }
5555  if (_unknownFields != null) {
5556  size += _unknownFields.CalculateSize();
5557  }
5558  return size;
5559  }
5560 
5561  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5562  public void MergeFrom(ConstraintProto other) {
5563  if (other == null) {
5564  return;
5565  }
5566  if (other.Name.Length != 0) {
5567  Name = other.Name;
5568  }
5569  enforcementLiteral_.Add(other.enforcementLiteral_);
5570  switch (other.ConstraintCase) {
5571  case ConstraintOneofCase.BoolOr:
5572  if (BoolOr == null) {
5573  BoolOr = new global::Google.OrTools.Sat.BoolArgumentProto();
5574  }
5575  BoolOr.MergeFrom(other.BoolOr);
5576  break;
5577  case ConstraintOneofCase.BoolAnd:
5578  if (BoolAnd == null) {
5579  BoolAnd = new global::Google.OrTools.Sat.BoolArgumentProto();
5580  }
5581  BoolAnd.MergeFrom(other.BoolAnd);
5582  break;
5583  case ConstraintOneofCase.AtMostOne:
5584  if (AtMostOne == null) {
5585  AtMostOne = new global::Google.OrTools.Sat.BoolArgumentProto();
5586  }
5587  AtMostOne.MergeFrom(other.AtMostOne);
5588  break;
5589  case ConstraintOneofCase.BoolXor:
5590  if (BoolXor == null) {
5591  BoolXor = new global::Google.OrTools.Sat.BoolArgumentProto();
5592  }
5593  BoolXor.MergeFrom(other.BoolXor);
5594  break;
5595  case ConstraintOneofCase.IntDiv:
5596  if (IntDiv == null) {
5597  IntDiv = new global::Google.OrTools.Sat.IntegerArgumentProto();
5598  }
5599  IntDiv.MergeFrom(other.IntDiv);
5600  break;
5601  case ConstraintOneofCase.IntMod:
5602  if (IntMod == null) {
5603  IntMod = new global::Google.OrTools.Sat.IntegerArgumentProto();
5604  }
5605  IntMod.MergeFrom(other.IntMod);
5606  break;
5607  case ConstraintOneofCase.IntMax:
5608  if (IntMax == null) {
5609  IntMax = new global::Google.OrTools.Sat.IntegerArgumentProto();
5610  }
5611  IntMax.MergeFrom(other.IntMax);
5612  break;
5613  case ConstraintOneofCase.LinMax:
5614  if (LinMax == null) {
5615  LinMax = new global::Google.OrTools.Sat.LinearArgumentProto();
5616  }
5617  LinMax.MergeFrom(other.LinMax);
5618  break;
5619  case ConstraintOneofCase.IntMin:
5620  if (IntMin == null) {
5621  IntMin = new global::Google.OrTools.Sat.IntegerArgumentProto();
5622  }
5623  IntMin.MergeFrom(other.IntMin);
5624  break;
5625  case ConstraintOneofCase.LinMin:
5626  if (LinMin == null) {
5627  LinMin = new global::Google.OrTools.Sat.LinearArgumentProto();
5628  }
5629  LinMin.MergeFrom(other.LinMin);
5630  break;
5631  case ConstraintOneofCase.IntProd:
5632  if (IntProd == null) {
5633  IntProd = new global::Google.OrTools.Sat.IntegerArgumentProto();
5634  }
5635  IntProd.MergeFrom(other.IntProd);
5636  break;
5637  case ConstraintOneofCase.Linear:
5638  if (Linear == null) {
5639  Linear = new global::Google.OrTools.Sat.LinearConstraintProto();
5640  }
5641  Linear.MergeFrom(other.Linear);
5642  break;
5643  case ConstraintOneofCase.AllDiff:
5644  if (AllDiff == null) {
5645  AllDiff = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
5646  }
5647  AllDiff.MergeFrom(other.AllDiff);
5648  break;
5649  case ConstraintOneofCase.Element:
5650  if (Element == null) {
5651  Element = new global::Google.OrTools.Sat.ElementConstraintProto();
5652  }
5653  Element.MergeFrom(other.Element);
5654  break;
5655  case ConstraintOneofCase.Circuit:
5656  if (Circuit == null) {
5657  Circuit = new global::Google.OrTools.Sat.CircuitConstraintProto();
5658  }
5659  Circuit.MergeFrom(other.Circuit);
5660  break;
5661  case ConstraintOneofCase.Routes:
5662  if (Routes == null) {
5663  Routes = new global::Google.OrTools.Sat.RoutesConstraintProto();
5664  }
5665  Routes.MergeFrom(other.Routes);
5666  break;
5667  case ConstraintOneofCase.CircuitCovering:
5668  if (CircuitCovering == null) {
5669  CircuitCovering = new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
5670  }
5671  CircuitCovering.MergeFrom(other.CircuitCovering);
5672  break;
5673  case ConstraintOneofCase.Table:
5674  if (Table == null) {
5675  Table = new global::Google.OrTools.Sat.TableConstraintProto();
5676  }
5677  Table.MergeFrom(other.Table);
5678  break;
5679  case ConstraintOneofCase.Automaton:
5680  if (Automaton == null) {
5681  Automaton = new global::Google.OrTools.Sat.AutomatonConstraintProto();
5682  }
5683  Automaton.MergeFrom(other.Automaton);
5684  break;
5685  case ConstraintOneofCase.Inverse:
5686  if (Inverse == null) {
5687  Inverse = new global::Google.OrTools.Sat.InverseConstraintProto();
5688  }
5689  Inverse.MergeFrom(other.Inverse);
5690  break;
5691  case ConstraintOneofCase.Reservoir:
5692  if (Reservoir == null) {
5693  Reservoir = new global::Google.OrTools.Sat.ReservoirConstraintProto();
5694  }
5695  Reservoir.MergeFrom(other.Reservoir);
5696  break;
5697  case ConstraintOneofCase.Interval:
5698  if (Interval == null) {
5699  Interval = new global::Google.OrTools.Sat.IntervalConstraintProto();
5700  }
5701  Interval.MergeFrom(other.Interval);
5702  break;
5703  case ConstraintOneofCase.NoOverlap:
5704  if (NoOverlap == null) {
5705  NoOverlap = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
5706  }
5707  NoOverlap.MergeFrom(other.NoOverlap);
5708  break;
5709  case ConstraintOneofCase.NoOverlap2D:
5710  if (NoOverlap2D == null) {
5711  NoOverlap2D = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
5712  }
5713  NoOverlap2D.MergeFrom(other.NoOverlap2D);
5714  break;
5715  case ConstraintOneofCase.Cumulative:
5716  if (Cumulative == null) {
5717  Cumulative = new global::Google.OrTools.Sat.CumulativeConstraintProto();
5718  }
5719  Cumulative.MergeFrom(other.Cumulative);
5720  break;
5721  }
5722 
5723  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5724  }
5725 
5726  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5727  public void MergeFrom(pb::CodedInputStream input) {
5728  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5729  input.ReadRawMessage(this);
5730  #else
5731  uint tag;
5732  while ((tag = input.ReadTag()) != 0) {
5733  switch(tag) {
5734  default:
5735  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5736  break;
5737  case 10: {
5738  Name = input.ReadString();
5739  break;
5740  }
5741  case 18:
5742  case 16: {
5743  enforcementLiteral_.AddEntriesFrom(input, _repeated_enforcementLiteral_codec);
5744  break;
5745  }
5746  case 26: {
5747  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5748  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5749  subBuilder.MergeFrom(BoolOr);
5750  }
5751  input.ReadMessage(subBuilder);
5752  BoolOr = subBuilder;
5753  break;
5754  }
5755  case 34: {
5756  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5757  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
5758  subBuilder.MergeFrom(BoolAnd);
5759  }
5760  input.ReadMessage(subBuilder);
5761  BoolAnd = subBuilder;
5762  break;
5763  }
5764  case 42: {
5765  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5766  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
5767  subBuilder.MergeFrom(BoolXor);
5768  }
5769  input.ReadMessage(subBuilder);
5770  BoolXor = subBuilder;
5771  break;
5772  }
5773  case 58: {
5774  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5775  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
5776  subBuilder.MergeFrom(IntDiv);
5777  }
5778  input.ReadMessage(subBuilder);
5779  IntDiv = subBuilder;
5780  break;
5781  }
5782  case 66: {
5783  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5784  if (constraintCase_ == ConstraintOneofCase.IntMod) {
5785  subBuilder.MergeFrom(IntMod);
5786  }
5787  input.ReadMessage(subBuilder);
5788  IntMod = subBuilder;
5789  break;
5790  }
5791  case 74: {
5792  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5793  if (constraintCase_ == ConstraintOneofCase.IntMax) {
5794  subBuilder.MergeFrom(IntMax);
5795  }
5796  input.ReadMessage(subBuilder);
5797  IntMax = subBuilder;
5798  break;
5799  }
5800  case 82: {
5801  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5802  if (constraintCase_ == ConstraintOneofCase.IntMin) {
5803  subBuilder.MergeFrom(IntMin);
5804  }
5805  input.ReadMessage(subBuilder);
5806  IntMin = subBuilder;
5807  break;
5808  }
5809  case 90: {
5810  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
5811  if (constraintCase_ == ConstraintOneofCase.IntProd) {
5812  subBuilder.MergeFrom(IntProd);
5813  }
5814  input.ReadMessage(subBuilder);
5815  IntProd = subBuilder;
5816  break;
5817  }
5818  case 98: {
5819  global::Google.OrTools.Sat.LinearConstraintProto subBuilder = new global::Google.OrTools.Sat.LinearConstraintProto();
5820  if (constraintCase_ == ConstraintOneofCase.Linear) {
5821  subBuilder.MergeFrom(Linear);
5822  }
5823  input.ReadMessage(subBuilder);
5824  Linear = subBuilder;
5825  break;
5826  }
5827  case 106: {
5828  global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
5829  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
5830  subBuilder.MergeFrom(AllDiff);
5831  }
5832  input.ReadMessage(subBuilder);
5833  AllDiff = subBuilder;
5834  break;
5835  }
5836  case 114: {
5837  global::Google.OrTools.Sat.ElementConstraintProto subBuilder = new global::Google.OrTools.Sat.ElementConstraintProto();
5838  if (constraintCase_ == ConstraintOneofCase.Element) {
5839  subBuilder.MergeFrom(Element);
5840  }
5841  input.ReadMessage(subBuilder);
5842  Element = subBuilder;
5843  break;
5844  }
5845  case 122: {
5846  global::Google.OrTools.Sat.CircuitConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitConstraintProto();
5847  if (constraintCase_ == ConstraintOneofCase.Circuit) {
5848  subBuilder.MergeFrom(Circuit);
5849  }
5850  input.ReadMessage(subBuilder);
5851  Circuit = subBuilder;
5852  break;
5853  }
5854  case 130: {
5855  global::Google.OrTools.Sat.TableConstraintProto subBuilder = new global::Google.OrTools.Sat.TableConstraintProto();
5856  if (constraintCase_ == ConstraintOneofCase.Table) {
5857  subBuilder.MergeFrom(Table);
5858  }
5859  input.ReadMessage(subBuilder);
5860  Table = subBuilder;
5861  break;
5862  }
5863  case 138: {
5864  global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder = new global::Google.OrTools.Sat.AutomatonConstraintProto();
5865  if (constraintCase_ == ConstraintOneofCase.Automaton) {
5866  subBuilder.MergeFrom(Automaton);
5867  }
5868  input.ReadMessage(subBuilder);
5869  Automaton = subBuilder;
5870  break;
5871  }
5872  case 146: {
5873  global::Google.OrTools.Sat.InverseConstraintProto subBuilder = new global::Google.OrTools.Sat.InverseConstraintProto();
5874  if (constraintCase_ == ConstraintOneofCase.Inverse) {
5875  subBuilder.MergeFrom(Inverse);
5876  }
5877  input.ReadMessage(subBuilder);
5878  Inverse = subBuilder;
5879  break;
5880  }
5881  case 154: {
5882  global::Google.OrTools.Sat.IntervalConstraintProto subBuilder = new global::Google.OrTools.Sat.IntervalConstraintProto();
5883  if (constraintCase_ == ConstraintOneofCase.Interval) {
5884  subBuilder.MergeFrom(Interval);
5885  }
5886  input.ReadMessage(subBuilder);
5887  Interval = subBuilder;
5888  break;
5889  }
5890  case 162: {
5891  global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
5892  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
5893  subBuilder.MergeFrom(NoOverlap);
5894  }
5895  input.ReadMessage(subBuilder);
5896  NoOverlap = subBuilder;
5897  break;
5898  }
5899  case 170: {
5900  global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
5901  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
5902  subBuilder.MergeFrom(NoOverlap2D);
5903  }
5904  input.ReadMessage(subBuilder);
5905  NoOverlap2D = subBuilder;
5906  break;
5907  }
5908  case 178: {
5909  global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder = new global::Google.OrTools.Sat.CumulativeConstraintProto();
5910  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
5911  subBuilder.MergeFrom(Cumulative);
5912  }
5913  input.ReadMessage(subBuilder);
5914  Cumulative = subBuilder;
5915  break;
5916  }
5917  case 186: {
5918  global::Google.OrTools.Sat.RoutesConstraintProto subBuilder = new global::Google.OrTools.Sat.RoutesConstraintProto();
5919  if (constraintCase_ == ConstraintOneofCase.Routes) {
5920  subBuilder.MergeFrom(Routes);
5921  }
5922  input.ReadMessage(subBuilder);
5923  Routes = subBuilder;
5924  break;
5925  }
5926  case 194: {
5927  global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder = new global::Google.OrTools.Sat.ReservoirConstraintProto();
5928  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
5929  subBuilder.MergeFrom(Reservoir);
5930  }
5931  input.ReadMessage(subBuilder);
5932  Reservoir = subBuilder;
5933  break;
5934  }
5935  case 202: {
5936  global::Google.OrTools.Sat.CircuitCoveringConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
5937  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
5938  subBuilder.MergeFrom(CircuitCovering);
5939  }
5940  input.ReadMessage(subBuilder);
5941  CircuitCovering = subBuilder;
5942  break;
5943  }
5944  case 210: {
5945  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5946  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
5947  subBuilder.MergeFrom(AtMostOne);
5948  }
5949  input.ReadMessage(subBuilder);
5950  AtMostOne = subBuilder;
5951  break;
5952  }
5953  case 218: {
5954  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
5955  if (constraintCase_ == ConstraintOneofCase.LinMax) {
5956  subBuilder.MergeFrom(LinMax);
5957  }
5958  input.ReadMessage(subBuilder);
5959  LinMax = subBuilder;
5960  break;
5961  }
5962  case 226: {
5963  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
5964  if (constraintCase_ == ConstraintOneofCase.LinMin) {
5965  subBuilder.MergeFrom(LinMin);
5966  }
5967  input.ReadMessage(subBuilder);
5968  LinMin = subBuilder;
5969  break;
5970  }
5971  }
5972  }
5973  #endif
5974  }
5975 
5976  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
5977  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5978  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
5979  uint tag;
5980  while ((tag = input.ReadTag()) != 0) {
5981  switch(tag) {
5982  default:
5983  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
5984  break;
5985  case 10: {
5986  Name = input.ReadString();
5987  break;
5988  }
5989  case 18:
5990  case 16: {
5991  enforcementLiteral_.AddEntriesFrom(ref input, _repeated_enforcementLiteral_codec);
5992  break;
5993  }
5994  case 26: {
5995  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
5996  if (constraintCase_ == ConstraintOneofCase.BoolOr) {
5997  subBuilder.MergeFrom(BoolOr);
5998  }
5999  input.ReadMessage(subBuilder);
6000  BoolOr = subBuilder;
6001  break;
6002  }
6003  case 34: {
6004  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6005  if (constraintCase_ == ConstraintOneofCase.BoolAnd) {
6006  subBuilder.MergeFrom(BoolAnd);
6007  }
6008  input.ReadMessage(subBuilder);
6009  BoolAnd = subBuilder;
6010  break;
6011  }
6012  case 42: {
6013  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6014  if (constraintCase_ == ConstraintOneofCase.BoolXor) {
6015  subBuilder.MergeFrom(BoolXor);
6016  }
6017  input.ReadMessage(subBuilder);
6018  BoolXor = subBuilder;
6019  break;
6020  }
6021  case 58: {
6022  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6023  if (constraintCase_ == ConstraintOneofCase.IntDiv) {
6024  subBuilder.MergeFrom(IntDiv);
6025  }
6026  input.ReadMessage(subBuilder);
6027  IntDiv = subBuilder;
6028  break;
6029  }
6030  case 66: {
6031  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6032  if (constraintCase_ == ConstraintOneofCase.IntMod) {
6033  subBuilder.MergeFrom(IntMod);
6034  }
6035  input.ReadMessage(subBuilder);
6036  IntMod = subBuilder;
6037  break;
6038  }
6039  case 74: {
6040  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6041  if (constraintCase_ == ConstraintOneofCase.IntMax) {
6042  subBuilder.MergeFrom(IntMax);
6043  }
6044  input.ReadMessage(subBuilder);
6045  IntMax = subBuilder;
6046  break;
6047  }
6048  case 82: {
6049  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6050  if (constraintCase_ == ConstraintOneofCase.IntMin) {
6051  subBuilder.MergeFrom(IntMin);
6052  }
6053  input.ReadMessage(subBuilder);
6054  IntMin = subBuilder;
6055  break;
6056  }
6057  case 90: {
6058  global::Google.OrTools.Sat.IntegerArgumentProto subBuilder = new global::Google.OrTools.Sat.IntegerArgumentProto();
6059  if (constraintCase_ == ConstraintOneofCase.IntProd) {
6060  subBuilder.MergeFrom(IntProd);
6061  }
6062  input.ReadMessage(subBuilder);
6063  IntProd = subBuilder;
6064  break;
6065  }
6066  case 98: {
6067  global::Google.OrTools.Sat.LinearConstraintProto subBuilder = new global::Google.OrTools.Sat.LinearConstraintProto();
6068  if (constraintCase_ == ConstraintOneofCase.Linear) {
6069  subBuilder.MergeFrom(Linear);
6070  }
6071  input.ReadMessage(subBuilder);
6072  Linear = subBuilder;
6073  break;
6074  }
6075  case 106: {
6076  global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder = new global::Google.OrTools.Sat.AllDifferentConstraintProto();
6077  if (constraintCase_ == ConstraintOneofCase.AllDiff) {
6078  subBuilder.MergeFrom(AllDiff);
6079  }
6080  input.ReadMessage(subBuilder);
6081  AllDiff = subBuilder;
6082  break;
6083  }
6084  case 114: {
6085  global::Google.OrTools.Sat.ElementConstraintProto subBuilder = new global::Google.OrTools.Sat.ElementConstraintProto();
6086  if (constraintCase_ == ConstraintOneofCase.Element) {
6087  subBuilder.MergeFrom(Element);
6088  }
6089  input.ReadMessage(subBuilder);
6090  Element = subBuilder;
6091  break;
6092  }
6093  case 122: {
6094  global::Google.OrTools.Sat.CircuitConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitConstraintProto();
6095  if (constraintCase_ == ConstraintOneofCase.Circuit) {
6096  subBuilder.MergeFrom(Circuit);
6097  }
6098  input.ReadMessage(subBuilder);
6099  Circuit = subBuilder;
6100  break;
6101  }
6102  case 130: {
6103  global::Google.OrTools.Sat.TableConstraintProto subBuilder = new global::Google.OrTools.Sat.TableConstraintProto();
6104  if (constraintCase_ == ConstraintOneofCase.Table) {
6105  subBuilder.MergeFrom(Table);
6106  }
6107  input.ReadMessage(subBuilder);
6108  Table = subBuilder;
6109  break;
6110  }
6111  case 138: {
6112  global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder = new global::Google.OrTools.Sat.AutomatonConstraintProto();
6113  if (constraintCase_ == ConstraintOneofCase.Automaton) {
6114  subBuilder.MergeFrom(Automaton);
6115  }
6116  input.ReadMessage(subBuilder);
6117  Automaton = subBuilder;
6118  break;
6119  }
6120  case 146: {
6121  global::Google.OrTools.Sat.InverseConstraintProto subBuilder = new global::Google.OrTools.Sat.InverseConstraintProto();
6122  if (constraintCase_ == ConstraintOneofCase.Inverse) {
6123  subBuilder.MergeFrom(Inverse);
6124  }
6125  input.ReadMessage(subBuilder);
6126  Inverse = subBuilder;
6127  break;
6128  }
6129  case 154: {
6130  global::Google.OrTools.Sat.IntervalConstraintProto subBuilder = new global::Google.OrTools.Sat.IntervalConstraintProto();
6131  if (constraintCase_ == ConstraintOneofCase.Interval) {
6132  subBuilder.MergeFrom(Interval);
6133  }
6134  input.ReadMessage(subBuilder);
6135  Interval = subBuilder;
6136  break;
6137  }
6138  case 162: {
6139  global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlapConstraintProto();
6140  if (constraintCase_ == ConstraintOneofCase.NoOverlap) {
6141  subBuilder.MergeFrom(NoOverlap);
6142  }
6143  input.ReadMessage(subBuilder);
6144  NoOverlap = subBuilder;
6145  break;
6146  }
6147  case 170: {
6148  global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder = new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
6149  if (constraintCase_ == ConstraintOneofCase.NoOverlap2D) {
6150  subBuilder.MergeFrom(NoOverlap2D);
6151  }
6152  input.ReadMessage(subBuilder);
6153  NoOverlap2D = subBuilder;
6154  break;
6155  }
6156  case 178: {
6157  global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder = new global::Google.OrTools.Sat.CumulativeConstraintProto();
6158  if (constraintCase_ == ConstraintOneofCase.Cumulative) {
6159  subBuilder.MergeFrom(Cumulative);
6160  }
6161  input.ReadMessage(subBuilder);
6162  Cumulative = subBuilder;
6163  break;
6164  }
6165  case 186: {
6166  global::Google.OrTools.Sat.RoutesConstraintProto subBuilder = new global::Google.OrTools.Sat.RoutesConstraintProto();
6167  if (constraintCase_ == ConstraintOneofCase.Routes) {
6168  subBuilder.MergeFrom(Routes);
6169  }
6170  input.ReadMessage(subBuilder);
6171  Routes = subBuilder;
6172  break;
6173  }
6174  case 194: {
6175  global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder = new global::Google.OrTools.Sat.ReservoirConstraintProto();
6176  if (constraintCase_ == ConstraintOneofCase.Reservoir) {
6177  subBuilder.MergeFrom(Reservoir);
6178  }
6179  input.ReadMessage(subBuilder);
6180  Reservoir = subBuilder;
6181  break;
6182  }
6183  case 202: {
6184  global::Google.OrTools.Sat.CircuitCoveringConstraintProto subBuilder = new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
6185  if (constraintCase_ == ConstraintOneofCase.CircuitCovering) {
6186  subBuilder.MergeFrom(CircuitCovering);
6187  }
6188  input.ReadMessage(subBuilder);
6189  CircuitCovering = subBuilder;
6190  break;
6191  }
6192  case 210: {
6193  global::Google.OrTools.Sat.BoolArgumentProto subBuilder = new global::Google.OrTools.Sat.BoolArgumentProto();
6194  if (constraintCase_ == ConstraintOneofCase.AtMostOne) {
6195  subBuilder.MergeFrom(AtMostOne);
6196  }
6197  input.ReadMessage(subBuilder);
6198  AtMostOne = subBuilder;
6199  break;
6200  }
6201  case 218: {
6202  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
6203  if (constraintCase_ == ConstraintOneofCase.LinMax) {
6204  subBuilder.MergeFrom(LinMax);
6205  }
6206  input.ReadMessage(subBuilder);
6207  LinMax = subBuilder;
6208  break;
6209  }
6210  case 226: {
6211  global::Google.OrTools.Sat.LinearArgumentProto subBuilder = new global::Google.OrTools.Sat.LinearArgumentProto();
6212  if (constraintCase_ == ConstraintOneofCase.LinMin) {
6213  subBuilder.MergeFrom(LinMin);
6214  }
6215  input.ReadMessage(subBuilder);
6216  LinMin = subBuilder;
6217  break;
6218  }
6219  }
6220  }
6221  }
6222  #endif
6223 
6224  }
6225 
6231  public sealed partial class CpObjectiveProto : pb::IMessage<CpObjectiveProto>
6232  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6233  , pb::IBufferMessage
6234  #endif
6235  {
6236  private static readonly pb::MessageParser<CpObjectiveProto> _parser = new pb::MessageParser<CpObjectiveProto>(() => new CpObjectiveProto());
6237  private pb::UnknownFieldSet _unknownFields;
6238  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6239  public static pb::MessageParser<CpObjectiveProto> Parser { get { return _parser; } }
6240 
6241  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6242  public static pbr::MessageDescriptor Descriptor {
6243  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[20]; }
6244  }
6245 
6246  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6247  pbr::MessageDescriptor pb::IMessage.Descriptor {
6248  get { return Descriptor; }
6249  }
6250 
6251  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6252  public CpObjectiveProto() {
6253  OnConstruction();
6254  }
6255 
6256  partial void OnConstruction();
6257 
6258  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6259  public CpObjectiveProto(CpObjectiveProto other) : this() {
6260  vars_ = other.vars_.Clone();
6261  coeffs_ = other.coeffs_.Clone();
6262  offset_ = other.offset_;
6263  scalingFactor_ = other.scalingFactor_;
6264  domain_ = other.domain_.Clone();
6265  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6266  }
6267 
6268  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6269  public CpObjectiveProto Clone() {
6270  return new CpObjectiveProto(this);
6271  }
6272 
6274  public const int VarsFieldNumber = 1;
6275  private static readonly pb::FieldCodec<int> _repeated_vars_codec
6276  = pb::FieldCodec.ForInt32(10);
6277  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
6283  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6284  public pbc::RepeatedField<int> Vars {
6285  get { return vars_; }
6286  }
6287 
6289  public const int CoeffsFieldNumber = 4;
6290  private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
6291  = pb::FieldCodec.ForInt64(34);
6292  private readonly pbc::RepeatedField<long> coeffs_ = new pbc::RepeatedField<long>();
6293  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6294  public pbc::RepeatedField<long> Coeffs {
6295  get { return coeffs_; }
6296  }
6297 
6299  public const int OffsetFieldNumber = 2;
6300  private double offset_;
6310  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6311  public double Offset {
6312  get { return offset_; }
6313  set {
6314  offset_ = value;
6315  }
6316  }
6317 
6319  public const int ScalingFactorFieldNumber = 3;
6320  private double scalingFactor_;
6321  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6322  public double ScalingFactor {
6323  get { return scalingFactor_; }
6324  set {
6325  scalingFactor_ = value;
6326  }
6327  }
6328 
6330  public const int DomainFieldNumber = 5;
6331  private static readonly pb::FieldCodec<long> _repeated_domain_codec
6332  = pb::FieldCodec.ForInt64(42);
6333  private readonly pbc::RepeatedField<long> domain_ = new pbc::RepeatedField<long>();
6339  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6340  public pbc::RepeatedField<long> Domain {
6341  get { return domain_; }
6342  }
6343 
6344  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6345  public override bool Equals(object other) {
6346  return Equals(other as CpObjectiveProto);
6347  }
6348 
6349  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6350  public bool Equals(CpObjectiveProto other) {
6351  if (ReferenceEquals(other, null)) {
6352  return false;
6353  }
6354  if (ReferenceEquals(other, this)) {
6355  return true;
6356  }
6357  if(!vars_.Equals(other.vars_)) return false;
6358  if(!coeffs_.Equals(other.coeffs_)) return false;
6359  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Offset, other.Offset)) return false;
6360  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ScalingFactor, other.ScalingFactor)) return false;
6361  if(!domain_.Equals(other.domain_)) return false;
6362  return Equals(_unknownFields, other._unknownFields);
6363  }
6364 
6365  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6366  public override int GetHashCode() {
6367  int hash = 1;
6368  hash ^= vars_.GetHashCode();
6369  hash ^= coeffs_.GetHashCode();
6370  if (Offset != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Offset);
6371  if (ScalingFactor != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ScalingFactor);
6372  hash ^= domain_.GetHashCode();
6373  if (_unknownFields != null) {
6374  hash ^= _unknownFields.GetHashCode();
6375  }
6376  return hash;
6377  }
6378 
6379  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6380  public override string ToString() {
6381  return pb::JsonFormatter.ToDiagnosticString(this);
6382  }
6383 
6384  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6385  public void WriteTo(pb::CodedOutputStream output) {
6386  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6387  output.WriteRawMessage(this);
6388  #else
6389  vars_.WriteTo(output, _repeated_vars_codec);
6390  if (Offset != 0D) {
6391  output.WriteRawTag(17);
6392  output.WriteDouble(Offset);
6393  }
6394  if (ScalingFactor != 0D) {
6395  output.WriteRawTag(25);
6396  output.WriteDouble(ScalingFactor);
6397  }
6398  coeffs_.WriteTo(output, _repeated_coeffs_codec);
6399  domain_.WriteTo(output, _repeated_domain_codec);
6400  if (_unknownFields != null) {
6401  _unknownFields.WriteTo(output);
6402  }
6403  #endif
6404  }
6405 
6406  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6407  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6408  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
6409  vars_.WriteTo(ref output, _repeated_vars_codec);
6410  if (Offset != 0D) {
6411  output.WriteRawTag(17);
6412  output.WriteDouble(Offset);
6413  }
6414  if (ScalingFactor != 0D) {
6415  output.WriteRawTag(25);
6416  output.WriteDouble(ScalingFactor);
6417  }
6418  coeffs_.WriteTo(ref output, _repeated_coeffs_codec);
6419  domain_.WriteTo(ref output, _repeated_domain_codec);
6420  if (_unknownFields != null) {
6421  _unknownFields.WriteTo(ref output);
6422  }
6423  }
6424  #endif
6425 
6426  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6427  public int CalculateSize() {
6428  int size = 0;
6429  size += vars_.CalculateSize(_repeated_vars_codec);
6430  size += coeffs_.CalculateSize(_repeated_coeffs_codec);
6431  if (Offset != 0D) {
6432  size += 1 + 8;
6433  }
6434  if (ScalingFactor != 0D) {
6435  size += 1 + 8;
6436  }
6437  size += domain_.CalculateSize(_repeated_domain_codec);
6438  if (_unknownFields != null) {
6439  size += _unknownFields.CalculateSize();
6440  }
6441  return size;
6442  }
6443 
6444  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6445  public void MergeFrom(CpObjectiveProto other) {
6446  if (other == null) {
6447  return;
6448  }
6449  vars_.Add(other.vars_);
6450  coeffs_.Add(other.coeffs_);
6451  if (other.Offset != 0D) {
6452  Offset = other.Offset;
6453  }
6454  if (other.ScalingFactor != 0D) {
6455  ScalingFactor = other.ScalingFactor;
6456  }
6457  domain_.Add(other.domain_);
6458  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
6459  }
6460 
6461  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6462  public void MergeFrom(pb::CodedInputStream input) {
6463  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6464  input.ReadRawMessage(this);
6465  #else
6466  uint tag;
6467  while ((tag = input.ReadTag()) != 0) {
6468  switch(tag) {
6469  default:
6470  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
6471  break;
6472  case 10:
6473  case 8: {
6474  vars_.AddEntriesFrom(input, _repeated_vars_codec);
6475  break;
6476  }
6477  case 17: {
6478  Offset = input.ReadDouble();
6479  break;
6480  }
6481  case 25: {
6482  ScalingFactor = input.ReadDouble();
6483  break;
6484  }
6485  case 34:
6486  case 32: {
6487  coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
6488  break;
6489  }
6490  case 42:
6491  case 40: {
6492  domain_.AddEntriesFrom(input, _repeated_domain_codec);
6493  break;
6494  }
6495  }
6496  }
6497  #endif
6498  }
6499 
6500  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6501  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6502  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
6503  uint tag;
6504  while ((tag = input.ReadTag()) != 0) {
6505  switch(tag) {
6506  default:
6507  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
6508  break;
6509  case 10:
6510  case 8: {
6511  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
6512  break;
6513  }
6514  case 17: {
6515  Offset = input.ReadDouble();
6516  break;
6517  }
6518  case 25: {
6519  ScalingFactor = input.ReadDouble();
6520  break;
6521  }
6522  case 34:
6523  case 32: {
6524  coeffs_.AddEntriesFrom(ref input, _repeated_coeffs_codec);
6525  break;
6526  }
6527  case 42:
6528  case 40: {
6529  domain_.AddEntriesFrom(ref input, _repeated_domain_codec);
6530  break;
6531  }
6532  }
6533  }
6534  }
6535  #endif
6536 
6537  }
6538 
6543  public sealed partial class DecisionStrategyProto : pb::IMessage<DecisionStrategyProto>
6544  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6545  , pb::IBufferMessage
6546  #endif
6547  {
6548  private static readonly pb::MessageParser<DecisionStrategyProto> _parser = new pb::MessageParser<DecisionStrategyProto>(() => new DecisionStrategyProto());
6549  private pb::UnknownFieldSet _unknownFields;
6550  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6551  public static pb::MessageParser<DecisionStrategyProto> Parser { get { return _parser; } }
6552 
6553  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6554  public static pbr::MessageDescriptor Descriptor {
6555  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[21]; }
6556  }
6557 
6558  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6559  pbr::MessageDescriptor pb::IMessage.Descriptor {
6560  get { return Descriptor; }
6561  }
6562 
6563  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6564  public DecisionStrategyProto() {
6565  OnConstruction();
6566  }
6567 
6568  partial void OnConstruction();
6569 
6570  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6571  public DecisionStrategyProto(DecisionStrategyProto other) : this() {
6572  variables_ = other.variables_.Clone();
6573  variableSelectionStrategy_ = other.variableSelectionStrategy_;
6574  domainReductionStrategy_ = other.domainReductionStrategy_;
6575  transformations_ = other.transformations_.Clone();
6576  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6577  }
6578 
6579  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6580  public DecisionStrategyProto Clone() {
6581  return new DecisionStrategyProto(this);
6582  }
6583 
6585  public const int VariablesFieldNumber = 1;
6586  private static readonly pb::FieldCodec<int> _repeated_variables_codec
6587  = pb::FieldCodec.ForInt32(10);
6588  private readonly pbc::RepeatedField<int> variables_ = new pbc::RepeatedField<int>();
6594  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6595  public pbc::RepeatedField<int> Variables {
6596  get { return variables_; }
6597  }
6598 
6600  public const int VariableSelectionStrategyFieldNumber = 2;
6601  private global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy variableSelectionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst;
6602  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6603  public global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy VariableSelectionStrategy {
6604  get { return variableSelectionStrategy_; }
6605  set {
6606  variableSelectionStrategy_ = value;
6607  }
6608  }
6609 
6611  public const int DomainReductionStrategyFieldNumber = 3;
6612  private global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy domainReductionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue;
6613  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6614  public global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy DomainReductionStrategy {
6615  get { return domainReductionStrategy_; }
6616  set {
6617  domainReductionStrategy_ = value;
6618  }
6619  }
6620 
6622  public const int TransformationsFieldNumber = 4;
6623  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> _repeated_transformations_codec
6624  = pb::FieldCodec.ForMessage(34, global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser);
6625  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> transformations_ = new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation>();
6626  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6627  public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> Transformations {
6628  get { return transformations_; }
6629  }
6630 
6631  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6632  public override bool Equals(object other) {
6633  return Equals(other as DecisionStrategyProto);
6634  }
6635 
6636  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6637  public bool Equals(DecisionStrategyProto other) {
6638  if (ReferenceEquals(other, null)) {
6639  return false;
6640  }
6641  if (ReferenceEquals(other, this)) {
6642  return true;
6643  }
6644  if(!variables_.Equals(other.variables_)) return false;
6645  if (VariableSelectionStrategy != other.VariableSelectionStrategy) return false;
6646  if (DomainReductionStrategy != other.DomainReductionStrategy) return false;
6647  if(!transformations_.Equals(other.transformations_)) return false;
6648  return Equals(_unknownFields, other._unknownFields);
6649  }
6650 
6651  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6652  public override int GetHashCode() {
6653  int hash = 1;
6654  hash ^= variables_.GetHashCode();
6655  if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) hash ^= VariableSelectionStrategy.GetHashCode();
6656  if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) hash ^= DomainReductionStrategy.GetHashCode();
6657  hash ^= transformations_.GetHashCode();
6658  if (_unknownFields != null) {
6659  hash ^= _unknownFields.GetHashCode();
6660  }
6661  return hash;
6662  }
6663 
6664  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6665  public override string ToString() {
6666  return pb::JsonFormatter.ToDiagnosticString(this);
6667  }
6668 
6669  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6670  public void WriteTo(pb::CodedOutputStream output) {
6671  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6672  output.WriteRawMessage(this);
6673  #else
6674  variables_.WriteTo(output, _repeated_variables_codec);
6675  if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
6676  output.WriteRawTag(16);
6677  output.WriteEnum((int) VariableSelectionStrategy);
6678  }
6679  if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
6680  output.WriteRawTag(24);
6681  output.WriteEnum((int) DomainReductionStrategy);
6682  }
6683  transformations_.WriteTo(output, _repeated_transformations_codec);
6684  if (_unknownFields != null) {
6685  _unknownFields.WriteTo(output);
6686  }
6687  #endif
6688  }
6689 
6690  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6691  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6692  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
6693  variables_.WriteTo(ref output, _repeated_variables_codec);
6694  if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
6695  output.WriteRawTag(16);
6696  output.WriteEnum((int) VariableSelectionStrategy);
6697  }
6698  if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
6699  output.WriteRawTag(24);
6700  output.WriteEnum((int) DomainReductionStrategy);
6701  }
6702  transformations_.WriteTo(ref output, _repeated_transformations_codec);
6703  if (_unknownFields != null) {
6704  _unknownFields.WriteTo(ref output);
6705  }
6706  }
6707  #endif
6708 
6709  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6710  public int CalculateSize() {
6711  int size = 0;
6712  size += variables_.CalculateSize(_repeated_variables_codec);
6713  if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
6714  size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) VariableSelectionStrategy);
6715  }
6716  if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
6717  size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DomainReductionStrategy);
6718  }
6719  size += transformations_.CalculateSize(_repeated_transformations_codec);
6720  if (_unknownFields != null) {
6721  size += _unknownFields.CalculateSize();
6722  }
6723  return size;
6724  }
6725 
6726  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6727  public void MergeFrom(DecisionStrategyProto other) {
6728  if (other == null) {
6729  return;
6730  }
6731  variables_.Add(other.variables_);
6732  if (other.VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
6733  VariableSelectionStrategy = other.VariableSelectionStrategy;
6734  }
6735  if (other.DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
6736  DomainReductionStrategy = other.DomainReductionStrategy;
6737  }
6738  transformations_.Add(other.transformations_);
6739  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
6740  }
6741 
6742  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6743  public void MergeFrom(pb::CodedInputStream input) {
6744  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6745  input.ReadRawMessage(this);
6746  #else
6747  uint tag;
6748  while ((tag = input.ReadTag()) != 0) {
6749  switch(tag) {
6750  default:
6751  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
6752  break;
6753  case 10:
6754  case 8: {
6755  variables_.AddEntriesFrom(input, _repeated_variables_codec);
6756  break;
6757  }
6758  case 16: {
6759  VariableSelectionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy) input.ReadEnum();
6760  break;
6761  }
6762  case 24: {
6763  DomainReductionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) input.ReadEnum();
6764  break;
6765  }
6766  case 34: {
6767  transformations_.AddEntriesFrom(input, _repeated_transformations_codec);
6768  break;
6769  }
6770  }
6771  }
6772  #endif
6773  }
6774 
6775  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6776  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6777  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
6778  uint tag;
6779  while ((tag = input.ReadTag()) != 0) {
6780  switch(tag) {
6781  default:
6782  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
6783  break;
6784  case 10:
6785  case 8: {
6786  variables_.AddEntriesFrom(ref input, _repeated_variables_codec);
6787  break;
6788  }
6789  case 16: {
6790  VariableSelectionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy) input.ReadEnum();
6791  break;
6792  }
6793  case 24: {
6794  DomainReductionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) input.ReadEnum();
6795  break;
6796  }
6797  case 34: {
6798  transformations_.AddEntriesFrom(ref input, _repeated_transformations_codec);
6799  break;
6800  }
6801  }
6802  }
6803  }
6804  #endif
6805 
6806  #region Nested types
6807  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6809  public static partial class Types {
6816  public enum VariableSelectionStrategy {
6817  [pbr::OriginalName("CHOOSE_FIRST")] ChooseFirst = 0,
6818  [pbr::OriginalName("CHOOSE_LOWEST_MIN")] ChooseLowestMin = 1,
6819  [pbr::OriginalName("CHOOSE_HIGHEST_MAX")] ChooseHighestMax = 2,
6820  [pbr::OriginalName("CHOOSE_MIN_DOMAIN_SIZE")] ChooseMinDomainSize = 3,
6821  [pbr::OriginalName("CHOOSE_MAX_DOMAIN_SIZE")] ChooseMaxDomainSize = 4,
6822  }
6823 
6830  public enum DomainReductionStrategy {
6831  [pbr::OriginalName("SELECT_MIN_VALUE")] SelectMinValue = 0,
6832  [pbr::OriginalName("SELECT_MAX_VALUE")] SelectMaxValue = 1,
6833  [pbr::OriginalName("SELECT_LOWER_HALF")] SelectLowerHalf = 2,
6834  [pbr::OriginalName("SELECT_UPPER_HALF")] SelectUpperHalf = 3,
6835  [pbr::OriginalName("SELECT_MEDIAN_VALUE")] SelectMedianValue = 4,
6836  }
6837 
6844  public sealed partial class AffineTransformation : pb::IMessage<AffineTransformation>
6845  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6846  , pb::IBufferMessage
6847  #endif
6848  {
6849  private static readonly pb::MessageParser<AffineTransformation> _parser = new pb::MessageParser<AffineTransformation>(() => new AffineTransformation());
6850  private pb::UnknownFieldSet _unknownFields;
6851  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6852  public static pb::MessageParser<AffineTransformation> Parser { get { return _parser; } }
6853 
6854  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6855  public static pbr::MessageDescriptor Descriptor {
6856  get { return global::Google.OrTools.Sat.DecisionStrategyProto.Descriptor.NestedTypes[0]; }
6857  }
6858 
6859  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6860  pbr::MessageDescriptor pb::IMessage.Descriptor {
6861  get { return Descriptor; }
6862  }
6863 
6864  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6865  public AffineTransformation() {
6866  OnConstruction();
6867  }
6868 
6869  partial void OnConstruction();
6870 
6871  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6872  public AffineTransformation(AffineTransformation other) : this() {
6873  var_ = other.var_;
6874  offset_ = other.offset_;
6875  positiveCoeff_ = other.positiveCoeff_;
6876  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6877  }
6878 
6879  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6880  public AffineTransformation Clone() {
6881  return new AffineTransformation(this);
6882  }
6883 
6885  public const int VarFieldNumber = 1;
6886  private int var_;
6887  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6888  public int Var {
6889  get { return var_; }
6890  set {
6891  var_ = value;
6892  }
6893  }
6894 
6896  public const int OffsetFieldNumber = 2;
6897  private long offset_;
6898  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6899  public long Offset {
6900  get { return offset_; }
6901  set {
6902  offset_ = value;
6903  }
6904  }
6905 
6907  public const int PositiveCoeffFieldNumber = 3;
6908  private long positiveCoeff_;
6909  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6910  public long PositiveCoeff {
6911  get { return positiveCoeff_; }
6912  set {
6913  positiveCoeff_ = value;
6914  }
6915  }
6916 
6917  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6918  public override bool Equals(object other) {
6919  return Equals(other as AffineTransformation);
6920  }
6921 
6922  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6923  public bool Equals(AffineTransformation other) {
6924  if (ReferenceEquals(other, null)) {
6925  return false;
6926  }
6927  if (ReferenceEquals(other, this)) {
6928  return true;
6929  }
6930  if (Var != other.Var) return false;
6931  if (Offset != other.Offset) return false;
6932  if (PositiveCoeff != other.PositiveCoeff) return false;
6933  return Equals(_unknownFields, other._unknownFields);
6934  }
6935 
6936  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6937  public override int GetHashCode() {
6938  int hash = 1;
6939  if (Var != 0) hash ^= Var.GetHashCode();
6940  if (Offset != 0L) hash ^= Offset.GetHashCode();
6941  if (PositiveCoeff != 0L) hash ^= PositiveCoeff.GetHashCode();
6942  if (_unknownFields != null) {
6943  hash ^= _unknownFields.GetHashCode();
6944  }
6945  return hash;
6946  }
6947 
6948  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6949  public override string ToString() {
6950  return pb::JsonFormatter.ToDiagnosticString(this);
6951  }
6952 
6953  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6954  public void WriteTo(pb::CodedOutputStream output) {
6955  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6956  output.WriteRawMessage(this);
6957  #else
6958  if (Var != 0) {
6959  output.WriteRawTag(8);
6960  output.WriteInt32(Var);
6961  }
6962  if (Offset != 0L) {
6963  output.WriteRawTag(16);
6964  output.WriteInt64(Offset);
6965  }
6966  if (PositiveCoeff != 0L) {
6967  output.WriteRawTag(24);
6968  output.WriteInt64(PositiveCoeff);
6969  }
6970  if (_unknownFields != null) {
6971  _unknownFields.WriteTo(output);
6972  }
6973  #endif
6974  }
6975 
6976  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
6977  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6978  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
6979  if (Var != 0) {
6980  output.WriteRawTag(8);
6981  output.WriteInt32(Var);
6982  }
6983  if (Offset != 0L) {
6984  output.WriteRawTag(16);
6985  output.WriteInt64(Offset);
6986  }
6987  if (PositiveCoeff != 0L) {
6988  output.WriteRawTag(24);
6989  output.WriteInt64(PositiveCoeff);
6990  }
6991  if (_unknownFields != null) {
6992  _unknownFields.WriteTo(ref output);
6993  }
6994  }
6995  #endif
6996 
6997  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6998  public int CalculateSize() {
6999  int size = 0;
7000  if (Var != 0) {
7001  size += 1 + pb::CodedOutputStream.ComputeInt32Size(Var);
7002  }
7003  if (Offset != 0L) {
7004  size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
7005  }
7006  if (PositiveCoeff != 0L) {
7007  size += 1 + pb::CodedOutputStream.ComputeInt64Size(PositiveCoeff);
7008  }
7009  if (_unknownFields != null) {
7010  size += _unknownFields.CalculateSize();
7011  }
7012  return size;
7013  }
7014 
7015  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7016  public void MergeFrom(AffineTransformation other) {
7017  if (other == null) {
7018  return;
7019  }
7020  if (other.Var != 0) {
7021  Var = other.Var;
7022  }
7023  if (other.Offset != 0L) {
7024  Offset = other.Offset;
7025  }
7026  if (other.PositiveCoeff != 0L) {
7027  PositiveCoeff = other.PositiveCoeff;
7028  }
7029  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
7030  }
7031 
7032  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7033  public void MergeFrom(pb::CodedInputStream input) {
7034  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7035  input.ReadRawMessage(this);
7036  #else
7037  uint tag;
7038  while ((tag = input.ReadTag()) != 0) {
7039  switch(tag) {
7040  default:
7041  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
7042  break;
7043  case 8: {
7044  Var = input.ReadInt32();
7045  break;
7046  }
7047  case 16: {
7048  Offset = input.ReadInt64();
7049  break;
7050  }
7051  case 24: {
7052  PositiveCoeff = input.ReadInt64();
7053  break;
7054  }
7055  }
7056  }
7057  #endif
7058  }
7059 
7060  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7061  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7062  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
7063  uint tag;
7064  while ((tag = input.ReadTag()) != 0) {
7065  switch(tag) {
7066  default:
7067  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
7068  break;
7069  case 8: {
7070  Var = input.ReadInt32();
7071  break;
7072  }
7073  case 16: {
7074  Offset = input.ReadInt64();
7075  break;
7076  }
7077  case 24: {
7078  PositiveCoeff = input.ReadInt64();
7079  break;
7080  }
7081  }
7082  }
7083  }
7084  #endif
7085 
7086  }
7087 
7088  }
7089  #endregion
7090 
7091  }
7092 
7098  public sealed partial class PartialVariableAssignment : pb::IMessage<PartialVariableAssignment>
7099  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7100  , pb::IBufferMessage
7101  #endif
7102  {
7103  private static readonly pb::MessageParser<PartialVariableAssignment> _parser = new pb::MessageParser<PartialVariableAssignment>(() => new PartialVariableAssignment());
7104  private pb::UnknownFieldSet _unknownFields;
7105  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7106  public static pb::MessageParser<PartialVariableAssignment> Parser { get { return _parser; } }
7107 
7108  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7109  public static pbr::MessageDescriptor Descriptor {
7110  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[22]; }
7111  }
7112 
7113  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7114  pbr::MessageDescriptor pb::IMessage.Descriptor {
7115  get { return Descriptor; }
7116  }
7117 
7118  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7119  public PartialVariableAssignment() {
7120  OnConstruction();
7121  }
7122 
7123  partial void OnConstruction();
7124 
7125  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7126  public PartialVariableAssignment(PartialVariableAssignment other) : this() {
7127  vars_ = other.vars_.Clone();
7128  values_ = other.values_.Clone();
7129  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
7130  }
7131 
7132  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7133  public PartialVariableAssignment Clone() {
7134  return new PartialVariableAssignment(this);
7135  }
7136 
7138  public const int VarsFieldNumber = 1;
7139  private static readonly pb::FieldCodec<int> _repeated_vars_codec
7140  = pb::FieldCodec.ForInt32(10);
7141  private readonly pbc::RepeatedField<int> vars_ = new pbc::RepeatedField<int>();
7142  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7143  public pbc::RepeatedField<int> Vars {
7144  get { return vars_; }
7145  }
7146 
7148  public const int ValuesFieldNumber = 2;
7149  private static readonly pb::FieldCodec<long> _repeated_values_codec
7150  = pb::FieldCodec.ForInt64(18);
7151  private readonly pbc::RepeatedField<long> values_ = new pbc::RepeatedField<long>();
7152  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7153  public pbc::RepeatedField<long> Values {
7154  get { return values_; }
7155  }
7156 
7157  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7158  public override bool Equals(object other) {
7159  return Equals(other as PartialVariableAssignment);
7160  }
7161 
7162  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7163  public bool Equals(PartialVariableAssignment other) {
7164  if (ReferenceEquals(other, null)) {
7165  return false;
7166  }
7167  if (ReferenceEquals(other, this)) {
7168  return true;
7169  }
7170  if(!vars_.Equals(other.vars_)) return false;
7171  if(!values_.Equals(other.values_)) return false;
7172  return Equals(_unknownFields, other._unknownFields);
7173  }
7174 
7175  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7176  public override int GetHashCode() {
7177  int hash = 1;
7178  hash ^= vars_.GetHashCode();
7179  hash ^= values_.GetHashCode();
7180  if (_unknownFields != null) {
7181  hash ^= _unknownFields.GetHashCode();
7182  }
7183  return hash;
7184  }
7185 
7186  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7187  public override string ToString() {
7188  return pb::JsonFormatter.ToDiagnosticString(this);
7189  }
7190 
7191  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7192  public void WriteTo(pb::CodedOutputStream output) {
7193  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7194  output.WriteRawMessage(this);
7195  #else
7196  vars_.WriteTo(output, _repeated_vars_codec);
7197  values_.WriteTo(output, _repeated_values_codec);
7198  if (_unknownFields != null) {
7199  _unknownFields.WriteTo(output);
7200  }
7201  #endif
7202  }
7203 
7204  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7205  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7206  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
7207  vars_.WriteTo(ref output, _repeated_vars_codec);
7208  values_.WriteTo(ref output, _repeated_values_codec);
7209  if (_unknownFields != null) {
7210  _unknownFields.WriteTo(ref output);
7211  }
7212  }
7213  #endif
7214 
7215  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7216  public int CalculateSize() {
7217  int size = 0;
7218  size += vars_.CalculateSize(_repeated_vars_codec);
7219  size += values_.CalculateSize(_repeated_values_codec);
7220  if (_unknownFields != null) {
7221  size += _unknownFields.CalculateSize();
7222  }
7223  return size;
7224  }
7225 
7226  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7227  public void MergeFrom(PartialVariableAssignment other) {
7228  if (other == null) {
7229  return;
7230  }
7231  vars_.Add(other.vars_);
7232  values_.Add(other.values_);
7233  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
7234  }
7235 
7236  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7237  public void MergeFrom(pb::CodedInputStream input) {
7238  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7239  input.ReadRawMessage(this);
7240  #else
7241  uint tag;
7242  while ((tag = input.ReadTag()) != 0) {
7243  switch(tag) {
7244  default:
7245  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
7246  break;
7247  case 10:
7248  case 8: {
7249  vars_.AddEntriesFrom(input, _repeated_vars_codec);
7250  break;
7251  }
7252  case 18:
7253  case 16: {
7254  values_.AddEntriesFrom(input, _repeated_values_codec);
7255  break;
7256  }
7257  }
7258  }
7259  #endif
7260  }
7261 
7262  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7263  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7264  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
7265  uint tag;
7266  while ((tag = input.ReadTag()) != 0) {
7267  switch(tag) {
7268  default:
7269  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
7270  break;
7271  case 10:
7272  case 8: {
7273  vars_.AddEntriesFrom(ref input, _repeated_vars_codec);
7274  break;
7275  }
7276  case 18:
7277  case 16: {
7278  values_.AddEntriesFrom(ref input, _repeated_values_codec);
7279  break;
7280  }
7281  }
7282  }
7283  }
7284  #endif
7285 
7286  }
7287 
7291  public sealed partial class CpModelProto : pb::IMessage<CpModelProto>
7292  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7293  , pb::IBufferMessage
7294  #endif
7295  {
7296  private static readonly pb::MessageParser<CpModelProto> _parser = new pb::MessageParser<CpModelProto>(() => new CpModelProto());
7297  private pb::UnknownFieldSet _unknownFields;
7298  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7299  public static pb::MessageParser<CpModelProto> Parser { get { return _parser; } }
7300 
7301  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7302  public static pbr::MessageDescriptor Descriptor {
7303  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[23]; }
7304  }
7305 
7306  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7307  pbr::MessageDescriptor pb::IMessage.Descriptor {
7308  get { return Descriptor; }
7309  }
7310 
7311  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7312  public CpModelProto() {
7313  OnConstruction();
7314  }
7315 
7316  partial void OnConstruction();
7317 
7318  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7319  public CpModelProto(CpModelProto other) : this() {
7320  name_ = other.name_;
7321  variables_ = other.variables_.Clone();
7322  constraints_ = other.constraints_.Clone();
7323  objective_ = other.objective_ != null ? other.objective_.Clone() : null;
7324  searchStrategy_ = other.searchStrategy_.Clone();
7325  solutionHint_ = other.solutionHint_ != null ? other.solutionHint_.Clone() : null;
7326  assumptions_ = other.assumptions_.Clone();
7327  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
7328  }
7329 
7330  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7331  public CpModelProto Clone() {
7332  return new CpModelProto(this);
7333  }
7334 
7336  public const int NameFieldNumber = 1;
7337  private string name_ = "";
7341  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7342  public string Name {
7343  get { return name_; }
7344  set {
7345  name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
7346  }
7347  }
7348 
7350  public const int VariablesFieldNumber = 2;
7351  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_variables_codec
7352  = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
7353  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> variables_ = new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
7357  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7358  public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> Variables {
7359  get { return variables_; }
7360  }
7361 
7363  public const int ConstraintsFieldNumber = 3;
7364  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.ConstraintProto> _repeated_constraints_codec
7365  = pb::FieldCodec.ForMessage(26, global::Google.OrTools.Sat.ConstraintProto.Parser);
7366  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> constraints_ = new pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto>();
7367  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7368  public pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> Constraints {
7369  get { return constraints_; }
7370  }
7371 
7373  public const int ObjectiveFieldNumber = 4;
7374  private global::Google.OrTools.Sat.CpObjectiveProto objective_;
7378  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7379  public global::Google.OrTools.Sat.CpObjectiveProto Objective {
7380  get { return objective_; }
7381  set {
7382  objective_ = value;
7383  }
7384  }
7385 
7387  public const int SearchStrategyFieldNumber = 5;
7388  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto> _repeated_searchStrategy_codec
7389  = pb::FieldCodec.ForMessage(42, global::Google.OrTools.Sat.DecisionStrategyProto.Parser);
7390  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> searchStrategy_ = new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto>();
7403  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7404  public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> SearchStrategy {
7405  get { return searchStrategy_; }
7406  }
7407 
7409  public const int SolutionHintFieldNumber = 6;
7410  private global::Google.OrTools.Sat.PartialVariableAssignment solutionHint_;
7424  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7425  public global::Google.OrTools.Sat.PartialVariableAssignment SolutionHint {
7426  get { return solutionHint_; }
7427  set {
7428  solutionHint_ = value;
7429  }
7430  }
7431 
7433  public const int AssumptionsFieldNumber = 7;
7434  private static readonly pb::FieldCodec<int> _repeated_assumptions_codec
7435  = pb::FieldCodec.ForInt32(58);
7436  private readonly pbc::RepeatedField<int> assumptions_ = new pbc::RepeatedField<int>();
7452  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7453  public pbc::RepeatedField<int> Assumptions {
7454  get { return assumptions_; }
7455  }
7456 
7457  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7458  public override bool Equals(object other) {
7459  return Equals(other as CpModelProto);
7460  }
7461 
7462  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7463  public bool Equals(CpModelProto other) {
7464  if (ReferenceEquals(other, null)) {
7465  return false;
7466  }
7467  if (ReferenceEquals(other, this)) {
7468  return true;
7469  }
7470  if (Name != other.Name) return false;
7471  if(!variables_.Equals(other.variables_)) return false;
7472  if(!constraints_.Equals(other.constraints_)) return false;
7473  if (!object.Equals(Objective, other.Objective)) return false;
7474  if(!searchStrategy_.Equals(other.searchStrategy_)) return false;
7475  if (!object.Equals(SolutionHint, other.SolutionHint)) return false;
7476  if(!assumptions_.Equals(other.assumptions_)) return false;
7477  return Equals(_unknownFields, other._unknownFields);
7478  }
7479 
7480  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7481  public override int GetHashCode() {
7482  int hash = 1;
7483  if (Name.Length != 0) hash ^= Name.GetHashCode();
7484  hash ^= variables_.GetHashCode();
7485  hash ^= constraints_.GetHashCode();
7486  if (objective_ != null) hash ^= Objective.GetHashCode();
7487  hash ^= searchStrategy_.GetHashCode();
7488  if (solutionHint_ != null) hash ^= SolutionHint.GetHashCode();
7489  hash ^= assumptions_.GetHashCode();
7490  if (_unknownFields != null) {
7491  hash ^= _unknownFields.GetHashCode();
7492  }
7493  return hash;
7494  }
7495 
7496  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7497  public override string ToString() {
7498  return pb::JsonFormatter.ToDiagnosticString(this);
7499  }
7500 
7501  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7502  public void WriteTo(pb::CodedOutputStream output) {
7503  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7504  output.WriteRawMessage(this);
7505  #else
7506  if (Name.Length != 0) {
7507  output.WriteRawTag(10);
7508  output.WriteString(Name);
7509  }
7510  variables_.WriteTo(output, _repeated_variables_codec);
7511  constraints_.WriteTo(output, _repeated_constraints_codec);
7512  if (objective_ != null) {
7513  output.WriteRawTag(34);
7514  output.WriteMessage(Objective);
7515  }
7516  searchStrategy_.WriteTo(output, _repeated_searchStrategy_codec);
7517  if (solutionHint_ != null) {
7518  output.WriteRawTag(50);
7519  output.WriteMessage(SolutionHint);
7520  }
7521  assumptions_.WriteTo(output, _repeated_assumptions_codec);
7522  if (_unknownFields != null) {
7523  _unknownFields.WriteTo(output);
7524  }
7525  #endif
7526  }
7527 
7528  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7529  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7530  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
7531  if (Name.Length != 0) {
7532  output.WriteRawTag(10);
7533  output.WriteString(Name);
7534  }
7535  variables_.WriteTo(ref output, _repeated_variables_codec);
7536  constraints_.WriteTo(ref output, _repeated_constraints_codec);
7537  if (objective_ != null) {
7538  output.WriteRawTag(34);
7539  output.WriteMessage(Objective);
7540  }
7541  searchStrategy_.WriteTo(ref output, _repeated_searchStrategy_codec);
7542  if (solutionHint_ != null) {
7543  output.WriteRawTag(50);
7544  output.WriteMessage(SolutionHint);
7545  }
7546  assumptions_.WriteTo(ref output, _repeated_assumptions_codec);
7547  if (_unknownFields != null) {
7548  _unknownFields.WriteTo(ref output);
7549  }
7550  }
7551  #endif
7552 
7553  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7554  public int CalculateSize() {
7555  int size = 0;
7556  if (Name.Length != 0) {
7557  size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
7558  }
7559  size += variables_.CalculateSize(_repeated_variables_codec);
7560  size += constraints_.CalculateSize(_repeated_constraints_codec);
7561  if (objective_ != null) {
7562  size += 1 + pb::CodedOutputStream.ComputeMessageSize(Objective);
7563  }
7564  size += searchStrategy_.CalculateSize(_repeated_searchStrategy_codec);
7565  if (solutionHint_ != null) {
7566  size += 1 + pb::CodedOutputStream.ComputeMessageSize(SolutionHint);
7567  }
7568  size += assumptions_.CalculateSize(_repeated_assumptions_codec);
7569  if (_unknownFields != null) {
7570  size += _unknownFields.CalculateSize();
7571  }
7572  return size;
7573  }
7574 
7575  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7576  public void MergeFrom(CpModelProto other) {
7577  if (other == null) {
7578  return;
7579  }
7580  if (other.Name.Length != 0) {
7581  Name = other.Name;
7582  }
7583  variables_.Add(other.variables_);
7584  constraints_.Add(other.constraints_);
7585  if (other.objective_ != null) {
7586  if (objective_ == null) {
7587  Objective = new global::Google.OrTools.Sat.CpObjectiveProto();
7588  }
7589  Objective.MergeFrom(other.Objective);
7590  }
7591  searchStrategy_.Add(other.searchStrategy_);
7592  if (other.solutionHint_ != null) {
7593  if (solutionHint_ == null) {
7594  SolutionHint = new global::Google.OrTools.Sat.PartialVariableAssignment();
7595  }
7596  SolutionHint.MergeFrom(other.SolutionHint);
7597  }
7598  assumptions_.Add(other.assumptions_);
7599  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
7600  }
7601 
7602  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7603  public void MergeFrom(pb::CodedInputStream input) {
7604  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7605  input.ReadRawMessage(this);
7606  #else
7607  uint tag;
7608  while ((tag = input.ReadTag()) != 0) {
7609  switch(tag) {
7610  default:
7611  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
7612  break;
7613  case 10: {
7614  Name = input.ReadString();
7615  break;
7616  }
7617  case 18: {
7618  variables_.AddEntriesFrom(input, _repeated_variables_codec);
7619  break;
7620  }
7621  case 26: {
7622  constraints_.AddEntriesFrom(input, _repeated_constraints_codec);
7623  break;
7624  }
7625  case 34: {
7626  if (objective_ == null) {
7627  Objective = new global::Google.OrTools.Sat.CpObjectiveProto();
7628  }
7629  input.ReadMessage(Objective);
7630  break;
7631  }
7632  case 42: {
7633  searchStrategy_.AddEntriesFrom(input, _repeated_searchStrategy_codec);
7634  break;
7635  }
7636  case 50: {
7637  if (solutionHint_ == null) {
7638  SolutionHint = new global::Google.OrTools.Sat.PartialVariableAssignment();
7639  }
7640  input.ReadMessage(SolutionHint);
7641  break;
7642  }
7643  case 58:
7644  case 56: {
7645  assumptions_.AddEntriesFrom(input, _repeated_assumptions_codec);
7646  break;
7647  }
7648  }
7649  }
7650  #endif
7651  }
7652 
7653  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7654  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7655  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
7656  uint tag;
7657  while ((tag = input.ReadTag()) != 0) {
7658  switch(tag) {
7659  default:
7660  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
7661  break;
7662  case 10: {
7663  Name = input.ReadString();
7664  break;
7665  }
7666  case 18: {
7667  variables_.AddEntriesFrom(ref input, _repeated_variables_codec);
7668  break;
7669  }
7670  case 26: {
7671  constraints_.AddEntriesFrom(ref input, _repeated_constraints_codec);
7672  break;
7673  }
7674  case 34: {
7675  if (objective_ == null) {
7676  Objective = new global::Google.OrTools.Sat.CpObjectiveProto();
7677  }
7678  input.ReadMessage(Objective);
7679  break;
7680  }
7681  case 42: {
7682  searchStrategy_.AddEntriesFrom(ref input, _repeated_searchStrategy_codec);
7683  break;
7684  }
7685  case 50: {
7686  if (solutionHint_ == null) {
7687  SolutionHint = new global::Google.OrTools.Sat.PartialVariableAssignment();
7688  }
7689  input.ReadMessage(SolutionHint);
7690  break;
7691  }
7692  case 58:
7693  case 56: {
7694  assumptions_.AddEntriesFrom(ref input, _repeated_assumptions_codec);
7695  break;
7696  }
7697  }
7698  }
7699  }
7700  #endif
7701 
7702  }
7703 
7711  public sealed partial class CpSolverResponse : pb::IMessage<CpSolverResponse>
7712  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
7713  , pb::IBufferMessage
7714  #endif
7715  {
7716  private static readonly pb::MessageParser<CpSolverResponse> _parser = new pb::MessageParser<CpSolverResponse>(() => new CpSolverResponse());
7717  private pb::UnknownFieldSet _unknownFields;
7718  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7719  public static pb::MessageParser<CpSolverResponse> Parser { get { return _parser; } }
7720 
7721  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7722  public static pbr::MessageDescriptor Descriptor {
7723  get { return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[24]; }
7724  }
7725 
7726  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7727  pbr::MessageDescriptor pb::IMessage.Descriptor {
7728  get { return Descriptor; }
7729  }
7730 
7731  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7732  public CpSolverResponse() {
7733  OnConstruction();
7734  }
7735 
7736  partial void OnConstruction();
7737 
7738  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7739  public CpSolverResponse(CpSolverResponse other) : this() {
7740  status_ = other.status_;
7741  solution_ = other.solution_.Clone();
7742  objectiveValue_ = other.objectiveValue_;
7743  bestObjectiveBound_ = other.bestObjectiveBound_;
7744  solutionLowerBounds_ = other.solutionLowerBounds_.Clone();
7745  solutionUpperBounds_ = other.solutionUpperBounds_.Clone();
7746  tightenedVariables_ = other.tightenedVariables_.Clone();
7747  sufficientAssumptionsForInfeasibility_ = other.sufficientAssumptionsForInfeasibility_.Clone();
7748  allSolutionsWereFound_ = other.allSolutionsWereFound_;
7749  numBooleans_ = other.numBooleans_;
7750  numConflicts_ = other.numConflicts_;
7751  numBranches_ = other.numBranches_;
7752  numBinaryPropagations_ = other.numBinaryPropagations_;
7753  numIntegerPropagations_ = other.numIntegerPropagations_;
7754  wallTime_ = other.wallTime_;
7755  userTime_ = other.userTime_;
7756  deterministicTime_ = other.deterministicTime_;
7757  primalIntegral_ = other.primalIntegral_;
7758  solutionInfo_ = other.solutionInfo_;
7759  _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
7760  }
7761 
7762  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7763  public CpSolverResponse Clone() {
7764  return new CpSolverResponse(this);
7765  }
7766 
7768  public const int StatusFieldNumber = 1;
7769  private global::Google.OrTools.Sat.CpSolverStatus status_ = global::Google.OrTools.Sat.CpSolverStatus.Unknown;
7773  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7774  public global::Google.OrTools.Sat.CpSolverStatus Status {
7775  get { return status_; }
7776  set {
7777  status_ = value;
7778  }
7779  }
7780 
7782  public const int SolutionFieldNumber = 2;
7783  private static readonly pb::FieldCodec<long> _repeated_solution_codec
7784  = pb::FieldCodec.ForInt64(18);
7785  private readonly pbc::RepeatedField<long> solution_ = new pbc::RepeatedField<long>();
7792  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7793  public pbc::RepeatedField<long> Solution {
7794  get { return solution_; }
7795  }
7796 
7798  public const int ObjectiveValueFieldNumber = 3;
7799  private double objectiveValue_;
7806  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7807  public double ObjectiveValue {
7808  get { return objectiveValue_; }
7809  set {
7810  objectiveValue_ = value;
7811  }
7812  }
7813 
7815  public const int BestObjectiveBoundFieldNumber = 4;
7816  private double bestObjectiveBound_;
7822  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7823  public double BestObjectiveBound {
7824  get { return bestObjectiveBound_; }
7825  set {
7826  bestObjectiveBound_ = value;
7827  }
7828  }
7829 
7831  public const int SolutionLowerBoundsFieldNumber = 18;
7832  private static readonly pb::FieldCodec<long> _repeated_solutionLowerBounds_codec
7833  = pb::FieldCodec.ForInt64(146);
7834  private readonly pbc::RepeatedField<long> solutionLowerBounds_ = new pbc::RepeatedField<long>();
7844  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7845  public pbc::RepeatedField<long> SolutionLowerBounds {
7846  get { return solutionLowerBounds_; }
7847  }
7848 
7850  public const int SolutionUpperBoundsFieldNumber = 19;
7851  private static readonly pb::FieldCodec<long> _repeated_solutionUpperBounds_codec
7852  = pb::FieldCodec.ForInt64(154);
7853  private readonly pbc::RepeatedField<long> solutionUpperBounds_ = new pbc::RepeatedField<long>();
7854  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7855  public pbc::RepeatedField<long> SolutionUpperBounds {
7856  get { return solutionUpperBounds_; }
7857  }
7858 
7860  public const int TightenedVariablesFieldNumber = 21;
7861  private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_tightenedVariables_codec
7862  = pb::FieldCodec.ForMessage(170, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
7863  private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> tightenedVariables_ = new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
7878  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7879  public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> TightenedVariables {
7880  get { return tightenedVariables_; }
7881  }
7882 
7884  public const int SufficientAssumptionsForInfeasibilityFieldNumber = 23;
7885  private static readonly pb::FieldCodec<int> _repeated_sufficientAssumptionsForInfeasibility_codec
7886  = pb::FieldCodec.ForInt32(186);
7887  private readonly pbc::RepeatedField<int> sufficientAssumptionsForInfeasibility_ = new pbc::RepeatedField<int>();
7905  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7906  public pbc::RepeatedField<int> SufficientAssumptionsForInfeasibility {
7907  get { return sufficientAssumptionsForInfeasibility_; }
7908  }
7909 
7911  public const int AllSolutionsWereFoundFieldNumber = 5;
7912  private bool allSolutionsWereFound_;
7920  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7921  public bool AllSolutionsWereFound {
7922  get { return allSolutionsWereFound_; }
7923  set {
7924  allSolutionsWereFound_ = value;
7925  }
7926  }
7927 
7929  public const int NumBooleansFieldNumber = 10;
7930  private long numBooleans_;
7934  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7935  public long NumBooleans {
7936  get { return numBooleans_; }
7937  set {
7938  numBooleans_ = value;
7939  }
7940  }
7941 
7943  public const int NumConflictsFieldNumber = 11;
7944  private long numConflicts_;
7945  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7946  public long NumConflicts {
7947  get { return numConflicts_; }
7948  set {
7949  numConflicts_ = value;
7950  }
7951  }
7952 
7954  public const int NumBranchesFieldNumber = 12;
7955  private long numBranches_;
7956  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7957  public long NumBranches {
7958  get { return numBranches_; }
7959  set {
7960  numBranches_ = value;
7961  }
7962  }
7963 
7965  public const int NumBinaryPropagationsFieldNumber = 13;
7966  private long numBinaryPropagations_;
7967  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7968  public long NumBinaryPropagations {
7969  get { return numBinaryPropagations_; }
7970  set {
7971  numBinaryPropagations_ = value;
7972  }
7973  }
7974 
7976  public const int NumIntegerPropagationsFieldNumber = 14;
7977  private long numIntegerPropagations_;
7978  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7979  public long NumIntegerPropagations {
7980  get { return numIntegerPropagations_; }
7981  set {
7982  numIntegerPropagations_ = value;
7983  }
7984  }
7985 
7987  public const int WallTimeFieldNumber = 15;
7988  private double wallTime_;
7989  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7990  public double WallTime {
7991  get { return wallTime_; }
7992  set {
7993  wallTime_ = value;
7994  }
7995  }
7996 
7998  public const int UserTimeFieldNumber = 16;
7999  private double userTime_;
8000  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8001  public double UserTime {
8002  get { return userTime_; }
8003  set {
8004  userTime_ = value;
8005  }
8006  }
8007 
8009  public const int DeterministicTimeFieldNumber = 17;
8010  private double deterministicTime_;
8011  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8012  public double DeterministicTime {
8013  get { return deterministicTime_; }
8014  set {
8015  deterministicTime_ = value;
8016  }
8017  }
8018 
8020  public const int PrimalIntegralFieldNumber = 22;
8021  private double primalIntegral_;
8022  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8023  public double PrimalIntegral {
8024  get { return primalIntegral_; }
8025  set {
8026  primalIntegral_ = value;
8027  }
8028  }
8029 
8031  public const int SolutionInfoFieldNumber = 20;
8032  private string solutionInfo_ = "";
8036  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8037  public string SolutionInfo {
8038  get { return solutionInfo_; }
8039  set {
8040  solutionInfo_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
8041  }
8042  }
8043 
8044  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8045  public override bool Equals(object other) {
8046  return Equals(other as CpSolverResponse);
8047  }
8048 
8049  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8050  public bool Equals(CpSolverResponse other) {
8051  if (ReferenceEquals(other, null)) {
8052  return false;
8053  }
8054  if (ReferenceEquals(other, this)) {
8055  return true;
8056  }
8057  if (Status != other.Status) return false;
8058  if(!solution_.Equals(other.solution_)) return false;
8059  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveValue, other.ObjectiveValue)) return false;
8060  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(BestObjectiveBound, other.BestObjectiveBound)) return false;
8061  if(!solutionLowerBounds_.Equals(other.solutionLowerBounds_)) return false;
8062  if(!solutionUpperBounds_.Equals(other.solutionUpperBounds_)) return false;
8063  if(!tightenedVariables_.Equals(other.tightenedVariables_)) return false;
8064  if(!sufficientAssumptionsForInfeasibility_.Equals(other.sufficientAssumptionsForInfeasibility_)) return false;
8065  if (AllSolutionsWereFound != other.AllSolutionsWereFound) return false;
8066  if (NumBooleans != other.NumBooleans) return false;
8067  if (NumConflicts != other.NumConflicts) return false;
8068  if (NumBranches != other.NumBranches) return false;
8069  if (NumBinaryPropagations != other.NumBinaryPropagations) return false;
8070  if (NumIntegerPropagations != other.NumIntegerPropagations) return false;
8071  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.WallTime)) return false;
8072  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(UserTime, other.UserTime)) return false;
8073  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DeterministicTime, other.DeterministicTime)) return false;
8074  if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalIntegral, other.PrimalIntegral)) return false;
8075  if (SolutionInfo != other.SolutionInfo) return false;
8076  return Equals(_unknownFields, other._unknownFields);
8077  }
8078 
8079  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8080  public override int GetHashCode() {
8081  int hash = 1;
8082  if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) hash ^= Status.GetHashCode();
8083  hash ^= solution_.GetHashCode();
8084  if (ObjectiveValue != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveValue);
8085  if (BestObjectiveBound != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BestObjectiveBound);
8086  hash ^= solutionLowerBounds_.GetHashCode();
8087  hash ^= solutionUpperBounds_.GetHashCode();
8088  hash ^= tightenedVariables_.GetHashCode();
8089  hash ^= sufficientAssumptionsForInfeasibility_.GetHashCode();
8090  if (AllSolutionsWereFound != false) hash ^= AllSolutionsWereFound.GetHashCode();
8091  if (NumBooleans != 0L) hash ^= NumBooleans.GetHashCode();
8092  if (NumConflicts != 0L) hash ^= NumConflicts.GetHashCode();
8093  if (NumBranches != 0L) hash ^= NumBranches.GetHashCode();
8094  if (NumBinaryPropagations != 0L) hash ^= NumBinaryPropagations.GetHashCode();
8095  if (NumIntegerPropagations != 0L) hash ^= NumIntegerPropagations.GetHashCode();
8096  if (WallTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);
8097  if (UserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(UserTime);
8098  if (DeterministicTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DeterministicTime);
8099  if (PrimalIntegral != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalIntegral);
8100  if (SolutionInfo.Length != 0) hash ^= SolutionInfo.GetHashCode();
8101  if (_unknownFields != null) {
8102  hash ^= _unknownFields.GetHashCode();
8103  }
8104  return hash;
8105  }
8106 
8107  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8108  public override string ToString() {
8109  return pb::JsonFormatter.ToDiagnosticString(this);
8110  }
8111 
8112  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8113  public void WriteTo(pb::CodedOutputStream output) {
8114  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
8115  output.WriteRawMessage(this);
8116  #else
8117  if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
8118  output.WriteRawTag(8);
8119  output.WriteEnum((int) Status);
8120  }
8121  solution_.WriteTo(output, _repeated_solution_codec);
8122  if (ObjectiveValue != 0D) {
8123  output.WriteRawTag(25);
8124  output.WriteDouble(ObjectiveValue);
8125  }
8126  if (BestObjectiveBound != 0D) {
8127  output.WriteRawTag(33);
8128  output.WriteDouble(BestObjectiveBound);
8129  }
8130  if (AllSolutionsWereFound != false) {
8131  output.WriteRawTag(40);
8132  output.WriteBool(AllSolutionsWereFound);
8133  }
8134  if (NumBooleans != 0L) {
8135  output.WriteRawTag(80);
8136  output.WriteInt64(NumBooleans);
8137  }
8138  if (NumConflicts != 0L) {
8139  output.WriteRawTag(88);
8140  output.WriteInt64(NumConflicts);
8141  }
8142  if (NumBranches != 0L) {
8143  output.WriteRawTag(96);
8144  output.WriteInt64(NumBranches);
8145  }
8146  if (NumBinaryPropagations != 0L) {
8147  output.WriteRawTag(104);
8148  output.WriteInt64(NumBinaryPropagations);
8149  }
8150  if (NumIntegerPropagations != 0L) {
8151  output.WriteRawTag(112);
8152  output.WriteInt64(NumIntegerPropagations);
8153  }
8154  if (WallTime != 0D) {
8155  output.WriteRawTag(121);
8156  output.WriteDouble(WallTime);
8157  }
8158  if (UserTime != 0D) {
8159  output.WriteRawTag(129, 1);
8160  output.WriteDouble(UserTime);
8161  }
8162  if (DeterministicTime != 0D) {
8163  output.WriteRawTag(137, 1);
8164  output.WriteDouble(DeterministicTime);
8165  }
8166  solutionLowerBounds_.WriteTo(output, _repeated_solutionLowerBounds_codec);
8167  solutionUpperBounds_.WriteTo(output, _repeated_solutionUpperBounds_codec);
8168  if (SolutionInfo.Length != 0) {
8169  output.WriteRawTag(162, 1);
8170  output.WriteString(SolutionInfo);
8171  }
8172  tightenedVariables_.WriteTo(output, _repeated_tightenedVariables_codec);
8173  if (PrimalIntegral != 0D) {
8174  output.WriteRawTag(177, 1);
8175  output.WriteDouble(PrimalIntegral);
8176  }
8177  sufficientAssumptionsForInfeasibility_.WriteTo(output, _repeated_sufficientAssumptionsForInfeasibility_codec);
8178  if (_unknownFields != null) {
8179  _unknownFields.WriteTo(output);
8180  }
8181  #endif
8182  }
8183 
8184  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
8185  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8186  void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
8187  if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
8188  output.WriteRawTag(8);
8189  output.WriteEnum((int) Status);
8190  }
8191  solution_.WriteTo(ref output, _repeated_solution_codec);
8192  if (ObjectiveValue != 0D) {
8193  output.WriteRawTag(25);
8194  output.WriteDouble(ObjectiveValue);
8195  }
8196  if (BestObjectiveBound != 0D) {
8197  output.WriteRawTag(33);
8198  output.WriteDouble(BestObjectiveBound);
8199  }
8200  if (AllSolutionsWereFound != false) {
8201  output.WriteRawTag(40);
8202  output.WriteBool(AllSolutionsWereFound);
8203  }
8204  if (NumBooleans != 0L) {
8205  output.WriteRawTag(80);
8206  output.WriteInt64(NumBooleans);
8207  }
8208  if (NumConflicts != 0L) {
8209  output.WriteRawTag(88);
8210  output.WriteInt64(NumConflicts);
8211  }
8212  if (NumBranches != 0L) {
8213  output.WriteRawTag(96);
8214  output.WriteInt64(NumBranches);
8215  }
8216  if (NumBinaryPropagations != 0L) {
8217  output.WriteRawTag(104);
8218  output.WriteInt64(NumBinaryPropagations);
8219  }
8220  if (NumIntegerPropagations != 0L) {
8221  output.WriteRawTag(112);
8222  output.WriteInt64(NumIntegerPropagations);
8223  }
8224  if (WallTime != 0D) {
8225  output.WriteRawTag(121);
8226  output.WriteDouble(WallTime);
8227  }
8228  if (UserTime != 0D) {
8229  output.WriteRawTag(129, 1);
8230  output.WriteDouble(UserTime);
8231  }
8232  if (DeterministicTime != 0D) {
8233  output.WriteRawTag(137, 1);
8234  output.WriteDouble(DeterministicTime);
8235  }
8236  solutionLowerBounds_.WriteTo(ref output, _repeated_solutionLowerBounds_codec);
8237  solutionUpperBounds_.WriteTo(ref output, _repeated_solutionUpperBounds_codec);
8238  if (SolutionInfo.Length != 0) {
8239  output.WriteRawTag(162, 1);
8240  output.WriteString(SolutionInfo);
8241  }
8242  tightenedVariables_.WriteTo(ref output, _repeated_tightenedVariables_codec);
8243  if (PrimalIntegral != 0D) {
8244  output.WriteRawTag(177, 1);
8245  output.WriteDouble(PrimalIntegral);
8246  }
8247  sufficientAssumptionsForInfeasibility_.WriteTo(ref output, _repeated_sufficientAssumptionsForInfeasibility_codec);
8248  if (_unknownFields != null) {
8249  _unknownFields.WriteTo(ref output);
8250  }
8251  }
8252  #endif
8253 
8254  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8255  public int CalculateSize() {
8256  int size = 0;
8257  if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
8258  size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Status);
8259  }
8260  size += solution_.CalculateSize(_repeated_solution_codec);
8261  if (ObjectiveValue != 0D) {
8262  size += 1 + 8;
8263  }
8264  if (BestObjectiveBound != 0D) {
8265  size += 1 + 8;
8266  }
8267  size += solutionLowerBounds_.CalculateSize(_repeated_solutionLowerBounds_codec);
8268  size += solutionUpperBounds_.CalculateSize(_repeated_solutionUpperBounds_codec);
8269  size += tightenedVariables_.CalculateSize(_repeated_tightenedVariables_codec);
8270  size += sufficientAssumptionsForInfeasibility_.CalculateSize(_repeated_sufficientAssumptionsForInfeasibility_codec);
8271  if (AllSolutionsWereFound != false) {
8272  size += 1 + 1;
8273  }
8274  if (NumBooleans != 0L) {
8275  size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBooleans);
8276  }
8277  if (NumConflicts != 0L) {
8278  size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumConflicts);
8279  }
8280  if (NumBranches != 0L) {
8281  size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBranches);
8282  }
8283  if (NumBinaryPropagations != 0L) {
8284  size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBinaryPropagations);
8285  }
8286  if (NumIntegerPropagations != 0L) {
8287  size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumIntegerPropagations);
8288  }
8289  if (WallTime != 0D) {
8290  size += 1 + 8;
8291  }
8292  if (UserTime != 0D) {
8293  size += 2 + 8;
8294  }
8295  if (DeterministicTime != 0D) {
8296  size += 2 + 8;
8297  }
8298  if (PrimalIntegral != 0D) {
8299  size += 2 + 8;
8300  }
8301  if (SolutionInfo.Length != 0) {
8302  size += 2 + pb::CodedOutputStream.ComputeStringSize(SolutionInfo);
8303  }
8304  if (_unknownFields != null) {
8305  size += _unknownFields.CalculateSize();
8306  }
8307  return size;
8308  }
8309 
8310  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8311  public void MergeFrom(CpSolverResponse other) {
8312  if (other == null) {
8313  return;
8314  }
8315  if (other.Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
8316  Status = other.Status;
8317  }
8318  solution_.Add(other.solution_);
8319  if (other.ObjectiveValue != 0D) {
8320  ObjectiveValue = other.ObjectiveValue;
8321  }
8322  if (other.BestObjectiveBound != 0D) {
8323  BestObjectiveBound = other.BestObjectiveBound;
8324  }
8325  solutionLowerBounds_.Add(other.solutionLowerBounds_);
8326  solutionUpperBounds_.Add(other.solutionUpperBounds_);
8327  tightenedVariables_.Add(other.tightenedVariables_);
8328  sufficientAssumptionsForInfeasibility_.Add(other.sufficientAssumptionsForInfeasibility_);
8329  if (other.AllSolutionsWereFound != false) {
8330  AllSolutionsWereFound = other.AllSolutionsWereFound;
8331  }
8332  if (other.NumBooleans != 0L) {
8333  NumBooleans = other.NumBooleans;
8334  }
8335  if (other.NumConflicts != 0L) {
8336  NumConflicts = other.NumConflicts;
8337  }
8338  if (other.NumBranches != 0L) {
8339  NumBranches = other.NumBranches;
8340  }
8341  if (other.NumBinaryPropagations != 0L) {
8342  NumBinaryPropagations = other.NumBinaryPropagations;
8343  }
8344  if (other.NumIntegerPropagations != 0L) {
8345  NumIntegerPropagations = other.NumIntegerPropagations;
8346  }
8347  if (other.WallTime != 0D) {
8348  WallTime = other.WallTime;
8349  }
8350  if (other.UserTime != 0D) {
8351  UserTime = other.UserTime;
8352  }
8353  if (other.DeterministicTime != 0D) {
8354  DeterministicTime = other.DeterministicTime;
8355  }
8356  if (other.PrimalIntegral != 0D) {
8357  PrimalIntegral = other.PrimalIntegral;
8358  }
8359  if (other.SolutionInfo.Length != 0) {
8360  SolutionInfo = other.SolutionInfo;
8361  }
8362  _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
8363  }
8364 
8365  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8366  public void MergeFrom(pb::CodedInputStream input) {
8367  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
8368  input.ReadRawMessage(this);
8369  #else
8370  uint tag;
8371  while ((tag = input.ReadTag()) != 0) {
8372  switch(tag) {
8373  default:
8374  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
8375  break;
8376  case 8: {
8377  Status = (global::Google.OrTools.Sat.CpSolverStatus) input.ReadEnum();
8378  break;
8379  }
8380  case 18:
8381  case 16: {
8382  solution_.AddEntriesFrom(input, _repeated_solution_codec);
8383  break;
8384  }
8385  case 25: {
8386  ObjectiveValue = input.ReadDouble();
8387  break;
8388  }
8389  case 33: {
8390  BestObjectiveBound = input.ReadDouble();
8391  break;
8392  }
8393  case 40: {
8394  AllSolutionsWereFound = input.ReadBool();
8395  break;
8396  }
8397  case 80: {
8398  NumBooleans = input.ReadInt64();
8399  break;
8400  }
8401  case 88: {
8402  NumConflicts = input.ReadInt64();
8403  break;
8404  }
8405  case 96: {
8406  NumBranches = input.ReadInt64();
8407  break;
8408  }
8409  case 104: {
8410  NumBinaryPropagations = input.ReadInt64();
8411  break;
8412  }
8413  case 112: {
8414  NumIntegerPropagations = input.ReadInt64();
8415  break;
8416  }
8417  case 121: {
8418  WallTime = input.ReadDouble();
8419  break;
8420  }
8421  case 129: {
8422  UserTime = input.ReadDouble();
8423  break;
8424  }
8425  case 137: {
8426  DeterministicTime = input.ReadDouble();
8427  break;
8428  }
8429  case 146:
8430  case 144: {
8431  solutionLowerBounds_.AddEntriesFrom(input, _repeated_solutionLowerBounds_codec);
8432  break;
8433  }
8434  case 154:
8435  case 152: {
8436  solutionUpperBounds_.AddEntriesFrom(input, _repeated_solutionUpperBounds_codec);
8437  break;
8438  }
8439  case 162: {
8440  SolutionInfo = input.ReadString();
8441  break;
8442  }
8443  case 170: {
8444  tightenedVariables_.AddEntriesFrom(input, _repeated_tightenedVariables_codec);
8445  break;
8446  }
8447  case 177: {
8448  PrimalIntegral = input.ReadDouble();
8449  break;
8450  }
8451  case 186:
8452  case 184: {
8453  sufficientAssumptionsForInfeasibility_.AddEntriesFrom(input, _repeated_sufficientAssumptionsForInfeasibility_codec);
8454  break;
8455  }
8456  }
8457  }
8458  #endif
8459  }
8460 
8461  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
8462  [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8463  void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
8464  uint tag;
8465  while ((tag = input.ReadTag()) != 0) {
8466  switch(tag) {
8467  default:
8468  _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
8469  break;
8470  case 8: {
8471  Status = (global::Google.OrTools.Sat.CpSolverStatus) input.ReadEnum();
8472  break;
8473  }
8474  case 18:
8475  case 16: {
8476  solution_.AddEntriesFrom(ref input, _repeated_solution_codec);
8477  break;
8478  }
8479  case 25: {
8480  ObjectiveValue = input.ReadDouble();
8481  break;
8482  }
8483  case 33: {
8484  BestObjectiveBound = input.ReadDouble();
8485  break;
8486  }
8487  case 40: {
8488  AllSolutionsWereFound = input.ReadBool();
8489  break;
8490  }
8491  case 80: {
8492  NumBooleans = input.ReadInt64();
8493  break;
8494  }
8495  case 88: {
8496  NumConflicts = input.ReadInt64();
8497  break;
8498  }
8499  case 96: {
8500  NumBranches = input.ReadInt64();
8501  break;
8502  }
8503  case 104: {
8504  NumBinaryPropagations = input.ReadInt64();
8505  break;
8506  }
8507  case 112: {
8508  NumIntegerPropagations = input.ReadInt64();
8509  break;
8510  }
8511  case 121: {
8512  WallTime = input.ReadDouble();
8513  break;
8514  }
8515  case 129: {
8516  UserTime = input.ReadDouble();
8517  break;
8518  }
8519  case 137: {
8520  DeterministicTime = input.ReadDouble();
8521  break;
8522  }
8523  case 146:
8524  case 144: {
8525  solutionLowerBounds_.AddEntriesFrom(ref input, _repeated_solutionLowerBounds_codec);
8526  break;
8527  }
8528  case 154:
8529  case 152: {
8530  solutionUpperBounds_.AddEntriesFrom(ref input, _repeated_solutionUpperBounds_codec);
8531  break;
8532  }
8533  case 162: {
8534  SolutionInfo = input.ReadString();
8535  break;
8536  }
8537  case 170: {
8538  tightenedVariables_.AddEntriesFrom(ref input, _repeated_tightenedVariables_codec);
8539  break;
8540  }
8541  case 177: {
8542  PrimalIntegral = input.ReadDouble();
8543  break;
8544  }
8545  case 186:
8546  case 184: {
8547  sufficientAssumptionsForInfeasibility_.AddEntriesFrom(ref input, _repeated_sufficientAssumptionsForInfeasibility_codec);
8548  break;
8549  }
8550  }
8551  }
8552  }
8553  #endif
8554 
8555  }
8556 
8557  #endregion
8558 
8559 }
8560 
8561 #endregion Designer generated code
Google.OrTools.Sat.NoOverlap2DConstraintProto.NoOverlap2DConstraintProto
NoOverlap2DConstraintProto(NoOverlap2DConstraintProto other)
Definition: CpModel.pb.cs:2347
Google.OrTools.Sat.DecisionStrategyProto.Types
Container for nested types declared in the DecisionStrategyProto message type.
Definition: CpModel.pb.cs:6809
Google.OrTools.Sat.IntegerArgumentProto
Argument of the constraints of the form target_var = OP(vars).
Definition: CpModel.pb.cs:638
Google.OrTools.Sat.NoOverlap2DConstraintProto.MergeFrom
void MergeFrom(NoOverlap2DConstraintProto other)
Definition: CpModel.pb.cs:2476
Google.OrTools.Sat.CircuitConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:3241
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:6954
Google.OrTools.Sat.LinearArgumentProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:1154
Google.OrTools.Sat.LinearConstraintProto
The linear sum vars[i] * coeffs[i] must fall in the given domain.
Definition: CpModel.pb.cs:1443
Google.OrTools.Sat.ConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:5202
Google.OrTools.Sat.RoutesConstraintProto.Equals
bool Equals(RoutesConstraintProto other)
Definition: CpModel.pb.cs:3446
Google.OrTools.Sat.LinearArgumentProto.Equals
bool Equals(LinearArgumentProto other)
Definition: CpModel.pb.cs:1125
Google.OrTools.Sat.LinearArgumentProto.MergeFrom
void MergeFrom(LinearArgumentProto other)
Definition: CpModel.pb.cs:1197
Google.OrTools.Sat.CpModelProto.SolutionHint
global::Google.OrTools.Sat.PartialVariableAssignment SolutionHint
Solution hint.
Definition: CpModel.pb.cs:7425
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.PositiveCoeff
long PositiveCoeff
Definition: CpModel.pb.cs:6910
Google.OrTools.Sat.ConstraintProto.NoOverlap2D
global::Google.OrTools.Sat.NoOverlap2DConstraintProto?? NoOverlap2D
The no_overlap_2d constraint prevents a set of boxes from overlapping.
Definition: CpModel.pb.cs:5091
Google.OrTools.Sat.ElementConstraintProto.Clone
ElementConstraintProto Clone()
Definition: CpModel.pb.cs:1699
Google.OrTools.Sat.PartialVariableAssignment.ToString
override string ToString()
Definition: CpModel.pb.cs:7187
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:6937
Google.OrTools.Sat.InverseConstraintProto.InverseConstraintProto
InverseConstraintProto(InverseConstraintProto other)
Definition: CpModel.pb.cs:4089
Google.OrTools.Sat.DecisionStrategyProto.DomainReductionStrategy
global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy DomainReductionStrategy
Definition: CpModel.pb.cs:6614
Google.OrTools.Sat.IntervalConstraintProto.Equals
bool Equals(IntervalConstraintProto other)
Definition: CpModel.pb.cs:1981
Google.OrTools.Sat.LinearExpressionProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:924
Google.OrTools.Sat.ConstraintProto.ConstraintCase
ConstraintOneofCase ConstraintCase
Definition: CpModel.pb.cs:5147
Google.OrTools.Sat.ConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:5239
Google.OrTools.Sat.AutomatonConstraintProto.MergeFrom
void MergeFrom(AutomatonConstraintProto other)
Definition: CpModel.pb.cs:4471
Google.OrTools.Sat.ElementConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:1772
Google.OrTools.Sat.ConstraintProto.LinMin
global::Google.OrTools.Sat.LinearArgumentProto?? LinMin
The lin_min constraint forces the target to equal the minimum of all linear expressions.
Definition: CpModel.pb.cs:4882
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Var
int Var
Definition: CpModel.pb.cs:6888
Google.OrTools.Sat.CpSolverResponse.Clone
CpSolverResponse Clone()
Definition: CpModel.pb.cs:7763
Google.OrTools.Sat.AutomatonConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:4487
Google.OrTools.Sat.IntegerArgumentProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:695
Google.OrTools.Sat.PartialVariableAssignment.Equals
bool Equals(PartialVariableAssignment other)
Definition: CpModel.pb.cs:7163
Google.OrTools.Sat.CpSolverResponse
The response returned by a solver trying to solve a CpModelProto.
Definition: CpModel.pb.cs:7715
Google.OrTools.Util.Domain
Definition: Domain.cs:17
Google.OrTools.Sat.CircuitCoveringConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:3721
Google.OrTools.Sat.IntegerVariableProto.IntegerVariableProto
IntegerVariableProto(IntegerVariableProto other)
Definition: CpModel.pb.cs:272
Google.OrTools.Sat.NoOverlap2DConstraintProto.NoOverlap2DConstraintProto
NoOverlap2DConstraintProto()
Definition: CpModel.pb.cs:2340
Google.OrTools.Sat.CpModelProto.ToString
override string ToString()
Definition: CpModel.pb.cs:7497
Google.OrTools.Sat.CircuitCoveringConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:3710
Google.OrTools.Sat.ReservoirConstraintProto.MergeFrom
void MergeFrom(ReservoirConstraintProto other)
Definition: CpModel.pb.cs:3003
Google.OrTools.Sat.InverseConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:4179
Google.OrTools.Sat.IntervalConstraintProto.End
int End
Definition: CpModel.pb.cs:1957
Google.OrTools.Sat.TableConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:3903
Google.OrTools.Sat.AutomatonConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:4454
Google.OrTools.Sat.CumulativeConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:2648
Google.OrTools.Sat.ConstraintProto.LinMax
global::Google.OrTools.Sat.LinearArgumentProto?? LinMax
The lin_max constraint forces the target to equal the maximum of all linear expressions.
Definition: CpModel.pb.cs:4851
Google.OrTools.Sat.IntegerArgumentProto.Equals
bool Equals(IntegerArgumentProto other)
Definition: CpModel.pb.cs:700
Google.OrTools.Sat.IntegerVariableProto.ToString
override string ToString()
Definition: CpModel.pb.cs:356
Google.OrTools.Sat.ConstraintProto.Name
string Name
For debug/logging only.
Definition: CpModel.pb.cs:4703
Google.OrTools.Sat.CpSolverResponse.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:8113
Google.OrTools.Sat.ConstraintProto.ConstraintOneofCase
ConstraintOneofCase
Enum of possible cases for the "constraint" oneof.
Definition: CpModel.pb.cs:5117
Google.OrTools.Sat.IntegerVariableProto.MergeFrom
void MergeFrom(IntegerVariableProto other)
Definition: CpModel.pb.cs:404
Google.OrTools.Sat.DecisionStrategyProto.VariableSelectionStrategy
global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy VariableSelectionStrategy
Definition: CpModel.pb.cs:6603
Google.OrTools.Sat.IntervalConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:2007
Google.OrTools.Sat.ReservoirConstraintProto.MinLevel
long MinLevel
Definition: CpModel.pb.cs:2845
Google.OrTools.Sat.IntervalConstraintProto.MergeFrom
void MergeFrom(IntervalConstraintProto other)
Definition: CpModel.pb.cs:2074
Google.OrTools.Sat.CpSolverResponse.PrimalIntegral
double PrimalIntegral
Definition: CpModel.pb.cs:8023
Google.OrTools.Sat.LinearArgumentProto.Target
global::Google.OrTools.Sat.LinearExpressionProto Target
Definition: CpModel.pb.cs:1102
Google.OrTools.Sat.NoOverlapConstraintProto
All the intervals (index of IntervalConstraintProto) must be disjoint.
Definition: CpModel.pb.cs:2157
Google.OrTools.Sat.ConstraintProto.AllDiff
global::Google.OrTools.Sat.AllDifferentConstraintProto?? AllDiff
The all_diff constraint forces all variables to take different values.
Definition: CpModel.pb.cs:4926
Google.OrTools.Sat.RoutesConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:3481
Google.OrTools.Sat.NoOverlap2DConstraintProto.BoxesWithNullAreaCanOverlap
bool BoxesWithNullAreaCanOverlap
Definition: CpModel.pb.cs:2386
Google.OrTools.Sat.LinearArgumentProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:1184
Google.OrTools.Sat.ConstraintProto.Linear
global::Google.OrTools.Sat.LinearConstraintProto?? Linear
The linear constraint enforces a linear inequality among the variables, such as 0 <= x + 2y <= 10.
Definition: CpModel.pb.cs:4912
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.AffineTransformation
AffineTransformation()
Definition: CpModel.pb.cs:6865
Google.OrTools.Sat.NoOverlapConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:2202
Google.OrTools.Sat.TableConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:3998
Google.OrTools.Sat.AllDifferentConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:1334
Google.OrTools.Sat.AutomatonConstraintProto.AutomatonConstraintProto
AutomatonConstraintProto(AutomatonConstraintProto other)
Definition: CpModel.pb.cs:4283
Google.OrTools.Sat.TableConstraintProto.Negated
bool Negated
If true, the meaning is "negated", that is we forbid any of the given tuple from a feasible assignmen...
Definition: CpModel.pb.cs:3895
Google.OrTools.Sat.PartialVariableAssignment.PartialVariableAssignment
PartialVariableAssignment()
Definition: CpModel.pb.cs:7119
Google.OrTools.Sat.CpSolverResponse.NumConflicts
long NumConflicts
Definition: CpModel.pb.cs:7946
Google.OrTools.Sat.CpModelProto.Name
string Name
For debug/logging only.
Definition: CpModel.pb.cs:7342
Google.OrTools.Sat.NoOverlapConstraintProto.NoOverlapConstraintProto
NoOverlapConstraintProto(NoOverlapConstraintProto other)
Definition: CpModel.pb.cs:2181
Google.OrTools.Sat.IntervalConstraintProto.Clone
IntervalConstraintProto Clone()
Definition: CpModel.pb.cs:1938
Google.OrTools.Sat.CpModelReflection
Holder for reflection information generated from ortools/sat/cp_model.proto
Definition: CpModel.pb.cs:15
Google.OrTools.Sat.NoOverlap2DConstraintProto.Clone
NoOverlap2DConstraintProto Clone()
Definition: CpModel.pb.cs:2355
Google.OrTools.Sat.CpObjectiveProto
Optimization objective.
Definition: CpModel.pb.cs:6235
Google.OrTools.Sat.AutomatonConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:4374
Google.OrTools.Sat.LinearArgumentProto.ToString
override string ToString()
Definition: CpModel.pb.cs:1149
Google.OrTools.Sat.CircuitCoveringConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:3726
Google.OrTools.Sat.IntervalConstraintProto.Size
int Size
Definition: CpModel.pb.cs:1968
Google.OrTools.Sat.BoolArgumentProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:571
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:7033
Google.OrTools.Sat.ConstraintProto.BoolXor
global::Google.OrTools.Sat.BoolArgumentProto?? BoolXor
The bool_xor constraint forces an odd number of the literals to be true.
Definition: CpModel.pb.cs:4792
Google.OrTools.Sat.CumulativeConstraintProto.CumulativeConstraintProto
CumulativeConstraintProto(CumulativeConstraintProto other)
Definition: CpModel.pb.cs:2582
Google.OrTools.Sat.IntegerArgumentProto.Clone
IntegerArgumentProto Clone()
Definition: CpModel.pb.cs:669
Google.OrTools.Sat.ConstraintProto.Routes
global::Google.OrTools.Sat.RoutesConstraintProto?? Routes
The routes constraint implements the vehicle routing problem.
Definition: CpModel.pb.cs:4970
Google.OrTools.Sat.IntegerVariableProto
An integer variable.
Definition: CpModel.pb.cs:248
Google.OrTools.Sat.ConstraintProto.Inverse
global::Google.OrTools.Sat.InverseConstraintProto?? Inverse
The inverse constraint forces two arrays to be inverses of each other: the values of one are the indi...
Definition: CpModel.pb.cs:5030
Google.OrTools.Sat.CpSolverResponse.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:8080
Google.OrTools.Sat.TableConstraintProto.MergeFrom
void MergeFrom(TableConstraintProto other)
Definition: CpModel.pb.cs:3985
Google.OrTools.Sat.ReservoirConstraintProto
Maintain a reservoir level within bounds.
Definition: CpModel.pb.cs:2803
Google.OrTools.Sat.IntegerVariableProto.Equals
bool Equals(IntegerVariableProto other)
Definition: CpModel.pb.cs:332
Google.OrTools.Sat.CpObjectiveProto.MergeFrom
void MergeFrom(CpObjectiveProto other)
Definition: CpModel.pb.cs:6445
Google.OrTools.Sat.IntegerArgumentProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:784
Google.OrTools.Sat.LinearArgumentProto.Clone
LinearArgumentProto Clone()
Definition: CpModel.pb.cs:1094
Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy
VariableSelectionStrategy
The order in which the variables above should be considered.
Definition: CpModel.pb.cs:6816
Google.OrTools.Sat.IntegerArgumentProto.ToString
override string ToString()
Definition: CpModel.pb.cs:724
Google.OrTools.Sat.NoOverlap2DConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:2462
Google.OrTools.Sat.LinearConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:1549
Google.OrTools.Sat.CircuitConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:3210
Google.OrTools.Sat.LinearConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:1544
Google.OrTools.Sat.LinearConstraintProto.Clone
LinearConstraintProto Clone()
Definition: CpModel.pb.cs:1475
Google.OrTools.Sat.RoutesConstraintProto.Capacity
long Capacity
Definition: CpModel.pb.cs:3433
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:6918
Google.OrTools.Sat.CircuitCoveringConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:3692
Google.OrTools.Sat.CumulativeConstraintProto
The sum of the demands of the intervals at each interval point cannot exceed a capacity.
Definition: CpModel.pb.cs:2558
Google.OrTools.Sat.ConstraintProto.Clone
ConstraintProto Clone()
Definition: CpModel.pb.cs:4692
Google.OrTools.Sat.NoOverlapConstraintProto.MergeFrom
void MergeFrom(NoOverlapConstraintProto other)
Definition: CpModel.pb.cs:2266
Google.OrTools.Sat.LinearExpressionProto.LinearExpressionProto
LinearExpressionProto(LinearExpressionProto other)
Definition: CpModel.pb.cs:861
Google.OrTools.Sat.CircuitConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:3215
Google.OrTools.Sat.CpSolverResponse.CpSolverResponse
CpSolverResponse(CpSolverResponse other)
Definition: CpModel.pb.cs:7739
Google.OrTools.Sat.CumulativeConstraintProto.Clone
CumulativeConstraintProto Clone()
Definition: CpModel.pb.cs:2590
Google.OrTools.Sat.CircuitCoveringConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:3750
Google.OrTools.Sat.TableConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:3939
Google.OrTools.Sat.CpObjectiveProto.ScalingFactor
double ScalingFactor
Definition: CpModel.pb.cs:6322
Google.OrTools.Sat.LinearConstraintProto.LinearConstraintProto
LinearConstraintProto(LinearConstraintProto other)
Definition: CpModel.pb.cs:1467
Google.OrTools.Sat.AllDifferentConstraintProto.Clone
AllDifferentConstraintProto Clone()
Definition: CpModel.pb.cs:1302
Google.OrTools.Sat.RoutesConstraintProto
The "VRP" (Vehicle Routing Problem) constraint.
Definition: CpModel.pb.cs:3346
Google.OrTools.Sat.ReservoirConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:3020
Google.OrTools.Sat.RoutesConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:3462
Google.OrTools.Sat.TableConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:3922
Google.OrTools.Sat.CpSolverResponse.BestObjectiveBound
double BestObjectiveBound
Only make sense for an optimization problem.
Definition: CpModel.pb.cs:7823
Google.OrTools.Sat.CpSolverResponse.Status
global::Google.OrTools.Sat.CpSolverStatus Status
The status of the solve.
Definition: CpModel.pb.cs:7774
Google.OrTools.Sat.ConstraintProto.ClearConstraint
void ClearConstraint()
Definition: CpModel.pb.cs:5152
Google.OrTools.Sat.NoOverlapConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:2219
Google.OrTools.Sat.CpSolverStatus
CpSolverStatus
The status returned by a solver trying to solve a CpModelProto.
Definition: CpModel.pb.cs:186
Google.OrTools.Sat.DecisionStrategyProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:6652
Google.OrTools.Sat.IntervalConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:2091
Google.OrTools.Sat.LinearConstraintProto.MergeFrom
void MergeFrom(LinearConstraintProto other)
Definition: CpModel.pb.cs:1587
Google.OrTools.Sat.AutomatonConstraintProto.Clone
AutomatonConstraintProto Clone()
Definition: CpModel.pb.cs:4294
Google.OrTools.Sat.LinearExpressionProto.Clone
LinearExpressionProto Clone()
Definition: CpModel.pb.cs:869
Google.OrTools.Sat.ReservoirConstraintProto.ReservoirConstraintProto
ReservoirConstraintProto(ReservoirConstraintProto other)
Definition: CpModel.pb.cs:2827
Google.OrTools.Sat.CpSolverResponse.UserTime
double UserTime
Definition: CpModel.pb.cs:8001
Google.OrTools.Sat.InverseConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:4121
Google.OrTools.Sat.IntegerArgumentProto.Target
int Target
Definition: CpModel.pb.cs:677
Google.OrTools.Sat.LinearExpressionProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:1000
Google.OrTools.Sat.AutomatonConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:4396
Google.OrTools.Sat.ElementConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:1736
Google.OrTools.Sat.LinearConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:1575
Google.OrTools.Sat.ReservoirConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:2903
Google.OrTools.Sat.CircuitCoveringConstraintProto.MergeFrom
void MergeFrom(CircuitCoveringConstraintProto other)
Definition: CpModel.pb.cs:3761
Google.OrTools.Sat.BoolArgumentProto.Clone
BoolArgumentProto Clone()
Definition: CpModel.pb.cs:502
Google.OrTools.Sat.IntegerArgumentProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:713
Google.OrTools.Sat.CpSolverResponse.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:8366
Google.OrTools.Sat.NoOverlap2DConstraintProto.Equals
bool Equals(NoOverlap2DConstraintProto other)
Definition: CpModel.pb.cs:2399
Google.OrTools.Sat.CpModelProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:7554
Google.OrTools.Sat.TableConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:3971
Google.OrTools.Sat.ReservoirConstraintProto.MaxLevel
long MaxLevel
Definition: CpModel.pb.cs:2856
Google.OrTools.Sat.InverseConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:4150
pb
global::Google.Protobuf pb
Definition: RoutingEnums.pb.cs:8
Google.OrTools.Sat.PartialVariableAssignment.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:7237
Google.OrTools.Sat.IntegerVariableProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:361
Google.OrTools.Sat.AllDifferentConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:1390
Google.OrTools.Sat.CircuitConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:3264
Google.OrTools.Sat.CpModelProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:7502
Google.OrTools.Sat.IntervalConstraintProto
This "special" constraint not only enforces (start + size == end) but can also be referred by other c...
Definition: CpModel.pb.cs:1906
Google.OrTools.Sat.ElementConstraintProto
The constraint target = vars[index].
Definition: CpModel.pb.cs:1667
Google.OrTools.Sat.LinearExpressionProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:941
Google.OrTools.Sat.NoOverlap2DConstraintProto
The boxes defined by [start_x, end_x) * [start_y, end_y) cannot overlap.
Definition: CpModel.pb.cs:2323
Google.OrTools.Sat.BoolArgumentProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:517
Google.OrTools.Sat.LinearConstraintProto.Equals
bool Equals(LinearConstraintProto other)
Definition: CpModel.pb.cs:1518
Google.OrTools.Sat.ConstraintProto.BoolAnd
global::Google.OrTools.Sat.BoolArgumentProto?? BoolAnd
The bool_and constraint forces all of the literals to be true.
Definition: CpModel.pb.cs:4760
Google.OrTools.Sat.CpObjectiveProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:6366
Google.OrTools.Sat.AutomatonConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:4416
Google.OrTools.Sat.RoutesConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:3548
Google.OrTools.Sat.LinearExpressionProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:905
Google.OrTools.Sat.LinearConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:1532
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Clone
AffineTransformation Clone()
Definition: CpModel.pb.cs:6880
Google.OrTools.Sat.CumulativeConstraintProto.CumulativeConstraintProto
CumulativeConstraintProto()
Definition: CpModel.pb.cs:2575
Google.OrTools.Sat.PartialVariableAssignment.PartialVariableAssignment
PartialVariableAssignment(PartialVariableAssignment other)
Definition: CpModel.pb.cs:7126
Google.OrTools.Sat.TableConstraintProto.TableConstraintProto
TableConstraintProto(TableConstraintProto other)
Definition: CpModel.pb.cs:3855
Google.OrTools.Sat.CpModelReflection.Descriptor
static pbr::FileDescriptor Descriptor
File descriptor for ortools/sat/cp_model.proto
Definition: CpModel.pb.cs:19
Google.OrTools.Sat.CpModelProto
A constraint programming problem.
Definition: CpModel.pb.cs:7295
Google.OrTools.Sat.CircuitCoveringConstraintProto
Another routing constraint.
Definition: CpModel.pb.cs:3636
Google.OrTools.Sat.TableConstraintProto.TableConstraintProto
TableConstraintProto()
Definition: CpModel.pb.cs:3848
Google.OrTools.Sat.CpSolverResponse.CpSolverResponse
CpSolverResponse()
Definition: CpModel.pb.cs:7732
Google.OrTools.Sat.ConstraintProto.ConstraintProto
ConstraintProto(ConstraintProto other)
Definition: CpModel.pb.cs:4607
Google.OrTools.Sat.InverseConstraintProto.Equals
bool Equals(InverseConstraintProto other)
Definition: CpModel.pb.cs:4126
Google.OrTools.Sat.AllDifferentConstraintProto.AllDifferentConstraintProto
AllDifferentConstraintProto()
Definition: CpModel.pb.cs:1289
Google.OrTools.Sat.ElementConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:1810
Google.OrTools.Sat.PartialVariableAssignment.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:7176
Google.OrTools.Sat.NoOverlapConstraintProto.Clone
NoOverlapConstraintProto Clone()
Definition: CpModel.pb.cs:2187
Google.OrTools.Sat.ElementConstraintProto.Target
int Target
Definition: CpModel.pb.cs:1718
Google.OrTools.Sat.ConstraintProto.Table
global::Google.OrTools.Sat.TableConstraintProto?? Table
The table constraint enforces what values a tuple of variables may take.
Definition: CpModel.pb.cs:5000
Google.OrTools.Sat.BoolArgumentProto
Argument of the constraints of the form OP(literals).
Definition: CpModel.pb.cs:472
Google.OrTools.Sat.BoolArgumentProto.MergeFrom
void MergeFrom(BoolArgumentProto other)
Definition: CpModel.pb.cs:581
Google.OrTools.Sat.TableConstraintProto
The values of the n-tuple formed by the given variables can only be one of the listed n-tuples in val...
Definition: CpModel.pb.cs:3831
Google.OrTools.Sat.ConstraintProto.AtMostOne
global::Google.OrTools.Sat.BoolArgumentProto?? AtMostOne
The at_most_one constraint enforces that no more than one literal is true at the same time.
Definition: CpModel.pb.cs:4778
Google.OrTools.Sat.BoolArgumentProto.Equals
bool Equals(BoolArgumentProto other)
Definition: CpModel.pb.cs:522
pbr
global::Google.Protobuf.Reflection pbr
Definition: RoutingEnums.pb.cs:10
Google.OrTools.Sat.CircuitConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:3179
Google.OrTools.Sat.DecisionStrategyProto.MergeFrom
void MergeFrom(DecisionStrategyProto other)
Definition: CpModel.pb.cs:6727
Google.OrTools.Sat.AutomatonConstraintProto
This constraint forces a sequence of variables to be accepted by an automaton.
Definition: CpModel.pb.cs:4259
Google.OrTools.Sat.ConstraintProto.IntMax
global::Google.OrTools.Sat.IntegerArgumentProto?? IntMax
The int_max constraint forces the target to equal the maximum of all variables.
Definition: CpModel.pb.cs:4836
Google.OrTools.Sat.TableConstraintProto.Clone
TableConstraintProto Clone()
Definition: CpModel.pb.cs:3863
Google.OrTools.Sat.ElementConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:1767
Google.OrTools.Sat.ConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:5158
Google.OrTools.Sat.TableConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:3934
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:6998
Google.OrTools.Sat.IntegerVariableProto.IntegerVariableProto
IntegerVariableProto()
Definition: CpModel.pb.cs:265
Google.OrTools.Sat.CpModelProto.MergeFrom
void MergeFrom(CpModelProto other)
Definition: CpModel.pb.cs:7576
Google.OrTools.Sat.CumulativeConstraintProto.MergeFrom
void MergeFrom(CumulativeConstraintProto other)
Definition: CpModel.pb.cs:2711
Google.OrTools.Sat.IntegerArgumentProto.MergeFrom
void MergeFrom(IntegerArgumentProto other)
Definition: CpModel.pb.cs:772
Google.OrTools.Sat.BoolArgumentProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:549
Google.OrTools.Sat.LinearArgumentProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:1120
Google.OrTools.Sat.IntegerVariableProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:416
Google.OrTools.Sat.NoOverlap2DConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:2413
Google.OrTools.Sat.AllDifferentConstraintProto.MergeFrom
void MergeFrom(AllDifferentConstraintProto other)
Definition: CpModel.pb.cs:1381
Google.OrTools.Sat.IntegerVariableProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:345
Google.OrTools.Sat.CumulativeConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:2629
Google.OrTools.Sat.IntervalConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:1976
Google.OrTools.Sat.CpSolverResponse.NumBinaryPropagations
long NumBinaryPropagations
Definition: CpModel.pb.cs:7968
Google.OrTools.Sat.AutomatonConstraintProto.Equals
bool Equals(AutomatonConstraintProto other)
Definition: CpModel.pb.cs:4379
Google.OrTools.Sat.CircuitConstraintProto.Equals
bool Equals(CircuitConstraintProto other)
Definition: CpModel.pb.cs:3184
Google.OrTools.Sat.ElementConstraintProto.Index
int Index
Definition: CpModel.pb.cs:1707
Google.OrTools.Sat.CpSolverResponse.NumIntegerPropagations
long NumIntegerPropagations
Definition: CpModel.pb.cs:7979
Google.OrTools.Sat.PartialVariableAssignment.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:7158
Google.OrTools.Sat.CircuitCoveringConstraintProto.Clone
CircuitCoveringConstraintProto Clone()
Definition: CpModel.pb.cs:3667
Google.OrTools.Sat.CpModelProto.Clone
CpModelProto Clone()
Definition: CpModel.pb.cs:7331
Google.OrTools.Sat.CumulativeConstraintProto.Capacity
int Capacity
Definition: CpModel.pb.cs:2598
Google.OrTools.Sat.CumulativeConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:2697
Google.OrTools.Sat.CircuitConstraintProto.Clone
CircuitConstraintProto Clone()
Definition: CpModel.pb.cs:3144
Google.OrTools.Sat.RoutesConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:3517
Google.OrTools.Sat.ConstraintProto.IntMod
global::Google.OrTools.Sat.IntegerArgumentProto?? IntMod
The int_mod constraint forces the target to equal vars[0] % vars[1].
Definition: CpModel.pb.cs:4820
Google.OrTools.Sat.CpModelProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:7481
Google.OrTools.Sat.ConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:5244
Google.OrTools.Sat.CpModelProto.Objective
global::Google.OrTools.Sat.CpObjectiveProto Objective
The objective to minimize.
Definition: CpModel.pb.cs:7379
Google.OrTools.Sat.IntegerVariableProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:391
Google.OrTools.Sat.DecisionStrategyProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:6632
Google.OrTools.Sat.RoutesConstraintProto.Clone
RoutesConstraintProto Clone()
Definition: CpModel.pb.cs:3380
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.MergeFrom
void MergeFrom(AffineTransformation other)
Definition: CpModel.pb.cs:7016
Google.OrTools.Sat.CircuitConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:3198
Google.OrTools.Sat.ReservoirConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:2943
Google.OrTools.Sat.AllDifferentConstraintProto.Equals
bool Equals(AllDifferentConstraintProto other)
Definition: CpModel.pb.cs:1322
Google.OrTools.Sat.CpObjectiveProto.Equals
bool Equals(CpObjectiveProto other)
Definition: CpModel.pb.cs:6350
Google.OrTools.Sat.NoOverlap2DConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:2425
Google.OrTools.Sat.LinearExpressionProto.ToString
override string ToString()
Definition: CpModel.pb.cs:936
Google.OrTools.Sat.CpSolverResponse.WallTime
double WallTime
Definition: CpModel.pb.cs:7990
Google.OrTools.Sat.NoOverlapConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:2234
Google.OrTools.Sat.ElementConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:1841
Google.OrTools.Sat.IntervalConstraintProto.Start
int Start
Definition: CpModel.pb.cs:1946
Google.OrTools.Sat.ReservoirConstraintProto.ReservoirConstraintProto
ReservoirConstraintProto()
Definition: CpModel.pb.cs:2820
Google.OrTools.Sat.AllDifferentConstraintProto.AllDifferentConstraintProto
AllDifferentConstraintProto(AllDifferentConstraintProto other)
Definition: CpModel.pb.cs:1296
Google.OrTools.Sat.ConstraintProto.IntProd
global::Google.OrTools.Sat.IntegerArgumentProto?? IntProd
The int_prod constraint forces the target to equal the product of all variables.
Definition: CpModel.pb.cs:4897
Google.OrTools.Sat.CpModelProto.Equals
bool Equals(CpModelProto other)
Definition: CpModel.pb.cs:7463
Google.OrTools.Sat.NoOverlapConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:2275
Google.OrTools.Sat.CircuitCoveringConstraintProto.CircuitCoveringConstraintProto
CircuitCoveringConstraintProto()
Definition: CpModel.pb.cs:3653
Google.OrTools.Sat.RoutesConstraintProto.RoutesConstraintProto
RoutesConstraintProto(RoutesConstraintProto other)
Definition: CpModel.pb.cs:3370
Google.OrTools.Sat.BoolArgumentProto.BoolArgumentProto
BoolArgumentProto()
Definition: CpModel.pb.cs:489
Google.OrTools.Sat.LinearArgumentProto.LinearArgumentProto
LinearArgumentProto(LinearArgumentProto other)
Definition: CpModel.pb.cs:1087
Google.OrTools.Sat.ConstraintProto.CircuitCovering
global::Google.OrTools.Sat.CircuitCoveringConstraintProto?? CircuitCovering
The circuit_covering constraint is similar to the circuit constraint, but allows multiple non-overlap...
Definition: CpModel.pb.cs:4985
Google.OrTools.Sat.InverseConstraintProto.InverseConstraintProto
InverseConstraintProto()
Definition: CpModel.pb.cs:4082
Google.OrTools.Sat.IntervalConstraintProto.IntervalConstraintProto
IntervalConstraintProto()
Definition: CpModel.pb.cs:1923
Google.OrTools.Sat.DecisionStrategyProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:6710
Google.OrTools.Sat.ElementConstraintProto.ElementConstraintProto
ElementConstraintProto(ElementConstraintProto other)
Definition: CpModel.pb.cs:1691
Google.OrTools.Sat.IntegerVariableProto.Clone
IntegerVariableProto Clone()
Definition: CpModel.pb.cs:279
Google.OrTools.Sat.ReservoirConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:2924
Google.OrTools.Sat.CpSolverResponse.MergeFrom
void MergeFrom(CpSolverResponse other)
Definition: CpModel.pb.cs:8311
Google.OrTools.Sat.LinearExpressionProto.LinearExpressionProto
LinearExpressionProto()
Definition: CpModel.pb.cs:854
Google.OrTools.Sat.LinearExpressionProto
Definition: CpModel.pb.cs:837
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation
Advanced usage.
Definition: CpModel.pb.cs:6848
Google.OrTools.Sat.ConstraintProto.Automaton
global::Google.OrTools.Sat.AutomatonConstraintProto?? Automaton
The automaton constraint forces a sequence of variables to be accepted by an automaton.
Definition: CpModel.pb.cs:5015
Google.OrTools.Sat.NoOverlap2DConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:2489
scg
global::System.Collections.Generic scg
Definition: RoutingEnums.pb.cs:11
Google.OrTools.Sat.CpObjectiveProto.ToString
override string ToString()
Definition: CpModel.pb.cs:6380
Google.OrTools.Sat.InverseConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:4155
Google.OrTools.Sat.CumulativeConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:2660
Google.OrTools.Sat.CpSolverResponse.DeterministicTime
double DeterministicTime
Definition: CpModel.pb.cs:8012
Google.OrTools.Sat.CpModelProto.CpModelProto
CpModelProto(CpModelProto other)
Definition: CpModel.pb.cs:7319
Google.OrTools.Sat.CumulativeConstraintProto.Equals
bool Equals(CumulativeConstraintProto other)
Definition: CpModel.pb.cs:2634
Google.OrTools.Sat.CpObjectiveProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:6345
Google.OrTools.Sat.ReservoirConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:2938
Google.OrTools.Sat.CpSolverResponse.AllSolutionsWereFound
bool AllSolutionsWereFound
This will be true iff the solver was asked to find all solutions to a satisfiability problem (or all ...
Definition: CpModel.pb.cs:7921
Google.OrTools.Sat.CumulativeConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:2724
Google.OrTools.Sat.ConstraintProto.Equals
bool Equals(ConstraintProto other)
Definition: CpModel.pb.cs:5163
Google.OrTools.Sat.LinearExpressionProto.Offset
long Offset
Definition: CpModel.pb.cs:897
Google.OrTools.Sat.LinearArgumentProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:1212
Google.OrTools.Sat.IntegerArgumentProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:729
Google.OrTools.Sat.DecisionStrategyProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:6743
Google.OrTools.Sat.CpSolverResponse.Equals
bool Equals(CpSolverResponse other)
Definition: CpModel.pb.cs:8050
Google.OrTools.Sat.ReservoirConstraintProto.Equals
bool Equals(ReservoirConstraintProto other)
Definition: CpModel.pb.cs:2908
Google.OrTools.Sat.RoutesConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:3476
Google.OrTools.Sat.ConstraintProto.MergeFrom
void MergeFrom(ConstraintProto other)
Definition: CpModel.pb.cs:5562
Google.OrTools.Sat.CpObjectiveProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:6462
Google.OrTools.Sat.CpModelProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:7603
Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy
DomainReductionStrategy
Once a variable has been chosen, this enum describe what decision is taken on its domain.
Definition: CpModel.pb.cs:6830
Google.OrTools.Sat.CpModelProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:7458
Google.OrTools.Sat.CpSolverResponse.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:8255
Google.OrTools.Sat.ElementConstraintProto.Equals
bool Equals(ElementConstraintProto other)
Definition: CpModel.pb.cs:1741
Google.OrTools.Sat.LinearConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:1513
Google.OrTools.Sat.CpObjectiveProto.CpObjectiveProto
CpObjectiveProto()
Definition: CpModel.pb.cs:6252
Google.OrTools.Sat.NoOverlap2DConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:2394
Google.OrTools.Sat.ConstraintProto.Circuit
global::Google.OrTools.Sat.CircuitConstraintProto?? Circuit
The circuit constraint takes a graph and forces the arcs present (with arc presence indicated by a li...
Definition: CpModel.pb.cs:4956
Google.OrTools.Sat.CpSolverResponse.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:8045
Google.OrTools.Sat.ConstraintProto.NoOverlap
global::Google.OrTools.Sat.NoOverlapConstraintProto?? NoOverlap
The no_overlap constraint prevents a set of intervals from overlapping; in scheduling,...
Definition: CpModel.pb.cs:5077
Google.OrTools.Sat.CpSolverResponse.ToString
override string ToString()
Definition: CpModel.pb.cs:8108
Google.OrTools.Sat.ReservoirConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:2985
Google.OrTools.Sat.LinearConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:1598
Google.OrTools.Sat.ConstraintProto.Cumulative
global::Google.OrTools.Sat.CumulativeConstraintProto?? Cumulative
The cumulative constraint ensures that for any integer point, the sum of the demands of the intervals...
Definition: CpModel.pb.cs:5107
Google.OrTools.Sat.DecisionStrategyProto.Equals
bool Equals(DecisionStrategyProto other)
Definition: CpModel.pb.cs:6637
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.ToString
override string ToString()
Definition: CpModel.pb.cs:6949
Google.OrTools.Sat.CircuitCoveringConstraintProto.CircuitCoveringConstraintProto
CircuitCoveringConstraintProto(CircuitCoveringConstraintProto other)
Definition: CpModel.pb.cs:3660
Google.OrTools.Sat.LinearArgumentProto
Definition: CpModel.pb.cs:1063
Google.OrTools.Sat.ConstraintProto
Next id: 29
Definition: CpModel.pb.cs:4583
Google.OrTools.Sat.NoOverlapConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:2229
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Offset
long Offset
Definition: CpModel.pb.cs:6899
Google.OrTools.Sat.CumulativeConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:2665
Google.OrTools.Sat.BoolArgumentProto.ToString
override string ToString()
Definition: CpModel.pb.cs:544
Google.OrTools.Sat.RoutesConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:3441
Google.OrTools.Sat.AllDifferentConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:1349
Google.OrTools.Sat.CpModelProto.CpModelProto
CpModelProto()
Definition: CpModel.pb.cs:7312
Google.OrTools.Sat.AllDifferentConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:1371
Google.OrTools.Sat.InverseConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:4200
Google.OrTools.Sat.CircuitConstraintProto
The circuit constraint is defined on a graph where the arc presence are controlled by literals.
Definition: CpModel.pb.cs:3112
Google.OrTools.Sat.NoOverlapConstraintProto.NoOverlapConstraintProto
NoOverlapConstraintProto()
Definition: CpModel.pb.cs:2174
Google.OrTools.Sat.ConstraintProto.BoolOr
global::Google.OrTools.Sat.BoolArgumentProto?? BoolOr
The bool_or constraint forces at least one literal to be true.
Definition: CpModel.pb.cs:4742
Google.OrTools.Sat.DecisionStrategyProto.ToString
override string ToString()
Definition: CpModel.pb.cs:6665
Google.OrTools.Sat.ConstraintProto.Reservoir
global::Google.OrTools.Sat.ReservoirConstraintProto?? Reservoir
The reservoir constraint forces the sum of a set of active demands to always be between a specified m...
Definition: CpModel.pb.cs:5046
Google.OrTools.Sat.LinearArgumentProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:1138
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Equals
bool Equals(AffineTransformation other)
Definition: CpModel.pb.cs:6923
Google.OrTools.Sat.InverseConstraintProto
The two arrays of variable each represent a function, the second is the inverse of the first: f_direc...
Definition: CpModel.pb.cs:4065
Google.OrTools.Sat.CpObjectiveProto.Clone
CpObjectiveProto Clone()
Definition: CpModel.pb.cs:6269
Google.OrTools.Sat.ConstraintProto.Element
global::Google.OrTools.Sat.ElementConstraintProto?? Element
The element constraint forces the variable with the given index to be equal to the target.
Definition: CpModel.pb.cs:4941
Google.OrTools.Sat.DecisionStrategyProto.DecisionStrategyProto
DecisionStrategyProto(DecisionStrategyProto other)
Definition: CpModel.pb.cs:6571
Google.OrTools.Sat.CircuitConstraintProto.MergeFrom
void MergeFrom(CircuitConstraintProto other)
Definition: CpModel.pb.cs:3253
Google.OrTools.Sat.PartialVariableAssignment.Clone
PartialVariableAssignment Clone()
Definition: CpModel.pb.cs:7133
Google.OrTools.Sat.BoolArgumentProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:534
Google.OrTools.Sat.AutomatonConstraintProto.StartingState
long StartingState
A state is identified by a non-negative number.
Definition: CpModel.pb.cs:4307
Google.OrTools.Sat.ReservoirConstraintProto.Clone
ReservoirConstraintProto Clone()
Definition: CpModel.pb.cs:2837
Google.OrTools.Sat.IntervalConstraintProto.IntervalConstraintProto
IntervalConstraintProto(IntervalConstraintProto other)
Definition: CpModel.pb.cs:1930
Google.OrTools.Sat.PartialVariableAssignment.MergeFrom
void MergeFrom(PartialVariableAssignment other)
Definition: CpModel.pb.cs:7227
Google.OrTools.Sat.ElementConstraintProto.MergeFrom
void MergeFrom(ElementConstraintProto other)
Definition: CpModel.pb.cs:1826
Google.OrTools.Sat.ElementConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:1755
Google.OrTools.Sat.ConstraintProto.IntMin
global::Google.OrTools.Sat.IntegerArgumentProto?? IntMin
The int_min constraint forces the target to equal the minimum of all variables.
Definition: CpModel.pb.cs:4867
Google.OrTools.Sat.LinearArgumentProto.LinearArgumentProto
LinearArgumentProto()
Definition: CpModel.pb.cs:1080
Google.OrTools.Sat.CircuitConstraintProto.CircuitConstraintProto
CircuitConstraintProto()
Definition: CpModel.pb.cs:3129
Google.OrTools.Sat.NoOverlap2DConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:2430
Google.OrTools.Sat.ConstraintProto.Interval
global::Google.OrTools.Sat.IntervalConstraintProto?? Interval
The interval constraint takes a start, end, and size, and forces start + size == end.
Definition: CpModel.pb.cs:5061
Google.OrTools.Sat.ElementConstraintProto.ElementConstraintProto
ElementConstraintProto()
Definition: CpModel.pb.cs:1684
Google.OrTools.Sat.IntervalConstraintProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:2012
Google.OrTools.Sat.IntegerArgumentProto.IntegerArgumentProto
IntegerArgumentProto(IntegerArgumentProto other)
Definition: CpModel.pb.cs:662
Google.OrTools.Sat.BoolArgumentProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:590
Google.OrTools.Sat.CpSolverResponse.ObjectiveValue
double ObjectiveValue
Only make sense for an optimization problem.
Definition: CpModel.pb.cs:7807
Google.OrTools.Sat.LinearExpressionProto.Equals
bool Equals(LinearExpressionProto other)
Definition: CpModel.pb.cs:910
Google.OrTools.Sat.InverseConstraintProto.Clone
InverseConstraintProto Clone()
Definition: CpModel.pb.cs:4096
Google.OrTools.Sat.IntegerArgumentProto.IntegerArgumentProto
IntegerArgumentProto()
Definition: CpModel.pb.cs:655
Google.OrTools.Sat.PartialVariableAssignment.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:7192
Google.OrTools.Sat.CpSolverResponse.NumBranches
long NumBranches
Definition: CpModel.pb.cs:7957
Google.OrTools.Sat.IntegerVariableProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:327
Google.OrTools.Sat.CpObjectiveProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:6427
Google.OrTools.Sat.DecisionStrategyProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:6670
Google.OrTools.Sat.CircuitConstraintProto.CircuitConstraintProto
CircuitConstraintProto(CircuitConstraintProto other)
Definition: CpModel.pb.cs:3136
Google.OrTools.Sat.CpSolverResponse.SolutionInfo
string SolutionInfo
Additional information about how the solution was found.
Definition: CpModel.pb.cs:8037
Google.OrTools.Sat.DecisionStrategyProto.Clone
DecisionStrategyProto Clone()
Definition: CpModel.pb.cs:6580
Google.OrTools.Sat.NoOverlapConstraintProto.Equals
bool Equals(NoOverlapConstraintProto other)
Definition: CpModel.pb.cs:2207
Google.OrTools.Sat.CircuitCoveringConstraintProto.Equals
bool Equals(CircuitCoveringConstraintProto other)
Definition: CpModel.pb.cs:3697
Google.OrTools.Sat.InverseConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:4139
Google.OrTools.Sat.ConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:5474
Google.OrTools.Sat.LinearConstraintProto.LinearConstraintProto
LinearConstraintProto()
Definition: CpModel.pb.cs:1460
Google.OrTools.Sat.DecisionStrategyProto
Define the strategy to follow when the solver needs to take a new decision.
Definition: CpModel.pb.cs:6547
Google.OrTools.Sat.CpSolverResponse.NumBooleans
long NumBooleans
Some statistics about the solve.
Definition: CpModel.pb.cs:7935
Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.AffineTransformation
AffineTransformation(AffineTransformation other)
Definition: CpModel.pb.cs:6872
Google.OrTools.Sat.AutomatonConstraintProto.AutomatonConstraintProto
AutomatonConstraintProto()
Definition: CpModel.pb.cs:4276
Google.OrTools.Sat.AllDifferentConstraintProto.Equals
override bool Equals(object other)
Definition: CpModel.pb.cs:1317
Google.OrTools.Sat.CircuitCoveringConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:3771
Google.OrTools.Sat.PartialVariableAssignment
This message encodes a partial (or full) assignment of the variables of a CpModelProto.
Definition: CpModel.pb.cs:7102
Google.OrTools.Sat.DecisionStrategyProto.DecisionStrategyProto
DecisionStrategyProto()
Definition: CpModel.pb.cs:6564
Google.OrTools.Sat.PartialVariableAssignment.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:7216
Google.OrTools.Sat.BoolArgumentProto.BoolArgumentProto
BoolArgumentProto(BoolArgumentProto other)
Definition: CpModel.pb.cs:496
Google.OrTools.Sat.RoutesConstraintProto.MergeFrom
void MergeFrom(RoutesConstraintProto other)
Definition: CpModel.pb.cs:3533
Google.OrTools.Sat.AutomatonConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:4411
Google.OrTools.Sat.ConstraintProto.MergeFrom
void MergeFrom(pb::CodedInputStream input)
Definition: CpModel.pb.cs:5727
Google.OrTools.Sat.IntegerArgumentProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:759
Google.OrTools.Sat.AllDifferentConstraintProto
All variables must take different values.
Definition: CpModel.pb.cs:1272
Google.OrTools.Sat.LinearExpressionProto.MergeFrom
void MergeFrom(LinearExpressionProto other)
Definition: CpModel.pb.cs:987
Google.OrTools.Sat.RoutesConstraintProto.RoutesConstraintProto
RoutesConstraintProto()
Definition: CpModel.pb.cs:3363
Google.OrTools.Sat.InverseConstraintProto.MergeFrom
void MergeFrom(InverseConstraintProto other)
Definition: CpModel.pb.cs:4190
Google.OrTools.Sat.ConstraintProto.IntDiv
global::Google.OrTools.Sat.IntegerArgumentProto?? IntDiv
The int_div constraint forces the target to equal vars[0] / vars[1].
Definition: CpModel.pb.cs:4806
pbc
global::Google.Protobuf.Collections pbc
Definition: RoutingEnums.pb.cs:9
Google.OrTools.Sat.IntervalConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:2056
Google.OrTools.Sat.LinearExpressionProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:973
Google.OrTools.Sat.CpObjectiveProto.Offset
double Offset
The displayed objective is always: scaling_factor * (sum(coefficients[i] * objective_vars[i]) + offse...
Definition: CpModel.pb.cs:6311
Google.OrTools.Sat.CpObjectiveProto.CpObjectiveProto
CpObjectiveProto(CpObjectiveProto other)
Definition: CpModel.pb.cs:6259
Google.OrTools.Sat.IntervalConstraintProto.GetHashCode
override int GetHashCode()
Definition: CpModel.pb.cs:1995
Google.OrTools.Sat.CpObjectiveProto.WriteTo
void WriteTo(pb::CodedOutputStream output)
Definition: CpModel.pb.cs:6385
Google.OrTools.Sat.TableConstraintProto.Equals
bool Equals(TableConstraintProto other)
Definition: CpModel.pb.cs:3908
Google.OrTools.Sat.AllDifferentConstraintProto.ToString
override string ToString()
Definition: CpModel.pb.cs:1344
Google.OrTools.Sat.NoOverlapConstraintProto.CalculateSize
int CalculateSize()
Definition: CpModel.pb.cs:2256
Google.OrTools.Sat.ConstraintProto.ConstraintProto
ConstraintProto()
Definition: CpModel.pb.cs:4600
Google.OrTools.Sat
Definition: CpModel.pb.cs:12