5 #pragma warning disable 1591, 0612, 3021
6 #region Designer generated code
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;
20 get {
return descriptor; }
22 private static pbr::FileDescriptor descriptor;
25 byte[] descriptorData = global::System.Convert.FromBase64String(
27 "ChpvcnRvb2xzL3NhdC9jcF9tb2RlbC5wcm90bxIXb3BlcmF0aW9uc19yZXNl",
28 "YXJjaC5zYXQiNAoUSW50ZWdlclZhcmlhYmxlUHJvdG8SDAoEbmFtZRgBIAEo",
29 "CRIOCgZkb21haW4YAiADKAMiJQoRQm9vbEFyZ3VtZW50UHJvdG8SEAoIbGl0",
30 "ZXJhbHMYASADKAUiNAoUSW50ZWdlckFyZ3VtZW50UHJvdG8SDgoGdGFyZ2V0",
31 "GAEgASgFEgwKBHZhcnMYAiADKAUiRQoVTGluZWFyRXhwcmVzc2lvblByb3Rv",
32 "EgwKBHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygFEg4KBm9mZnNldBgDIAEo",
33 "AyKUAQoTTGluZWFyQXJndW1lbnRQcm90bxI+CgZ0YXJnZXQYASABKAsyLi5v",
34 "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5lYXJFeHByZXNzaW9uUHJvdG8S",
35 "PQoFZXhwcnMYAiADKAsyLi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5MaW5l",
36 "YXJFeHByZXNzaW9uUHJvdG8iKwobQWxsRGlmZmVyZW50Q29uc3RyYWludFBy",
37 "b3RvEgwKBHZhcnMYASADKAUiRQoVTGluZWFyQ29uc3RyYWludFByb3RvEgwK",
38 "BHZhcnMYASADKAUSDgoGY29lZmZzGAIgAygDEg4KBmRvbWFpbhgDIAMoAyJF",
39 "ChZFbGVtZW50Q29uc3RyYWludFByb3RvEg0KBWluZGV4GAEgASgFEg4KBnRh",
40 "cmdldBgCIAEoBRIMCgR2YXJzGAMgAygFIkMKF0ludGVydmFsQ29uc3RyYWlu",
41 "dFByb3RvEg0KBXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBRIMCgRzaXplGAMg",
42 "ASgFIi0KGE5vT3ZlcmxhcENvbnN0cmFpbnRQcm90bxIRCglpbnRlcnZhbHMY",
43 "ASADKAUicAoaTm9PdmVybGFwMkRDb25zdHJhaW50UHJvdG8SEwoLeF9pbnRl",
44 "cnZhbHMYASADKAUSEwoLeV9pbnRlcnZhbHMYAiADKAUSKAogYm94ZXNfd2l0",
45 "aF9udWxsX2FyZWFfY2FuX292ZXJsYXAYAyABKAgiUQoZQ3VtdWxhdGl2ZUNv",
46 "bnN0cmFpbnRQcm90bxIQCghjYXBhY2l0eRgBIAEoBRIRCglpbnRlcnZhbHMY",
47 "AiADKAUSDwoHZGVtYW5kcxgDIAMoBSJxChhSZXNlcnZvaXJDb25zdHJhaW50",
48 "UHJvdG8SEQoJbWluX2xldmVsGAEgASgDEhEKCW1heF9sZXZlbBgCIAEoAxIN",
49 "CgV0aW1lcxgDIAMoBRIPCgdkZW1hbmRzGAQgAygDEg8KB2FjdGl2ZXMYBSAD",
50 "KAUiSAoWQ2lyY3VpdENvbnN0cmFpbnRQcm90bxINCgV0YWlscxgDIAMoBRIN",
51 "CgVoZWFkcxgEIAMoBRIQCghsaXRlcmFscxgFIAMoBSJqChVSb3V0ZXNDb25z",
52 "dHJhaW50UHJvdG8SDQoFdGFpbHMYASADKAUSDQoFaGVhZHMYAiADKAUSEAoI",
53 "bGl0ZXJhbHMYAyADKAUSDwoHZGVtYW5kcxgEIAMoBRIQCghjYXBhY2l0eRgF",
54 "IAEoAyJMCh5DaXJjdWl0Q292ZXJpbmdDb25zdHJhaW50UHJvdG8SDQoFbmV4",
55 "dHMYASADKAUSGwoTZGlzdGluZ3Vpc2hlZF9ub2RlcxgCIAMoAyJFChRUYWJs",
56 "ZUNvbnN0cmFpbnRQcm90bxIMCgR2YXJzGAEgAygFEg4KBnZhbHVlcxgCIAMo",
57 "AxIPCgduZWdhdGVkGAMgASgIIj0KFkludmVyc2VDb25zdHJhaW50UHJvdG8S",
58 "EAoIZl9kaXJlY3QYASADKAUSEQoJZl9pbnZlcnNlGAIgAygFIqIBChhBdXRv",
59 "bWF0b25Db25zdHJhaW50UHJvdG8SFgoOc3RhcnRpbmdfc3RhdGUYAiABKAMS",
60 "FAoMZmluYWxfc3RhdGVzGAMgAygDEhcKD3RyYW5zaXRpb25fdGFpbBgEIAMo",
61 "AxIXCg90cmFuc2l0aW9uX2hlYWQYBSADKAMSGAoQdHJhbnNpdGlvbl9sYWJl",
62 "bBgGIAMoAxIMCgR2YXJzGAcgAygFIv8NCg9Db25zdHJhaW50UHJvdG8SDAoE",
63 "bmFtZRgBIAEoCRIbChNlbmZvcmNlbWVudF9saXRlcmFsGAIgAygFEj0KB2Jv",
64 "b2xfb3IYAyABKAsyKi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5Cb29sQXJn",
65 "dW1lbnRQcm90b0gAEj4KCGJvb2xfYW5kGAQgASgLMioub3BlcmF0aW9uc19y",
66 "ZXNlYXJjaC5zYXQuQm9vbEFyZ3VtZW50UHJvdG9IABJBCgthdF9tb3N0X29u",
67 "ZRgaIAEoCzIqLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkJvb2xBcmd1bWVu",
68 "dFByb3RvSAASPgoIYm9vbF94b3IYBSABKAsyKi5vcGVyYXRpb25zX3Jlc2Vh",
69 "cmNoLnNhdC5Cb29sQXJndW1lbnRQcm90b0gAEkAKB2ludF9kaXYYByABKAsy",
70 "LS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90",
71 "b0gAEkAKB2ludF9tb2QYCCABKAsyLS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNh",
72 "dC5JbnRlZ2VyQXJndW1lbnRQcm90b0gAEkAKB2ludF9tYXgYCSABKAsyLS5v",
73 "cGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2VyQXJndW1lbnRQcm90b0gA",
74 "Ej8KB2xpbl9tYXgYGyABKAsyLC5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5M",
75 "aW5lYXJBcmd1bWVudFByb3RvSAASQAoHaW50X21pbhgKIAEoCzItLm9wZXJh",
76 "dGlvbnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASPwoH",
77 "bGluX21pbhgcIAEoCzIsLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkxpbmVh",
78 "ckFyZ3VtZW50UHJvdG9IABJBCghpbnRfcHJvZBgLIAEoCzItLm9wZXJhdGlv",
79 "bnNfcmVzZWFyY2guc2F0LkludGVnZXJBcmd1bWVudFByb3RvSAASQAoGbGlu",
80 "ZWFyGAwgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuTGluZWFyQ29u",
81 "c3RyYWludFByb3RvSAASSAoIYWxsX2RpZmYYDSABKAsyNC5vcGVyYXRpb25z",
82 "X3Jlc2VhcmNoLnNhdC5BbGxEaWZmZXJlbnRDb25zdHJhaW50UHJvdG9IABJC",
83 "CgdlbGVtZW50GA4gASgLMi8ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRWxl",
84 "bWVudENvbnN0cmFpbnRQcm90b0gAEkIKB2NpcmN1aXQYDyABKAsyLy5vcGVy",
85 "YXRpb25zX3Jlc2VhcmNoLnNhdC5DaXJjdWl0Q29uc3RyYWludFByb3RvSAAS",
86 "QAoGcm91dGVzGBcgASgLMi4ub3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuUm91",
87 "dGVzQ29uc3RyYWludFByb3RvSAASUwoQY2lyY3VpdF9jb3ZlcmluZxgZIAEo",
88 "CzI3Lm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNpcmN1aXRDb3ZlcmluZ0Nv",
89 "bnN0cmFpbnRQcm90b0gAEj4KBXRhYmxlGBAgASgLMi0ub3BlcmF0aW9uc19y",
90 "ZXNlYXJjaC5zYXQuVGFibGVDb25zdHJhaW50UHJvdG9IABJGCglhdXRvbWF0",
91 "b24YESABKAsyMS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5BdXRvbWF0b25D",
92 "b25zdHJhaW50UHJvdG9IABJCCgdpbnZlcnNlGBIgASgLMi8ub3BlcmF0aW9u",
93 "c19yZXNlYXJjaC5zYXQuSW52ZXJzZUNvbnN0cmFpbnRQcm90b0gAEkYKCXJl",
94 "c2Vydm9pchgYIAEoCzIxLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LlJlc2Vy",
95 "dm9pckNvbnN0cmFpbnRQcm90b0gAEkQKCGludGVydmFsGBMgASgLMjAub3Bl",
96 "cmF0aW9uc19yZXNlYXJjaC5zYXQuSW50ZXJ2YWxDb25zdHJhaW50UHJvdG9I",
97 "ABJHCgpub19vdmVybGFwGBQgASgLMjEub3BlcmF0aW9uc19yZXNlYXJjaC5z",
98 "YXQuTm9PdmVybGFwQ29uc3RyYWludFByb3RvSAASTAoNbm9fb3ZlcmxhcF8y",
99 "ZBgVIAEoCzIzLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0Lk5vT3ZlcmxhcDJE",
100 "Q29uc3RyYWludFByb3RvSAASSAoKY3VtdWxhdGl2ZRgWIAEoCzIyLm9wZXJh",
101 "dGlvbnNfcmVzZWFyY2guc2F0LkN1bXVsYXRpdmVDb25zdHJhaW50UHJvdG9I",
102 "AEIMCgpjb25zdHJhaW50ImgKEENwT2JqZWN0aXZlUHJvdG8SDAoEdmFycxgB",
103 "IAMoBRIOCgZjb2VmZnMYBCADKAMSDgoGb2Zmc2V0GAIgASgBEhYKDnNjYWxp",
104 "bmdfZmFjdG9yGAMgASgBEg4KBmRvbWFpbhgFIAMoAyLVBQoVRGVjaXNpb25T",
105 "dHJhdGVneVByb3RvEhEKCXZhcmlhYmxlcxgBIAMoBRJtCht2YXJpYWJsZV9z",
106 "ZWxlY3Rpb25fc3RyYXRlZ3kYAiABKA4ySC5vcGVyYXRpb25zX3Jlc2VhcmNo",
107 "LnNhdC5EZWNpc2lvblN0cmF0ZWd5UHJvdG8uVmFyaWFibGVTZWxlY3Rpb25T",
108 "dHJhdGVneRJpChlkb21haW5fcmVkdWN0aW9uX3N0cmF0ZWd5GAMgASgOMkYu",
109 "b3BlcmF0aW9uc19yZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3Rv",
110 "LkRvbWFpblJlZHVjdGlvblN0cmF0ZWd5ElwKD3RyYW5zZm9ybWF0aW9ucxgE",
111 "IAMoCzJDLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkRlY2lzaW9uU3RyYXRl",
112 "Z3lQcm90by5BZmZpbmVUcmFuc2Zvcm1hdGlvbhpLChRBZmZpbmVUcmFuc2Zv",
113 "cm1hdGlvbhILCgN2YXIYASABKAUSDgoGb2Zmc2V0GAIgASgDEhYKDnBvc2l0",
114 "aXZlX2NvZWZmGAMgASgDIpQBChlWYXJpYWJsZVNlbGVjdGlvblN0cmF0ZWd5",
115 "EhAKDENIT09TRV9GSVJTVBAAEhUKEUNIT09TRV9MT1dFU1RfTUlOEAESFgoS",
116 "Q0hPT1NFX0hJR0hFU1RfTUFYEAISGgoWQ0hPT1NFX01JTl9ET01BSU5fU0la",
117 "RRADEhoKFkNIT09TRV9NQVhfRE9NQUlOX1NJWkUQBCKMAQoXRG9tYWluUmVk",
118 "dWN0aW9uU3RyYXRlZ3kSFAoQU0VMRUNUX01JTl9WQUxVRRAAEhQKEFNFTEVD",
119 "VF9NQVhfVkFMVUUQARIVChFTRUxFQ1RfTE9XRVJfSEFMRhACEhUKEVNFTEVD",
120 "VF9VUFBFUl9IQUxGEAMSFwoTU0VMRUNUX01FRElBTl9WQUxVRRAEIjkKGVBh",
121 "cnRpYWxWYXJpYWJsZUFzc2lnbm1lbnQSDAoEdmFycxgBIAMoBRIOCgZ2YWx1",
122 "ZXMYAiADKAMihAMKDENwTW9kZWxQcm90bxIMCgRuYW1lGAEgASgJEkAKCXZh",
123 "cmlhYmxlcxgCIAMoCzItLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkludGVn",
124 "ZXJWYXJpYWJsZVByb3RvEj0KC2NvbnN0cmFpbnRzGAMgAygLMigub3BlcmF0",
125 "aW9uc19yZXNlYXJjaC5zYXQuQ29uc3RyYWludFByb3RvEjwKCW9iamVjdGl2",
126 "ZRgEIAEoCzIpLm9wZXJhdGlvbnNfcmVzZWFyY2guc2F0LkNwT2JqZWN0aXZl",
127 "UHJvdG8SRwoPc2VhcmNoX3N0cmF0ZWd5GAUgAygLMi4ub3BlcmF0aW9uc19y",
128 "ZXNlYXJjaC5zYXQuRGVjaXNpb25TdHJhdGVneVByb3RvEkkKDXNvbHV0aW9u",
129 "X2hpbnQYBiABKAsyMi5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5QYXJ0aWFs",
130 "VmFyaWFibGVBc3NpZ25tZW50EhMKC2Fzc3VtcHRpb25zGAcgAygFIuoEChBD",
131 "cFNvbHZlclJlc3BvbnNlEjcKBnN0YXR1cxgBIAEoDjInLm9wZXJhdGlvbnNf",
132 "cmVzZWFyY2guc2F0LkNwU29sdmVyU3RhdHVzEhAKCHNvbHV0aW9uGAIgAygD",
133 "EhcKD29iamVjdGl2ZV92YWx1ZRgDIAEoARIcChRiZXN0X29iamVjdGl2ZV9i",
134 "b3VuZBgEIAEoARIdChVzb2x1dGlvbl9sb3dlcl9ib3VuZHMYEiADKAMSHQoV",
135 "c29sdXRpb25fdXBwZXJfYm91bmRzGBMgAygDEkoKE3RpZ2h0ZW5lZF92YXJp",
136 "YWJsZXMYFSADKAsyLS5vcGVyYXRpb25zX3Jlc2VhcmNoLnNhdC5JbnRlZ2Vy",
137 "VmFyaWFibGVQcm90bxIwCihzdWZmaWNpZW50X2Fzc3VtcHRpb25zX2Zvcl9p",
138 "bmZlYXNpYmlsaXR5GBcgAygFEiAKGGFsbF9zb2x1dGlvbnNfd2VyZV9mb3Vu",
139 "ZBgFIAEoCBIUCgxudW1fYm9vbGVhbnMYCiABKAMSFQoNbnVtX2NvbmZsaWN0",
140 "cxgLIAEoAxIUCgxudW1fYnJhbmNoZXMYDCABKAMSHwoXbnVtX2JpbmFyeV9w",
141 "cm9wYWdhdGlvbnMYDSABKAMSIAoYbnVtX2ludGVnZXJfcHJvcGFnYXRpb25z",
142 "GA4gASgDEhEKCXdhbGxfdGltZRgPIAEoARIRCgl1c2VyX3RpbWUYECABKAES",
143 "GgoSZGV0ZXJtaW5pc3RpY190aW1lGBEgASgBEhcKD3ByaW1hbF9pbnRlZ3Jh",
144 "bBgWIAEoARIVCg1zb2x1dGlvbl9pbmZvGBQgASgJKlsKDkNwU29sdmVyU3Rh",
145 "dHVzEgsKB1VOS05PV04QABIRCg1NT0RFTF9JTlZBTElEEAESDAoIRkVBU0lC",
146 "TEUQAhIOCgpJTkZFQVNJQkxFEAMSCwoHT1BUSU1BTBAEQkAKFmNvbS5nb29n",
147 "bGUub3J0b29scy5zYXRCD0NwTW9kZWxQcm90b2J1ZlABqgISR29vZ2xlLk9y",
148 "VG9vbHMuU2F0YgZwcm90bzM="));
149 descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
150 new pbr::FileDescriptor[] { },
151 new pbr::GeneratedClrTypeInfo(
new[] {typeof(global::Google.OrTools.Sat.CpSolverStatus), },
null,
new pbr::GeneratedClrTypeInfo[] {
152 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerVariableProto), global::Google.OrTools.Sat.IntegerVariableProto.Parser,
new[]{
"Name",
"Domain" },
null,
null,
null,
null),
153 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.BoolArgumentProto), global::Google.OrTools.Sat.BoolArgumentProto.Parser,
new[]{
"Literals" },
null,
null,
null,
null),
154 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntegerArgumentProto), global::Google.OrTools.Sat.IntegerArgumentProto.Parser,
new[]{
"Target",
"Vars" },
null,
null,
null,
null),
155 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearExpressionProto), global::Google.OrTools.Sat.LinearExpressionProto.Parser,
new[]{
"Vars",
"Coeffs",
"Offset" },
null,
null,
null,
null),
156 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearArgumentProto), global::Google.OrTools.Sat.LinearArgumentProto.Parser,
new[]{
"Target",
"Exprs" },
null,
null,
null,
null),
157 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AllDifferentConstraintProto), global::Google.OrTools.Sat.AllDifferentConstraintProto.Parser,
new[]{
"Vars" },
null,
null,
null,
null),
158 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.LinearConstraintProto), global::Google.OrTools.Sat.LinearConstraintProto.Parser,
new[]{
"Vars",
"Coeffs",
"Domain" },
null,
null,
null,
null),
159 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ElementConstraintProto), global::Google.OrTools.Sat.ElementConstraintProto.Parser,
new[]{
"Index",
"Target",
"Vars" },
null,
null,
null,
null),
160 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.IntervalConstraintProto), global::Google.OrTools.Sat.IntervalConstraintProto.Parser,
new[]{
"Start",
"End",
"Size" },
null,
null,
null,
null),
161 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlapConstraintProto), global::Google.OrTools.Sat.NoOverlapConstraintProto.Parser,
new[]{
"Intervals" },
null,
null,
null,
null),
162 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.NoOverlap2DConstraintProto), global::Google.OrTools.Sat.NoOverlap2DConstraintProto.Parser,
new[]{
"XIntervals",
"YIntervals",
"BoxesWithNullAreaCanOverlap" },
null,
null,
null,
null),
163 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CumulativeConstraintProto), global::Google.OrTools.Sat.CumulativeConstraintProto.Parser,
new[]{
"Capacity",
"Intervals",
"Demands" },
null,
null,
null,
null),
164 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ReservoirConstraintProto), global::Google.OrTools.Sat.ReservoirConstraintProto.Parser,
new[]{
"MinLevel",
"MaxLevel",
"Times",
"Demands",
"Actives" },
null,
null,
null,
null),
165 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitConstraintProto), global::Google.OrTools.Sat.CircuitConstraintProto.Parser,
new[]{
"Tails",
"Heads",
"Literals" },
null,
null,
null,
null),
166 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.RoutesConstraintProto), global::Google.OrTools.Sat.RoutesConstraintProto.Parser,
new[]{
"Tails",
"Heads",
"Literals",
"Demands",
"Capacity" },
null,
null,
null,
null),
167 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CircuitCoveringConstraintProto), global::Google.OrTools.Sat.CircuitCoveringConstraintProto.Parser,
new[]{
"Nexts",
"DistinguishedNodes" },
null,
null,
null,
null),
168 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.TableConstraintProto), global::Google.OrTools.Sat.TableConstraintProto.Parser,
new[]{
"Vars",
"Values",
"Negated" },
null,
null,
null,
null),
169 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.InverseConstraintProto), global::Google.OrTools.Sat.InverseConstraintProto.Parser,
new[]{
"FDirect",
"FInverse" },
null,
null,
null,
null),
170 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.AutomatonConstraintProto), global::Google.OrTools.Sat.AutomatonConstraintProto.Parser,
new[]{
"StartingState",
"FinalStates",
"TransitionTail",
"TransitionHead",
"TransitionLabel",
"Vars" },
null,
null,
null,
null),
171 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.ConstraintProto), global::Google.OrTools.Sat.ConstraintProto.Parser,
new[]{
"Name",
"EnforcementLiteral",
"BoolOr",
"BoolAnd",
"AtMostOne",
"BoolXor",
"IntDiv",
"IntMod",
"IntMax",
"LinMax",
"IntMin",
"LinMin",
"IntProd",
"Linear",
"AllDiff",
"Element",
"Circuit",
"Routes",
"CircuitCovering",
"Table",
"Automaton",
"Inverse",
"Reservoir",
"Interval",
"NoOverlap",
"NoOverlap2D",
"Cumulative" },
new[]{
"Constraint" },
null,
null,
null),
172 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpObjectiveProto), global::Google.OrTools.Sat.CpObjectiveProto.Parser,
new[]{
"Vars",
"Coeffs",
"Offset",
"ScalingFactor",
"Domain" },
null,
null,
null,
null),
173 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto), global::Google.OrTools.Sat.DecisionStrategyProto.Parser,
new[]{
"Variables",
"VariableSelectionStrategy",
"DomainReductionStrategy",
"Transformations" },
null,
new[]{ typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy), typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) },
null,
new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation), global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser, new[]{
"Var",
"Offset",
"PositiveCoeff" },
null,
null,
null,
null)}),
174 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.PartialVariableAssignment), global::Google.OrTools.Sat.PartialVariableAssignment.Parser,
new[]{
"Vars",
"Values" },
null,
null,
null,
null),
175 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpModelProto), global::Google.OrTools.Sat.CpModelProto.Parser,
new[]{
"Name",
"Variables",
"Constraints",
"Objective",
"SearchStrategy",
"SolutionHint",
"Assumptions" },
null,
null,
null,
null),
176 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Sat.CpSolverResponse), global::Google.OrTools.Sat.CpSolverResponse.Parser,
new[]{
"Status",
"Solution",
"ObjectiveValue",
"BestObjectiveBound",
"SolutionLowerBounds",
"SolutionUpperBounds",
"TightenedVariables",
"SufficientAssumptionsForInfeasibility",
"AllSolutionsWereFound",
"NumBooleans",
"NumConflicts",
"NumBranches",
"NumBinaryPropagations",
"NumIntegerPropagations",
"WallTime",
"UserTime",
"DeterministicTime",
"PrimalIntegral",
"SolutionInfo" },
null,
null,
null,
null)
191 [pbr::OriginalName(
"UNKNOWN")] Unknown = 0,
196 [pbr::OriginalName(
"MODEL_INVALID")] ModelInvalid = 1,
202 [pbr::OriginalName(
"FEASIBLE")] Feasible = 2,
206 [pbr::OriginalName(
"INFEASIBLE")] Infeasible = 3,
217 [pbr::OriginalName(
"OPTIMAL")] Optimal = 4,
223 public sealed
partial class IntegerVariableProto : pb::IMessage<IntegerVariableProto> {
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; } }
250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
251 public static pbr::MessageDescriptor Descriptor {
252 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[0]; }
255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
256 pbr::MessageDescriptor pb::IMessage.Descriptor {
257 get {
return Descriptor; }
260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
265 partial
void OnConstruction();
267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
270 domain_ = other.domain_.Clone();
271 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
280 public const int NameFieldNumber = 1;
281 private string name_ =
"";
285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
287 get {
return name_; }
289 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
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]
319 get {
return domain_; }
322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
323 public override bool Equals(
object other) {
327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
329 if (ReferenceEquals(other,
null)) {
332 if (ReferenceEquals(other,
this)) {
335 if (Name != other.Name)
return false;
336 if(!domain_.Equals(other.domain_))
return false;
337 return Equals(_unknownFields, other._unknownFields);
340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
343 if (Name.Length != 0) hash ^= Name.GetHashCode();
344 hash ^= domain_.GetHashCode();
345 if (_unknownFields !=
null) {
346 hash ^= _unknownFields.GetHashCode();
351 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
353 return pb::JsonFormatter.ToDiagnosticString(
this);
356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
357 public void WriteTo(pb::CodedOutputStream output) {
358 if (Name.Length != 0) {
359 output.WriteRawTag(10);
360 output.WriteString(Name);
362 domain_.WriteTo(output, _repeated_domain_codec);
363 if (_unknownFields !=
null) {
364 _unknownFields.WriteTo(output);
368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
371 if (Name.Length != 0) {
372 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
374 size += domain_.CalculateSize(_repeated_domain_codec);
375 if (_unknownFields !=
null) {
376 size += _unknownFields.CalculateSize();
381 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
386 if (other.Name.Length != 0) {
389 domain_.Add(other.domain_);
390 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
393 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
396 while ((tag = input.ReadTag()) != 0) {
399 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
402 Name = input.ReadString();
407 domain_.AddEntriesFrom(input, _repeated_domain_codec);
420 private static readonly pb::MessageParser<BoolArgumentProto> _parser =
new pb::MessageParser<BoolArgumentProto>(() =>
new BoolArgumentProto());
421 private pb::UnknownFieldSet _unknownFields;
422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
423 public static pb::MessageParser<BoolArgumentProto> Parser {
get {
return _parser; } }
425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
426 public static pbr::MessageDescriptor Descriptor {
427 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[1]; }
430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
431 pbr::MessageDescriptor pb::IMessage.Descriptor {
432 get {
return Descriptor; }
435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
440 partial
void OnConstruction();
442 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
444 literals_ = other.literals_.Clone();
445 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
454 public const int LiteralsFieldNumber = 1;
455 private static readonly pb::FieldCodec<int> _repeated_literals_codec
456 = pb::FieldCodec.ForInt32(10);
457 private readonly pbc::RepeatedField<int> literals_ =
new pbc::RepeatedField<int>();
458 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
459 public pbc::RepeatedField<int> Literals {
460 get {
return literals_; }
463 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
464 public override bool Equals(
object other) {
468 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
470 if (ReferenceEquals(other,
null)) {
473 if (ReferenceEquals(other,
this)) {
476 if(!literals_.Equals(other.literals_))
return false;
477 return Equals(_unknownFields, other._unknownFields);
480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
483 hash ^= literals_.GetHashCode();
484 if (_unknownFields !=
null) {
485 hash ^= _unknownFields.GetHashCode();
490 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
492 return pb::JsonFormatter.ToDiagnosticString(
this);
495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
496 public void WriteTo(pb::CodedOutputStream output) {
497 literals_.WriteTo(output, _repeated_literals_codec);
498 if (_unknownFields !=
null) {
499 _unknownFields.WriteTo(output);
503 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
506 size += literals_.CalculateSize(_repeated_literals_codec);
507 if (_unknownFields !=
null) {
508 size += _unknownFields.CalculateSize();
513 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
518 literals_.Add(other.literals_);
519 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
525 while ((tag = input.ReadTag()) != 0) {
528 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
532 literals_.AddEntriesFrom(input, _repeated_literals_codec);
545 private static readonly pb::MessageParser<IntegerArgumentProto> _parser =
new pb::MessageParser<IntegerArgumentProto>(() =>
new IntegerArgumentProto());
546 private pb::UnknownFieldSet _unknownFields;
547 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
548 public static pb::MessageParser<IntegerArgumentProto> Parser {
get {
return _parser; } }
550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
551 public static pbr::MessageDescriptor Descriptor {
552 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[2]; }
555 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
556 pbr::MessageDescriptor pb::IMessage.Descriptor {
557 get {
return Descriptor; }
560 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
565 partial
void OnConstruction();
567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
569 target_ = other.target_;
570 vars_ = other.vars_.Clone();
571 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
574 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
580 public const int TargetFieldNumber = 1;
582 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
584 get {
return target_; }
591 public const int VarsFieldNumber = 2;
592 private static readonly pb::FieldCodec<int> _repeated_vars_codec
593 = pb::FieldCodec.ForInt32(18);
594 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
596 public pbc::RepeatedField<int> Vars {
597 get {
return vars_; }
600 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
601 public override bool Equals(
object other) {
605 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
607 if (ReferenceEquals(other,
null)) {
610 if (ReferenceEquals(other,
this)) {
613 if (Target != other.
Target)
return false;
614 if(!vars_.Equals(other.vars_))
return false;
615 return Equals(_unknownFields, other._unknownFields);
618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
621 if (Target != 0) hash ^= Target.GetHashCode();
622 hash ^= vars_.GetHashCode();
623 if (_unknownFields !=
null) {
624 hash ^= _unknownFields.GetHashCode();
629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
631 return pb::JsonFormatter.ToDiagnosticString(
this);
634 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
635 public void WriteTo(pb::CodedOutputStream output) {
637 output.WriteRawTag(8);
638 output.WriteInt32(Target);
640 vars_.WriteTo(output, _repeated_vars_codec);
641 if (_unknownFields !=
null) {
642 _unknownFields.WriteTo(output);
646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
650 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
652 size += vars_.CalculateSize(_repeated_vars_codec);
653 if (_unknownFields !=
null) {
654 size += _unknownFields.CalculateSize();
659 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
667 vars_.Add(other.vars_);
668 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
671 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
674 while ((tag = input.ReadTag()) != 0) {
677 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
680 Target = input.ReadInt32();
685 vars_.AddEntriesFrom(input, _repeated_vars_codec);
695 private static readonly pb::MessageParser<LinearExpressionProto> _parser =
new pb::MessageParser<LinearExpressionProto>(() =>
new LinearExpressionProto());
696 private pb::UnknownFieldSet _unknownFields;
697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
698 public static pb::MessageParser<LinearExpressionProto> Parser {
get {
return _parser; } }
700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
701 public static pbr::MessageDescriptor Descriptor {
702 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[3]; }
705 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
706 pbr::MessageDescriptor pb::IMessage.Descriptor {
707 get {
return Descriptor; }
710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
715 partial
void OnConstruction();
717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
719 vars_ = other.vars_.Clone();
720 coeffs_ = other.coeffs_.Clone();
721 offset_ = other.offset_;
722 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
731 public const int VarsFieldNumber = 1;
732 private static readonly pb::FieldCodec<int> _repeated_vars_codec
733 = pb::FieldCodec.ForInt32(10);
734 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
735 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
736 public pbc::RepeatedField<int> Vars {
737 get {
return vars_; }
741 public const int CoeffsFieldNumber = 2;
742 private static readonly pb::FieldCodec<int> _repeated_coeffs_codec
743 = pb::FieldCodec.ForInt32(18);
744 private readonly pbc::RepeatedField<int> coeffs_ =
new pbc::RepeatedField<int>();
745 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
746 public pbc::RepeatedField<int> Coeffs {
747 get {
return coeffs_; }
751 public const int OffsetFieldNumber = 3;
752 private long offset_;
753 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
755 get {
return offset_; }
761 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
762 public override bool Equals(
object other) {
766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
768 if (ReferenceEquals(other,
null)) {
771 if (ReferenceEquals(other,
this)) {
774 if(!vars_.Equals(other.vars_))
return false;
775 if(!coeffs_.Equals(other.coeffs_))
return false;
776 if (Offset != other.
Offset)
return false;
777 return Equals(_unknownFields, other._unknownFields);
780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
783 hash ^= vars_.GetHashCode();
784 hash ^= coeffs_.GetHashCode();
785 if (Offset != 0L) hash ^= Offset.GetHashCode();
786 if (_unknownFields !=
null) {
787 hash ^= _unknownFields.GetHashCode();
792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
794 return pb::JsonFormatter.ToDiagnosticString(
this);
797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
798 public void WriteTo(pb::CodedOutputStream output) {
799 vars_.WriteTo(output, _repeated_vars_codec);
800 coeffs_.WriteTo(output, _repeated_coeffs_codec);
802 output.WriteRawTag(24);
803 output.WriteInt64(Offset);
805 if (_unknownFields !=
null) {
806 _unknownFields.WriteTo(output);
810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
813 size += vars_.CalculateSize(_repeated_vars_codec);
814 size += coeffs_.CalculateSize(_repeated_coeffs_codec);
816 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
818 if (_unknownFields !=
null) {
819 size += _unknownFields.CalculateSize();
824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
829 vars_.Add(other.vars_);
830 coeffs_.Add(other.coeffs_);
834 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
837 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
840 while ((tag = input.ReadTag()) != 0) {
843 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
847 vars_.AddEntriesFrom(input, _repeated_vars_codec);
852 coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
856 Offset = input.ReadInt64();
866 private static readonly pb::MessageParser<LinearArgumentProto> _parser =
new pb::MessageParser<LinearArgumentProto>(() =>
new LinearArgumentProto());
867 private pb::UnknownFieldSet _unknownFields;
868 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
869 public static pb::MessageParser<LinearArgumentProto> Parser {
get {
return _parser; } }
871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
872 public static pbr::MessageDescriptor Descriptor {
873 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[4]; }
876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
877 pbr::MessageDescriptor pb::IMessage.Descriptor {
878 get {
return Descriptor; }
881 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
886 partial
void OnConstruction();
888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
890 target_ = other.target_ !=
null ? other.target_.
Clone() :
null;
891 exprs_ = other.exprs_.Clone();
892 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
895 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
901 public const int TargetFieldNumber = 1;
902 private global::Google.OrTools.Sat.LinearExpressionProto target_;
903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
904 public global::Google.OrTools.Sat.LinearExpressionProto Target {
905 get {
return target_; }
912 public const int ExprsFieldNumber = 2;
913 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.LinearExpressionProto> _repeated_exprs_codec
914 = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.LinearExpressionProto.Parser);
915 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> exprs_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto>();
916 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
917 public pbc::RepeatedField<global::Google.OrTools.Sat.LinearExpressionProto> Exprs {
918 get {
return exprs_; }
921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
922 public override bool Equals(
object other) {
926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
928 if (ReferenceEquals(other,
null)) {
931 if (ReferenceEquals(other,
this)) {
934 if (!
object.Equals(Target, other.
Target))
return false;
935 if(!exprs_.Equals(other.exprs_))
return false;
936 return Equals(_unknownFields, other._unknownFields);
939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
942 if (target_ !=
null) hash ^= Target.GetHashCode();
943 hash ^= exprs_.GetHashCode();
944 if (_unknownFields !=
null) {
945 hash ^= _unknownFields.GetHashCode();
950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
952 return pb::JsonFormatter.ToDiagnosticString(
this);
955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
956 public void WriteTo(pb::CodedOutputStream output) {
957 if (target_ !=
null) {
958 output.WriteRawTag(10);
959 output.WriteMessage(Target);
961 exprs_.WriteTo(output, _repeated_exprs_codec);
962 if (_unknownFields !=
null) {
963 _unknownFields.WriteTo(output);
967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
970 if (target_ !=
null) {
971 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Target);
973 size += exprs_.CalculateSize(_repeated_exprs_codec);
974 if (_unknownFields !=
null) {
975 size += _unknownFields.CalculateSize();
980 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
985 if (other.target_ !=
null) {
986 if (target_ ==
null) {
987 Target =
new global::Google.OrTools.Sat.LinearExpressionProto();
989 Target.MergeFrom(other.
Target);
991 exprs_.Add(other.exprs_);
992 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
995 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
998 while ((tag = input.ReadTag()) != 0) {
1001 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1004 if (target_ ==
null) {
1005 Target =
new global::Google.OrTools.Sat.LinearExpressionProto();
1007 input.ReadMessage(Target);
1011 exprs_.AddEntriesFrom(input, _repeated_exprs_codec);
1024 private static readonly pb::MessageParser<AllDifferentConstraintProto> _parser =
new pb::MessageParser<AllDifferentConstraintProto>(() =>
new AllDifferentConstraintProto());
1025 private pb::UnknownFieldSet _unknownFields;
1026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1027 public static pb::MessageParser<AllDifferentConstraintProto> Parser {
get {
return _parser; } }
1029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1030 public static pbr::MessageDescriptor Descriptor {
1031 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[5]; }
1034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1035 pbr::MessageDescriptor pb::IMessage.Descriptor {
1036 get {
return Descriptor; }
1039 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1044 partial
void OnConstruction();
1046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1048 vars_ = other.vars_.Clone();
1049 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1052 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1058 public const int VarsFieldNumber = 1;
1059 private static readonly pb::FieldCodec<int> _repeated_vars_codec
1060 = pb::FieldCodec.ForInt32(10);
1061 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
1062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1063 public pbc::RepeatedField<int> Vars {
1064 get {
return vars_; }
1067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1072 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1074 if (ReferenceEquals(other,
null)) {
1077 if (ReferenceEquals(other,
this)) {
1080 if(!vars_.Equals(other.vars_))
return false;
1081 return Equals(_unknownFields, other._unknownFields);
1084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1087 hash ^= vars_.GetHashCode();
1088 if (_unknownFields !=
null) {
1089 hash ^= _unknownFields.GetHashCode();
1094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1096 return pb::JsonFormatter.ToDiagnosticString(
this);
1099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1100 public void WriteTo(pb::CodedOutputStream output) {
1101 vars_.WriteTo(output, _repeated_vars_codec);
1102 if (_unknownFields !=
null) {
1103 _unknownFields.WriteTo(output);
1107 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1110 size += vars_.CalculateSize(_repeated_vars_codec);
1111 if (_unknownFields !=
null) {
1112 size += _unknownFields.CalculateSize();
1117 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1119 if (other ==
null) {
1122 vars_.Add(other.vars_);
1123 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1129 while ((tag = input.ReadTag()) != 0) {
1132 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1136 vars_.AddEntriesFrom(input, _repeated_vars_codec);
1154 private static readonly pb::MessageParser<LinearConstraintProto> _parser =
new pb::MessageParser<LinearConstraintProto>(() =>
new LinearConstraintProto());
1155 private pb::UnknownFieldSet _unknownFields;
1156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1157 public static pb::MessageParser<LinearConstraintProto> Parser {
get {
return _parser; } }
1159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1160 public static pbr::MessageDescriptor Descriptor {
1161 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[6]; }
1164 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1165 pbr::MessageDescriptor pb::IMessage.Descriptor {
1166 get {
return Descriptor; }
1169 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1174 partial
void OnConstruction();
1176 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1178 vars_ = other.vars_.Clone();
1179 coeffs_ = other.coeffs_.Clone();
1180 domain_ = other.domain_.Clone();
1181 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1184 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1190 public const int VarsFieldNumber = 1;
1191 private static readonly pb::FieldCodec<int> _repeated_vars_codec
1192 = pb::FieldCodec.ForInt32(10);
1193 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
1194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1195 public pbc::RepeatedField<int> Vars {
1196 get {
return vars_; }
1200 public const int CoeffsFieldNumber = 2;
1201 private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
1202 = pb::FieldCodec.ForInt64(18);
1203 private readonly pbc::RepeatedField<long> coeffs_ =
new pbc::RepeatedField<long>();
1207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1208 public pbc::RepeatedField<long> Coeffs {
1209 get {
return coeffs_; }
1213 public const int DomainFieldNumber = 3;
1214 private static readonly pb::FieldCodec<long> _repeated_domain_codec
1215 = pb::FieldCodec.ForInt64(26);
1216 private readonly pbc::RepeatedField<long> domain_ =
new pbc::RepeatedField<long>();
1217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1219 get {
return domain_; }
1222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1227 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1229 if (ReferenceEquals(other,
null)) {
1232 if (ReferenceEquals(other,
this)) {
1235 if(!vars_.Equals(other.vars_))
return false;
1236 if(!coeffs_.Equals(other.coeffs_))
return false;
1237 if(!domain_.Equals(other.domain_))
return false;
1238 return Equals(_unknownFields, other._unknownFields);
1241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1244 hash ^= vars_.GetHashCode();
1245 hash ^= coeffs_.GetHashCode();
1246 hash ^= domain_.GetHashCode();
1247 if (_unknownFields !=
null) {
1248 hash ^= _unknownFields.GetHashCode();
1253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1255 return pb::JsonFormatter.ToDiagnosticString(
this);
1258 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1259 public void WriteTo(pb::CodedOutputStream output) {
1260 vars_.WriteTo(output, _repeated_vars_codec);
1261 coeffs_.WriteTo(output, _repeated_coeffs_codec);
1262 domain_.WriteTo(output, _repeated_domain_codec);
1263 if (_unknownFields !=
null) {
1264 _unknownFields.WriteTo(output);
1268 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1271 size += vars_.CalculateSize(_repeated_vars_codec);
1272 size += coeffs_.CalculateSize(_repeated_coeffs_codec);
1273 size += domain_.CalculateSize(_repeated_domain_codec);
1274 if (_unknownFields !=
null) {
1275 size += _unknownFields.CalculateSize();
1280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1282 if (other ==
null) {
1285 vars_.Add(other.vars_);
1286 coeffs_.Add(other.coeffs_);
1287 domain_.Add(other.domain_);
1288 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1294 while ((tag = input.ReadTag()) != 0) {
1297 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1301 vars_.AddEntriesFrom(input, _repeated_vars_codec);
1306 coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
1311 domain_.AddEntriesFrom(input, _repeated_domain_codec);
1325 private static readonly pb::MessageParser<ElementConstraintProto> _parser =
new pb::MessageParser<ElementConstraintProto>(() =>
new ElementConstraintProto());
1326 private pb::UnknownFieldSet _unknownFields;
1327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1328 public static pb::MessageParser<ElementConstraintProto> Parser {
get {
return _parser; } }
1330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1331 public static pbr::MessageDescriptor Descriptor {
1332 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[7]; }
1335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1336 pbr::MessageDescriptor pb::IMessage.Descriptor {
1337 get {
return Descriptor; }
1340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1345 partial
void OnConstruction();
1347 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1349 index_ = other.index_;
1350 target_ = other.target_;
1351 vars_ = other.vars_.Clone();
1352 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1361 public const int IndexFieldNumber = 1;
1363 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1365 get {
return index_; }
1372 public const int TargetFieldNumber = 2;
1373 private int target_;
1374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1376 get {
return target_; }
1383 public const int VarsFieldNumber = 3;
1384 private static readonly pb::FieldCodec<int> _repeated_vars_codec
1385 = pb::FieldCodec.ForInt32(26);
1386 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
1387 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1388 public pbc::RepeatedField<int> Vars {
1389 get {
return vars_; }
1392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1397 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1399 if (ReferenceEquals(other,
null)) {
1402 if (ReferenceEquals(other,
this)) {
1405 if (Index != other.
Index)
return false;
1406 if (Target != other.
Target)
return false;
1407 if(!vars_.Equals(other.vars_))
return false;
1408 return Equals(_unknownFields, other._unknownFields);
1411 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1414 if (Index != 0) hash ^= Index.GetHashCode();
1415 if (Target != 0) hash ^= Target.GetHashCode();
1416 hash ^= vars_.GetHashCode();
1417 if (_unknownFields !=
null) {
1418 hash ^= _unknownFields.GetHashCode();
1423 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1425 return pb::JsonFormatter.ToDiagnosticString(
this);
1428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1429 public void WriteTo(pb::CodedOutputStream output) {
1431 output.WriteRawTag(8);
1432 output.WriteInt32(Index);
1435 output.WriteRawTag(16);
1436 output.WriteInt32(Target);
1438 vars_.WriteTo(output, _repeated_vars_codec);
1439 if (_unknownFields !=
null) {
1440 _unknownFields.WriteTo(output);
1444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1448 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Index);
1451 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Target);
1453 size += vars_.CalculateSize(_repeated_vars_codec);
1454 if (_unknownFields !=
null) {
1455 size += _unknownFields.CalculateSize();
1460 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1462 if (other ==
null) {
1465 if (other.
Index != 0) {
1466 Index = other.
Index;
1471 vars_.Add(other.vars_);
1472 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1478 while ((tag = input.ReadTag()) != 0) {
1481 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1484 Index = input.ReadInt32();
1488 Target = input.ReadInt32();
1493 vars_.AddEntriesFrom(input, _repeated_vars_codec);
1507 private static readonly pb::MessageParser<IntervalConstraintProto> _parser =
new pb::MessageParser<IntervalConstraintProto>(() =>
new IntervalConstraintProto());
1508 private pb::UnknownFieldSet _unknownFields;
1509 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1510 public static pb::MessageParser<IntervalConstraintProto> Parser {
get {
return _parser; } }
1512 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1513 public static pbr::MessageDescriptor Descriptor {
1514 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[8]; }
1517 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1518 pbr::MessageDescriptor pb::IMessage.Descriptor {
1519 get {
return Descriptor; }
1522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1527 partial
void OnConstruction();
1529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1531 start_ = other.start_;
1533 size_ = other.size_;
1534 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1537 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1543 public const int StartFieldNumber = 1;
1545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1547 get {
return start_; }
1554 public const int EndFieldNumber = 2;
1556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1558 get {
return end_; }
1565 public const int SizeFieldNumber = 3;
1567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1569 get {
return size_; }
1575 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1580 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1582 if (ReferenceEquals(other,
null)) {
1585 if (ReferenceEquals(other,
this)) {
1588 if (Start != other.
Start)
return false;
1589 if (End != other.
End)
return false;
1590 if (Size != other.
Size)
return false;
1591 return Equals(_unknownFields, other._unknownFields);
1594 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1597 if (Start != 0) hash ^= Start.GetHashCode();
1598 if (End != 0) hash ^= End.GetHashCode();
1599 if (Size != 0) hash ^= Size.GetHashCode();
1600 if (_unknownFields !=
null) {
1601 hash ^= _unknownFields.GetHashCode();
1606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1608 return pb::JsonFormatter.ToDiagnosticString(
this);
1611 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1612 public void WriteTo(pb::CodedOutputStream output) {
1614 output.WriteRawTag(8);
1615 output.WriteInt32(Start);
1618 output.WriteRawTag(16);
1619 output.WriteInt32(End);
1622 output.WriteRawTag(24);
1623 output.WriteInt32(Size);
1625 if (_unknownFields !=
null) {
1626 _unknownFields.WriteTo(output);
1630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1634 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Start);
1637 size += 1 + pb::CodedOutputStream.ComputeInt32Size(End);
1640 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Size);
1642 if (_unknownFields !=
null) {
1643 size += _unknownFields.CalculateSize();
1648 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1650 if (other ==
null) {
1653 if (other.
Start != 0) {
1654 Start = other.
Start;
1656 if (other.
End != 0) {
1659 if (other.
Size != 0) {
1662 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1665 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1668 while ((tag = input.ReadTag()) != 0) {
1671 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1674 Start = input.ReadInt32();
1678 End = input.ReadInt32();
1682 Size = input.ReadInt32();
1699 private static readonly pb::MessageParser<NoOverlapConstraintProto> _parser =
new pb::MessageParser<NoOverlapConstraintProto>(() =>
new NoOverlapConstraintProto());
1700 private pb::UnknownFieldSet _unknownFields;
1701 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1702 public static pb::MessageParser<NoOverlapConstraintProto> Parser {
get {
return _parser; } }
1704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1705 public static pbr::MessageDescriptor Descriptor {
1706 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[9]; }
1709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1710 pbr::MessageDescriptor pb::IMessage.Descriptor {
1711 get {
return Descriptor; }
1714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1719 partial
void OnConstruction();
1721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1723 intervals_ = other.intervals_.Clone();
1724 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1733 public const int IntervalsFieldNumber = 1;
1734 private static readonly pb::FieldCodec<int> _repeated_intervals_codec
1735 = pb::FieldCodec.ForInt32(10);
1736 private readonly pbc::RepeatedField<int> intervals_ =
new pbc::RepeatedField<int>();
1737 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1738 public pbc::RepeatedField<int> Intervals {
1739 get {
return intervals_; }
1742 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1749 if (ReferenceEquals(other,
null)) {
1752 if (ReferenceEquals(other,
this)) {
1755 if(!intervals_.Equals(other.intervals_))
return false;
1756 return Equals(_unknownFields, other._unknownFields);
1759 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1762 hash ^= intervals_.GetHashCode();
1763 if (_unknownFields !=
null) {
1764 hash ^= _unknownFields.GetHashCode();
1769 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1771 return pb::JsonFormatter.ToDiagnosticString(
this);
1774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1775 public void WriteTo(pb::CodedOutputStream output) {
1776 intervals_.WriteTo(output, _repeated_intervals_codec);
1777 if (_unknownFields !=
null) {
1778 _unknownFields.WriteTo(output);
1782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1785 size += intervals_.CalculateSize(_repeated_intervals_codec);
1786 if (_unknownFields !=
null) {
1787 size += _unknownFields.CalculateSize();
1792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1794 if (other ==
null) {
1797 intervals_.Add(other.intervals_);
1798 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1804 while ((tag = input.ReadTag()) != 0) {
1807 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1811 intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
1824 private static readonly pb::MessageParser<NoOverlap2DConstraintProto> _parser =
new pb::MessageParser<NoOverlap2DConstraintProto>(() =>
new NoOverlap2DConstraintProto());
1825 private pb::UnknownFieldSet _unknownFields;
1826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1827 public static pb::MessageParser<NoOverlap2DConstraintProto> Parser {
get {
return _parser; } }
1829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1830 public static pbr::MessageDescriptor Descriptor {
1831 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[10]; }
1834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1835 pbr::MessageDescriptor pb::IMessage.Descriptor {
1836 get {
return Descriptor; }
1839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1844 partial
void OnConstruction();
1846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1848 xIntervals_ = other.xIntervals_.Clone();
1849 yIntervals_ = other.yIntervals_.Clone();
1850 boxesWithNullAreaCanOverlap_ = other.boxesWithNullAreaCanOverlap_;
1851 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
1854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1860 public const int XIntervalsFieldNumber = 1;
1861 private static readonly pb::FieldCodec<int> _repeated_xIntervals_codec
1862 = pb::FieldCodec.ForInt32(10);
1863 private readonly pbc::RepeatedField<int> xIntervals_ =
new pbc::RepeatedField<int>();
1864 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1865 public pbc::RepeatedField<int> XIntervals {
1866 get {
return xIntervals_; }
1870 public const int YIntervalsFieldNumber = 2;
1871 private static readonly pb::FieldCodec<int> _repeated_yIntervals_codec
1872 = pb::FieldCodec.ForInt32(18);
1873 private readonly pbc::RepeatedField<int> yIntervals_ =
new pbc::RepeatedField<int>();
1877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1878 public pbc::RepeatedField<int> YIntervals {
1879 get {
return yIntervals_; }
1883 public const int BoxesWithNullAreaCanOverlapFieldNumber = 3;
1884 private bool boxesWithNullAreaCanOverlap_;
1885 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1886 public bool BoxesWithNullAreaCanOverlap {
1887 get {
return boxesWithNullAreaCanOverlap_; }
1889 boxesWithNullAreaCanOverlap_ = value;
1893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1898 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1900 if (ReferenceEquals(other,
null)) {
1903 if (ReferenceEquals(other,
this)) {
1906 if(!xIntervals_.Equals(other.xIntervals_))
return false;
1907 if(!yIntervals_.Equals(other.yIntervals_))
return false;
1909 return Equals(_unknownFields, other._unknownFields);
1912 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1915 hash ^= xIntervals_.GetHashCode();
1916 hash ^= yIntervals_.GetHashCode();
1917 if (BoxesWithNullAreaCanOverlap !=
false) hash ^= BoxesWithNullAreaCanOverlap.GetHashCode();
1918 if (_unknownFields !=
null) {
1919 hash ^= _unknownFields.GetHashCode();
1924 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1926 return pb::JsonFormatter.ToDiagnosticString(
this);
1929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1930 public void WriteTo(pb::CodedOutputStream output) {
1931 xIntervals_.WriteTo(output, _repeated_xIntervals_codec);
1932 yIntervals_.WriteTo(output, _repeated_yIntervals_codec);
1933 if (BoxesWithNullAreaCanOverlap !=
false) {
1934 output.WriteRawTag(24);
1935 output.WriteBool(BoxesWithNullAreaCanOverlap);
1937 if (_unknownFields !=
null) {
1938 _unknownFields.WriteTo(output);
1942 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1945 size += xIntervals_.CalculateSize(_repeated_xIntervals_codec);
1946 size += yIntervals_.CalculateSize(_repeated_yIntervals_codec);
1947 if (BoxesWithNullAreaCanOverlap !=
false) {
1950 if (_unknownFields !=
null) {
1951 size += _unknownFields.CalculateSize();
1956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1958 if (other ==
null) {
1961 xIntervals_.Add(other.xIntervals_);
1962 yIntervals_.Add(other.yIntervals_);
1966 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
1969 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1972 while ((tag = input.ReadTag()) != 0) {
1975 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
1979 xIntervals_.AddEntriesFrom(input, _repeated_xIntervals_codec);
1984 yIntervals_.AddEntriesFrom(input, _repeated_yIntervals_codec);
1988 BoxesWithNullAreaCanOverlap = input.ReadBool();
2004 private static readonly pb::MessageParser<CumulativeConstraintProto> _parser =
new pb::MessageParser<CumulativeConstraintProto>(() =>
new CumulativeConstraintProto());
2005 private pb::UnknownFieldSet _unknownFields;
2006 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2007 public static pb::MessageParser<CumulativeConstraintProto> Parser {
get {
return _parser; } }
2009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2010 public static pbr::MessageDescriptor Descriptor {
2011 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[11]; }
2014 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2015 pbr::MessageDescriptor pb::IMessage.Descriptor {
2016 get {
return Descriptor; }
2019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2024 partial
void OnConstruction();
2026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2028 capacity_ = other.capacity_;
2029 intervals_ = other.intervals_.Clone();
2030 demands_ = other.demands_.Clone();
2031 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2040 public const int CapacityFieldNumber = 1;
2041 private int capacity_;
2042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2043 public int Capacity {
2044 get {
return capacity_; }
2051 public const int IntervalsFieldNumber = 2;
2052 private static readonly pb::FieldCodec<int> _repeated_intervals_codec
2053 = pb::FieldCodec.ForInt32(18);
2054 private readonly pbc::RepeatedField<int> intervals_ =
new pbc::RepeatedField<int>();
2055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2056 public pbc::RepeatedField<int> Intervals {
2057 get {
return intervals_; }
2061 public const int DemandsFieldNumber = 3;
2062 private static readonly pb::FieldCodec<int> _repeated_demands_codec
2063 = pb::FieldCodec.ForInt32(26);
2064 private readonly pbc::RepeatedField<int> demands_ =
new pbc::RepeatedField<int>();
2068 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2069 public pbc::RepeatedField<int> Demands {
2070 get {
return demands_; }
2073 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2080 if (ReferenceEquals(other,
null)) {
2083 if (ReferenceEquals(other,
this)) {
2086 if (Capacity != other.
Capacity)
return false;
2087 if(!intervals_.Equals(other.intervals_))
return false;
2088 if(!demands_.Equals(other.demands_))
return false;
2089 return Equals(_unknownFields, other._unknownFields);
2092 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2095 if (Capacity != 0) hash ^= Capacity.GetHashCode();
2096 hash ^= intervals_.GetHashCode();
2097 hash ^= demands_.GetHashCode();
2098 if (_unknownFields !=
null) {
2099 hash ^= _unknownFields.GetHashCode();
2104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2106 return pb::JsonFormatter.ToDiagnosticString(
this);
2109 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2110 public void WriteTo(pb::CodedOutputStream output) {
2111 if (Capacity != 0) {
2112 output.WriteRawTag(8);
2113 output.WriteInt32(Capacity);
2115 intervals_.WriteTo(output, _repeated_intervals_codec);
2116 demands_.WriteTo(output, _repeated_demands_codec);
2117 if (_unknownFields !=
null) {
2118 _unknownFields.WriteTo(output);
2122 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2125 if (Capacity != 0) {
2126 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Capacity);
2128 size += intervals_.CalculateSize(_repeated_intervals_codec);
2129 size += demands_.CalculateSize(_repeated_demands_codec);
2130 if (_unknownFields !=
null) {
2131 size += _unknownFields.CalculateSize();
2136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2138 if (other ==
null) {
2144 intervals_.Add(other.intervals_);
2145 demands_.Add(other.demands_);
2146 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2149 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2152 while ((tag = input.ReadTag()) != 0) {
2155 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2158 Capacity = input.ReadInt32();
2163 intervals_.AddEntriesFrom(input, _repeated_intervals_codec);
2168 demands_.AddEntriesFrom(input, _repeated_demands_codec);
2194 private static readonly pb::MessageParser<ReservoirConstraintProto> _parser =
new pb::MessageParser<ReservoirConstraintProto>(() =>
new ReservoirConstraintProto());
2195 private pb::UnknownFieldSet _unknownFields;
2196 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2197 public static pb::MessageParser<ReservoirConstraintProto> Parser {
get {
return _parser; } }
2199 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2200 public static pbr::MessageDescriptor Descriptor {
2201 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[12]; }
2204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2205 pbr::MessageDescriptor pb::IMessage.Descriptor {
2206 get {
return Descriptor; }
2209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2214 partial
void OnConstruction();
2216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2218 minLevel_ = other.minLevel_;
2219 maxLevel_ = other.maxLevel_;
2220 times_ = other.times_.Clone();
2221 demands_ = other.demands_.Clone();
2222 actives_ = other.actives_.Clone();
2223 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2232 public const int MinLevelFieldNumber = 1;
2233 private long minLevel_;
2234 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2235 public long MinLevel {
2236 get {
return minLevel_; }
2243 public const int MaxLevelFieldNumber = 2;
2244 private long maxLevel_;
2245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2246 public long MaxLevel {
2247 get {
return maxLevel_; }
2254 public const int TimesFieldNumber = 3;
2255 private static readonly pb::FieldCodec<int> _repeated_times_codec
2256 = pb::FieldCodec.ForInt32(26);
2257 private readonly pbc::RepeatedField<int> times_ =
new pbc::RepeatedField<int>();
2261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2262 public pbc::RepeatedField<int> Times {
2263 get {
return times_; }
2267 public const int DemandsFieldNumber = 4;
2268 private static readonly pb::FieldCodec<long> _repeated_demands_codec
2269 = pb::FieldCodec.ForInt64(34);
2270 private readonly pbc::RepeatedField<long> demands_ =
new pbc::RepeatedField<long>();
2274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2275 public pbc::RepeatedField<long> Demands {
2276 get {
return demands_; }
2280 public const int ActivesFieldNumber = 5;
2281 private static readonly pb::FieldCodec<int> _repeated_actives_codec
2282 = pb::FieldCodec.ForInt32(42);
2283 private readonly pbc::RepeatedField<int> actives_ =
new pbc::RepeatedField<int>();
2287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2288 public pbc::RepeatedField<int> Actives {
2289 get {
return actives_; }
2292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2299 if (ReferenceEquals(other,
null)) {
2302 if (ReferenceEquals(other,
this)) {
2305 if (MinLevel != other.
MinLevel)
return false;
2306 if (MaxLevel != other.
MaxLevel)
return false;
2307 if(!times_.Equals(other.times_))
return false;
2308 if(!demands_.Equals(other.demands_))
return false;
2309 if(!actives_.Equals(other.actives_))
return false;
2310 return Equals(_unknownFields, other._unknownFields);
2313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2316 if (MinLevel != 0L) hash ^= MinLevel.GetHashCode();
2317 if (MaxLevel != 0L) hash ^= MaxLevel.GetHashCode();
2318 hash ^= times_.GetHashCode();
2319 hash ^= demands_.GetHashCode();
2320 hash ^= actives_.GetHashCode();
2321 if (_unknownFields !=
null) {
2322 hash ^= _unknownFields.GetHashCode();
2327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2329 return pb::JsonFormatter.ToDiagnosticString(
this);
2332 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2333 public void WriteTo(pb::CodedOutputStream output) {
2334 if (MinLevel != 0L) {
2335 output.WriteRawTag(8);
2336 output.WriteInt64(MinLevel);
2338 if (MaxLevel != 0L) {
2339 output.WriteRawTag(16);
2340 output.WriteInt64(MaxLevel);
2342 times_.WriteTo(output, _repeated_times_codec);
2343 demands_.WriteTo(output, _repeated_demands_codec);
2344 actives_.WriteTo(output, _repeated_actives_codec);
2345 if (_unknownFields !=
null) {
2346 _unknownFields.WriteTo(output);
2350 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2353 if (MinLevel != 0L) {
2354 size += 1 + pb::CodedOutputStream.ComputeInt64Size(MinLevel);
2356 if (MaxLevel != 0L) {
2357 size += 1 + pb::CodedOutputStream.ComputeInt64Size(MaxLevel);
2359 size += times_.CalculateSize(_repeated_times_codec);
2360 size += demands_.CalculateSize(_repeated_demands_codec);
2361 size += actives_.CalculateSize(_repeated_actives_codec);
2362 if (_unknownFields !=
null) {
2363 size += _unknownFields.CalculateSize();
2368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2370 if (other ==
null) {
2379 times_.Add(other.times_);
2380 demands_.Add(other.demands_);
2381 actives_.Add(other.actives_);
2382 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2388 while ((tag = input.ReadTag()) != 0) {
2391 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2394 MinLevel = input.ReadInt64();
2398 MaxLevel = input.ReadInt64();
2403 times_.AddEntriesFrom(input, _repeated_times_codec);
2408 demands_.AddEntriesFrom(input, _repeated_demands_codec);
2413 actives_.AddEntriesFrom(input, _repeated_actives_codec);
2434 private static readonly pb::MessageParser<CircuitConstraintProto> _parser =
new pb::MessageParser<CircuitConstraintProto>(() =>
new CircuitConstraintProto());
2435 private pb::UnknownFieldSet _unknownFields;
2436 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2437 public static pb::MessageParser<CircuitConstraintProto> Parser {
get {
return _parser; } }
2439 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2440 public static pbr::MessageDescriptor Descriptor {
2441 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[13]; }
2444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2445 pbr::MessageDescriptor pb::IMessage.Descriptor {
2446 get {
return Descriptor; }
2449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2454 partial
void OnConstruction();
2456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2458 tails_ = other.tails_.Clone();
2459 heads_ = other.heads_.Clone();
2460 literals_ = other.literals_.Clone();
2461 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2464 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2470 public const int TailsFieldNumber = 3;
2471 private static readonly pb::FieldCodec<int> _repeated_tails_codec
2472 = pb::FieldCodec.ForInt32(26);
2473 private readonly pbc::RepeatedField<int> tails_ =
new pbc::RepeatedField<int>();
2474 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2475 public pbc::RepeatedField<int> Tails {
2476 get {
return tails_; }
2480 public const int HeadsFieldNumber = 4;
2481 private static readonly pb::FieldCodec<int> _repeated_heads_codec
2482 = pb::FieldCodec.ForInt32(34);
2483 private readonly pbc::RepeatedField<int> heads_ =
new pbc::RepeatedField<int>();
2484 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2485 public pbc::RepeatedField<int> Heads {
2486 get {
return heads_; }
2490 public const int LiteralsFieldNumber = 5;
2491 private static readonly pb::FieldCodec<int> _repeated_literals_codec
2492 = pb::FieldCodec.ForInt32(42);
2493 private readonly pbc::RepeatedField<int> literals_ =
new pbc::RepeatedField<int>();
2494 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2495 public pbc::RepeatedField<int> Literals {
2496 get {
return literals_; }
2499 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2506 if (ReferenceEquals(other,
null)) {
2509 if (ReferenceEquals(other,
this)) {
2512 if(!tails_.Equals(other.tails_))
return false;
2513 if(!heads_.Equals(other.heads_))
return false;
2514 if(!literals_.Equals(other.literals_))
return false;
2515 return Equals(_unknownFields, other._unknownFields);
2518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2521 hash ^= tails_.GetHashCode();
2522 hash ^= heads_.GetHashCode();
2523 hash ^= literals_.GetHashCode();
2524 if (_unknownFields !=
null) {
2525 hash ^= _unknownFields.GetHashCode();
2530 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2532 return pb::JsonFormatter.ToDiagnosticString(
this);
2535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2536 public void WriteTo(pb::CodedOutputStream output) {
2537 tails_.WriteTo(output, _repeated_tails_codec);
2538 heads_.WriteTo(output, _repeated_heads_codec);
2539 literals_.WriteTo(output, _repeated_literals_codec);
2540 if (_unknownFields !=
null) {
2541 _unknownFields.WriteTo(output);
2545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2548 size += tails_.CalculateSize(_repeated_tails_codec);
2549 size += heads_.CalculateSize(_repeated_heads_codec);
2550 size += literals_.CalculateSize(_repeated_literals_codec);
2551 if (_unknownFields !=
null) {
2552 size += _unknownFields.CalculateSize();
2557 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2559 if (other ==
null) {
2562 tails_.Add(other.tails_);
2563 heads_.Add(other.heads_);
2564 literals_.Add(other.literals_);
2565 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2571 while ((tag = input.ReadTag()) != 0) {
2574 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2578 tails_.AddEntriesFrom(input, _repeated_tails_codec);
2583 heads_.AddEntriesFrom(input, _repeated_heads_codec);
2588 literals_.AddEntriesFrom(input, _repeated_literals_codec);
2615 private static readonly pb::MessageParser<RoutesConstraintProto> _parser =
new pb::MessageParser<RoutesConstraintProto>(() =>
new RoutesConstraintProto());
2616 private pb::UnknownFieldSet _unknownFields;
2617 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2618 public static pb::MessageParser<RoutesConstraintProto> Parser {
get {
return _parser; } }
2620 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2621 public static pbr::MessageDescriptor Descriptor {
2622 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[14]; }
2625 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2626 pbr::MessageDescriptor pb::IMessage.Descriptor {
2627 get {
return Descriptor; }
2630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2635 partial
void OnConstruction();
2637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2639 tails_ = other.tails_.Clone();
2640 heads_ = other.heads_.Clone();
2641 literals_ = other.literals_.Clone();
2642 demands_ = other.demands_.Clone();
2643 capacity_ = other.capacity_;
2644 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2653 public const int TailsFieldNumber = 1;
2654 private static readonly pb::FieldCodec<int> _repeated_tails_codec
2655 = pb::FieldCodec.ForInt32(10);
2656 private readonly pbc::RepeatedField<int> tails_ =
new pbc::RepeatedField<int>();
2657 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2658 public pbc::RepeatedField<int> Tails {
2659 get {
return tails_; }
2663 public const int HeadsFieldNumber = 2;
2664 private static readonly pb::FieldCodec<int> _repeated_heads_codec
2665 = pb::FieldCodec.ForInt32(18);
2666 private readonly pbc::RepeatedField<int> heads_ =
new pbc::RepeatedField<int>();
2667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2668 public pbc::RepeatedField<int> Heads {
2669 get {
return heads_; }
2673 public const int LiteralsFieldNumber = 3;
2674 private static readonly pb::FieldCodec<int> _repeated_literals_codec
2675 = pb::FieldCodec.ForInt32(26);
2676 private readonly pbc::RepeatedField<int> literals_ =
new pbc::RepeatedField<int>();
2677 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2678 public pbc::RepeatedField<int> Literals {
2679 get {
return literals_; }
2683 public const int DemandsFieldNumber = 4;
2684 private static readonly pb::FieldCodec<int> _repeated_demands_codec
2685 = pb::FieldCodec.ForInt32(34);
2686 private readonly pbc::RepeatedField<int> demands_ =
new pbc::RepeatedField<int>();
2692 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2693 public pbc::RepeatedField<int> Demands {
2694 get {
return demands_; }
2698 public const int CapacityFieldNumber = 5;
2699 private long capacity_;
2700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2701 public long Capacity {
2702 get {
return capacity_; }
2708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2713 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2715 if (ReferenceEquals(other,
null)) {
2718 if (ReferenceEquals(other,
this)) {
2721 if(!tails_.Equals(other.tails_))
return false;
2722 if(!heads_.Equals(other.heads_))
return false;
2723 if(!literals_.Equals(other.literals_))
return false;
2724 if(!demands_.Equals(other.demands_))
return false;
2725 if (Capacity != other.
Capacity)
return false;
2726 return Equals(_unknownFields, other._unknownFields);
2729 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2732 hash ^= tails_.GetHashCode();
2733 hash ^= heads_.GetHashCode();
2734 hash ^= literals_.GetHashCode();
2735 hash ^= demands_.GetHashCode();
2736 if (Capacity != 0L) hash ^= Capacity.GetHashCode();
2737 if (_unknownFields !=
null) {
2738 hash ^= _unknownFields.GetHashCode();
2743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2745 return pb::JsonFormatter.ToDiagnosticString(
this);
2748 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2749 public void WriteTo(pb::CodedOutputStream output) {
2750 tails_.WriteTo(output, _repeated_tails_codec);
2751 heads_.WriteTo(output, _repeated_heads_codec);
2752 literals_.WriteTo(output, _repeated_literals_codec);
2753 demands_.WriteTo(output, _repeated_demands_codec);
2754 if (Capacity != 0L) {
2755 output.WriteRawTag(40);
2756 output.WriteInt64(Capacity);
2758 if (_unknownFields !=
null) {
2759 _unknownFields.WriteTo(output);
2763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2766 size += tails_.CalculateSize(_repeated_tails_codec);
2767 size += heads_.CalculateSize(_repeated_heads_codec);
2768 size += literals_.CalculateSize(_repeated_literals_codec);
2769 size += demands_.CalculateSize(_repeated_demands_codec);
2770 if (Capacity != 0L) {
2771 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Capacity);
2773 if (_unknownFields !=
null) {
2774 size += _unknownFields.CalculateSize();
2779 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2781 if (other ==
null) {
2784 tails_.Add(other.tails_);
2785 heads_.Add(other.heads_);
2786 literals_.Add(other.literals_);
2787 demands_.Add(other.demands_);
2791 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2794 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2797 while ((tag = input.ReadTag()) != 0) {
2800 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2804 tails_.AddEntriesFrom(input, _repeated_tails_codec);
2809 heads_.AddEntriesFrom(input, _repeated_heads_codec);
2814 literals_.AddEntriesFrom(input, _repeated_literals_codec);
2819 demands_.AddEntriesFrom(input, _repeated_demands_codec);
2823 Capacity = input.ReadInt64();
2838 private static readonly pb::MessageParser<CircuitCoveringConstraintProto> _parser =
new pb::MessageParser<CircuitCoveringConstraintProto>(() =>
new CircuitCoveringConstraintProto());
2839 private pb::UnknownFieldSet _unknownFields;
2840 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2841 public static pb::MessageParser<CircuitCoveringConstraintProto> Parser {
get {
return _parser; } }
2843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2844 public static pbr::MessageDescriptor Descriptor {
2845 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[15]; }
2848 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2849 pbr::MessageDescriptor pb::IMessage.Descriptor {
2850 get {
return Descriptor; }
2853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2858 partial
void OnConstruction();
2860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2862 nexts_ = other.nexts_.Clone();
2863 distinguishedNodes_ = other.distinguishedNodes_.Clone();
2864 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
2867 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2873 public const int NextsFieldNumber = 1;
2874 private static readonly pb::FieldCodec<int> _repeated_nexts_codec
2875 = pb::FieldCodec.ForInt32(10);
2876 private readonly pbc::RepeatedField<int> nexts_ =
new pbc::RepeatedField<int>();
2877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2878 public pbc::RepeatedField<int> Nexts {
2879 get {
return nexts_; }
2883 public const int DistinguishedNodesFieldNumber = 2;
2884 private static readonly pb::FieldCodec<long> _repeated_distinguishedNodes_codec
2885 = pb::FieldCodec.ForInt64(18);
2886 private readonly pbc::RepeatedField<long> distinguishedNodes_ =
new pbc::RepeatedField<long>();
2887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2888 public pbc::RepeatedField<long> DistinguishedNodes {
2889 get {
return distinguishedNodes_; }
2892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2897 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2899 if (ReferenceEquals(other,
null)) {
2902 if (ReferenceEquals(other,
this)) {
2905 if(!nexts_.Equals(other.nexts_))
return false;
2906 if(!distinguishedNodes_.Equals(other.distinguishedNodes_))
return false;
2907 return Equals(_unknownFields, other._unknownFields);
2910 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2913 hash ^= nexts_.GetHashCode();
2914 hash ^= distinguishedNodes_.GetHashCode();
2915 if (_unknownFields !=
null) {
2916 hash ^= _unknownFields.GetHashCode();
2921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2923 return pb::JsonFormatter.ToDiagnosticString(
this);
2926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2927 public void WriteTo(pb::CodedOutputStream output) {
2928 nexts_.WriteTo(output, _repeated_nexts_codec);
2929 distinguishedNodes_.WriteTo(output, _repeated_distinguishedNodes_codec);
2930 if (_unknownFields !=
null) {
2931 _unknownFields.WriteTo(output);
2935 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2938 size += nexts_.CalculateSize(_repeated_nexts_codec);
2939 size += distinguishedNodes_.CalculateSize(_repeated_distinguishedNodes_codec);
2940 if (_unknownFields !=
null) {
2941 size += _unknownFields.CalculateSize();
2946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2948 if (other ==
null) {
2951 nexts_.Add(other.nexts_);
2952 distinguishedNodes_.Add(other.distinguishedNodes_);
2953 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
2956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2959 while ((tag = input.ReadTag()) != 0) {
2962 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
2966 nexts_.AddEntriesFrom(input, _repeated_nexts_codec);
2971 distinguishedNodes_.AddEntriesFrom(input, _repeated_distinguishedNodes_codec);
2986 private static readonly pb::MessageParser<TableConstraintProto> _parser =
new pb::MessageParser<TableConstraintProto>(() =>
new TableConstraintProto());
2987 private pb::UnknownFieldSet _unknownFields;
2988 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2989 public static pb::MessageParser<TableConstraintProto> Parser {
get {
return _parser; } }
2991 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2992 public static pbr::MessageDescriptor Descriptor {
2993 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[16]; }
2996 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2997 pbr::MessageDescriptor pb::IMessage.Descriptor {
2998 get {
return Descriptor; }
3001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3006 partial
void OnConstruction();
3008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3010 vars_ = other.vars_.Clone();
3011 values_ = other.values_.Clone();
3012 negated_ = other.negated_;
3013 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3016 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3022 public const int VarsFieldNumber = 1;
3023 private static readonly pb::FieldCodec<int> _repeated_vars_codec
3024 = pb::FieldCodec.ForInt32(10);
3025 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
3026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3027 public pbc::RepeatedField<int> Vars {
3028 get {
return vars_; }
3032 public const int ValuesFieldNumber = 2;
3033 private static readonly pb::FieldCodec<long> _repeated_values_codec
3034 = pb::FieldCodec.ForInt64(18);
3035 private readonly pbc::RepeatedField<long> values_ =
new pbc::RepeatedField<long>();
3036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3037 public pbc::RepeatedField<long> Values {
3038 get {
return values_; }
3042 public const int NegatedFieldNumber = 3;
3043 private bool negated_;
3048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3049 public bool Negated {
3050 get {
return negated_; }
3056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3063 if (ReferenceEquals(other,
null)) {
3066 if (ReferenceEquals(other,
this)) {
3069 if(!vars_.Equals(other.vars_))
return false;
3070 if(!values_.Equals(other.values_))
return false;
3071 if (Negated != other.
Negated)
return false;
3072 return Equals(_unknownFields, other._unknownFields);
3075 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3078 hash ^= vars_.GetHashCode();
3079 hash ^= values_.GetHashCode();
3080 if (Negated !=
false) hash ^= Negated.GetHashCode();
3081 if (_unknownFields !=
null) {
3082 hash ^= _unknownFields.GetHashCode();
3087 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3089 return pb::JsonFormatter.ToDiagnosticString(
this);
3092 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3093 public void WriteTo(pb::CodedOutputStream output) {
3094 vars_.WriteTo(output, _repeated_vars_codec);
3095 values_.WriteTo(output, _repeated_values_codec);
3096 if (Negated !=
false) {
3097 output.WriteRawTag(24);
3098 output.WriteBool(Negated);
3100 if (_unknownFields !=
null) {
3101 _unknownFields.WriteTo(output);
3105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3108 size += vars_.CalculateSize(_repeated_vars_codec);
3109 size += values_.CalculateSize(_repeated_values_codec);
3110 if (Negated !=
false) {
3113 if (_unknownFields !=
null) {
3114 size += _unknownFields.CalculateSize();
3119 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3121 if (other ==
null) {
3124 vars_.Add(other.vars_);
3125 values_.Add(other.values_);
3129 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3135 while ((tag = input.ReadTag()) != 0) {
3138 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3142 vars_.AddEntriesFrom(input, _repeated_vars_codec);
3147 values_.AddEntriesFrom(input, _repeated_values_codec);
3151 Negated = input.ReadBool();
3165 private static readonly pb::MessageParser<InverseConstraintProto> _parser =
new pb::MessageParser<InverseConstraintProto>(() =>
new InverseConstraintProto());
3166 private pb::UnknownFieldSet _unknownFields;
3167 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3168 public static pb::MessageParser<InverseConstraintProto> Parser {
get {
return _parser; } }
3170 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3171 public static pbr::MessageDescriptor Descriptor {
3172 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[17]; }
3175 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3176 pbr::MessageDescriptor pb::IMessage.Descriptor {
3177 get {
return Descriptor; }
3180 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3185 partial
void OnConstruction();
3187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3189 fDirect_ = other.fDirect_.Clone();
3190 fInverse_ = other.fInverse_.Clone();
3191 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3200 public const int FDirectFieldNumber = 1;
3201 private static readonly pb::FieldCodec<int> _repeated_fDirect_codec
3202 = pb::FieldCodec.ForInt32(10);
3203 private readonly pbc::RepeatedField<int> fDirect_ =
new pbc::RepeatedField<int>();
3204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3205 public pbc::RepeatedField<int> FDirect {
3206 get {
return fDirect_; }
3210 public const int FInverseFieldNumber = 2;
3211 private static readonly pb::FieldCodec<int> _repeated_fInverse_codec
3212 = pb::FieldCodec.ForInt32(18);
3213 private readonly pbc::RepeatedField<int> fInverse_ =
new pbc::RepeatedField<int>();
3214 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3215 public pbc::RepeatedField<int> FInverse {
3216 get {
return fInverse_; }
3219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3226 if (ReferenceEquals(other,
null)) {
3229 if (ReferenceEquals(other,
this)) {
3232 if(!fDirect_.Equals(other.fDirect_))
return false;
3233 if(!fInverse_.Equals(other.fInverse_))
return false;
3234 return Equals(_unknownFields, other._unknownFields);
3237 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3240 hash ^= fDirect_.GetHashCode();
3241 hash ^= fInverse_.GetHashCode();
3242 if (_unknownFields !=
null) {
3243 hash ^= _unknownFields.GetHashCode();
3248 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3250 return pb::JsonFormatter.ToDiagnosticString(
this);
3253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3254 public void WriteTo(pb::CodedOutputStream output) {
3255 fDirect_.WriteTo(output, _repeated_fDirect_codec);
3256 fInverse_.WriteTo(output, _repeated_fInverse_codec);
3257 if (_unknownFields !=
null) {
3258 _unknownFields.WriteTo(output);
3262 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3265 size += fDirect_.CalculateSize(_repeated_fDirect_codec);
3266 size += fInverse_.CalculateSize(_repeated_fInverse_codec);
3267 if (_unknownFields !=
null) {
3268 size += _unknownFields.CalculateSize();
3273 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3275 if (other ==
null) {
3278 fDirect_.Add(other.fDirect_);
3279 fInverse_.Add(other.fInverse_);
3280 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3286 while ((tag = input.ReadTag()) != 0) {
3289 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3293 fDirect_.AddEntriesFrom(input, _repeated_fDirect_codec);
3298 fInverse_.AddEntriesFrom(input, _repeated_fInverse_codec);
3312 private static readonly pb::MessageParser<AutomatonConstraintProto> _parser =
new pb::MessageParser<AutomatonConstraintProto>(() =>
new AutomatonConstraintProto());
3313 private pb::UnknownFieldSet _unknownFields;
3314 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3315 public static pb::MessageParser<AutomatonConstraintProto> Parser {
get {
return _parser; } }
3317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3318 public static pbr::MessageDescriptor Descriptor {
3319 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[18]; }
3322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3323 pbr::MessageDescriptor pb::IMessage.Descriptor {
3324 get {
return Descriptor; }
3327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3332 partial
void OnConstruction();
3334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3336 startingState_ = other.startingState_;
3337 finalStates_ = other.finalStates_.Clone();
3338 transitionTail_ = other.transitionTail_.Clone();
3339 transitionHead_ = other.transitionHead_.Clone();
3340 transitionLabel_ = other.transitionLabel_.Clone();
3341 vars_ = other.vars_.Clone();
3342 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
3345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3351 public const int StartingStateFieldNumber = 2;
3352 private long startingState_;
3358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3359 public long StartingState {
3360 get {
return startingState_; }
3362 startingState_ = value;
3367 public const int FinalStatesFieldNumber = 3;
3368 private static readonly pb::FieldCodec<long> _repeated_finalStates_codec
3369 = pb::FieldCodec.ForInt64(26);
3370 private readonly pbc::RepeatedField<long> finalStates_ =
new pbc::RepeatedField<long>();
3371 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3372 public pbc::RepeatedField<long> FinalStates {
3373 get {
return finalStates_; }
3377 public const int TransitionTailFieldNumber = 4;
3378 private static readonly pb::FieldCodec<long> _repeated_transitionTail_codec
3379 = pb::FieldCodec.ForInt64(34);
3380 private readonly pbc::RepeatedField<long> transitionTail_ =
new pbc::RepeatedField<long>();
3386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3387 public pbc::RepeatedField<long> TransitionTail {
3388 get {
return transitionTail_; }
3392 public const int TransitionHeadFieldNumber = 5;
3393 private static readonly pb::FieldCodec<long> _repeated_transitionHead_codec
3394 = pb::FieldCodec.ForInt64(42);
3395 private readonly pbc::RepeatedField<long> transitionHead_ =
new pbc::RepeatedField<long>();
3396 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3397 public pbc::RepeatedField<long> TransitionHead {
3398 get {
return transitionHead_; }
3402 public const int TransitionLabelFieldNumber = 6;
3403 private static readonly pb::FieldCodec<long> _repeated_transitionLabel_codec
3404 = pb::FieldCodec.ForInt64(50);
3405 private readonly pbc::RepeatedField<long> transitionLabel_ =
new pbc::RepeatedField<long>();
3406 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3407 public pbc::RepeatedField<long> TransitionLabel {
3408 get {
return transitionLabel_; }
3412 public const int VarsFieldNumber = 7;
3413 private static readonly pb::FieldCodec<int> _repeated_vars_codec
3414 = pb::FieldCodec.ForInt32(58);
3415 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
3420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3421 public pbc::RepeatedField<int> Vars {
3422 get {
return vars_; }
3425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3432 if (ReferenceEquals(other,
null)) {
3435 if (ReferenceEquals(other,
this)) {
3439 if(!finalStates_.Equals(other.finalStates_))
return false;
3440 if(!transitionTail_.Equals(other.transitionTail_))
return false;
3441 if(!transitionHead_.Equals(other.transitionHead_))
return false;
3442 if(!transitionLabel_.Equals(other.transitionLabel_))
return false;
3443 if(!vars_.Equals(other.vars_))
return false;
3444 return Equals(_unknownFields, other._unknownFields);
3447 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3450 if (StartingState != 0L) hash ^= StartingState.GetHashCode();
3451 hash ^= finalStates_.GetHashCode();
3452 hash ^= transitionTail_.GetHashCode();
3453 hash ^= transitionHead_.GetHashCode();
3454 hash ^= transitionLabel_.GetHashCode();
3455 hash ^= vars_.GetHashCode();
3456 if (_unknownFields !=
null) {
3457 hash ^= _unknownFields.GetHashCode();
3462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3464 return pb::JsonFormatter.ToDiagnosticString(
this);
3467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3468 public void WriteTo(pb::CodedOutputStream output) {
3469 if (StartingState != 0L) {
3470 output.WriteRawTag(16);
3471 output.WriteInt64(StartingState);
3473 finalStates_.WriteTo(output, _repeated_finalStates_codec);
3474 transitionTail_.WriteTo(output, _repeated_transitionTail_codec);
3475 transitionHead_.WriteTo(output, _repeated_transitionHead_codec);
3476 transitionLabel_.WriteTo(output, _repeated_transitionLabel_codec);
3477 vars_.WriteTo(output, _repeated_vars_codec);
3478 if (_unknownFields !=
null) {
3479 _unknownFields.WriteTo(output);
3483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3486 if (StartingState != 0L) {
3487 size += 1 + pb::CodedOutputStream.ComputeInt64Size(StartingState);
3489 size += finalStates_.CalculateSize(_repeated_finalStates_codec);
3490 size += transitionTail_.CalculateSize(_repeated_transitionTail_codec);
3491 size += transitionHead_.CalculateSize(_repeated_transitionHead_codec);
3492 size += transitionLabel_.CalculateSize(_repeated_transitionLabel_codec);
3493 size += vars_.CalculateSize(_repeated_vars_codec);
3494 if (_unknownFields !=
null) {
3495 size += _unknownFields.CalculateSize();
3500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3502 if (other ==
null) {
3508 finalStates_.Add(other.finalStates_);
3509 transitionTail_.Add(other.transitionTail_);
3510 transitionHead_.Add(other.transitionHead_);
3511 transitionLabel_.Add(other.transitionLabel_);
3512 vars_.Add(other.vars_);
3513 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3519 while ((tag = input.ReadTag()) != 0) {
3522 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3525 StartingState = input.ReadInt64();
3530 finalStates_.AddEntriesFrom(input, _repeated_finalStates_codec);
3535 transitionTail_.AddEntriesFrom(input, _repeated_transitionTail_codec);
3540 transitionHead_.AddEntriesFrom(input, _repeated_transitionHead_codec);
3545 transitionLabel_.AddEntriesFrom(input, _repeated_transitionLabel_codec);
3550 vars_.AddEntriesFrom(input, _repeated_vars_codec);
3563 private static readonly pb::MessageParser<ConstraintProto> _parser =
new pb::MessageParser<ConstraintProto>(() =>
new ConstraintProto());
3564 private pb::UnknownFieldSet _unknownFields;
3565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3566 public static pb::MessageParser<ConstraintProto> Parser {
get {
return _parser; } }
3568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3569 public static pbr::MessageDescriptor Descriptor {
3570 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[19]; }
3573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3574 pbr::MessageDescriptor pb::IMessage.Descriptor {
3575 get {
return Descriptor; }
3578 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3583 partial
void OnConstruction();
3585 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3587 name_ = other.name_;
3588 enforcementLiteral_ = other.enforcementLiteral_.Clone();
3667 _unknownFields = pb::UnknownFieldSet.
Clone(other._unknownFields);
3670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3676 public const int NameFieldNumber = 1;
3677 private string name_ =
"";
3681 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3682 public string Name {
3683 get {
return name_; }
3685 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
3690 public const int EnforcementLiteralFieldNumber = 2;
3691 private static readonly pb::FieldCodec<int> _repeated_enforcementLiteral_codec
3692 = pb::FieldCodec.ForInt32(18);
3693 private readonly pbc::RepeatedField<int> enforcementLiteral_ =
new pbc::RepeatedField<int>();
3710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3711 public pbc::RepeatedField<int> EnforcementLiteral {
3712 get {
return enforcementLiteral_; }
3716 public const int BoolOrFieldNumber = 3;
3720 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3721 public global::Google.OrTools.Sat.BoolArgumentProto BoolOr {
3722 get {
return constraintCase_ ==
ConstraintOneofCase.BoolOr ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ :
null; }
3724 constraint_ = value;
3730 public const int BoolAndFieldNumber = 4;
3738 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3739 public global::Google.OrTools.Sat.BoolArgumentProto BoolAnd {
3740 get {
return constraintCase_ ==
ConstraintOneofCase.BoolAnd ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ :
null; }
3742 constraint_ = value;
3748 public const int AtMostOneFieldNumber = 26;
3756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3757 public global::Google.OrTools.Sat.BoolArgumentProto AtMostOne {
3758 get {
return constraintCase_ ==
ConstraintOneofCase.AtMostOne ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ :
null; }
3760 constraint_ = value;
3766 public const int BoolXorFieldNumber = 5;
3770 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3771 public global::Google.OrTools.Sat.BoolArgumentProto BoolXor {
3772 get {
return constraintCase_ ==
ConstraintOneofCase.BoolXor ? (global::Google.OrTools.Sat.BoolArgumentProto) constraint_ :
null; }
3774 constraint_ = value;
3780 public const int IntDivFieldNumber = 7;
3784 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3785 public global::Google.OrTools.Sat.IntegerArgumentProto IntDiv {
3786 get {
return constraintCase_ ==
ConstraintOneofCase.IntDiv ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ :
null; }
3788 constraint_ = value;
3794 public const int IntModFieldNumber = 8;
3798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3799 public global::Google.OrTools.Sat.IntegerArgumentProto IntMod {
3800 get {
return constraintCase_ ==
ConstraintOneofCase.IntMod ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ :
null; }
3802 constraint_ = value;
3808 public const int IntMaxFieldNumber = 9;
3814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3815 public global::Google.OrTools.Sat.IntegerArgumentProto IntMax {
3816 get {
return constraintCase_ ==
ConstraintOneofCase.IntMax ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ :
null; }
3818 constraint_ = value;
3824 public const int LinMaxFieldNumber = 27;
3829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3830 public global::Google.OrTools.Sat.LinearArgumentProto LinMax {
3831 get {
return constraintCase_ ==
ConstraintOneofCase.LinMax ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ :
null; }
3833 constraint_ = value;
3839 public const int IntMinFieldNumber = 10;
3845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3846 public global::Google.OrTools.Sat.IntegerArgumentProto IntMin {
3847 get {
return constraintCase_ ==
ConstraintOneofCase.IntMin ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ :
null; }
3849 constraint_ = value;
3855 public const int LinMinFieldNumber = 28;
3860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3861 public global::Google.OrTools.Sat.LinearArgumentProto LinMin {
3862 get {
return constraintCase_ ==
ConstraintOneofCase.LinMin ? (global::Google.OrTools.Sat.LinearArgumentProto) constraint_ :
null; }
3864 constraint_ = value;
3870 public const int IntProdFieldNumber = 11;
3875 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3876 public global::Google.OrTools.Sat.IntegerArgumentProto IntProd {
3877 get {
return constraintCase_ ==
ConstraintOneofCase.IntProd ? (global::Google.OrTools.Sat.IntegerArgumentProto) constraint_ :
null; }
3879 constraint_ = value;
3885 public const int LinearFieldNumber = 12;
3890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3891 public global::Google.OrTools.Sat.LinearConstraintProto Linear {
3892 get {
return constraintCase_ ==
ConstraintOneofCase.Linear ? (global::Google.OrTools.Sat.LinearConstraintProto) constraint_ :
null; }
3894 constraint_ = value;
3900 public const int AllDiffFieldNumber = 13;
3904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3905 public global::Google.OrTools.Sat.AllDifferentConstraintProto AllDiff {
3906 get {
return constraintCase_ ==
ConstraintOneofCase.AllDiff ? (global::Google.OrTools.Sat.AllDifferentConstraintProto) constraint_ :
null; }
3908 constraint_ = value;
3914 public const int ElementFieldNumber = 14;
3919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3920 public global::Google.OrTools.Sat.ElementConstraintProto Element {
3921 get {
return constraintCase_ ==
ConstraintOneofCase.Element ? (global::Google.OrTools.Sat.ElementConstraintProto) constraint_ :
null; }
3923 constraint_ = value;
3929 public const int CircuitFieldNumber = 15;
3934 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3935 public global::Google.OrTools.Sat.CircuitConstraintProto Circuit {
3936 get {
return constraintCase_ ==
ConstraintOneofCase.Circuit ? (global::Google.OrTools.Sat.CircuitConstraintProto) constraint_ :
null; }
3938 constraint_ = value;
3944 public const int RoutesFieldNumber = 23;
3948 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3949 public global::Google.OrTools.Sat.RoutesConstraintProto Routes {
3950 get {
return constraintCase_ ==
ConstraintOneofCase.Routes ? (global::Google.OrTools.Sat.RoutesConstraintProto) constraint_ :
null; }
3952 constraint_ = value;
3958 public const int CircuitCoveringFieldNumber = 25;
3963 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3964 public global::Google.OrTools.Sat.CircuitCoveringConstraintProto CircuitCovering {
3965 get {
return constraintCase_ ==
ConstraintOneofCase.CircuitCovering ? (global::Google.OrTools.Sat.CircuitCoveringConstraintProto) constraint_ :
null; }
3967 constraint_ = value;
3973 public const int TableFieldNumber = 16;
3978 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3979 public global::Google.OrTools.Sat.TableConstraintProto Table {
3980 get {
return constraintCase_ ==
ConstraintOneofCase.Table ? (global::Google.OrTools.Sat.TableConstraintProto) constraint_ :
null; }
3982 constraint_ = value;
3988 public const int AutomatonFieldNumber = 17;
3993 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3994 public global::Google.OrTools.Sat.AutomatonConstraintProto Automaton {
3995 get {
return constraintCase_ ==
ConstraintOneofCase.Automaton ? (global::Google.OrTools.Sat.AutomatonConstraintProto) constraint_ :
null; }
3997 constraint_ = value;
4003 public const int InverseFieldNumber = 18;
4008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4009 public global::Google.OrTools.Sat.InverseConstraintProto Inverse {
4010 get {
return constraintCase_ ==
ConstraintOneofCase.Inverse ? (global::Google.OrTools.Sat.InverseConstraintProto) constraint_ :
null; }
4012 constraint_ = value;
4018 public const int ReservoirFieldNumber = 24;
4024 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4025 public global::Google.OrTools.Sat.ReservoirConstraintProto Reservoir {
4026 get {
return constraintCase_ ==
ConstraintOneofCase.Reservoir ? (global::Google.OrTools.Sat.ReservoirConstraintProto) constraint_ :
null; }
4028 constraint_ = value;
4034 public const int IntervalFieldNumber = 19;
4039 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4040 public global::Google.OrTools.Sat.IntervalConstraintProto Interval {
4041 get {
return constraintCase_ ==
ConstraintOneofCase.Interval ? (global::Google.OrTools.Sat.IntervalConstraintProto) constraint_ :
null; }
4043 constraint_ = value;
4049 public const int NoOverlapFieldNumber = 20;
4055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4056 public global::Google.OrTools.Sat.NoOverlapConstraintProto NoOverlap {
4057 get {
return constraintCase_ ==
ConstraintOneofCase.NoOverlap ? (global::Google.OrTools.Sat.NoOverlapConstraintProto) constraint_ :
null; }
4059 constraint_ = value;
4065 public const int NoOverlap2DFieldNumber = 21;
4069 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4070 public global::Google.OrTools.Sat.NoOverlap2DConstraintProto NoOverlap2D {
4071 get {
return constraintCase_ ==
ConstraintOneofCase.NoOverlap2D ? (global::Google.OrTools.Sat.NoOverlap2DConstraintProto) constraint_ :
null; }
4073 constraint_ = value;
4079 public const int CumulativeFieldNumber = 22;
4085 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4086 public global::Google.OrTools.Sat.CumulativeConstraintProto Cumulative {
4087 get {
return constraintCase_ ==
ConstraintOneofCase.Cumulative ? (global::Google.OrTools.Sat.CumulativeConstraintProto) constraint_ :
null; }
4089 constraint_ = value;
4094 private object constraint_;
4114 CircuitCovering = 25,
4124 private ConstraintOneofCase constraintCase_ = ConstraintOneofCase.None;
4125 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4127 get {
return constraintCase_; }
4130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4143 if (ReferenceEquals(other,
null)) {
4146 if (ReferenceEquals(other,
this)) {
4149 if (Name != other.
Name)
return false;
4150 if(!enforcementLiteral_.Equals(other.enforcementLiteral_))
return false;
4151 if (!
object.Equals(BoolOr, other.
BoolOr))
return false;
4152 if (!
object.Equals(BoolAnd, other.
BoolAnd))
return false;
4153 if (!
object.Equals(AtMostOne, other.
AtMostOne))
return false;
4154 if (!
object.Equals(BoolXor, other.
BoolXor))
return false;
4155 if (!
object.Equals(IntDiv, other.
IntDiv))
return false;
4156 if (!
object.Equals(IntMod, other.
IntMod))
return false;
4157 if (!
object.Equals(IntMax, other.
IntMax))
return false;
4158 if (!
object.Equals(LinMax, other.
LinMax))
return false;
4159 if (!
object.Equals(IntMin, other.
IntMin))
return false;
4160 if (!
object.Equals(LinMin, other.
LinMin))
return false;
4161 if (!
object.Equals(IntProd, other.
IntProd))
return false;
4162 if (!
object.Equals(Linear, other.
Linear))
return false;
4163 if (!
object.Equals(AllDiff, other.
AllDiff))
return false;
4164 if (!
object.Equals(Element, other.
Element))
return false;
4165 if (!
object.Equals(Circuit, other.
Circuit))
return false;
4166 if (!
object.Equals(Routes, other.
Routes))
return false;
4167 if (!
object.Equals(CircuitCovering, other.
CircuitCovering))
return false;
4168 if (!
object.Equals(Table, other.
Table))
return false;
4169 if (!
object.Equals(Automaton, other.
Automaton))
return false;
4170 if (!
object.Equals(Inverse, other.
Inverse))
return false;
4171 if (!
object.Equals(Reservoir, other.
Reservoir))
return false;
4172 if (!
object.Equals(Interval, other.
Interval))
return false;
4173 if (!
object.Equals(NoOverlap, other.
NoOverlap))
return false;
4174 if (!
object.Equals(NoOverlap2D, other.
NoOverlap2D))
return false;
4175 if (!
object.Equals(Cumulative, other.
Cumulative))
return false;
4177 return Equals(_unknownFields, other._unknownFields);
4180 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4183 if (Name.Length != 0) hash ^= Name.GetHashCode();
4184 hash ^= enforcementLiteral_.GetHashCode();
4201 if (constraintCase_ ==
ConstraintOneofCase.CircuitCovering) hash ^= CircuitCovering.GetHashCode();
4208 if (constraintCase_ ==
ConstraintOneofCase.NoOverlap2D) hash ^= NoOverlap2D.GetHashCode();
4210 hash ^= (int) constraintCase_;
4211 if (_unknownFields !=
null) {
4212 hash ^= _unknownFields.GetHashCode();
4217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4219 return pb::JsonFormatter.ToDiagnosticString(
this);
4222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4223 public void WriteTo(pb::CodedOutputStream output) {
4224 if (Name.Length != 0) {
4225 output.WriteRawTag(10);
4226 output.WriteString(Name);
4228 enforcementLiteral_.WriteTo(output, _repeated_enforcementLiteral_codec);
4230 output.WriteRawTag(26);
4231 output.WriteMessage(BoolOr);
4234 output.WriteRawTag(34);
4235 output.WriteMessage(BoolAnd);
4238 output.WriteRawTag(42);
4239 output.WriteMessage(BoolXor);
4242 output.WriteRawTag(58);
4243 output.WriteMessage(IntDiv);
4246 output.WriteRawTag(66);
4247 output.WriteMessage(IntMod);
4250 output.WriteRawTag(74);
4251 output.WriteMessage(IntMax);
4254 output.WriteRawTag(82);
4255 output.WriteMessage(IntMin);
4258 output.WriteRawTag(90);
4259 output.WriteMessage(IntProd);
4262 output.WriteRawTag(98);
4263 output.WriteMessage(Linear);
4266 output.WriteRawTag(106);
4267 output.WriteMessage(AllDiff);
4270 output.WriteRawTag(114);
4271 output.WriteMessage(Element);
4274 output.WriteRawTag(122);
4275 output.WriteMessage(Circuit);
4278 output.WriteRawTag(130, 1);
4279 output.WriteMessage(Table);
4282 output.WriteRawTag(138, 1);
4283 output.WriteMessage(Automaton);
4286 output.WriteRawTag(146, 1);
4287 output.WriteMessage(Inverse);
4290 output.WriteRawTag(154, 1);
4291 output.WriteMessage(Interval);
4294 output.WriteRawTag(162, 1);
4295 output.WriteMessage(NoOverlap);
4298 output.WriteRawTag(170, 1);
4299 output.WriteMessage(NoOverlap2D);
4302 output.WriteRawTag(178, 1);
4303 output.WriteMessage(Cumulative);
4306 output.WriteRawTag(186, 1);
4307 output.WriteMessage(Routes);
4310 output.WriteRawTag(194, 1);
4311 output.WriteMessage(Reservoir);
4314 output.WriteRawTag(202, 1);
4315 output.WriteMessage(CircuitCovering);
4318 output.WriteRawTag(210, 1);
4319 output.WriteMessage(AtMostOne);
4322 output.WriteRawTag(218, 1);
4323 output.WriteMessage(LinMax);
4326 output.WriteRawTag(226, 1);
4327 output.WriteMessage(LinMin);
4329 if (_unknownFields !=
null) {
4330 _unknownFields.WriteTo(output);
4334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4337 if (Name.Length != 0) {
4338 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
4340 size += enforcementLiteral_.CalculateSize(_repeated_enforcementLiteral_codec);
4342 size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolOr);
4345 size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolAnd);
4348 size += 2 + pb::CodedOutputStream.ComputeMessageSize(AtMostOne);
4351 size += 1 + pb::CodedOutputStream.ComputeMessageSize(BoolXor);
4354 size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntDiv);
4357 size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMod);
4360 size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMax);
4363 size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMax);
4366 size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntMin);
4369 size += 2 + pb::CodedOutputStream.ComputeMessageSize(LinMin);
4372 size += 1 + pb::CodedOutputStream.ComputeMessageSize(IntProd);
4375 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Linear);
4378 size += 1 + pb::CodedOutputStream.ComputeMessageSize(AllDiff);
4381 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Element);
4384 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Circuit);
4387 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Routes);
4390 size += 2 + pb::CodedOutputStream.ComputeMessageSize(CircuitCovering);
4393 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Table);
4396 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Automaton);
4399 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Inverse);
4402 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Reservoir);
4405 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Interval);
4408 size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap);
4411 size += 2 + pb::CodedOutputStream.ComputeMessageSize(NoOverlap2D);
4414 size += 2 + pb::CodedOutputStream.ComputeMessageSize(Cumulative);
4416 if (_unknownFields !=
null) {
4417 size += _unknownFields.CalculateSize();
4422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4424 if (other ==
null) {
4427 if (other.
Name.Length != 0) {
4430 enforcementLiteral_.Add(other.enforcementLiteral_);
4433 if (BoolOr ==
null) {
4434 BoolOr =
new global::Google.OrTools.Sat.BoolArgumentProto();
4436 BoolOr.MergeFrom(other.
BoolOr);
4439 if (BoolAnd ==
null) {
4440 BoolAnd =
new global::Google.OrTools.Sat.BoolArgumentProto();
4442 BoolAnd.MergeFrom(other.
BoolAnd);
4445 if (AtMostOne ==
null) {
4446 AtMostOne =
new global::Google.OrTools.Sat.BoolArgumentProto();
4451 if (BoolXor ==
null) {
4452 BoolXor =
new global::Google.OrTools.Sat.BoolArgumentProto();
4454 BoolXor.MergeFrom(other.
BoolXor);
4457 if (IntDiv ==
null) {
4458 IntDiv =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4460 IntDiv.MergeFrom(other.
IntDiv);
4463 if (IntMod ==
null) {
4464 IntMod =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4466 IntMod.MergeFrom(other.
IntMod);
4469 if (IntMax ==
null) {
4470 IntMax =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4472 IntMax.MergeFrom(other.
IntMax);
4475 if (LinMax ==
null) {
4476 LinMax =
new global::Google.OrTools.Sat.LinearArgumentProto();
4478 LinMax.MergeFrom(other.
LinMax);
4481 if (IntMin ==
null) {
4482 IntMin =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4484 IntMin.MergeFrom(other.
IntMin);
4487 if (LinMin ==
null) {
4488 LinMin =
new global::Google.OrTools.Sat.LinearArgumentProto();
4490 LinMin.MergeFrom(other.
LinMin);
4493 if (IntProd ==
null) {
4494 IntProd =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4496 IntProd.MergeFrom(other.
IntProd);
4499 if (Linear ==
null) {
4500 Linear =
new global::Google.OrTools.Sat.LinearConstraintProto();
4502 Linear.MergeFrom(other.
Linear);
4505 if (AllDiff ==
null) {
4506 AllDiff =
new global::Google.OrTools.Sat.AllDifferentConstraintProto();
4508 AllDiff.MergeFrom(other.
AllDiff);
4511 if (Element ==
null) {
4512 Element =
new global::Google.OrTools.Sat.ElementConstraintProto();
4514 Element.MergeFrom(other.
Element);
4517 if (Circuit ==
null) {
4518 Circuit =
new global::Google.OrTools.Sat.CircuitConstraintProto();
4520 Circuit.MergeFrom(other.
Circuit);
4523 if (Routes ==
null) {
4524 Routes =
new global::Google.OrTools.Sat.RoutesConstraintProto();
4526 Routes.MergeFrom(other.
Routes);
4529 if (CircuitCovering ==
null) {
4530 CircuitCovering =
new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
4535 if (Table ==
null) {
4536 Table =
new global::Google.OrTools.Sat.TableConstraintProto();
4538 Table.MergeFrom(other.
Table);
4541 if (Automaton ==
null) {
4542 Automaton =
new global::Google.OrTools.Sat.AutomatonConstraintProto();
4547 if (Inverse ==
null) {
4548 Inverse =
new global::Google.OrTools.Sat.InverseConstraintProto();
4550 Inverse.MergeFrom(other.
Inverse);
4553 if (Reservoir ==
null) {
4554 Reservoir =
new global::Google.OrTools.Sat.ReservoirConstraintProto();
4559 if (Interval ==
null) {
4560 Interval =
new global::Google.OrTools.Sat.IntervalConstraintProto();
4562 Interval.MergeFrom(other.
Interval);
4565 if (NoOverlap ==
null) {
4566 NoOverlap =
new global::Google.OrTools.Sat.NoOverlapConstraintProto();
4571 if (NoOverlap2D ==
null) {
4572 NoOverlap2D =
new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
4577 if (Cumulative ==
null) {
4578 Cumulative =
new global::Google.OrTools.Sat.CumulativeConstraintProto();
4584 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
4587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4590 while ((tag = input.ReadTag()) != 0) {
4593 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
4596 Name = input.ReadString();
4601 enforcementLiteral_.AddEntriesFrom(input, _repeated_enforcementLiteral_codec);
4605 global::Google.OrTools.Sat.BoolArgumentProto subBuilder =
new global::Google.OrTools.Sat.BoolArgumentProto();
4607 subBuilder.MergeFrom(BoolOr);
4609 input.ReadMessage(subBuilder);
4610 BoolOr = subBuilder;
4614 global::Google.OrTools.Sat.BoolArgumentProto subBuilder =
new global::Google.OrTools.Sat.BoolArgumentProto();
4616 subBuilder.MergeFrom(BoolAnd);
4618 input.ReadMessage(subBuilder);
4619 BoolAnd = subBuilder;
4623 global::Google.OrTools.Sat.BoolArgumentProto subBuilder =
new global::Google.OrTools.Sat.BoolArgumentProto();
4625 subBuilder.MergeFrom(BoolXor);
4627 input.ReadMessage(subBuilder);
4628 BoolXor = subBuilder;
4632 global::Google.OrTools.Sat.IntegerArgumentProto subBuilder =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4634 subBuilder.MergeFrom(IntDiv);
4636 input.ReadMessage(subBuilder);
4637 IntDiv = subBuilder;
4641 global::Google.OrTools.Sat.IntegerArgumentProto subBuilder =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4643 subBuilder.MergeFrom(IntMod);
4645 input.ReadMessage(subBuilder);
4646 IntMod = subBuilder;
4650 global::Google.OrTools.Sat.IntegerArgumentProto subBuilder =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4652 subBuilder.MergeFrom(IntMax);
4654 input.ReadMessage(subBuilder);
4655 IntMax = subBuilder;
4659 global::Google.OrTools.Sat.IntegerArgumentProto subBuilder =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4661 subBuilder.MergeFrom(IntMin);
4663 input.ReadMessage(subBuilder);
4664 IntMin = subBuilder;
4668 global::Google.OrTools.Sat.IntegerArgumentProto subBuilder =
new global::Google.OrTools.Sat.IntegerArgumentProto();
4670 subBuilder.MergeFrom(IntProd);
4672 input.ReadMessage(subBuilder);
4673 IntProd = subBuilder;
4677 global::Google.OrTools.Sat.LinearConstraintProto subBuilder =
new global::Google.OrTools.Sat.LinearConstraintProto();
4679 subBuilder.MergeFrom(Linear);
4681 input.ReadMessage(subBuilder);
4682 Linear = subBuilder;
4686 global::Google.OrTools.Sat.AllDifferentConstraintProto subBuilder =
new global::Google.OrTools.Sat.AllDifferentConstraintProto();
4688 subBuilder.MergeFrom(AllDiff);
4690 input.ReadMessage(subBuilder);
4691 AllDiff = subBuilder;
4695 global::Google.OrTools.Sat.ElementConstraintProto subBuilder =
new global::Google.OrTools.Sat.ElementConstraintProto();
4697 subBuilder.MergeFrom(Element);
4699 input.ReadMessage(subBuilder);
4700 Element = subBuilder;
4704 global::Google.OrTools.Sat.CircuitConstraintProto subBuilder =
new global::Google.OrTools.Sat.CircuitConstraintProto();
4706 subBuilder.MergeFrom(Circuit);
4708 input.ReadMessage(subBuilder);
4709 Circuit = subBuilder;
4713 global::Google.OrTools.Sat.TableConstraintProto subBuilder =
new global::Google.OrTools.Sat.TableConstraintProto();
4715 subBuilder.MergeFrom(Table);
4717 input.ReadMessage(subBuilder);
4722 global::Google.OrTools.Sat.AutomatonConstraintProto subBuilder =
new global::Google.OrTools.Sat.AutomatonConstraintProto();
4724 subBuilder.MergeFrom(Automaton);
4726 input.ReadMessage(subBuilder);
4727 Automaton = subBuilder;
4731 global::Google.OrTools.Sat.InverseConstraintProto subBuilder =
new global::Google.OrTools.Sat.InverseConstraintProto();
4733 subBuilder.MergeFrom(Inverse);
4735 input.ReadMessage(subBuilder);
4736 Inverse = subBuilder;
4740 global::Google.OrTools.Sat.IntervalConstraintProto subBuilder =
new global::Google.OrTools.Sat.IntervalConstraintProto();
4742 subBuilder.MergeFrom(Interval);
4744 input.ReadMessage(subBuilder);
4745 Interval = subBuilder;
4749 global::Google.OrTools.Sat.NoOverlapConstraintProto subBuilder =
new global::Google.OrTools.Sat.NoOverlapConstraintProto();
4751 subBuilder.MergeFrom(NoOverlap);
4753 input.ReadMessage(subBuilder);
4754 NoOverlap = subBuilder;
4758 global::Google.OrTools.Sat.NoOverlap2DConstraintProto subBuilder =
new global::Google.OrTools.Sat.NoOverlap2DConstraintProto();
4760 subBuilder.MergeFrom(NoOverlap2D);
4762 input.ReadMessage(subBuilder);
4763 NoOverlap2D = subBuilder;
4767 global::Google.OrTools.Sat.CumulativeConstraintProto subBuilder =
new global::Google.OrTools.Sat.CumulativeConstraintProto();
4769 subBuilder.MergeFrom(Cumulative);
4771 input.ReadMessage(subBuilder);
4772 Cumulative = subBuilder;
4776 global::Google.OrTools.Sat.RoutesConstraintProto subBuilder =
new global::Google.OrTools.Sat.RoutesConstraintProto();
4778 subBuilder.MergeFrom(Routes);
4780 input.ReadMessage(subBuilder);
4781 Routes = subBuilder;
4785 global::Google.OrTools.Sat.ReservoirConstraintProto subBuilder =
new global::Google.OrTools.Sat.ReservoirConstraintProto();
4787 subBuilder.MergeFrom(Reservoir);
4789 input.ReadMessage(subBuilder);
4790 Reservoir = subBuilder;
4794 global::Google.OrTools.Sat.CircuitCoveringConstraintProto subBuilder =
new global::Google.OrTools.Sat.CircuitCoveringConstraintProto();
4796 subBuilder.MergeFrom(CircuitCovering);
4798 input.ReadMessage(subBuilder);
4799 CircuitCovering = subBuilder;
4803 global::Google.OrTools.Sat.BoolArgumentProto subBuilder =
new global::Google.OrTools.Sat.BoolArgumentProto();
4805 subBuilder.MergeFrom(AtMostOne);
4807 input.ReadMessage(subBuilder);
4808 AtMostOne = subBuilder;
4812 global::Google.OrTools.Sat.LinearArgumentProto subBuilder =
new global::Google.OrTools.Sat.LinearArgumentProto();
4814 subBuilder.MergeFrom(LinMax);
4816 input.ReadMessage(subBuilder);
4817 LinMax = subBuilder;
4821 global::Google.OrTools.Sat.LinearArgumentProto subBuilder =
new global::Google.OrTools.Sat.LinearArgumentProto();
4823 subBuilder.MergeFrom(LinMin);
4825 input.ReadMessage(subBuilder);
4826 LinMin = subBuilder;
4841 private static readonly pb::MessageParser<CpObjectiveProto> _parser =
new pb::MessageParser<CpObjectiveProto>(() =>
new CpObjectiveProto());
4842 private pb::UnknownFieldSet _unknownFields;
4843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4844 public static pb::MessageParser<CpObjectiveProto> Parser {
get {
return _parser; } }
4846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4847 public static pbr::MessageDescriptor Descriptor {
4848 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[20]; }
4851 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4852 pbr::MessageDescriptor pb::IMessage.Descriptor {
4853 get {
return Descriptor; }
4856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4861 partial
void OnConstruction();
4863 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4865 vars_ = other.vars_.Clone();
4866 coeffs_ = other.coeffs_.Clone();
4867 offset_ = other.offset_;
4868 scalingFactor_ = other.scalingFactor_;
4869 domain_ = other.domain_.Clone();
4870 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
4873 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4879 public const int VarsFieldNumber = 1;
4880 private static readonly pb::FieldCodec<int> _repeated_vars_codec
4881 = pb::FieldCodec.ForInt32(10);
4882 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
4888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4889 public pbc::RepeatedField<int> Vars {
4890 get {
return vars_; }
4894 public const int CoeffsFieldNumber = 4;
4895 private static readonly pb::FieldCodec<long> _repeated_coeffs_codec
4896 = pb::FieldCodec.ForInt64(34);
4897 private readonly pbc::RepeatedField<long> coeffs_ =
new pbc::RepeatedField<long>();
4898 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4899 public pbc::RepeatedField<long> Coeffs {
4900 get {
return coeffs_; }
4904 public const int OffsetFieldNumber = 2;
4905 private double offset_;
4915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4916 public double Offset {
4917 get {
return offset_; }
4924 public const int ScalingFactorFieldNumber = 3;
4925 private double scalingFactor_;
4926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4927 public double ScalingFactor {
4928 get {
return scalingFactor_; }
4930 scalingFactor_ = value;
4935 public const int DomainFieldNumber = 5;
4936 private static readonly pb::FieldCodec<long> _repeated_domain_codec
4937 = pb::FieldCodec.ForInt64(42);
4938 private readonly pbc::RepeatedField<long> domain_ =
new pbc::RepeatedField<long>();
4944 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4946 get {
return domain_; }
4949 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4954 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4956 if (ReferenceEquals(other,
null)) {
4959 if (ReferenceEquals(other,
this)) {
4962 if(!vars_.Equals(other.vars_))
return false;
4963 if(!coeffs_.Equals(other.coeffs_))
return false;
4964 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Offset, other.
Offset))
return false;
4965 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ScalingFactor, other.
ScalingFactor))
return false;
4966 if(!domain_.Equals(other.domain_))
return false;
4967 return Equals(_unknownFields, other._unknownFields);
4970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4973 hash ^= vars_.GetHashCode();
4974 hash ^= coeffs_.GetHashCode();
4975 if (Offset != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Offset);
4976 if (ScalingFactor != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ScalingFactor);
4977 hash ^= domain_.GetHashCode();
4978 if (_unknownFields !=
null) {
4979 hash ^= _unknownFields.GetHashCode();
4984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4986 return pb::JsonFormatter.ToDiagnosticString(
this);
4989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4990 public void WriteTo(pb::CodedOutputStream output) {
4991 vars_.WriteTo(output, _repeated_vars_codec);
4993 output.WriteRawTag(17);
4994 output.WriteDouble(Offset);
4996 if (ScalingFactor != 0D) {
4997 output.WriteRawTag(25);
4998 output.WriteDouble(ScalingFactor);
5000 coeffs_.WriteTo(output, _repeated_coeffs_codec);
5001 domain_.WriteTo(output, _repeated_domain_codec);
5002 if (_unknownFields !=
null) {
5003 _unknownFields.WriteTo(output);
5007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5010 size += vars_.CalculateSize(_repeated_vars_codec);
5011 size += coeffs_.CalculateSize(_repeated_coeffs_codec);
5015 if (ScalingFactor != 0D) {
5018 size += domain_.CalculateSize(_repeated_domain_codec);
5019 if (_unknownFields !=
null) {
5020 size += _unknownFields.CalculateSize();
5025 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5027 if (other ==
null) {
5030 vars_.Add(other.vars_);
5031 coeffs_.Add(other.coeffs_);
5032 if (other.
Offset != 0D) {
5038 domain_.Add(other.domain_);
5039 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5045 while ((tag = input.ReadTag()) != 0) {
5048 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5052 vars_.AddEntriesFrom(input, _repeated_vars_codec);
5056 Offset = input.ReadDouble();
5060 ScalingFactor = input.ReadDouble();
5065 coeffs_.AddEntriesFrom(input, _repeated_coeffs_codec);
5070 domain_.AddEntriesFrom(input, _repeated_domain_codec);
5084 private static readonly pb::MessageParser<DecisionStrategyProto> _parser =
new pb::MessageParser<DecisionStrategyProto>(() =>
new DecisionStrategyProto());
5085 private pb::UnknownFieldSet _unknownFields;
5086 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5087 public static pb::MessageParser<DecisionStrategyProto> Parser {
get {
return _parser; } }
5089 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5090 public static pbr::MessageDescriptor Descriptor {
5091 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[21]; }
5094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5095 pbr::MessageDescriptor pb::IMessage.Descriptor {
5096 get {
return Descriptor; }
5099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5104 partial
void OnConstruction();
5106 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5108 variables_ = other.variables_.Clone();
5109 variableSelectionStrategy_ = other.variableSelectionStrategy_;
5110 domainReductionStrategy_ = other.domainReductionStrategy_;
5111 transformations_ = other.transformations_.Clone();
5112 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
5115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5121 public const int VariablesFieldNumber = 1;
5122 private static readonly pb::FieldCodec<int> _repeated_variables_codec
5123 = pb::FieldCodec.ForInt32(10);
5124 private readonly pbc::RepeatedField<int> variables_ =
new pbc::RepeatedField<int>();
5130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5131 public pbc::RepeatedField<int> Variables {
5132 get {
return variables_; }
5136 public const int VariableSelectionStrategyFieldNumber = 2;
5137 private global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy variableSelectionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst;
5138 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5139 public global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy VariableSelectionStrategy {
5140 get {
return variableSelectionStrategy_; }
5142 variableSelectionStrategy_ = value;
5147 public const int DomainReductionStrategyFieldNumber = 3;
5148 private global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy domainReductionStrategy_ = global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue;
5149 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5150 public global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy DomainReductionStrategy {
5151 get {
return domainReductionStrategy_; }
5153 domainReductionStrategy_ = value;
5158 public const int TransformationsFieldNumber = 4;
5159 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> _repeated_transformations_codec
5160 = pb::FieldCodec.ForMessage(34, global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation.Parser);
5161 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> transformations_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation>();
5162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5163 public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto.Types.AffineTransformation> Transformations {
5164 get {
return transformations_; }
5167 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5174 if (ReferenceEquals(other,
null)) {
5177 if (ReferenceEquals(other,
this)) {
5180 if(!variables_.Equals(other.variables_))
return false;
5183 if(!transformations_.Equals(other.transformations_))
return false;
5184 return Equals(_unknownFields, other._unknownFields);
5187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5190 hash ^= variables_.GetHashCode();
5191 if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) hash ^= VariableSelectionStrategy.GetHashCode();
5192 if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) hash ^= DomainReductionStrategy.GetHashCode();
5193 hash ^= transformations_.GetHashCode();
5194 if (_unknownFields !=
null) {
5195 hash ^= _unknownFields.GetHashCode();
5200 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5202 return pb::JsonFormatter.ToDiagnosticString(
this);
5205 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5206 public void WriteTo(pb::CodedOutputStream output) {
5207 variables_.WriteTo(output, _repeated_variables_codec);
5208 if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
5209 output.WriteRawTag(16);
5210 output.WriteEnum((
int) VariableSelectionStrategy);
5212 if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
5213 output.WriteRawTag(24);
5214 output.WriteEnum((
int) DomainReductionStrategy);
5216 transformations_.WriteTo(output, _repeated_transformations_codec);
5217 if (_unknownFields !=
null) {
5218 _unknownFields.WriteTo(output);
5222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5225 size += variables_.CalculateSize(_repeated_variables_codec);
5226 if (VariableSelectionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy.ChooseFirst) {
5227 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) VariableSelectionStrategy);
5229 if (DomainReductionStrategy != global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy.SelectMinValue) {
5230 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) DomainReductionStrategy);
5232 size += transformations_.CalculateSize(_repeated_transformations_codec);
5233 if (_unknownFields !=
null) {
5234 size += _unknownFields.CalculateSize();
5239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5241 if (other ==
null) {
5244 variables_.Add(other.variables_);
5251 transformations_.Add(other.transformations_);
5252 _unknownFields = pb::UnknownFieldSet.
MergeFrom(_unknownFields, other._unknownFields);
5255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5258 while ((tag = input.ReadTag()) != 0) {
5261 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5265 variables_.AddEntriesFrom(input, _repeated_variables_codec);
5269 VariableSelectionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.VariableSelectionStrategy) input.ReadEnum();
5273 DomainReductionStrategy = (global::Google.OrTools.Sat.DecisionStrategyProto.Types.DomainReductionStrategy) input.ReadEnum();
5277 transformations_.AddEntriesFrom(input, _repeated_transformations_codec);
5284 #region Nested types
5285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5295 [pbr::OriginalName(
"CHOOSE_FIRST")] ChooseFirst = 0,
5296 [pbr::OriginalName(
"CHOOSE_LOWEST_MIN")] ChooseLowestMin = 1,
5297 [pbr::OriginalName(
"CHOOSE_HIGHEST_MAX")] ChooseHighestMax = 2,
5298 [pbr::OriginalName(
"CHOOSE_MIN_DOMAIN_SIZE")] ChooseMinDomainSize = 3,
5299 [pbr::OriginalName(
"CHOOSE_MAX_DOMAIN_SIZE")] ChooseMaxDomainSize = 4,
5309 [pbr::OriginalName(
"SELECT_MIN_VALUE")] SelectMinValue = 0,
5310 [pbr::OriginalName(
"SELECT_MAX_VALUE")] SelectMaxValue = 1,
5311 [pbr::OriginalName(
"SELECT_LOWER_HALF")] SelectLowerHalf = 2,
5312 [pbr::OriginalName(
"SELECT_UPPER_HALF")] SelectUpperHalf = 3,
5313 [pbr::OriginalName(
"SELECT_MEDIAN_VALUE")] SelectMedianValue = 4,
5323 private static readonly pb::MessageParser<AffineTransformation> _parser =
new pb::MessageParser<AffineTransformation>(() =>
new AffineTransformation());
5324 private pb::UnknownFieldSet _unknownFields;
5325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5326 public static pb::MessageParser<AffineTransformation> Parser {
get {
return _parser; } }
5328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5329 public static pbr::MessageDescriptor Descriptor {
5330 get {
return global::Google.OrTools.Sat.DecisionStrategyProto.Descriptor.NestedTypes[0]; }
5333 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5334 pbr::MessageDescriptor pb::IMessage.Descriptor {
5335 get {
return Descriptor; }
5338 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5343 partial
void OnConstruction();
5345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5348 offset_ = other.offset_;
5349 positiveCoeff_ = other.positiveCoeff_;
5350 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
5353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5359 public const int VarFieldNumber = 1;
5361 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5363 get {
return var_; }
5370 public const int OffsetFieldNumber = 2;
5371 private long offset_;
5372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5373 public long Offset {
5374 get {
return offset_; }
5381 public const int PositiveCoeffFieldNumber = 3;
5382 private long positiveCoeff_;
5383 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5384 public long PositiveCoeff {
5385 get {
return positiveCoeff_; }
5387 positiveCoeff_ = value;
5391 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5396 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5398 if (ReferenceEquals(other,
null)) {
5401 if (ReferenceEquals(other,
this)) {
5404 if (Var != other.
Var)
return false;
5405 if (Offset != other.
Offset)
return false;
5407 return Equals(_unknownFields, other._unknownFields);
5410 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5413 if (Var != 0) hash ^= Var.GetHashCode();
5414 if (Offset != 0L) hash ^= Offset.GetHashCode();
5415 if (PositiveCoeff != 0L) hash ^= PositiveCoeff.GetHashCode();
5416 if (_unknownFields !=
null) {
5417 hash ^= _unknownFields.GetHashCode();
5422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5424 return pb::JsonFormatter.ToDiagnosticString(
this);
5427 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5428 public void WriteTo(pb::CodedOutputStream output) {
5430 output.WriteRawTag(8);
5431 output.WriteInt32(Var);
5434 output.WriteRawTag(16);
5435 output.WriteInt64(Offset);
5437 if (PositiveCoeff != 0L) {
5438 output.WriteRawTag(24);
5439 output.WriteInt64(PositiveCoeff);
5441 if (_unknownFields !=
null) {
5442 _unknownFields.WriteTo(output);
5446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5450 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Var);
5453 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Offset);
5455 if (PositiveCoeff != 0L) {
5456 size += 1 + pb::CodedOutputStream.ComputeInt64Size(PositiveCoeff);
5458 if (_unknownFields !=
null) {
5459 size += _unknownFields.CalculateSize();
5464 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5466 if (other ==
null) {
5469 if (other.
Var != 0) {
5472 if (other.
Offset != 0L) {
5478 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5484 while ((tag = input.ReadTag()) != 0) {
5487 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5490 Var = input.ReadInt32();
5494 Offset = input.ReadInt64();
5498 PositiveCoeff = input.ReadInt64();
5518 private static readonly pb::MessageParser<PartialVariableAssignment> _parser =
new pb::MessageParser<PartialVariableAssignment>(() =>
new PartialVariableAssignment());
5519 private pb::UnknownFieldSet _unknownFields;
5520 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5521 public static pb::MessageParser<PartialVariableAssignment> Parser {
get {
return _parser; } }
5523 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5524 public static pbr::MessageDescriptor Descriptor {
5525 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[22]; }
5528 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5529 pbr::MessageDescriptor pb::IMessage.Descriptor {
5530 get {
return Descriptor; }
5533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5538 partial
void OnConstruction();
5540 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5542 vars_ = other.vars_.Clone();
5543 values_ = other.values_.Clone();
5544 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
5547 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5553 public const int VarsFieldNumber = 1;
5554 private static readonly pb::FieldCodec<int> _repeated_vars_codec
5555 = pb::FieldCodec.ForInt32(10);
5556 private readonly pbc::RepeatedField<int> vars_ =
new pbc::RepeatedField<int>();
5557 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5558 public pbc::RepeatedField<int> Vars {
5559 get {
return vars_; }
5563 public const int ValuesFieldNumber = 2;
5564 private static readonly pb::FieldCodec<long> _repeated_values_codec
5565 = pb::FieldCodec.ForInt64(18);
5566 private readonly pbc::RepeatedField<long> values_ =
new pbc::RepeatedField<long>();
5567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5568 public pbc::RepeatedField<long> Values {
5569 get {
return values_; }
5572 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5579 if (ReferenceEquals(other,
null)) {
5582 if (ReferenceEquals(other,
this)) {
5585 if(!vars_.Equals(other.vars_))
return false;
5586 if(!values_.Equals(other.values_))
return false;
5587 return Equals(_unknownFields, other._unknownFields);
5590 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5593 hash ^= vars_.GetHashCode();
5594 hash ^= values_.GetHashCode();
5595 if (_unknownFields !=
null) {
5596 hash ^= _unknownFields.GetHashCode();
5601 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5603 return pb::JsonFormatter.ToDiagnosticString(
this);
5606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5607 public void WriteTo(pb::CodedOutputStream output) {
5608 vars_.WriteTo(output, _repeated_vars_codec);
5609 values_.WriteTo(output, _repeated_values_codec);
5610 if (_unknownFields !=
null) {
5611 _unknownFields.WriteTo(output);
5615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5618 size += vars_.CalculateSize(_repeated_vars_codec);
5619 size += values_.CalculateSize(_repeated_values_codec);
5620 if (_unknownFields !=
null) {
5621 size += _unknownFields.CalculateSize();
5626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5628 if (other ==
null) {
5631 vars_.Add(other.vars_);
5632 values_.Add(other.values_);
5633 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5639 while ((tag = input.ReadTag()) != 0) {
5642 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5646 vars_.AddEntriesFrom(input, _repeated_vars_codec);
5651 values_.AddEntriesFrom(input, _repeated_values_codec);
5664 private static readonly pb::MessageParser<CpModelProto> _parser =
new pb::MessageParser<CpModelProto>(() =>
new CpModelProto());
5665 private pb::UnknownFieldSet _unknownFields;
5666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5667 public static pb::MessageParser<CpModelProto> Parser {
get {
return _parser; } }
5669 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5670 public static pbr::MessageDescriptor Descriptor {
5671 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[23]; }
5674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5675 pbr::MessageDescriptor pb::IMessage.Descriptor {
5676 get {
return Descriptor; }
5679 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5684 partial
void OnConstruction();
5686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5688 name_ = other.name_;
5689 variables_ = other.variables_.Clone();
5690 constraints_ = other.constraints_.Clone();
5691 objective_ = other.objective_ !=
null ? other.objective_.
Clone() :
null;
5692 searchStrategy_ = other.searchStrategy_.Clone();
5693 solutionHint_ = other.solutionHint_ !=
null ? other.solutionHint_.
Clone() :
null;
5694 assumptions_ = other.assumptions_.Clone();
5695 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
5698 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5704 public const int NameFieldNumber = 1;
5705 private string name_ =
"";
5709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5710 public string Name {
5711 get {
return name_; }
5713 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
5718 public const int VariablesFieldNumber = 2;
5719 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_variables_codec
5720 = pb::FieldCodec.ForMessage(18, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
5721 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> variables_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
5725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5726 public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> Variables {
5727 get {
return variables_; }
5731 public const int ConstraintsFieldNumber = 3;
5732 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.ConstraintProto> _repeated_constraints_codec
5733 = pb::FieldCodec.ForMessage(26, global::Google.OrTools.Sat.ConstraintProto.Parser);
5734 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> constraints_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto>();
5735 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5736 public pbc::RepeatedField<global::Google.OrTools.Sat.ConstraintProto> Constraints {
5737 get {
return constraints_; }
5741 public const int ObjectiveFieldNumber = 4;
5742 private global::Google.OrTools.Sat.CpObjectiveProto objective_;
5746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5747 public global::Google.OrTools.Sat.CpObjectiveProto Objective {
5748 get {
return objective_; }
5755 public const int SearchStrategyFieldNumber = 5;
5756 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.DecisionStrategyProto> _repeated_searchStrategy_codec
5757 = pb::FieldCodec.ForMessage(42, global::Google.OrTools.Sat.DecisionStrategyProto.Parser);
5758 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> searchStrategy_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto>();
5771 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5772 public pbc::RepeatedField<global::Google.OrTools.Sat.DecisionStrategyProto> SearchStrategy {
5773 get {
return searchStrategy_; }
5777 public const int SolutionHintFieldNumber = 6;
5778 private global::Google.OrTools.Sat.PartialVariableAssignment solutionHint_;
5792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5793 public global::Google.OrTools.Sat.PartialVariableAssignment SolutionHint {
5794 get {
return solutionHint_; }
5796 solutionHint_ = value;
5801 public const int AssumptionsFieldNumber = 7;
5802 private static readonly pb::FieldCodec<int> _repeated_assumptions_codec
5803 = pb::FieldCodec.ForInt32(58);
5804 private readonly pbc::RepeatedField<int> assumptions_ =
new pbc::RepeatedField<int>();
5820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5821 public pbc::RepeatedField<int> Assumptions {
5822 get {
return assumptions_; }
5825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5832 if (ReferenceEquals(other,
null)) {
5835 if (ReferenceEquals(other,
this)) {
5838 if (Name != other.
Name)
return false;
5839 if(!variables_.Equals(other.variables_))
return false;
5840 if(!constraints_.Equals(other.constraints_))
return false;
5841 if (!
object.Equals(Objective, other.
Objective))
return false;
5842 if(!searchStrategy_.Equals(other.searchStrategy_))
return false;
5843 if (!
object.Equals(SolutionHint, other.
SolutionHint))
return false;
5844 if(!assumptions_.Equals(other.assumptions_))
return false;
5845 return Equals(_unknownFields, other._unknownFields);
5848 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5851 if (Name.Length != 0) hash ^= Name.GetHashCode();
5852 hash ^= variables_.GetHashCode();
5853 hash ^= constraints_.GetHashCode();
5854 if (objective_ !=
null) hash ^= Objective.GetHashCode();
5855 hash ^= searchStrategy_.GetHashCode();
5856 if (solutionHint_ !=
null) hash ^= SolutionHint.GetHashCode();
5857 hash ^= assumptions_.GetHashCode();
5858 if (_unknownFields !=
null) {
5859 hash ^= _unknownFields.GetHashCode();
5864 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5866 return pb::JsonFormatter.ToDiagnosticString(
this);
5869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5870 public void WriteTo(pb::CodedOutputStream output) {
5871 if (Name.Length != 0) {
5872 output.WriteRawTag(10);
5873 output.WriteString(Name);
5875 variables_.WriteTo(output, _repeated_variables_codec);
5876 constraints_.WriteTo(output, _repeated_constraints_codec);
5877 if (objective_ !=
null) {
5878 output.WriteRawTag(34);
5879 output.WriteMessage(Objective);
5881 searchStrategy_.WriteTo(output, _repeated_searchStrategy_codec);
5882 if (solutionHint_ !=
null) {
5883 output.WriteRawTag(50);
5884 output.WriteMessage(SolutionHint);
5886 assumptions_.WriteTo(output, _repeated_assumptions_codec);
5887 if (_unknownFields !=
null) {
5888 _unknownFields.WriteTo(output);
5892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5895 if (Name.Length != 0) {
5896 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
5898 size += variables_.CalculateSize(_repeated_variables_codec);
5899 size += constraints_.CalculateSize(_repeated_constraints_codec);
5900 if (objective_ !=
null) {
5901 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Objective);
5903 size += searchStrategy_.CalculateSize(_repeated_searchStrategy_codec);
5904 if (solutionHint_ !=
null) {
5905 size += 1 + pb::CodedOutputStream.ComputeMessageSize(SolutionHint);
5907 size += assumptions_.CalculateSize(_repeated_assumptions_codec);
5908 if (_unknownFields !=
null) {
5909 size += _unknownFields.CalculateSize();
5914 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5916 if (other ==
null) {
5919 if (other.
Name.Length != 0) {
5922 variables_.Add(other.variables_);
5923 constraints_.Add(other.constraints_);
5924 if (other.objective_ !=
null) {
5925 if (objective_ ==
null) {
5926 Objective =
new global::Google.OrTools.Sat.CpObjectiveProto();
5930 searchStrategy_.Add(other.searchStrategy_);
5931 if (other.solutionHint_ !=
null) {
5932 if (solutionHint_ ==
null) {
5933 SolutionHint =
new global::Google.OrTools.Sat.PartialVariableAssignment();
5937 assumptions_.Add(other.assumptions_);
5938 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
5941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5944 while ((tag = input.ReadTag()) != 0) {
5947 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
5950 Name = input.ReadString();
5954 variables_.AddEntriesFrom(input, _repeated_variables_codec);
5958 constraints_.AddEntriesFrom(input, _repeated_constraints_codec);
5962 if (objective_ ==
null) {
5963 Objective =
new global::Google.OrTools.Sat.CpObjectiveProto();
5965 input.ReadMessage(Objective);
5969 searchStrategy_.AddEntriesFrom(input, _repeated_searchStrategy_codec);
5973 if (solutionHint_ ==
null) {
5974 SolutionHint =
new global::Google.OrTools.Sat.PartialVariableAssignment();
5976 input.ReadMessage(SolutionHint);
5981 assumptions_.AddEntriesFrom(input, _repeated_assumptions_codec);
5998 private static readonly pb::MessageParser<CpSolverResponse> _parser =
new pb::MessageParser<CpSolverResponse>(() =>
new CpSolverResponse());
5999 private pb::UnknownFieldSet _unknownFields;
6000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6001 public static pb::MessageParser<CpSolverResponse> Parser {
get {
return _parser; } }
6003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6004 public static pbr::MessageDescriptor Descriptor {
6005 get {
return global::Google.OrTools.Sat.CpModelReflection.Descriptor.MessageTypes[24]; }
6008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6009 pbr::MessageDescriptor pb::IMessage.Descriptor {
6010 get {
return Descriptor; }
6013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6018 partial
void OnConstruction();
6020 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6022 status_ = other.status_;
6023 solution_ = other.solution_.Clone();
6024 objectiveValue_ = other.objectiveValue_;
6025 bestObjectiveBound_ = other.bestObjectiveBound_;
6026 solutionLowerBounds_ = other.solutionLowerBounds_.Clone();
6027 solutionUpperBounds_ = other.solutionUpperBounds_.Clone();
6028 tightenedVariables_ = other.tightenedVariables_.Clone();
6029 sufficientAssumptionsForInfeasibility_ = other.sufficientAssumptionsForInfeasibility_.Clone();
6030 allSolutionsWereFound_ = other.allSolutionsWereFound_;
6031 numBooleans_ = other.numBooleans_;
6032 numConflicts_ = other.numConflicts_;
6033 numBranches_ = other.numBranches_;
6034 numBinaryPropagations_ = other.numBinaryPropagations_;
6035 numIntegerPropagations_ = other.numIntegerPropagations_;
6036 wallTime_ = other.wallTime_;
6037 userTime_ = other.userTime_;
6038 deterministicTime_ = other.deterministicTime_;
6039 primalIntegral_ = other.primalIntegral_;
6040 solutionInfo_ = other.solutionInfo_;
6041 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
6044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6050 public const int StatusFieldNumber = 1;
6051 private global::Google.OrTools.Sat.CpSolverStatus status_ = global::Google.OrTools.Sat.CpSolverStatus.Unknown;
6055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6056 public global::Google.OrTools.Sat.CpSolverStatus Status {
6057 get {
return status_; }
6064 public const int SolutionFieldNumber = 2;
6065 private static readonly pb::FieldCodec<long> _repeated_solution_codec
6066 = pb::FieldCodec.ForInt64(18);
6067 private readonly pbc::RepeatedField<long> solution_ =
new pbc::RepeatedField<long>();
6074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6075 public pbc::RepeatedField<long> Solution {
6076 get {
return solution_; }
6080 public const int ObjectiveValueFieldNumber = 3;
6081 private double objectiveValue_;
6088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6089 public double ObjectiveValue {
6090 get {
return objectiveValue_; }
6092 objectiveValue_ = value;
6097 public const int BestObjectiveBoundFieldNumber = 4;
6098 private double bestObjectiveBound_;
6104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6105 public double BestObjectiveBound {
6106 get {
return bestObjectiveBound_; }
6108 bestObjectiveBound_ = value;
6113 public const int SolutionLowerBoundsFieldNumber = 18;
6114 private static readonly pb::FieldCodec<long> _repeated_solutionLowerBounds_codec
6115 = pb::FieldCodec.ForInt64(146);
6116 private readonly pbc::RepeatedField<long> solutionLowerBounds_ =
new pbc::RepeatedField<long>();
6126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6127 public pbc::RepeatedField<long> SolutionLowerBounds {
6128 get {
return solutionLowerBounds_; }
6132 public const int SolutionUpperBoundsFieldNumber = 19;
6133 private static readonly pb::FieldCodec<long> _repeated_solutionUpperBounds_codec
6134 = pb::FieldCodec.ForInt64(154);
6135 private readonly pbc::RepeatedField<long> solutionUpperBounds_ =
new pbc::RepeatedField<long>();
6136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6137 public pbc::RepeatedField<long> SolutionUpperBounds {
6138 get {
return solutionUpperBounds_; }
6142 public const int TightenedVariablesFieldNumber = 21;
6143 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.IntegerVariableProto> _repeated_tightenedVariables_codec
6144 = pb::FieldCodec.ForMessage(170, global::Google.OrTools.Sat.IntegerVariableProto.Parser);
6145 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> tightenedVariables_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto>();
6160 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6161 public pbc::RepeatedField<global::Google.OrTools.Sat.IntegerVariableProto> TightenedVariables {
6162 get {
return tightenedVariables_; }
6166 public const int SufficientAssumptionsForInfeasibilityFieldNumber = 23;
6167 private static readonly pb::FieldCodec<int> _repeated_sufficientAssumptionsForInfeasibility_codec
6168 = pb::FieldCodec.ForInt32(186);
6169 private readonly pbc::RepeatedField<int> sufficientAssumptionsForInfeasibility_ =
new pbc::RepeatedField<int>();
6185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6186 public pbc::RepeatedField<int> SufficientAssumptionsForInfeasibility {
6187 get {
return sufficientAssumptionsForInfeasibility_; }
6191 public const int AllSolutionsWereFoundFieldNumber = 5;
6192 private bool allSolutionsWereFound_;
6200 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6201 public bool AllSolutionsWereFound {
6202 get {
return allSolutionsWereFound_; }
6204 allSolutionsWereFound_ = value;
6209 public const int NumBooleansFieldNumber = 10;
6210 private long numBooleans_;
6214 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6215 public long NumBooleans {
6216 get {
return numBooleans_; }
6218 numBooleans_ = value;
6223 public const int NumConflictsFieldNumber = 11;
6224 private long numConflicts_;
6225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6226 public long NumConflicts {
6227 get {
return numConflicts_; }
6229 numConflicts_ = value;
6234 public const int NumBranchesFieldNumber = 12;
6235 private long numBranches_;
6236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6237 public long NumBranches {
6238 get {
return numBranches_; }
6240 numBranches_ = value;
6245 public const int NumBinaryPropagationsFieldNumber = 13;
6246 private long numBinaryPropagations_;
6247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6248 public long NumBinaryPropagations {
6249 get {
return numBinaryPropagations_; }
6251 numBinaryPropagations_ = value;
6256 public const int NumIntegerPropagationsFieldNumber = 14;
6257 private long numIntegerPropagations_;
6258 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6259 public long NumIntegerPropagations {
6260 get {
return numIntegerPropagations_; }
6262 numIntegerPropagations_ = value;
6267 public const int WallTimeFieldNumber = 15;
6268 private double wallTime_;
6269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6270 public double WallTime {
6271 get {
return wallTime_; }
6278 public const int UserTimeFieldNumber = 16;
6279 private double userTime_;
6280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6281 public double UserTime {
6282 get {
return userTime_; }
6289 public const int DeterministicTimeFieldNumber = 17;
6290 private double deterministicTime_;
6291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6292 public double DeterministicTime {
6293 get {
return deterministicTime_; }
6295 deterministicTime_ = value;
6300 public const int PrimalIntegralFieldNumber = 22;
6301 private double primalIntegral_;
6302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6303 public double PrimalIntegral {
6304 get {
return primalIntegral_; }
6306 primalIntegral_ = value;
6311 public const int SolutionInfoFieldNumber = 20;
6312 private string solutionInfo_ =
"";
6316 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6317 public string SolutionInfo {
6318 get {
return solutionInfo_; }
6320 solutionInfo_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
6324 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6331 if (ReferenceEquals(other,
null)) {
6334 if (ReferenceEquals(other,
this)) {
6337 if (Status != other.
Status)
return false;
6338 if(!solution_.Equals(other.solution_))
return false;
6339 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveValue, other.
ObjectiveValue))
return false;
6340 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(BestObjectiveBound, other.
BestObjectiveBound))
return false;
6341 if(!solutionLowerBounds_.Equals(other.solutionLowerBounds_))
return false;
6342 if(!solutionUpperBounds_.Equals(other.solutionUpperBounds_))
return false;
6343 if(!tightenedVariables_.Equals(other.tightenedVariables_))
return false;
6344 if(!sufficientAssumptionsForInfeasibility_.Equals(other.sufficientAssumptionsForInfeasibility_))
return false;
6346 if (NumBooleans != other.
NumBooleans)
return false;
6348 if (NumBranches != other.
NumBranches)
return false;
6351 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.
WallTime))
return false;
6352 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(UserTime, other.
UserTime))
return false;
6353 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DeterministicTime, other.
DeterministicTime))
return false;
6354 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalIntegral, other.
PrimalIntegral))
return false;
6356 return Equals(_unknownFields, other._unknownFields);
6359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6362 if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) hash ^= Status.GetHashCode();
6363 hash ^= solution_.GetHashCode();
6364 if (ObjectiveValue != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveValue);
6365 if (BestObjectiveBound != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BestObjectiveBound);
6366 hash ^= solutionLowerBounds_.GetHashCode();
6367 hash ^= solutionUpperBounds_.GetHashCode();
6368 hash ^= tightenedVariables_.GetHashCode();
6369 hash ^= sufficientAssumptionsForInfeasibility_.GetHashCode();
6370 if (AllSolutionsWereFound !=
false) hash ^= AllSolutionsWereFound.GetHashCode();
6371 if (NumBooleans != 0L) hash ^= NumBooleans.GetHashCode();
6372 if (NumConflicts != 0L) hash ^= NumConflicts.GetHashCode();
6373 if (NumBranches != 0L) hash ^= NumBranches.GetHashCode();
6374 if (NumBinaryPropagations != 0L) hash ^= NumBinaryPropagations.GetHashCode();
6375 if (NumIntegerPropagations != 0L) hash ^= NumIntegerPropagations.GetHashCode();
6376 if (WallTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);
6377 if (UserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(UserTime);
6378 if (DeterministicTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DeterministicTime);
6379 if (PrimalIntegral != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalIntegral);
6380 if (SolutionInfo.Length != 0) hash ^= SolutionInfo.GetHashCode();
6381 if (_unknownFields !=
null) {
6382 hash ^= _unknownFields.GetHashCode();
6387 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6389 return pb::JsonFormatter.ToDiagnosticString(
this);
6392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6393 public void WriteTo(pb::CodedOutputStream output) {
6394 if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
6395 output.WriteRawTag(8);
6396 output.WriteEnum((
int) Status);
6398 solution_.WriteTo(output, _repeated_solution_codec);
6399 if (ObjectiveValue != 0D) {
6400 output.WriteRawTag(25);
6401 output.WriteDouble(ObjectiveValue);
6403 if (BestObjectiveBound != 0D) {
6404 output.WriteRawTag(33);
6405 output.WriteDouble(BestObjectiveBound);
6407 if (AllSolutionsWereFound !=
false) {
6408 output.WriteRawTag(40);
6409 output.WriteBool(AllSolutionsWereFound);
6411 if (NumBooleans != 0L) {
6412 output.WriteRawTag(80);
6413 output.WriteInt64(NumBooleans);
6415 if (NumConflicts != 0L) {
6416 output.WriteRawTag(88);
6417 output.WriteInt64(NumConflicts);
6419 if (NumBranches != 0L) {
6420 output.WriteRawTag(96);
6421 output.WriteInt64(NumBranches);
6423 if (NumBinaryPropagations != 0L) {
6424 output.WriteRawTag(104);
6425 output.WriteInt64(NumBinaryPropagations);
6427 if (NumIntegerPropagations != 0L) {
6428 output.WriteRawTag(112);
6429 output.WriteInt64(NumIntegerPropagations);
6431 if (WallTime != 0D) {
6432 output.WriteRawTag(121);
6433 output.WriteDouble(WallTime);
6435 if (UserTime != 0D) {
6436 output.WriteRawTag(129, 1);
6437 output.WriteDouble(UserTime);
6439 if (DeterministicTime != 0D) {
6440 output.WriteRawTag(137, 1);
6441 output.WriteDouble(DeterministicTime);
6443 solutionLowerBounds_.WriteTo(output, _repeated_solutionLowerBounds_codec);
6444 solutionUpperBounds_.WriteTo(output, _repeated_solutionUpperBounds_codec);
6445 if (SolutionInfo.Length != 0) {
6446 output.WriteRawTag(162, 1);
6447 output.WriteString(SolutionInfo);
6449 tightenedVariables_.WriteTo(output, _repeated_tightenedVariables_codec);
6450 if (PrimalIntegral != 0D) {
6451 output.WriteRawTag(177, 1);
6452 output.WriteDouble(PrimalIntegral);
6454 sufficientAssumptionsForInfeasibility_.WriteTo(output, _repeated_sufficientAssumptionsForInfeasibility_codec);
6455 if (_unknownFields !=
null) {
6456 _unknownFields.WriteTo(output);
6460 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6463 if (Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
6464 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) Status);
6466 size += solution_.CalculateSize(_repeated_solution_codec);
6467 if (ObjectiveValue != 0D) {
6470 if (BestObjectiveBound != 0D) {
6473 size += solutionLowerBounds_.CalculateSize(_repeated_solutionLowerBounds_codec);
6474 size += solutionUpperBounds_.CalculateSize(_repeated_solutionUpperBounds_codec);
6475 size += tightenedVariables_.CalculateSize(_repeated_tightenedVariables_codec);
6476 size += sufficientAssumptionsForInfeasibility_.CalculateSize(_repeated_sufficientAssumptionsForInfeasibility_codec);
6477 if (AllSolutionsWereFound !=
false) {
6480 if (NumBooleans != 0L) {
6481 size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBooleans);
6483 if (NumConflicts != 0L) {
6484 size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumConflicts);
6486 if (NumBranches != 0L) {
6487 size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBranches);
6489 if (NumBinaryPropagations != 0L) {
6490 size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumBinaryPropagations);
6492 if (NumIntegerPropagations != 0L) {
6493 size += 1 + pb::CodedOutputStream.ComputeInt64Size(NumIntegerPropagations);
6495 if (WallTime != 0D) {
6498 if (UserTime != 0D) {
6501 if (DeterministicTime != 0D) {
6504 if (PrimalIntegral != 0D) {
6507 if (SolutionInfo.Length != 0) {
6508 size += 2 + pb::CodedOutputStream.ComputeStringSize(SolutionInfo);
6510 if (_unknownFields !=
null) {
6511 size += _unknownFields.CalculateSize();
6516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6518 if (other ==
null) {
6521 if (other.
Status != global::Google.OrTools.Sat.CpSolverStatus.Unknown) {
6524 solution_.Add(other.solution_);
6531 solutionLowerBounds_.Add(other.solutionLowerBounds_);
6532 solutionUpperBounds_.Add(other.solutionUpperBounds_);
6533 tightenedVariables_.Add(other.tightenedVariables_);
6534 sufficientAssumptionsForInfeasibility_.Add(other.sufficientAssumptionsForInfeasibility_);
6568 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
6571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6574 while ((tag = input.ReadTag()) != 0) {
6577 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
6580 Status = (global::Google.OrTools.Sat.CpSolverStatus) input.ReadEnum();
6585 solution_.AddEntriesFrom(input, _repeated_solution_codec);
6589 ObjectiveValue = input.ReadDouble();
6593 BestObjectiveBound = input.ReadDouble();
6597 AllSolutionsWereFound = input.ReadBool();
6601 NumBooleans = input.ReadInt64();
6605 NumConflicts = input.ReadInt64();
6609 NumBranches = input.ReadInt64();
6613 NumBinaryPropagations = input.ReadInt64();
6617 NumIntegerPropagations = input.ReadInt64();
6621 WallTime = input.ReadDouble();
6625 UserTime = input.ReadDouble();
6629 DeterministicTime = input.ReadDouble();
6634 solutionLowerBounds_.AddEntriesFrom(input, _repeated_solutionLowerBounds_codec);
6639 solutionUpperBounds_.AddEntriesFrom(input, _repeated_solutionUpperBounds_codec);
6643 SolutionInfo = input.ReadString();
6647 tightenedVariables_.AddEntriesFrom(input, _repeated_tightenedVariables_codec);
6651 PrimalIntegral = input.ReadDouble();
6656 sufficientAssumptionsForInfeasibility_.AddEntriesFrom(input, _repeated_sufficientAssumptionsForInfeasibility_codec);
6669 #endregion Designer generated code