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