Skip to content

Instantly share code, notes, and snippets.

@akonradi

akonradi/bool.pb.validate.h

Created November 22, 2017 19:00
Show Gist options
  • Save akonradi/33f7fe85de29edce2fad5653ffffb6f0 to your computer and use it in GitHub Desktop.
Save akonradi/33f7fe85de29edce2fad5653ffffb6f0 to your computer and use it in GitHub Desktop.
Download ZIP
Protoc-gen-validate C++ numeric validation code
Raw
bool.pb.validate.h
// Code generated by protoc-gen-validate
// source: tests/harness/cases/bool.proto
// DO NOT EDIT!!!
#include <string>
#include "tests/harness/cases/bool.pb.h"
namespace tests {
namespace harness {
namespace cases {
using std::string;
// Validate checks the field values on BoolNone with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const BoolNone& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on BoolConstTrue with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const BoolConstTrue& m, string* err) {
if (m.val() != true) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal true";
return false;
}
}
return true;
}
// Validate checks the field values on BoolConstFalse with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const BoolConstFalse& m, string* err) {
if (m.val() != false) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal false";
return false;
}
}
return true;
}
} // namespace
} // namespace
} // namespace
#define X_TESTS_HARNESS_CASES_BOOL(X) \
X(::tests::harness::cases::BoolNone) \
X(::tests::harness::cases::BoolConstTrue) \
X(::tests::harness::cases::BoolConstFalse) \
Raw
numbers.pb.validate.h
// Code generated by protoc-gen-validate
// source: tests/harness/cases/numbers.proto
// DO NOT EDIT!!!
#include <string>
#include "tests/harness/cases/numbers.pb.h"
namespace tests {
namespace harness {
namespace cases {
using std::string;
// Validate checks the field values on FloatNone with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatNone& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on FloatConst with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatConst& m, string* err) {
if (m.val() != 1.230000F) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1.23";
return false;
}
}
return true;
}
// Validate checks the field values on FloatIn with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<float> _FloatIn_Val_InLookup = {
4.560000F,
7.890000F,
};
bool Validate(const FloatIn& m, string* err) {
if (_FloatIn_Val_InLookup.find(m.val()) == _FloatIn_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [4.56 7.89]";
return false;
}
}
return true;
}
// Validate checks the field values on FloatNotIn with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<float> _FloatNotIn_Val_NotInLookup = {
0.000000F,
};
bool Validate(const FloatNotIn& m, string* err) {
if (_FloatNotIn_Val_NotInLookup.find(m.val()) != _FloatNotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on FloatLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatLT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on FloatLTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatLTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on FloatGT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatGT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on FloatGTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatGTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on FloatGTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const FloatGTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on FloatExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const FloatExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on FloatGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const FloatGTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on FloatExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const FloatExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleNone with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleNone& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on DoubleConst with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const DoubleConst& m, string* err) {
if (m.val() != 1.23) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1.23";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleIn with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<double> _DoubleIn_Val_InLookup = {
4.56,
7.89,
};
bool Validate(const DoubleIn& m, string* err) {
if (_DoubleIn_Val_InLookup.find(m.val()) == _DoubleIn_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [4.56 7.89]";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleNotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<double> _DoubleNotIn_Val_NotInLookup = {
0,
};
bool Validate(const DoubleNotIn& m, string* err) {
if (_DoubleNotIn_Val_NotInLookup.find(m.val()) != _DoubleNotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleLT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleLTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleLTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleGT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleGT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleGTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleGTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleGTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const DoubleGTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const DoubleExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const DoubleGTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on DoubleExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const DoubleExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on Int32None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on Int32Const with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on Int32In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int32_t> _Int32In_Val_InLookup = {
2,
3,
};
bool Validate(const Int32In& m, string* err) {
if (_Int32In_Val_InLookup.find(m.val()) == _Int32In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on Int32NotIn with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int32_t> _Int32NotIn_Val_NotInLookup = {
0,
};
bool Validate(const Int32NotIn& m, string* err) {
if (_Int32NotIn_Val_NotInLookup.find(m.val()) != _Int32NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on Int32LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on Int32LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on Int32GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on Int32GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on Int32GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int32GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on Int32ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int32ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on Int32GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int32GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on Int32ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int32ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on Int64None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on Int64Const with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on Int64In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int64_t> _Int64In_Val_InLookup = {
2,
3,
};
bool Validate(const Int64In& m, string* err) {
if (_Int64In_Val_InLookup.find(m.val()) == _Int64In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on Int64NotIn with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int64_t> _Int64NotIn_Val_NotInLookup = {
0,
};
bool Validate(const Int64NotIn& m, string* err) {
if (_Int64NotIn_Val_NotInLookup.find(m.val()) != _Int64NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on Int64LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on Int64LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on Int64GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on Int64GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on Int64GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Int64GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on Int64ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int64ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on Int64GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int64GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on Int64ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Int64ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on UInt32Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt32Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<uint32_t> _UInt32In_Val_InLookup = {
2,
3,
};
bool Validate(const UInt32In& m, string* err) {
if (_UInt32In_Val_InLookup.find(m.val()) == _UInt32In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<uint32_t> _UInt32NotIn_Val_NotInLookup = {
0,
};
bool Validate(const UInt32NotIn& m, string* err) {
if (_UInt32NotIn_Val_NotInLookup.find(m.val()) != _UInt32NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32LT& m, string* err) {
if (m.val() >= 5) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 5";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt32GTLT& m, string* err) {
if (m.val() <= 5 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (5, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt32ExLTGT& m, string* err) {
if (m.val() >= 5 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [5, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt32GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt32ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt32ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on UInt64Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt64Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<uint64_t> _UInt64In_Val_InLookup = {
2,
3,
};
bool Validate(const UInt64In& m, string* err) {
if (_UInt64In_Val_InLookup.find(m.val()) == _UInt64In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<uint64_t> _UInt64NotIn_Val_NotInLookup = {
0,
};
bool Validate(const UInt64NotIn& m, string* err) {
if (_UInt64NotIn_Val_NotInLookup.find(m.val()) != _UInt64NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64LT& m, string* err) {
if (m.val() >= 5) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 5";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const UInt64GTLT& m, string* err) {
if (m.val() <= 5 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (5, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt64ExLTGT& m, string* err) {
if (m.val() >= 5 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [5, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt64GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on UInt64ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const UInt64ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on SInt32Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt32Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int32_t> _SInt32In_Val_InLookup = {
2,
3,
};
bool Validate(const SInt32In& m, string* err) {
if (_SInt32In_Val_InLookup.find(m.val()) == _SInt32In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<int32_t> _SInt32NotIn_Val_NotInLookup = {
0,
};
bool Validate(const SInt32NotIn& m, string* err) {
if (_SInt32NotIn_Val_NotInLookup.find(m.val()) != _SInt32NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt32GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt32ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt32GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt32ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt32ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64None with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on SInt64Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt64Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int64_t> _SInt64In_Val_InLookup = {
2,
3,
};
bool Validate(const SInt64In& m, string* err) {
if (_SInt64In_Val_InLookup.find(m.val()) == _SInt64In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<int64_t> _SInt64NotIn_Val_NotInLookup = {
0,
};
bool Validate(const SInt64NotIn& m, string* err) {
if (_SInt64NotIn_Val_NotInLookup.find(m.val()) != _SInt64NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64GTLT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SInt64GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt64ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt64GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on SInt64ExGTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SInt64ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32None with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on Fixed32Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<uint32_t> _Fixed32In_Val_InLookup = {
2,
3,
};
bool Validate(const Fixed32In& m, string* err) {
if (_Fixed32In_Val_InLookup.find(m.val()) == _Fixed32In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<uint32_t> _Fixed32NotIn_Val_NotInLookup = {
0,
};
bool Validate(const Fixed32NotIn& m, string* err) {
if (_Fixed32NotIn_Val_NotInLookup.find(m.val()) != _Fixed32NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed32LT& m, string* err) {
if (m.val() >= 5) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 5";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed32LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed32GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed32GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32GTLT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32GTLT& m, string* err) {
if (m.val() <= 5 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (5, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32ExLTGT& m, string* err) {
if (m.val() >= 5 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [5, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed32ExGTELTE with the rules defined
// in the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed32ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64None with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on Fixed64Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<uint64_t> _Fixed64In_Val_InLookup = {
2,
3,
};
bool Validate(const Fixed64In& m, string* err) {
if (_Fixed64In_Val_InLookup.find(m.val()) == _Fixed64In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<uint64_t> _Fixed64NotIn_Val_NotInLookup = {
0,
};
bool Validate(const Fixed64NotIn& m, string* err) {
if (_Fixed64NotIn_Val_NotInLookup.find(m.val()) != _Fixed64NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed64LT& m, string* err) {
if (m.val() >= 5) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 5";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64LTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed64LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed64GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64GTE with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const Fixed64GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64GTLT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64GTLT& m, string* err) {
if (m.val() <= 5 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (5, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64ExLTGT& m, string* err) {
if (m.val() >= 5 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [5, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on Fixed64ExGTELTE with the rules defined
// in the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const Fixed64ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32None with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on SFixed32Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int32_t> _SFixed32In_Val_InLookup = {
2,
3,
};
bool Validate(const SFixed32In& m, string* err) {
if (_SFixed32In_Val_InLookup.find(m.val()) == _SFixed32In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<int32_t> _SFixed32NotIn_Val_NotInLookup = {
0,
};
bool Validate(const SFixed32NotIn& m, string* err) {
if (_SFixed32NotIn_Val_NotInLookup.find(m.val()) != _SFixed32NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SFixed32LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32LTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SFixed32GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32GTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32GTLT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed32ExGTELTE with the rules defined
// in the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed32ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64None with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64None& m, string* err) {// no validation rules for Val
return true;
}
// Validate checks the field values on SFixed64Const with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64Const& m, string* err) {
if (m.val() != 1) {
{
*err = "field: " "\"Val\"" ", reason: " "value must equal 1";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64In with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
const std::set<int64_t> _SFixed64In_Val_InLookup = {
2,
3,
};
bool Validate(const SFixed64In& m, string* err) {
if (_SFixed64In_Val_InLookup.find(m.val()) == _SFixed64In_Val_InLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be in list [2 3]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64NotIn with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
const std::set<int64_t> _SFixed64NotIn_Val_NotInLookup = {
0,
};
bool Validate(const SFixed64NotIn& m, string* err) {
if (_SFixed64NotIn_Val_NotInLookup.find(m.val()) != _SFixed64NotIn_Val_NotInLookup.end()) {
{
*err = "field: " "\"Val\"" ", reason: " "value must not be in list [0]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64LT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SFixed64LT& m, string* err) {
if (m.val() >= 0) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than 0";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64LTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64LTE& m, string* err) {
if (m.val() > 64) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be less than or equal to 64";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64GT with the rules defined in the
// proto definition for this message. If any rules are violated, the return
// value is false and an error message is written to the input string argument.
bool Validate(const SFixed64GT& m, string* err) {
if (m.val() <= 16) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than 16";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64GTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64GTE& m, string* err) {
if (m.val() < 8) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be greater than or equal to 8";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64GTLT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64GTLT& m, string* err) {
if (m.val() <= 0 || m.val() >= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range (0, 10)";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64ExLTGT with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64ExLTGT& m, string* err) {
if (m.val() >= 0 && m.val() <= 10) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range [0, 10]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64GTELTE with the rules defined in
// the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64GTELTE& m, string* err) {
if (m.val() < 128 || m.val() > 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be inside range [128, 256]";
return false;
}
}
return true;
}
// Validate checks the field values on SFixed64ExGTELTE with the rules defined
// in the proto definition for this message. If any rules are violated, the
// return value is false and an error message is written to the input string argument.
bool Validate(const SFixed64ExGTELTE& m, string* err) {
if (m.val() > 128 && m.val() < 256) {
{
*err = "field: " "\"Val\"" ", reason: " "value must be outside range (128, 256)";
return false;
}
}
return true;
}
} // namespace
} // namespace
} // namespace
#define X_TESTS_HARNESS_CASES_NUMBERS(X) \
X(::tests::harness::cases::FloatNone) \
X(::tests::harness::cases::FloatConst) \
X(::tests::harness::cases::FloatIn) \
X(::tests::harness::cases::FloatNotIn) \
X(::tests::harness::cases::FloatLT) \
X(::tests::harness::cases::FloatLTE) \
X(::tests::harness::cases::FloatGT) \
X(::tests::harness::cases::FloatGTE) \
X(::tests::harness::cases::FloatGTLT) \
X(::tests::harness::cases::FloatExLTGT) \
X(::tests::harness::cases::FloatGTELTE) \
X(::tests::harness::cases::FloatExGTELTE) \
X(::tests::harness::cases::DoubleNone) \
X(::tests::harness::cases::DoubleConst) \
X(::tests::harness::cases::DoubleIn) \
X(::tests::harness::cases::DoubleNotIn) \
X(::tests::harness::cases::DoubleLT) \
X(::tests::harness::cases::DoubleLTE) \
X(::tests::harness::cases::DoubleGT) \
X(::tests::harness::cases::DoubleGTE) \
X(::tests::harness::cases::DoubleGTLT) \
X(::tests::harness::cases::DoubleExLTGT) \
X(::tests::harness::cases::DoubleGTELTE) \
X(::tests::harness::cases::DoubleExGTELTE) \
X(::tests::harness::cases::Int32None) \
X(::tests::harness::cases::Int32Const) \
X(::tests::harness::cases::Int32In) \
X(::tests::harness::cases::Int32NotIn) \
X(::tests::harness::cases::Int32LT) \
X(::tests::harness::cases::Int32LTE) \
X(::tests::harness::cases::Int32GT) \
X(::tests::harness::cases::Int32GTE) \
X(::tests::harness::cases::Int32GTLT) \
X(::tests::harness::cases::Int32ExLTGT) \
X(::tests::harness::cases::Int32GTELTE) \
X(::tests::harness::cases::Int32ExGTELTE) \
X(::tests::harness::cases::Int64None) \
X(::tests::harness::cases::Int64Const) \
X(::tests::harness::cases::Int64In) \
X(::tests::harness::cases::Int64NotIn) \
X(::tests::harness::cases::Int64LT) \
X(::tests::harness::cases::Int64LTE) \
X(::tests::harness::cases::Int64GT) \
X(::tests::harness::cases::Int64GTE) \
X(::tests::harness::cases::Int64GTLT) \
X(::tests::harness::cases::Int64ExLTGT) \
X(::tests::harness::cases::Int64GTELTE) \
X(::tests::harness::cases::Int64ExGTELTE) \
X(::tests::harness::cases::UInt32None) \
X(::tests::harness::cases::UInt32Const) \
X(::tests::harness::cases::UInt32In) \
X(::tests::harness::cases::UInt32NotIn) \
X(::tests::harness::cases::UInt32LT) \
X(::tests::harness::cases::UInt32LTE) \
X(::tests::harness::cases::UInt32GT) \
X(::tests::harness::cases::UInt32GTE) \
X(::tests::harness::cases::UInt32GTLT) \
X(::tests::harness::cases::UInt32ExLTGT) \
X(::tests::harness::cases::UInt32GTELTE) \
X(::tests::harness::cases::UInt32ExGTELTE) \
X(::tests::harness::cases::UInt64None) \
X(::tests::harness::cases::UInt64Const) \
X(::tests::harness::cases::UInt64In) \
X(::tests::harness::cases::UInt64NotIn) \
X(::tests::harness::cases::UInt64LT) \
X(::tests::harness::cases::UInt64LTE) \
X(::tests::harness::cases::UInt64GT) \
X(::tests::harness::cases::UInt64GTE) \
X(::tests::harness::cases::UInt64GTLT) \
X(::tests::harness::cases::UInt64ExLTGT) \
X(::tests::harness::cases::UInt64GTELTE) \
X(::tests::harness::cases::UInt64ExGTELTE) \
X(::tests::harness::cases::SInt32None) \
X(::tests::harness::cases::SInt32Const) \
X(::tests::harness::cases::SInt32In) \
X(::tests::harness::cases::SInt32NotIn) \
X(::tests::harness::cases::SInt32LT) \
X(::tests::harness::cases::SInt32LTE) \
X(::tests::harness::cases::SInt32GT) \
X(::tests::harness::cases::SInt32GTE) \
X(::tests::harness::cases::SInt32GTLT) \
X(::tests::harness::cases::SInt32ExLTGT) \
X(::tests::harness::cases::SInt32GTELTE) \
X(::tests::harness::cases::SInt32ExGTELTE) \
X(::tests::harness::cases::SInt64None) \
X(::tests::harness::cases::SInt64Const) \
X(::tests::harness::cases::SInt64In) \
X(::tests::harness::cases::SInt64NotIn) \
X(::tests::harness::cases::SInt64LT) \
X(::tests::harness::cases::SInt64LTE) \
X(::tests::harness::cases::SInt64GT) \
X(::tests::harness::cases::SInt64GTE) \
X(::tests::harness::cases::SInt64GTLT) \
X(::tests::harness::cases::SInt64ExLTGT) \
X(::tests::harness::cases::SInt64GTELTE) \
X(::tests::harness::cases::SInt64ExGTELTE) \
X(::tests::harness::cases::Fixed32None) \
X(::tests::harness::cases::Fixed32Const) \
X(::tests::harness::cases::Fixed32In) \
X(::tests::harness::cases::Fixed32NotIn) \
X(::tests::harness::cases::Fixed32LT) \
X(::tests::harness::cases::Fixed32LTE) \
X(::tests::harness::cases::Fixed32GT) \
X(::tests::harness::cases::Fixed32GTE) \
X(::tests::harness::cases::Fixed32GTLT) \
X(::tests::harness::cases::Fixed32ExLTGT) \
X(::tests::harness::cases::Fixed32GTELTE) \
X(::tests::harness::cases::Fixed32ExGTELTE) \
X(::tests::harness::cases::Fixed64None) \
X(::tests::harness::cases::Fixed64Const) \
X(::tests::harness::cases::Fixed64In) \
X(::tests::harness::cases::Fixed64NotIn) \
X(::tests::harness::cases::Fixed64LT) \
X(::tests::harness::cases::Fixed64LTE) \
X(::tests::harness::cases::Fixed64GT) \
X(::tests::harness::cases::Fixed64GTE) \
X(::tests::harness::cases::Fixed64GTLT) \
X(::tests::harness::cases::Fixed64ExLTGT) \
X(::tests::harness::cases::Fixed64GTELTE) \
X(::tests::harness::cases::Fixed64ExGTELTE) \
X(::tests::harness::cases::SFixed32None) \
X(::tests::harness::cases::SFixed32Const) \
X(::tests::harness::cases::SFixed32In) \
X(::tests::harness::cases::SFixed32NotIn) \
X(::tests::harness::cases::SFixed32LT) \
X(::tests::harness::cases::SFixed32LTE) \
X(::tests::harness::cases::SFixed32GT) \
X(::tests::harness::cases::SFixed32GTE) \
X(::tests::harness::cases::SFixed32GTLT) \
X(::tests::harness::cases::SFixed32ExLTGT) \
X(::tests::harness::cases::SFixed32GTELTE) \
X(::tests::harness::cases::SFixed32ExGTELTE) \
X(::tests::harness::cases::SFixed64None) \
X(::tests::harness::cases::SFixed64Const) \
X(::tests::harness::cases::SFixed64In) \
X(::tests::harness::cases::SFixed64NotIn) \
X(::tests::harness::cases::SFixed64LT) \
X(::tests::harness::cases::SFixed64LTE) \
X(::tests::harness::cases::SFixed64GT) \
X(::tests::harness::cases::SFixed64GTE) \
X(::tests::harness::cases::SFixed64GTLT) \
X(::tests::harness::cases::SFixed64ExLTGT) \
X(::tests::harness::cases::SFixed64GTELTE) \
X(::tests::harness::cases::SFixed64ExGTELTE) \
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment