3293 lines
135 KiB
C++
Executable File
3293 lines
135 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: study.proto
|
|
|
|
#ifndef PROTOBUF_study_2eproto__INCLUDED
|
|
#define PROTOBUF_study_2eproto__INCLUDED
|
|
|
|
#include <string>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
|
|
#if GOOGLE_PROTOBUF_VERSION < 3003000
|
|
#error This file was generated by a newer version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please update
|
|
#error your headers.
|
|
#endif
|
|
#if 3003002 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
|
|
#error This file was generated by an older version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please
|
|
#error regenerate this file with a newer version of protoc.
|
|
#endif
|
|
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/arena.h>
|
|
#include <google/protobuf/arenastring.h>
|
|
#include <google/protobuf/generated_message_table_driven.h>
|
|
#include <google/protobuf/generated_message_util.h>
|
|
#include <google/protobuf/metadata_lite.h>
|
|
#include <google/protobuf/message_lite.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/generated_enum_util.h>
|
|
// @@protoc_insertion_point(includes)
|
|
namespace variations {
|
|
class Study;
|
|
class StudyDefaultTypeInternal;
|
|
extern StudyDefaultTypeInternal _Study_default_instance_;
|
|
class Study_Experiment;
|
|
class Study_ExperimentDefaultTypeInternal;
|
|
extern Study_ExperimentDefaultTypeInternal _Study_Experiment_default_instance_;
|
|
class Study_Experiment_FeatureAssociation;
|
|
class Study_Experiment_FeatureAssociationDefaultTypeInternal;
|
|
extern Study_Experiment_FeatureAssociationDefaultTypeInternal _Study_Experiment_FeatureAssociation_default_instance_;
|
|
class Study_Experiment_OverrideUIString;
|
|
class Study_Experiment_OverrideUIStringDefaultTypeInternal;
|
|
extern Study_Experiment_OverrideUIStringDefaultTypeInternal _Study_Experiment_OverrideUIString_default_instance_;
|
|
class Study_Experiment_Param;
|
|
class Study_Experiment_ParamDefaultTypeInternal;
|
|
extern Study_Experiment_ParamDefaultTypeInternal _Study_Experiment_Param_default_instance_;
|
|
class Study_Filter;
|
|
class Study_FilterDefaultTypeInternal;
|
|
extern Study_FilterDefaultTypeInternal _Study_Filter_default_instance_;
|
|
} // namespace variations
|
|
|
|
namespace variations {
|
|
|
|
namespace protobuf_study_2eproto {
|
|
// Internal implementation detail -- do not call these.
|
|
struct TableStruct {
|
|
static const ::google::protobuf::internal::ParseTableField entries[];
|
|
static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
|
|
static const ::google::protobuf::internal::ParseTable schema[];
|
|
static const ::google::protobuf::uint32 offsets[];
|
|
static void InitDefaultsImpl();
|
|
static void Shutdown();
|
|
};
|
|
void AddDescriptors();
|
|
void InitDefaults();
|
|
} // namespace protobuf_study_2eproto
|
|
|
|
enum Study_Experiment_Type {
|
|
Study_Experiment_Type_NORMAL = 0,
|
|
Study_Experiment_Type_IGNORE_CHANGE = 1,
|
|
Study_Experiment_Type_KILL_BEST_EFFORT = 2,
|
|
Study_Experiment_Type_KILL_CRITICAL = 3
|
|
};
|
|
bool Study_Experiment_Type_IsValid(int value);
|
|
const Study_Experiment_Type Study_Experiment_Type_Type_MIN = Study_Experiment_Type_NORMAL;
|
|
const Study_Experiment_Type Study_Experiment_Type_Type_MAX = Study_Experiment_Type_KILL_CRITICAL;
|
|
const int Study_Experiment_Type_Type_ARRAYSIZE = Study_Experiment_Type_Type_MAX + 1;
|
|
|
|
enum Study_Consistency {
|
|
Study_Consistency_SESSION = 0,
|
|
Study_Consistency_PERMANENT = 1
|
|
};
|
|
bool Study_Consistency_IsValid(int value);
|
|
const Study_Consistency Study_Consistency_Consistency_MIN = Study_Consistency_SESSION;
|
|
const Study_Consistency Study_Consistency_Consistency_MAX = Study_Consistency_PERMANENT;
|
|
const int Study_Consistency_Consistency_ARRAYSIZE = Study_Consistency_Consistency_MAX + 1;
|
|
|
|
enum Study_Channel {
|
|
Study_Channel_UNKNOWN = -1,
|
|
Study_Channel_CANARY = 0,
|
|
Study_Channel_DEV = 1,
|
|
Study_Channel_BETA = 2,
|
|
Study_Channel_STABLE = 3
|
|
};
|
|
bool Study_Channel_IsValid(int value);
|
|
const Study_Channel Study_Channel_Channel_MIN = Study_Channel_UNKNOWN;
|
|
const Study_Channel Study_Channel_Channel_MAX = Study_Channel_STABLE;
|
|
const int Study_Channel_Channel_ARRAYSIZE = Study_Channel_Channel_MAX + 1;
|
|
|
|
enum Study_Platform {
|
|
Study_Platform_PLATFORM_WINDOWS = 0,
|
|
Study_Platform_PLATFORM_MAC = 1,
|
|
Study_Platform_PLATFORM_LINUX = 2,
|
|
Study_Platform_PLATFORM_CHROMEOS = 3,
|
|
Study_Platform_PLATFORM_ANDROID = 4,
|
|
Study_Platform_PLATFORM_IOS = 5,
|
|
Study_Platform_PLATFORM_ANDROID_WEBVIEW = 6,
|
|
Study_Platform_PLATFORM_FUCHSIA = 7
|
|
};
|
|
bool Study_Platform_IsValid(int value);
|
|
const Study_Platform Study_Platform_Platform_MIN = Study_Platform_PLATFORM_WINDOWS;
|
|
const Study_Platform Study_Platform_Platform_MAX = Study_Platform_PLATFORM_FUCHSIA;
|
|
const int Study_Platform_Platform_ARRAYSIZE = Study_Platform_Platform_MAX + 1;
|
|
|
|
enum Study_FormFactor {
|
|
Study_FormFactor_DESKTOP = 0,
|
|
Study_FormFactor_PHONE = 1,
|
|
Study_FormFactor_TABLET = 2,
|
|
Study_FormFactor_KIOSK = 3
|
|
};
|
|
bool Study_FormFactor_IsValid(int value);
|
|
const Study_FormFactor Study_FormFactor_FormFactor_MIN = Study_FormFactor_DESKTOP;
|
|
const Study_FormFactor Study_FormFactor_FormFactor_MAX = Study_FormFactor_KIOSK;
|
|
const int Study_FormFactor_FormFactor_ARRAYSIZE = Study_FormFactor_FormFactor_MAX + 1;
|
|
|
|
enum Study_ActivationType {
|
|
Study_ActivationType_ACTIVATION_EXPLICIT = 0,
|
|
Study_ActivationType_ACTIVATION_AUTO = 1
|
|
};
|
|
bool Study_ActivationType_IsValid(int value);
|
|
const Study_ActivationType Study_ActivationType_ActivationType_MIN = Study_ActivationType_ACTIVATION_EXPLICIT;
|
|
const Study_ActivationType Study_ActivationType_ActivationType_MAX = Study_ActivationType_ACTIVATION_AUTO;
|
|
const int Study_ActivationType_ActivationType_ARRAYSIZE = Study_ActivationType_ActivationType_MAX + 1;
|
|
|
|
// ===================================================================
|
|
|
|
class Study_Experiment_Param : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study.Experiment.Param) */ {
|
|
public:
|
|
Study_Experiment_Param();
|
|
virtual ~Study_Experiment_Param();
|
|
|
|
Study_Experiment_Param(const Study_Experiment_Param& from);
|
|
|
|
inline Study_Experiment_Param& operator=(const Study_Experiment_Param& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study_Experiment_Param& default_instance();
|
|
|
|
static inline const Study_Experiment_Param* internal_default_instance() {
|
|
return reinterpret_cast<const Study_Experiment_Param*>(
|
|
&_Study_Experiment_Param_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
0;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study_Experiment_Param* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study_Experiment_Param* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study_Experiment_Param* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study_Experiment_Param& from);
|
|
void MergeFrom(const Study_Experiment_Param& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study_Experiment_Param* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// optional string name = 1;
|
|
bool has_name() const;
|
|
void clear_name();
|
|
static const int kNameFieldNumber = 1;
|
|
const ::std::string& name() const;
|
|
void set_name(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_name(::std::string&& value);
|
|
#endif
|
|
void set_name(const char* value);
|
|
void set_name(const char* value, size_t size);
|
|
::std::string* mutable_name();
|
|
::std::string* release_name();
|
|
void set_allocated_name(::std::string* name);
|
|
|
|
// optional string value = 2;
|
|
bool has_value() const;
|
|
void clear_value();
|
|
static const int kValueFieldNumber = 2;
|
|
const ::std::string& value() const;
|
|
void set_value(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_value(::std::string&& value);
|
|
#endif
|
|
void set_value(const char* value);
|
|
void set_value(const char* value, size_t size);
|
|
::std::string* mutable_value();
|
|
::std::string* release_value();
|
|
void set_allocated_value(::std::string* value);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study.Experiment.Param)
|
|
private:
|
|
void set_has_name();
|
|
void clear_has_name();
|
|
void set_has_value();
|
|
void clear_has_value();
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::internal::ArenaStringPtr name_;
|
|
::google::protobuf::internal::ArenaStringPtr value_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Study_Experiment_FeatureAssociation : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study.Experiment.FeatureAssociation) */ {
|
|
public:
|
|
Study_Experiment_FeatureAssociation();
|
|
virtual ~Study_Experiment_FeatureAssociation();
|
|
|
|
Study_Experiment_FeatureAssociation(const Study_Experiment_FeatureAssociation& from);
|
|
|
|
inline Study_Experiment_FeatureAssociation& operator=(const Study_Experiment_FeatureAssociation& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study_Experiment_FeatureAssociation& default_instance();
|
|
|
|
static inline const Study_Experiment_FeatureAssociation* internal_default_instance() {
|
|
return reinterpret_cast<const Study_Experiment_FeatureAssociation*>(
|
|
&_Study_Experiment_FeatureAssociation_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
1;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study_Experiment_FeatureAssociation* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study_Experiment_FeatureAssociation* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study_Experiment_FeatureAssociation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study_Experiment_FeatureAssociation& from);
|
|
void MergeFrom(const Study_Experiment_FeatureAssociation& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study_Experiment_FeatureAssociation* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// repeated string enable_feature = 1;
|
|
int enable_feature_size() const;
|
|
void clear_enable_feature();
|
|
static const int kEnableFeatureFieldNumber = 1;
|
|
const ::std::string& enable_feature(int index) const;
|
|
::std::string* mutable_enable_feature(int index);
|
|
void set_enable_feature(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_enable_feature(int index, ::std::string&& value);
|
|
#endif
|
|
void set_enable_feature(int index, const char* value);
|
|
void set_enable_feature(int index, const char* value, size_t size);
|
|
::std::string* add_enable_feature();
|
|
void add_enable_feature(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_enable_feature(::std::string&& value);
|
|
#endif
|
|
void add_enable_feature(const char* value);
|
|
void add_enable_feature(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& enable_feature() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_enable_feature();
|
|
|
|
// repeated string disable_feature = 2;
|
|
int disable_feature_size() const;
|
|
void clear_disable_feature();
|
|
static const int kDisableFeatureFieldNumber = 2;
|
|
const ::std::string& disable_feature(int index) const;
|
|
::std::string* mutable_disable_feature(int index);
|
|
void set_disable_feature(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_disable_feature(int index, ::std::string&& value);
|
|
#endif
|
|
void set_disable_feature(int index, const char* value);
|
|
void set_disable_feature(int index, const char* value, size_t size);
|
|
::std::string* add_disable_feature();
|
|
void add_disable_feature(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_disable_feature(::std::string&& value);
|
|
#endif
|
|
void add_disable_feature(const char* value);
|
|
void add_disable_feature(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& disable_feature() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_disable_feature();
|
|
|
|
// optional string forcing_feature_on = 3;
|
|
bool has_forcing_feature_on() const;
|
|
void clear_forcing_feature_on();
|
|
static const int kForcingFeatureOnFieldNumber = 3;
|
|
const ::std::string& forcing_feature_on() const;
|
|
void set_forcing_feature_on(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_forcing_feature_on(::std::string&& value);
|
|
#endif
|
|
void set_forcing_feature_on(const char* value);
|
|
void set_forcing_feature_on(const char* value, size_t size);
|
|
::std::string* mutable_forcing_feature_on();
|
|
::std::string* release_forcing_feature_on();
|
|
void set_allocated_forcing_feature_on(::std::string* forcing_feature_on);
|
|
|
|
// optional string forcing_feature_off = 4;
|
|
bool has_forcing_feature_off() const;
|
|
void clear_forcing_feature_off();
|
|
static const int kForcingFeatureOffFieldNumber = 4;
|
|
const ::std::string& forcing_feature_off() const;
|
|
void set_forcing_feature_off(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_forcing_feature_off(::std::string&& value);
|
|
#endif
|
|
void set_forcing_feature_off(const char* value);
|
|
void set_forcing_feature_off(const char* value, size_t size);
|
|
::std::string* mutable_forcing_feature_off();
|
|
::std::string* release_forcing_feature_off();
|
|
void set_allocated_forcing_feature_off(::std::string* forcing_feature_off);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study.Experiment.FeatureAssociation)
|
|
private:
|
|
void set_has_forcing_feature_on();
|
|
void clear_has_forcing_feature_on();
|
|
void set_has_forcing_feature_off();
|
|
void clear_has_forcing_feature_off();
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> enable_feature_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> disable_feature_;
|
|
::google::protobuf::internal::ArenaStringPtr forcing_feature_on_;
|
|
::google::protobuf::internal::ArenaStringPtr forcing_feature_off_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Study_Experiment_OverrideUIString : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study.Experiment.OverrideUIString) */ {
|
|
public:
|
|
Study_Experiment_OverrideUIString();
|
|
virtual ~Study_Experiment_OverrideUIString();
|
|
|
|
Study_Experiment_OverrideUIString(const Study_Experiment_OverrideUIString& from);
|
|
|
|
inline Study_Experiment_OverrideUIString& operator=(const Study_Experiment_OverrideUIString& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study_Experiment_OverrideUIString& default_instance();
|
|
|
|
static inline const Study_Experiment_OverrideUIString* internal_default_instance() {
|
|
return reinterpret_cast<const Study_Experiment_OverrideUIString*>(
|
|
&_Study_Experiment_OverrideUIString_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
2;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study_Experiment_OverrideUIString* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study_Experiment_OverrideUIString* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study_Experiment_OverrideUIString* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study_Experiment_OverrideUIString& from);
|
|
void MergeFrom(const Study_Experiment_OverrideUIString& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study_Experiment_OverrideUIString* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// optional string value = 2;
|
|
bool has_value() const;
|
|
void clear_value();
|
|
static const int kValueFieldNumber = 2;
|
|
const ::std::string& value() const;
|
|
void set_value(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_value(::std::string&& value);
|
|
#endif
|
|
void set_value(const char* value);
|
|
void set_value(const char* value, size_t size);
|
|
::std::string* mutable_value();
|
|
::std::string* release_value();
|
|
void set_allocated_value(::std::string* value);
|
|
|
|
// optional fixed32 name_hash = 1;
|
|
bool has_name_hash() const;
|
|
void clear_name_hash();
|
|
static const int kNameHashFieldNumber = 1;
|
|
::google::protobuf::uint32 name_hash() const;
|
|
void set_name_hash(::google::protobuf::uint32 value);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study.Experiment.OverrideUIString)
|
|
private:
|
|
void set_has_name_hash();
|
|
void clear_has_name_hash();
|
|
void set_has_value();
|
|
void clear_has_value();
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::internal::ArenaStringPtr value_;
|
|
::google::protobuf::uint32 name_hash_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Study_Experiment : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study.Experiment) */ {
|
|
public:
|
|
Study_Experiment();
|
|
virtual ~Study_Experiment();
|
|
|
|
Study_Experiment(const Study_Experiment& from);
|
|
|
|
inline Study_Experiment& operator=(const Study_Experiment& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study_Experiment& default_instance();
|
|
|
|
static inline const Study_Experiment* internal_default_instance() {
|
|
return reinterpret_cast<const Study_Experiment*>(
|
|
&_Study_Experiment_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
3;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study_Experiment* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study_Experiment* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study_Experiment* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study_Experiment& from);
|
|
void MergeFrom(const Study_Experiment& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study_Experiment* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Study_Experiment_Param Param;
|
|
typedef Study_Experiment_FeatureAssociation FeatureAssociation;
|
|
typedef Study_Experiment_OverrideUIString OverrideUIString;
|
|
|
|
typedef Study_Experiment_Type Type;
|
|
static const Type NORMAL =
|
|
Study_Experiment_Type_NORMAL;
|
|
static const Type IGNORE_CHANGE =
|
|
Study_Experiment_Type_IGNORE_CHANGE;
|
|
static const Type KILL_BEST_EFFORT =
|
|
Study_Experiment_Type_KILL_BEST_EFFORT;
|
|
static const Type KILL_CRITICAL =
|
|
Study_Experiment_Type_KILL_CRITICAL;
|
|
static inline bool Type_IsValid(int value) {
|
|
return Study_Experiment_Type_IsValid(value);
|
|
}
|
|
static const Type Type_MIN =
|
|
Study_Experiment_Type_Type_MIN;
|
|
static const Type Type_MAX =
|
|
Study_Experiment_Type_Type_MAX;
|
|
static const int Type_ARRAYSIZE =
|
|
Study_Experiment_Type_Type_ARRAYSIZE;
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// repeated .variations.Study.Experiment.Param param = 6;
|
|
int param_size() const;
|
|
void clear_param();
|
|
static const int kParamFieldNumber = 6;
|
|
const ::variations::Study_Experiment_Param& param(int index) const;
|
|
::variations::Study_Experiment_Param* mutable_param(int index);
|
|
::variations::Study_Experiment_Param* add_param();
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_Param >*
|
|
mutable_param();
|
|
const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_Param >&
|
|
param() const;
|
|
|
|
// repeated .variations.Study.Experiment.OverrideUIString override_ui_string = 9;
|
|
int override_ui_string_size() const;
|
|
void clear_override_ui_string();
|
|
static const int kOverrideUiStringFieldNumber = 9;
|
|
const ::variations::Study_Experiment_OverrideUIString& override_ui_string(int index) const;
|
|
::variations::Study_Experiment_OverrideUIString* mutable_override_ui_string(int index);
|
|
::variations::Study_Experiment_OverrideUIString* add_override_ui_string();
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_OverrideUIString >*
|
|
mutable_override_ui_string();
|
|
const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_OverrideUIString >&
|
|
override_ui_string() const;
|
|
|
|
// required string name = 1;
|
|
bool has_name() const;
|
|
void clear_name();
|
|
static const int kNameFieldNumber = 1;
|
|
const ::std::string& name() const;
|
|
void set_name(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_name(::std::string&& value);
|
|
#endif
|
|
void set_name(const char* value);
|
|
void set_name(const char* value, size_t size);
|
|
::std::string* mutable_name();
|
|
::std::string* release_name();
|
|
void set_allocated_name(::std::string* name);
|
|
|
|
// optional string forcing_flag = 5;
|
|
bool has_forcing_flag() const;
|
|
void clear_forcing_flag();
|
|
static const int kForcingFlagFieldNumber = 5;
|
|
const ::std::string& forcing_flag() const;
|
|
void set_forcing_flag(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_forcing_flag(::std::string&& value);
|
|
#endif
|
|
void set_forcing_flag(const char* value);
|
|
void set_forcing_flag(const char* value, size_t size);
|
|
::std::string* mutable_forcing_flag();
|
|
::std::string* release_forcing_flag();
|
|
void set_allocated_forcing_flag(::std::string* forcing_flag);
|
|
|
|
// optional .variations.Study.Experiment.FeatureAssociation feature_association = 12;
|
|
bool has_feature_association() const;
|
|
void clear_feature_association();
|
|
static const int kFeatureAssociationFieldNumber = 12;
|
|
const ::variations::Study_Experiment_FeatureAssociation& feature_association() const;
|
|
::variations::Study_Experiment_FeatureAssociation* mutable_feature_association();
|
|
::variations::Study_Experiment_FeatureAssociation* release_feature_association();
|
|
void set_allocated_feature_association(::variations::Study_Experiment_FeatureAssociation* feature_association);
|
|
|
|
// optional uint64 google_web_experiment_id = 3;
|
|
bool has_google_web_experiment_id() const;
|
|
void clear_google_web_experiment_id();
|
|
static const int kGoogleWebExperimentIdFieldNumber = 3;
|
|
::google::protobuf::uint64 google_web_experiment_id() const;
|
|
void set_google_web_experiment_id(::google::protobuf::uint64 value);
|
|
|
|
// required uint32 probability_weight = 2;
|
|
bool has_probability_weight() const;
|
|
void clear_probability_weight();
|
|
static const int kProbabilityWeightFieldNumber = 2;
|
|
::google::protobuf::uint32 probability_weight() const;
|
|
void set_probability_weight(::google::protobuf::uint32 value);
|
|
|
|
// optional .variations.Study.Experiment.Type type = 7 [default = NORMAL];
|
|
bool has_type() const;
|
|
void clear_type();
|
|
static const int kTypeFieldNumber = 7;
|
|
::variations::Study_Experiment_Type type() const;
|
|
void set_type(::variations::Study_Experiment_Type value);
|
|
|
|
// optional uint64 google_web_trigger_experiment_id = 8;
|
|
bool has_google_web_trigger_experiment_id() const;
|
|
void clear_google_web_trigger_experiment_id();
|
|
static const int kGoogleWebTriggerExperimentIdFieldNumber = 8;
|
|
::google::protobuf::uint64 google_web_trigger_experiment_id() const;
|
|
void set_google_web_trigger_experiment_id(::google::protobuf::uint64 value);
|
|
|
|
// optional uint64 chrome_sync_experiment_id = 10;
|
|
bool has_chrome_sync_experiment_id() const;
|
|
void clear_chrome_sync_experiment_id();
|
|
static const int kChromeSyncExperimentIdFieldNumber = 10;
|
|
::google::protobuf::uint64 chrome_sync_experiment_id() const;
|
|
void set_chrome_sync_experiment_id(::google::protobuf::uint64 value);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study.Experiment)
|
|
private:
|
|
void set_has_name();
|
|
void clear_has_name();
|
|
void set_has_probability_weight();
|
|
void clear_has_probability_weight();
|
|
void set_has_google_web_experiment_id();
|
|
void clear_has_google_web_experiment_id();
|
|
void set_has_google_web_trigger_experiment_id();
|
|
void clear_has_google_web_trigger_experiment_id();
|
|
void set_has_chrome_sync_experiment_id();
|
|
void clear_has_chrome_sync_experiment_id();
|
|
void set_has_feature_association();
|
|
void clear_has_feature_association();
|
|
void set_has_forcing_flag();
|
|
void clear_has_forcing_flag();
|
|
void set_has_type();
|
|
void clear_has_type();
|
|
|
|
// helper for ByteSizeLong()
|
|
size_t RequiredFieldsByteSizeFallback() const;
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_Param > param_;
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_OverrideUIString > override_ui_string_;
|
|
::google::protobuf::internal::ArenaStringPtr name_;
|
|
::google::protobuf::internal::ArenaStringPtr forcing_flag_;
|
|
::variations::Study_Experiment_FeatureAssociation* feature_association_;
|
|
::google::protobuf::uint64 google_web_experiment_id_;
|
|
::google::protobuf::uint32 probability_weight_;
|
|
int type_;
|
|
::google::protobuf::uint64 google_web_trigger_experiment_id_;
|
|
::google::protobuf::uint64 chrome_sync_experiment_id_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Study_Filter : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study.Filter) */ {
|
|
public:
|
|
Study_Filter();
|
|
virtual ~Study_Filter();
|
|
|
|
Study_Filter(const Study_Filter& from);
|
|
|
|
inline Study_Filter& operator=(const Study_Filter& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study_Filter& default_instance();
|
|
|
|
static inline const Study_Filter* internal_default_instance() {
|
|
return reinterpret_cast<const Study_Filter*>(
|
|
&_Study_Filter_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
4;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study_Filter* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study_Filter* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study_Filter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study_Filter& from);
|
|
void MergeFrom(const Study_Filter& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study_Filter* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// repeated .variations.Study.Channel channel = 4;
|
|
int channel_size() const;
|
|
void clear_channel();
|
|
static const int kChannelFieldNumber = 4;
|
|
::variations::Study_Channel channel(int index) const;
|
|
void set_channel(int index, ::variations::Study_Channel value);
|
|
void add_channel(::variations::Study_Channel value);
|
|
const ::google::protobuf::RepeatedField<int>& channel() const;
|
|
::google::protobuf::RepeatedField<int>* mutable_channel();
|
|
|
|
// repeated .variations.Study.Platform platform = 5;
|
|
int platform_size() const;
|
|
void clear_platform();
|
|
static const int kPlatformFieldNumber = 5;
|
|
::variations::Study_Platform platform(int index) const;
|
|
void set_platform(int index, ::variations::Study_Platform value);
|
|
void add_platform(::variations::Study_Platform value);
|
|
const ::google::protobuf::RepeatedField<int>& platform() const;
|
|
::google::protobuf::RepeatedField<int>* mutable_platform();
|
|
|
|
// repeated string locale = 6;
|
|
int locale_size() const;
|
|
void clear_locale();
|
|
static const int kLocaleFieldNumber = 6;
|
|
const ::std::string& locale(int index) const;
|
|
::std::string* mutable_locale(int index);
|
|
void set_locale(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_locale(int index, ::std::string&& value);
|
|
#endif
|
|
void set_locale(int index, const char* value);
|
|
void set_locale(int index, const char* value, size_t size);
|
|
::std::string* add_locale();
|
|
void add_locale(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_locale(::std::string&& value);
|
|
#endif
|
|
void add_locale(const char* value);
|
|
void add_locale(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& locale() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_locale();
|
|
|
|
// repeated .variations.Study.FormFactor form_factor = 7;
|
|
int form_factor_size() const;
|
|
void clear_form_factor();
|
|
static const int kFormFactorFieldNumber = 7;
|
|
::variations::Study_FormFactor form_factor(int index) const;
|
|
void set_form_factor(int index, ::variations::Study_FormFactor value);
|
|
void add_form_factor(::variations::Study_FormFactor value);
|
|
const ::google::protobuf::RepeatedField<int>& form_factor() const;
|
|
::google::protobuf::RepeatedField<int>* mutable_form_factor();
|
|
|
|
// repeated string hardware_class = 8;
|
|
int hardware_class_size() const;
|
|
void clear_hardware_class();
|
|
static const int kHardwareClassFieldNumber = 8;
|
|
const ::std::string& hardware_class(int index) const;
|
|
::std::string* mutable_hardware_class(int index);
|
|
void set_hardware_class(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_hardware_class(int index, ::std::string&& value);
|
|
#endif
|
|
void set_hardware_class(int index, const char* value);
|
|
void set_hardware_class(int index, const char* value, size_t size);
|
|
::std::string* add_hardware_class();
|
|
void add_hardware_class(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_hardware_class(::std::string&& value);
|
|
#endif
|
|
void add_hardware_class(const char* value);
|
|
void add_hardware_class(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& hardware_class() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_hardware_class();
|
|
|
|
// repeated string exclude_hardware_class = 9;
|
|
int exclude_hardware_class_size() const;
|
|
void clear_exclude_hardware_class();
|
|
static const int kExcludeHardwareClassFieldNumber = 9;
|
|
const ::std::string& exclude_hardware_class(int index) const;
|
|
::std::string* mutable_exclude_hardware_class(int index);
|
|
void set_exclude_hardware_class(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_exclude_hardware_class(int index, ::std::string&& value);
|
|
#endif
|
|
void set_exclude_hardware_class(int index, const char* value);
|
|
void set_exclude_hardware_class(int index, const char* value, size_t size);
|
|
::std::string* add_exclude_hardware_class();
|
|
void add_exclude_hardware_class(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_exclude_hardware_class(::std::string&& value);
|
|
#endif
|
|
void add_exclude_hardware_class(const char* value);
|
|
void add_exclude_hardware_class(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& exclude_hardware_class() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_exclude_hardware_class();
|
|
|
|
// repeated string country = 10;
|
|
int country_size() const;
|
|
void clear_country();
|
|
static const int kCountryFieldNumber = 10;
|
|
const ::std::string& country(int index) const;
|
|
::std::string* mutable_country(int index);
|
|
void set_country(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_country(int index, ::std::string&& value);
|
|
#endif
|
|
void set_country(int index, const char* value);
|
|
void set_country(int index, const char* value, size_t size);
|
|
::std::string* add_country();
|
|
void add_country(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_country(::std::string&& value);
|
|
#endif
|
|
void add_country(const char* value);
|
|
void add_country(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& country() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_country();
|
|
|
|
// repeated string exclude_country = 11;
|
|
int exclude_country_size() const;
|
|
void clear_exclude_country();
|
|
static const int kExcludeCountryFieldNumber = 11;
|
|
const ::std::string& exclude_country(int index) const;
|
|
::std::string* mutable_exclude_country(int index);
|
|
void set_exclude_country(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_exclude_country(int index, ::std::string&& value);
|
|
#endif
|
|
void set_exclude_country(int index, const char* value);
|
|
void set_exclude_country(int index, const char* value, size_t size);
|
|
::std::string* add_exclude_country();
|
|
void add_exclude_country(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_exclude_country(::std::string&& value);
|
|
#endif
|
|
void add_exclude_country(const char* value);
|
|
void add_exclude_country(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& exclude_country() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_exclude_country();
|
|
|
|
// repeated string exclude_locale = 12;
|
|
int exclude_locale_size() const;
|
|
void clear_exclude_locale();
|
|
static const int kExcludeLocaleFieldNumber = 12;
|
|
const ::std::string& exclude_locale(int index) const;
|
|
::std::string* mutable_exclude_locale(int index);
|
|
void set_exclude_locale(int index, const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_exclude_locale(int index, ::std::string&& value);
|
|
#endif
|
|
void set_exclude_locale(int index, const char* value);
|
|
void set_exclude_locale(int index, const char* value, size_t size);
|
|
::std::string* add_exclude_locale();
|
|
void add_exclude_locale(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void add_exclude_locale(::std::string&& value);
|
|
#endif
|
|
void add_exclude_locale(const char* value);
|
|
void add_exclude_locale(const char* value, size_t size);
|
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& exclude_locale() const;
|
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_exclude_locale();
|
|
|
|
// repeated .variations.Study.FormFactor exclude_form_factor = 14;
|
|
int exclude_form_factor_size() const;
|
|
void clear_exclude_form_factor();
|
|
static const int kExcludeFormFactorFieldNumber = 14;
|
|
::variations::Study_FormFactor exclude_form_factor(int index) const;
|
|
void set_exclude_form_factor(int index, ::variations::Study_FormFactor value);
|
|
void add_exclude_form_factor(::variations::Study_FormFactor value);
|
|
const ::google::protobuf::RepeatedField<int>& exclude_form_factor() const;
|
|
::google::protobuf::RepeatedField<int>* mutable_exclude_form_factor();
|
|
|
|
// optional string min_version = 2;
|
|
bool has_min_version() const;
|
|
void clear_min_version();
|
|
static const int kMinVersionFieldNumber = 2;
|
|
const ::std::string& min_version() const;
|
|
void set_min_version(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_min_version(::std::string&& value);
|
|
#endif
|
|
void set_min_version(const char* value);
|
|
void set_min_version(const char* value, size_t size);
|
|
::std::string* mutable_min_version();
|
|
::std::string* release_min_version();
|
|
void set_allocated_min_version(::std::string* min_version);
|
|
|
|
// optional string max_version = 3;
|
|
bool has_max_version() const;
|
|
void clear_max_version();
|
|
static const int kMaxVersionFieldNumber = 3;
|
|
const ::std::string& max_version() const;
|
|
void set_max_version(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_max_version(::std::string&& value);
|
|
#endif
|
|
void set_max_version(const char* value);
|
|
void set_max_version(const char* value, size_t size);
|
|
::std::string* mutable_max_version();
|
|
::std::string* release_max_version();
|
|
void set_allocated_max_version(::std::string* max_version);
|
|
|
|
// optional int64 start_date = 1;
|
|
bool has_start_date() const;
|
|
void clear_start_date();
|
|
static const int kStartDateFieldNumber = 1;
|
|
::google::protobuf::int64 start_date() const;
|
|
void set_start_date(::google::protobuf::int64 value);
|
|
|
|
// optional int64 end_date = 13;
|
|
bool has_end_date() const;
|
|
void clear_end_date();
|
|
static const int kEndDateFieldNumber = 13;
|
|
::google::protobuf::int64 end_date() const;
|
|
void set_end_date(::google::protobuf::int64 value);
|
|
|
|
// optional bool is_low_end_device = 15;
|
|
bool has_is_low_end_device() const;
|
|
void clear_is_low_end_device();
|
|
static const int kIsLowEndDeviceFieldNumber = 15;
|
|
bool is_low_end_device() const;
|
|
void set_is_low_end_device(bool value);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study.Filter)
|
|
private:
|
|
void set_has_start_date();
|
|
void clear_has_start_date();
|
|
void set_has_end_date();
|
|
void clear_has_end_date();
|
|
void set_has_min_version();
|
|
void clear_has_min_version();
|
|
void set_has_max_version();
|
|
void clear_has_max_version();
|
|
void set_has_is_low_end_device();
|
|
void clear_has_is_low_end_device();
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::RepeatedField<int> channel_;
|
|
::google::protobuf::RepeatedField<int> platform_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> locale_;
|
|
::google::protobuf::RepeatedField<int> form_factor_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> hardware_class_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> exclude_hardware_class_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> country_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> exclude_country_;
|
|
::google::protobuf::RepeatedPtrField< ::std::string> exclude_locale_;
|
|
::google::protobuf::RepeatedField<int> exclude_form_factor_;
|
|
::google::protobuf::internal::ArenaStringPtr min_version_;
|
|
::google::protobuf::internal::ArenaStringPtr max_version_;
|
|
::google::protobuf::int64 start_date_;
|
|
::google::protobuf::int64 end_date_;
|
|
bool is_low_end_device_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Study : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:variations.Study) */ {
|
|
public:
|
|
Study();
|
|
virtual ~Study();
|
|
|
|
Study(const Study& from);
|
|
|
|
inline Study& operator=(const Study& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
|
|
inline const ::std::string& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields();
|
|
}
|
|
|
|
inline ::std::string* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields();
|
|
}
|
|
|
|
static const Study& default_instance();
|
|
|
|
static inline const Study* internal_default_instance() {
|
|
return reinterpret_cast<const Study*>(
|
|
&_Study_default_instance_);
|
|
}
|
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
|
5;
|
|
|
|
GOOGLE_ATTRIBUTE_NOINLINE void Swap(Study* other);
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Study* New() const PROTOBUF_FINAL { return New(NULL); }
|
|
|
|
Study* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
|
void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
|
|
PROTOBUF_FINAL;
|
|
void CopyFrom(const Study& from);
|
|
void MergeFrom(const Study& from);
|
|
void Clear() PROTOBUF_FINAL;
|
|
bool IsInitialized() const PROTOBUF_FINAL;
|
|
|
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
|
bool MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
|
void SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
|
void DiscardUnknownFields();
|
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const;
|
|
void InternalSwap(Study* other);
|
|
private:
|
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
|
return NULL;
|
|
}
|
|
inline void* MaybeArenaPtr() const {
|
|
return NULL;
|
|
}
|
|
public:
|
|
|
|
::std::string GetTypeName() const PROTOBUF_FINAL;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Study_Experiment Experiment;
|
|
typedef Study_Filter Filter;
|
|
|
|
typedef Study_Consistency Consistency;
|
|
static const Consistency SESSION =
|
|
Study_Consistency_SESSION;
|
|
static const Consistency PERMANENT =
|
|
Study_Consistency_PERMANENT;
|
|
static inline bool Consistency_IsValid(int value) {
|
|
return Study_Consistency_IsValid(value);
|
|
}
|
|
static const Consistency Consistency_MIN =
|
|
Study_Consistency_Consistency_MIN;
|
|
static const Consistency Consistency_MAX =
|
|
Study_Consistency_Consistency_MAX;
|
|
static const int Consistency_ARRAYSIZE =
|
|
Study_Consistency_Consistency_ARRAYSIZE;
|
|
|
|
typedef Study_Channel Channel;
|
|
static const Channel UNKNOWN =
|
|
Study_Channel_UNKNOWN;
|
|
static const Channel CANARY =
|
|
Study_Channel_CANARY;
|
|
static const Channel DEV =
|
|
Study_Channel_DEV;
|
|
static const Channel BETA =
|
|
Study_Channel_BETA;
|
|
static const Channel STABLE =
|
|
Study_Channel_STABLE;
|
|
static inline bool Channel_IsValid(int value) {
|
|
return Study_Channel_IsValid(value);
|
|
}
|
|
static const Channel Channel_MIN =
|
|
Study_Channel_Channel_MIN;
|
|
static const Channel Channel_MAX =
|
|
Study_Channel_Channel_MAX;
|
|
static const int Channel_ARRAYSIZE =
|
|
Study_Channel_Channel_ARRAYSIZE;
|
|
|
|
typedef Study_Platform Platform;
|
|
static const Platform PLATFORM_WINDOWS =
|
|
Study_Platform_PLATFORM_WINDOWS;
|
|
static const Platform PLATFORM_MAC =
|
|
Study_Platform_PLATFORM_MAC;
|
|
static const Platform PLATFORM_LINUX =
|
|
Study_Platform_PLATFORM_LINUX;
|
|
static const Platform PLATFORM_CHROMEOS =
|
|
Study_Platform_PLATFORM_CHROMEOS;
|
|
static const Platform PLATFORM_ANDROID =
|
|
Study_Platform_PLATFORM_ANDROID;
|
|
static const Platform PLATFORM_IOS =
|
|
Study_Platform_PLATFORM_IOS;
|
|
static const Platform PLATFORM_ANDROID_WEBVIEW =
|
|
Study_Platform_PLATFORM_ANDROID_WEBVIEW;
|
|
static const Platform PLATFORM_FUCHSIA =
|
|
Study_Platform_PLATFORM_FUCHSIA;
|
|
static inline bool Platform_IsValid(int value) {
|
|
return Study_Platform_IsValid(value);
|
|
}
|
|
static const Platform Platform_MIN =
|
|
Study_Platform_Platform_MIN;
|
|
static const Platform Platform_MAX =
|
|
Study_Platform_Platform_MAX;
|
|
static const int Platform_ARRAYSIZE =
|
|
Study_Platform_Platform_ARRAYSIZE;
|
|
|
|
typedef Study_FormFactor FormFactor;
|
|
static const FormFactor DESKTOP =
|
|
Study_FormFactor_DESKTOP;
|
|
static const FormFactor PHONE =
|
|
Study_FormFactor_PHONE;
|
|
static const FormFactor TABLET =
|
|
Study_FormFactor_TABLET;
|
|
static const FormFactor KIOSK =
|
|
Study_FormFactor_KIOSK;
|
|
static inline bool FormFactor_IsValid(int value) {
|
|
return Study_FormFactor_IsValid(value);
|
|
}
|
|
static const FormFactor FormFactor_MIN =
|
|
Study_FormFactor_FormFactor_MIN;
|
|
static const FormFactor FormFactor_MAX =
|
|
Study_FormFactor_FormFactor_MAX;
|
|
static const int FormFactor_ARRAYSIZE =
|
|
Study_FormFactor_FormFactor_ARRAYSIZE;
|
|
|
|
typedef Study_ActivationType ActivationType;
|
|
static const ActivationType ACTIVATION_EXPLICIT =
|
|
Study_ActivationType_ACTIVATION_EXPLICIT;
|
|
static const ActivationType ACTIVATION_AUTO =
|
|
Study_ActivationType_ACTIVATION_AUTO;
|
|
static inline bool ActivationType_IsValid(int value) {
|
|
return Study_ActivationType_IsValid(value);
|
|
}
|
|
static const ActivationType ActivationType_MIN =
|
|
Study_ActivationType_ActivationType_MIN;
|
|
static const ActivationType ActivationType_MAX =
|
|
Study_ActivationType_ActivationType_MAX;
|
|
static const int ActivationType_ARRAYSIZE =
|
|
Study_ActivationType_ActivationType_ARRAYSIZE;
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
// repeated .variations.Study.Experiment experiment = 9;
|
|
int experiment_size() const;
|
|
void clear_experiment();
|
|
static const int kExperimentFieldNumber = 9;
|
|
const ::variations::Study_Experiment& experiment(int index) const;
|
|
::variations::Study_Experiment* mutable_experiment(int index);
|
|
::variations::Study_Experiment* add_experiment();
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment >*
|
|
mutable_experiment();
|
|
const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment >&
|
|
experiment() const;
|
|
|
|
// required string name = 1;
|
|
bool has_name() const;
|
|
void clear_name();
|
|
static const int kNameFieldNumber = 1;
|
|
const ::std::string& name() const;
|
|
void set_name(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_name(::std::string&& value);
|
|
#endif
|
|
void set_name(const char* value);
|
|
void set_name(const char* value, size_t size);
|
|
::std::string* mutable_name();
|
|
::std::string* release_name();
|
|
void set_allocated_name(::std::string* name);
|
|
|
|
// optional string default_experiment_name = 8;
|
|
bool has_default_experiment_name() const;
|
|
void clear_default_experiment_name();
|
|
static const int kDefaultExperimentNameFieldNumber = 8;
|
|
const ::std::string& default_experiment_name() const;
|
|
void set_default_experiment_name(const ::std::string& value);
|
|
#if LANG_CXX11
|
|
void set_default_experiment_name(::std::string&& value);
|
|
#endif
|
|
void set_default_experiment_name(const char* value);
|
|
void set_default_experiment_name(const char* value, size_t size);
|
|
::std::string* mutable_default_experiment_name();
|
|
::std::string* release_default_experiment_name();
|
|
void set_allocated_default_experiment_name(::std::string* default_experiment_name);
|
|
|
|
// optional .variations.Study.Filter filter = 10;
|
|
bool has_filter() const;
|
|
void clear_filter();
|
|
static const int kFilterFieldNumber = 10;
|
|
const ::variations::Study_Filter& filter() const;
|
|
::variations::Study_Filter* mutable_filter();
|
|
::variations::Study_Filter* release_filter();
|
|
void set_allocated_filter(::variations::Study_Filter* filter);
|
|
|
|
// optional int64 expiry_date = 3;
|
|
bool has_expiry_date() const;
|
|
void clear_expiry_date();
|
|
static const int kExpiryDateFieldNumber = 3;
|
|
::google::protobuf::int64 expiry_date() const;
|
|
void set_expiry_date(::google::protobuf::int64 value);
|
|
|
|
// optional .variations.Study.Consistency consistency = 7 [default = SESSION];
|
|
bool has_consistency() const;
|
|
void clear_consistency();
|
|
static const int kConsistencyFieldNumber = 7;
|
|
::variations::Study_Consistency consistency() const;
|
|
void set_consistency(::variations::Study_Consistency value);
|
|
|
|
// optional uint32 randomization_seed = 11;
|
|
bool has_randomization_seed() const;
|
|
void clear_randomization_seed();
|
|
static const int kRandomizationSeedFieldNumber = 11;
|
|
::google::protobuf::uint32 randomization_seed() const;
|
|
void set_randomization_seed(::google::protobuf::uint32 value);
|
|
|
|
// optional .variations.Study.ActivationType activation_type = 12;
|
|
bool has_activation_type() const;
|
|
void clear_activation_type();
|
|
static const int kActivationTypeFieldNumber = 12;
|
|
::variations::Study_ActivationType activation_type() const;
|
|
void set_activation_type(::variations::Study_ActivationType value);
|
|
|
|
// @@protoc_insertion_point(class_scope:variations.Study)
|
|
private:
|
|
void set_has_name();
|
|
void clear_has_name();
|
|
void set_has_expiry_date();
|
|
void clear_has_expiry_date();
|
|
void set_has_consistency();
|
|
void clear_has_consistency();
|
|
void set_has_default_experiment_name();
|
|
void clear_has_default_experiment_name();
|
|
void set_has_filter();
|
|
void clear_has_filter();
|
|
void set_has_randomization_seed();
|
|
void clear_has_randomization_seed();
|
|
void set_has_activation_type();
|
|
void clear_has_activation_type();
|
|
|
|
::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
|
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
|
mutable int _cached_size_;
|
|
::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment > experiment_;
|
|
::google::protobuf::internal::ArenaStringPtr name_;
|
|
::google::protobuf::internal::ArenaStringPtr default_experiment_name_;
|
|
::variations::Study_Filter* filter_;
|
|
::google::protobuf::int64 expiry_date_;
|
|
int consistency_;
|
|
::google::protobuf::uint32 randomization_seed_;
|
|
int activation_type_;
|
|
friend struct protobuf_study_2eproto::TableStruct;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#if !PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// Study_Experiment_Param
|
|
|
|
// optional string name = 1;
|
|
inline bool Study_Experiment_Param::has_name() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study_Experiment_Param::set_has_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study_Experiment_Param::clear_has_name() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study_Experiment_Param::clear_name() {
|
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_name();
|
|
}
|
|
inline const ::std::string& Study_Experiment_Param::name() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.Param.name)
|
|
return name_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment_Param::set_name(const ::std::string& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.Param.name)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_Param::set_name(::std::string&& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.Param.name)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_Param::set_name(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.Param.name)
|
|
}
|
|
inline void Study_Experiment_Param::set_name(const char* value, size_t size) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.Param.name)
|
|
}
|
|
inline ::std::string* Study_Experiment_Param::mutable_name() {
|
|
set_has_name();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.Param.name)
|
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment_Param::release_name() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.Param.name)
|
|
clear_has_name();
|
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment_Param::set_allocated_name(::std::string* name) {
|
|
if (name != NULL) {
|
|
set_has_name();
|
|
} else {
|
|
clear_has_name();
|
|
}
|
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.Param.name)
|
|
}
|
|
|
|
// optional string value = 2;
|
|
inline bool Study_Experiment_Param::has_value() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study_Experiment_Param::set_has_value() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study_Experiment_Param::clear_has_value() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study_Experiment_Param::clear_value() {
|
|
value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_value();
|
|
}
|
|
inline const ::std::string& Study_Experiment_Param::value() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.Param.value)
|
|
return value_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment_Param::set_value(const ::std::string& value) {
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.Param.value)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_Param::set_value(::std::string&& value) {
|
|
set_has_value();
|
|
value_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.Param.value)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_Param::set_value(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.Param.value)
|
|
}
|
|
inline void Study_Experiment_Param::set_value(const char* value, size_t size) {
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.Param.value)
|
|
}
|
|
inline ::std::string* Study_Experiment_Param::mutable_value() {
|
|
set_has_value();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.Param.value)
|
|
return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment_Param::release_value() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.Param.value)
|
|
clear_has_value();
|
|
return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment_Param::set_allocated_value(::std::string* value) {
|
|
if (value != NULL) {
|
|
set_has_value();
|
|
} else {
|
|
clear_has_value();
|
|
}
|
|
value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.Param.value)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Study_Experiment_FeatureAssociation
|
|
|
|
// repeated string enable_feature = 1;
|
|
inline int Study_Experiment_FeatureAssociation::enable_feature_size() const {
|
|
return enable_feature_.size();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_enable_feature() {
|
|
enable_feature_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Experiment_FeatureAssociation::enable_feature(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
return enable_feature_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::mutable_enable_feature(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
return enable_feature_.Mutable(index);
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_enable_feature(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
enable_feature_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::set_enable_feature(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
enable_feature_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::set_enable_feature(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
enable_feature_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_enable_feature(int index, const char* value, size_t size) {
|
|
enable_feature_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::add_enable_feature() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
return enable_feature_.Add();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::add_enable_feature(const ::std::string& value) {
|
|
enable_feature_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::add_enable_feature(::std::string&& value) {
|
|
enable_feature_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::add_enable_feature(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
enable_feature_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::add_enable_feature(const char* value, size_t size) {
|
|
enable_feature_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Experiment_FeatureAssociation::enable_feature() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
return enable_feature_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Experiment_FeatureAssociation::mutable_enable_feature() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Experiment.FeatureAssociation.enable_feature)
|
|
return &enable_feature_;
|
|
}
|
|
|
|
// repeated string disable_feature = 2;
|
|
inline int Study_Experiment_FeatureAssociation::disable_feature_size() const {
|
|
return disable_feature_.size();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_disable_feature() {
|
|
disable_feature_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Experiment_FeatureAssociation::disable_feature(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
return disable_feature_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::mutable_disable_feature(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
return disable_feature_.Mutable(index);
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_disable_feature(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
disable_feature_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::set_disable_feature(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
disable_feature_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::set_disable_feature(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
disable_feature_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_disable_feature(int index, const char* value, size_t size) {
|
|
disable_feature_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::add_disable_feature() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
return disable_feature_.Add();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::add_disable_feature(const ::std::string& value) {
|
|
disable_feature_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::add_disable_feature(::std::string&& value) {
|
|
disable_feature_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::add_disable_feature(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
disable_feature_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::add_disable_feature(const char* value, size_t size) {
|
|
disable_feature_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Experiment_FeatureAssociation::disable_feature() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
return disable_feature_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Experiment_FeatureAssociation::mutable_disable_feature() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Experiment.FeatureAssociation.disable_feature)
|
|
return &disable_feature_;
|
|
}
|
|
|
|
// optional string forcing_feature_on = 3;
|
|
inline bool Study_Experiment_FeatureAssociation::has_forcing_feature_on() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_has_forcing_feature_on() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_has_forcing_feature_on() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_forcing_feature_on() {
|
|
forcing_feature_on_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_forcing_feature_on();
|
|
}
|
|
inline const ::std::string& Study_Experiment_FeatureAssociation::forcing_feature_on() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
return forcing_feature_on_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_on(const ::std::string& value) {
|
|
set_has_forcing_feature_on();
|
|
forcing_feature_on_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_on(::std::string&& value) {
|
|
set_has_forcing_feature_on();
|
|
forcing_feature_on_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_on(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_forcing_feature_on();
|
|
forcing_feature_on_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_on(const char* value, size_t size) {
|
|
set_has_forcing_feature_on();
|
|
forcing_feature_on_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::mutable_forcing_feature_on() {
|
|
set_has_forcing_feature_on();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
return forcing_feature_on_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::release_forcing_feature_on() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
clear_has_forcing_feature_on();
|
|
return forcing_feature_on_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_allocated_forcing_feature_on(::std::string* forcing_feature_on) {
|
|
if (forcing_feature_on != NULL) {
|
|
set_has_forcing_feature_on();
|
|
} else {
|
|
clear_has_forcing_feature_on();
|
|
}
|
|
forcing_feature_on_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), forcing_feature_on);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.FeatureAssociation.forcing_feature_on)
|
|
}
|
|
|
|
// optional string forcing_feature_off = 4;
|
|
inline bool Study_Experiment_FeatureAssociation::has_forcing_feature_off() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_has_forcing_feature_off() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_has_forcing_feature_off() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::clear_forcing_feature_off() {
|
|
forcing_feature_off_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_forcing_feature_off();
|
|
}
|
|
inline const ::std::string& Study_Experiment_FeatureAssociation::forcing_feature_off() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
return forcing_feature_off_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_off(const ::std::string& value) {
|
|
set_has_forcing_feature_off();
|
|
forcing_feature_off_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_off(::std::string&& value) {
|
|
set_has_forcing_feature_off();
|
|
forcing_feature_off_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_off(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_forcing_feature_off();
|
|
forcing_feature_off_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_forcing_feature_off(const char* value, size_t size) {
|
|
set_has_forcing_feature_off();
|
|
forcing_feature_off_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::mutable_forcing_feature_off() {
|
|
set_has_forcing_feature_off();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
return forcing_feature_off_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment_FeatureAssociation::release_forcing_feature_off() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
clear_has_forcing_feature_off();
|
|
return forcing_feature_off_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment_FeatureAssociation::set_allocated_forcing_feature_off(::std::string* forcing_feature_off) {
|
|
if (forcing_feature_off != NULL) {
|
|
set_has_forcing_feature_off();
|
|
} else {
|
|
clear_has_forcing_feature_off();
|
|
}
|
|
forcing_feature_off_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), forcing_feature_off);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.FeatureAssociation.forcing_feature_off)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Study_Experiment_OverrideUIString
|
|
|
|
// optional fixed32 name_hash = 1;
|
|
inline bool Study_Experiment_OverrideUIString::has_name_hash() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_has_name_hash() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::clear_has_name_hash() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::clear_name_hash() {
|
|
name_hash_ = 0u;
|
|
clear_has_name_hash();
|
|
}
|
|
inline ::google::protobuf::uint32 Study_Experiment_OverrideUIString::name_hash() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.OverrideUIString.name_hash)
|
|
return name_hash_;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_name_hash(::google::protobuf::uint32 value) {
|
|
set_has_name_hash();
|
|
name_hash_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.OverrideUIString.name_hash)
|
|
}
|
|
|
|
// optional string value = 2;
|
|
inline bool Study_Experiment_OverrideUIString::has_value() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_has_value() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::clear_has_value() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::clear_value() {
|
|
value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_value();
|
|
}
|
|
inline const ::std::string& Study_Experiment_OverrideUIString::value() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.OverrideUIString.value)
|
|
return value_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_value(const ::std::string& value) {
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.OverrideUIString.value)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment_OverrideUIString::set_value(::std::string&& value) {
|
|
set_has_value();
|
|
value_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.OverrideUIString.value)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment_OverrideUIString::set_value(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.OverrideUIString.value)
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_value(const char* value, size_t size) {
|
|
set_has_value();
|
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.OverrideUIString.value)
|
|
}
|
|
inline ::std::string* Study_Experiment_OverrideUIString::mutable_value() {
|
|
set_has_value();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.OverrideUIString.value)
|
|
return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment_OverrideUIString::release_value() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.OverrideUIString.value)
|
|
clear_has_value();
|
|
return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment_OverrideUIString::set_allocated_value(::std::string* value) {
|
|
if (value != NULL) {
|
|
set_has_value();
|
|
} else {
|
|
clear_has_value();
|
|
}
|
|
value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.OverrideUIString.value)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Study_Experiment
|
|
|
|
// required string name = 1;
|
|
inline bool Study_Experiment::has_name() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study_Experiment::clear_has_name() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study_Experiment::clear_name() {
|
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_name();
|
|
}
|
|
inline const ::std::string& Study_Experiment::name() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.name)
|
|
return name_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment::set_name(const ::std::string& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.name)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment::set_name(::std::string&& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.name)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment::set_name(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.name)
|
|
}
|
|
inline void Study_Experiment::set_name(const char* value, size_t size) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.name)
|
|
}
|
|
inline ::std::string* Study_Experiment::mutable_name() {
|
|
set_has_name();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.name)
|
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment::release_name() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.name)
|
|
clear_has_name();
|
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment::set_allocated_name(::std::string* name) {
|
|
if (name != NULL) {
|
|
set_has_name();
|
|
} else {
|
|
clear_has_name();
|
|
}
|
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.name)
|
|
}
|
|
|
|
// required uint32 probability_weight = 2;
|
|
inline bool Study_Experiment::has_probability_weight() const {
|
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_probability_weight() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
}
|
|
inline void Study_Experiment::clear_has_probability_weight() {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline void Study_Experiment::clear_probability_weight() {
|
|
probability_weight_ = 0u;
|
|
clear_has_probability_weight();
|
|
}
|
|
inline ::google::protobuf::uint32 Study_Experiment::probability_weight() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.probability_weight)
|
|
return probability_weight_;
|
|
}
|
|
inline void Study_Experiment::set_probability_weight(::google::protobuf::uint32 value) {
|
|
set_has_probability_weight();
|
|
probability_weight_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.probability_weight)
|
|
}
|
|
|
|
// optional uint64 google_web_experiment_id = 3;
|
|
inline bool Study_Experiment::has_google_web_experiment_id() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_google_web_experiment_id() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
inline void Study_Experiment::clear_has_google_web_experiment_id() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline void Study_Experiment::clear_google_web_experiment_id() {
|
|
google_web_experiment_id_ = GOOGLE_ULONGLONG(0);
|
|
clear_has_google_web_experiment_id();
|
|
}
|
|
inline ::google::protobuf::uint64 Study_Experiment::google_web_experiment_id() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.google_web_experiment_id)
|
|
return google_web_experiment_id_;
|
|
}
|
|
inline void Study_Experiment::set_google_web_experiment_id(::google::protobuf::uint64 value) {
|
|
set_has_google_web_experiment_id();
|
|
google_web_experiment_id_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.google_web_experiment_id)
|
|
}
|
|
|
|
// optional uint64 google_web_trigger_experiment_id = 8;
|
|
inline bool Study_Experiment::has_google_web_trigger_experiment_id() const {
|
|
return (_has_bits_[0] & 0x00000040u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_google_web_trigger_experiment_id() {
|
|
_has_bits_[0] |= 0x00000040u;
|
|
}
|
|
inline void Study_Experiment::clear_has_google_web_trigger_experiment_id() {
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
inline void Study_Experiment::clear_google_web_trigger_experiment_id() {
|
|
google_web_trigger_experiment_id_ = GOOGLE_ULONGLONG(0);
|
|
clear_has_google_web_trigger_experiment_id();
|
|
}
|
|
inline ::google::protobuf::uint64 Study_Experiment::google_web_trigger_experiment_id() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.google_web_trigger_experiment_id)
|
|
return google_web_trigger_experiment_id_;
|
|
}
|
|
inline void Study_Experiment::set_google_web_trigger_experiment_id(::google::protobuf::uint64 value) {
|
|
set_has_google_web_trigger_experiment_id();
|
|
google_web_trigger_experiment_id_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.google_web_trigger_experiment_id)
|
|
}
|
|
|
|
// optional uint64 chrome_sync_experiment_id = 10;
|
|
inline bool Study_Experiment::has_chrome_sync_experiment_id() const {
|
|
return (_has_bits_[0] & 0x00000080u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_chrome_sync_experiment_id() {
|
|
_has_bits_[0] |= 0x00000080u;
|
|
}
|
|
inline void Study_Experiment::clear_has_chrome_sync_experiment_id() {
|
|
_has_bits_[0] &= ~0x00000080u;
|
|
}
|
|
inline void Study_Experiment::clear_chrome_sync_experiment_id() {
|
|
chrome_sync_experiment_id_ = GOOGLE_ULONGLONG(0);
|
|
clear_has_chrome_sync_experiment_id();
|
|
}
|
|
inline ::google::protobuf::uint64 Study_Experiment::chrome_sync_experiment_id() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.chrome_sync_experiment_id)
|
|
return chrome_sync_experiment_id_;
|
|
}
|
|
inline void Study_Experiment::set_chrome_sync_experiment_id(::google::protobuf::uint64 value) {
|
|
set_has_chrome_sync_experiment_id();
|
|
chrome_sync_experiment_id_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.chrome_sync_experiment_id)
|
|
}
|
|
|
|
// optional .variations.Study.Experiment.FeatureAssociation feature_association = 12;
|
|
inline bool Study_Experiment::has_feature_association() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_feature_association() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void Study_Experiment::clear_has_feature_association() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void Study_Experiment::clear_feature_association() {
|
|
if (feature_association_ != NULL) feature_association_->::variations::Study_Experiment_FeatureAssociation::Clear();
|
|
clear_has_feature_association();
|
|
}
|
|
inline const ::variations::Study_Experiment_FeatureAssociation& Study_Experiment::feature_association() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.feature_association)
|
|
return feature_association_ != NULL ? *feature_association_
|
|
: *::variations::Study_Experiment_FeatureAssociation::internal_default_instance();
|
|
}
|
|
inline ::variations::Study_Experiment_FeatureAssociation* Study_Experiment::mutable_feature_association() {
|
|
set_has_feature_association();
|
|
if (feature_association_ == NULL) {
|
|
feature_association_ = new ::variations::Study_Experiment_FeatureAssociation;
|
|
}
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.feature_association)
|
|
return feature_association_;
|
|
}
|
|
inline ::variations::Study_Experiment_FeatureAssociation* Study_Experiment::release_feature_association() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.feature_association)
|
|
clear_has_feature_association();
|
|
::variations::Study_Experiment_FeatureAssociation* temp = feature_association_;
|
|
feature_association_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void Study_Experiment::set_allocated_feature_association(::variations::Study_Experiment_FeatureAssociation* feature_association) {
|
|
delete feature_association_;
|
|
feature_association_ = feature_association;
|
|
if (feature_association) {
|
|
set_has_feature_association();
|
|
} else {
|
|
clear_has_feature_association();
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.feature_association)
|
|
}
|
|
|
|
// optional string forcing_flag = 5;
|
|
inline bool Study_Experiment::has_forcing_flag() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_forcing_flag() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study_Experiment::clear_has_forcing_flag() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study_Experiment::clear_forcing_flag() {
|
|
forcing_flag_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_forcing_flag();
|
|
}
|
|
inline const ::std::string& Study_Experiment::forcing_flag() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.forcing_flag)
|
|
return forcing_flag_.GetNoArena();
|
|
}
|
|
inline void Study_Experiment::set_forcing_flag(const ::std::string& value) {
|
|
set_has_forcing_flag();
|
|
forcing_flag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.forcing_flag)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Experiment::set_forcing_flag(::std::string&& value) {
|
|
set_has_forcing_flag();
|
|
forcing_flag_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Experiment.forcing_flag)
|
|
}
|
|
#endif
|
|
inline void Study_Experiment::set_forcing_flag(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_forcing_flag();
|
|
forcing_flag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Experiment.forcing_flag)
|
|
}
|
|
inline void Study_Experiment::set_forcing_flag(const char* value, size_t size) {
|
|
set_has_forcing_flag();
|
|
forcing_flag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Experiment.forcing_flag)
|
|
}
|
|
inline ::std::string* Study_Experiment::mutable_forcing_flag() {
|
|
set_has_forcing_flag();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.forcing_flag)
|
|
return forcing_flag_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Experiment::release_forcing_flag() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Experiment.forcing_flag)
|
|
clear_has_forcing_flag();
|
|
return forcing_flag_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Experiment::set_allocated_forcing_flag(::std::string* forcing_flag) {
|
|
if (forcing_flag != NULL) {
|
|
set_has_forcing_flag();
|
|
} else {
|
|
clear_has_forcing_flag();
|
|
}
|
|
forcing_flag_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), forcing_flag);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Experiment.forcing_flag)
|
|
}
|
|
|
|
// repeated .variations.Study.Experiment.Param param = 6;
|
|
inline int Study_Experiment::param_size() const {
|
|
return param_.size();
|
|
}
|
|
inline void Study_Experiment::clear_param() {
|
|
param_.Clear();
|
|
}
|
|
inline const ::variations::Study_Experiment_Param& Study_Experiment::param(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.param)
|
|
return param_.Get(index);
|
|
}
|
|
inline ::variations::Study_Experiment_Param* Study_Experiment::mutable_param(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.param)
|
|
return param_.Mutable(index);
|
|
}
|
|
inline ::variations::Study_Experiment_Param* Study_Experiment::add_param() {
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.param)
|
|
return param_.Add();
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_Param >*
|
|
Study_Experiment::mutable_param() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Experiment.param)
|
|
return ¶m_;
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_Param >&
|
|
Study_Experiment::param() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Experiment.param)
|
|
return param_;
|
|
}
|
|
|
|
// optional .variations.Study.Experiment.Type type = 7 [default = NORMAL];
|
|
inline bool Study_Experiment::has_type() const {
|
|
return (_has_bits_[0] & 0x00000020u) != 0;
|
|
}
|
|
inline void Study_Experiment::set_has_type() {
|
|
_has_bits_[0] |= 0x00000020u;
|
|
}
|
|
inline void Study_Experiment::clear_has_type() {
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline void Study_Experiment::clear_type() {
|
|
type_ = 0;
|
|
clear_has_type();
|
|
}
|
|
inline ::variations::Study_Experiment_Type Study_Experiment::type() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.type)
|
|
return static_cast< ::variations::Study_Experiment_Type >(type_);
|
|
}
|
|
inline void Study_Experiment::set_type(::variations::Study_Experiment_Type value) {
|
|
assert(::variations::Study_Experiment_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Experiment.type)
|
|
}
|
|
|
|
// repeated .variations.Study.Experiment.OverrideUIString override_ui_string = 9;
|
|
inline int Study_Experiment::override_ui_string_size() const {
|
|
return override_ui_string_.size();
|
|
}
|
|
inline void Study_Experiment::clear_override_ui_string() {
|
|
override_ui_string_.Clear();
|
|
}
|
|
inline const ::variations::Study_Experiment_OverrideUIString& Study_Experiment::override_ui_string(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Experiment.override_ui_string)
|
|
return override_ui_string_.Get(index);
|
|
}
|
|
inline ::variations::Study_Experiment_OverrideUIString* Study_Experiment::mutable_override_ui_string(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Experiment.override_ui_string)
|
|
return override_ui_string_.Mutable(index);
|
|
}
|
|
inline ::variations::Study_Experiment_OverrideUIString* Study_Experiment::add_override_ui_string() {
|
|
// @@protoc_insertion_point(field_add:variations.Study.Experiment.override_ui_string)
|
|
return override_ui_string_.Add();
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_OverrideUIString >*
|
|
Study_Experiment::mutable_override_ui_string() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Experiment.override_ui_string)
|
|
return &override_ui_string_;
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment_OverrideUIString >&
|
|
Study_Experiment::override_ui_string() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Experiment.override_ui_string)
|
|
return override_ui_string_;
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Study_Filter
|
|
|
|
// optional int64 start_date = 1;
|
|
inline bool Study_Filter::has_start_date() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void Study_Filter::set_has_start_date() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void Study_Filter::clear_has_start_date() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void Study_Filter::clear_start_date() {
|
|
start_date_ = GOOGLE_LONGLONG(0);
|
|
clear_has_start_date();
|
|
}
|
|
inline ::google::protobuf::int64 Study_Filter::start_date() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.start_date)
|
|
return start_date_;
|
|
}
|
|
inline void Study_Filter::set_start_date(::google::protobuf::int64 value) {
|
|
set_has_start_date();
|
|
start_date_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.start_date)
|
|
}
|
|
|
|
// optional int64 end_date = 13;
|
|
inline bool Study_Filter::has_end_date() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
inline void Study_Filter::set_has_end_date() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
inline void Study_Filter::clear_has_end_date() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline void Study_Filter::clear_end_date() {
|
|
end_date_ = GOOGLE_LONGLONG(0);
|
|
clear_has_end_date();
|
|
}
|
|
inline ::google::protobuf::int64 Study_Filter::end_date() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.end_date)
|
|
return end_date_;
|
|
}
|
|
inline void Study_Filter::set_end_date(::google::protobuf::int64 value) {
|
|
set_has_end_date();
|
|
end_date_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.end_date)
|
|
}
|
|
|
|
// optional string min_version = 2;
|
|
inline bool Study_Filter::has_min_version() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study_Filter::set_has_min_version() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study_Filter::clear_has_min_version() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study_Filter::clear_min_version() {
|
|
min_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_min_version();
|
|
}
|
|
inline const ::std::string& Study_Filter::min_version() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.min_version)
|
|
return min_version_.GetNoArena();
|
|
}
|
|
inline void Study_Filter::set_min_version(const ::std::string& value) {
|
|
set_has_min_version();
|
|
min_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.min_version)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_min_version(::std::string&& value) {
|
|
set_has_min_version();
|
|
min_version_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Filter.min_version)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_min_version(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_min_version();
|
|
min_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.min_version)
|
|
}
|
|
inline void Study_Filter::set_min_version(const char* value, size_t size) {
|
|
set_has_min_version();
|
|
min_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.min_version)
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_min_version() {
|
|
set_has_min_version();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.min_version)
|
|
return min_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Filter::release_min_version() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Filter.min_version)
|
|
clear_has_min_version();
|
|
return min_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Filter::set_allocated_min_version(::std::string* min_version) {
|
|
if (min_version != NULL) {
|
|
set_has_min_version();
|
|
} else {
|
|
clear_has_min_version();
|
|
}
|
|
min_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), min_version);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Filter.min_version)
|
|
}
|
|
|
|
// optional string max_version = 3;
|
|
inline bool Study_Filter::has_max_version() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study_Filter::set_has_max_version() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study_Filter::clear_has_max_version() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study_Filter::clear_max_version() {
|
|
max_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_max_version();
|
|
}
|
|
inline const ::std::string& Study_Filter::max_version() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.max_version)
|
|
return max_version_.GetNoArena();
|
|
}
|
|
inline void Study_Filter::set_max_version(const ::std::string& value) {
|
|
set_has_max_version();
|
|
max_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.max_version)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_max_version(::std::string&& value) {
|
|
set_has_max_version();
|
|
max_version_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.Filter.max_version)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_max_version(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_max_version();
|
|
max_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.max_version)
|
|
}
|
|
inline void Study_Filter::set_max_version(const char* value, size_t size) {
|
|
set_has_max_version();
|
|
max_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.max_version)
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_max_version() {
|
|
set_has_max_version();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.max_version)
|
|
return max_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study_Filter::release_max_version() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.Filter.max_version)
|
|
clear_has_max_version();
|
|
return max_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study_Filter::set_allocated_max_version(::std::string* max_version) {
|
|
if (max_version != NULL) {
|
|
set_has_max_version();
|
|
} else {
|
|
clear_has_max_version();
|
|
}
|
|
max_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), max_version);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.Filter.max_version)
|
|
}
|
|
|
|
// repeated .variations.Study.Channel channel = 4;
|
|
inline int Study_Filter::channel_size() const {
|
|
return channel_.size();
|
|
}
|
|
inline void Study_Filter::clear_channel() {
|
|
channel_.Clear();
|
|
}
|
|
inline ::variations::Study_Channel Study_Filter::channel(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.channel)
|
|
return static_cast< ::variations::Study_Channel >(channel_.Get(index));
|
|
}
|
|
inline void Study_Filter::set_channel(int index, ::variations::Study_Channel value) {
|
|
assert(::variations::Study_Channel_IsValid(value));
|
|
channel_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.channel)
|
|
}
|
|
inline void Study_Filter::add_channel(::variations::Study_Channel value) {
|
|
assert(::variations::Study_Channel_IsValid(value));
|
|
channel_.Add(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.channel)
|
|
}
|
|
inline const ::google::protobuf::RepeatedField<int>&
|
|
Study_Filter::channel() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.channel)
|
|
return channel_;
|
|
}
|
|
inline ::google::protobuf::RepeatedField<int>*
|
|
Study_Filter::mutable_channel() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.channel)
|
|
return &channel_;
|
|
}
|
|
|
|
// repeated .variations.Study.Platform platform = 5;
|
|
inline int Study_Filter::platform_size() const {
|
|
return platform_.size();
|
|
}
|
|
inline void Study_Filter::clear_platform() {
|
|
platform_.Clear();
|
|
}
|
|
inline ::variations::Study_Platform Study_Filter::platform(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.platform)
|
|
return static_cast< ::variations::Study_Platform >(platform_.Get(index));
|
|
}
|
|
inline void Study_Filter::set_platform(int index, ::variations::Study_Platform value) {
|
|
assert(::variations::Study_Platform_IsValid(value));
|
|
platform_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.platform)
|
|
}
|
|
inline void Study_Filter::add_platform(::variations::Study_Platform value) {
|
|
assert(::variations::Study_Platform_IsValid(value));
|
|
platform_.Add(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.platform)
|
|
}
|
|
inline const ::google::protobuf::RepeatedField<int>&
|
|
Study_Filter::platform() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.platform)
|
|
return platform_;
|
|
}
|
|
inline ::google::protobuf::RepeatedField<int>*
|
|
Study_Filter::mutable_platform() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.platform)
|
|
return &platform_;
|
|
}
|
|
|
|
// repeated string locale = 6;
|
|
inline int Study_Filter::locale_size() const {
|
|
return locale_.size();
|
|
}
|
|
inline void Study_Filter::clear_locale() {
|
|
locale_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::locale(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.locale)
|
|
return locale_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_locale(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.locale)
|
|
return locale_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_locale(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.locale)
|
|
locale_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_locale(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.locale)
|
|
locale_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_locale(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
locale_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.locale)
|
|
}
|
|
inline void Study_Filter::set_locale(int index, const char* value, size_t size) {
|
|
locale_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.locale)
|
|
}
|
|
inline ::std::string* Study_Filter::add_locale() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.locale)
|
|
return locale_.Add();
|
|
}
|
|
inline void Study_Filter::add_locale(const ::std::string& value) {
|
|
locale_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.locale)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_locale(::std::string&& value) {
|
|
locale_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.locale)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_locale(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
locale_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.locale)
|
|
}
|
|
inline void Study_Filter::add_locale(const char* value, size_t size) {
|
|
locale_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.locale)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::locale() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.locale)
|
|
return locale_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_locale() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.locale)
|
|
return &locale_;
|
|
}
|
|
|
|
// repeated string exclude_locale = 12;
|
|
inline int Study_Filter::exclude_locale_size() const {
|
|
return exclude_locale_.size();
|
|
}
|
|
inline void Study_Filter::clear_exclude_locale() {
|
|
exclude_locale_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::exclude_locale(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.exclude_locale)
|
|
return exclude_locale_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_exclude_locale(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.exclude_locale)
|
|
return exclude_locale_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_exclude_locale(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_locale)
|
|
exclude_locale_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_exclude_locale(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_locale)
|
|
exclude_locale_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_exclude_locale(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_locale_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.exclude_locale)
|
|
}
|
|
inline void Study_Filter::set_exclude_locale(int index, const char* value, size_t size) {
|
|
exclude_locale_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.exclude_locale)
|
|
}
|
|
inline ::std::string* Study_Filter::add_exclude_locale() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.exclude_locale)
|
|
return exclude_locale_.Add();
|
|
}
|
|
inline void Study_Filter::add_exclude_locale(const ::std::string& value) {
|
|
exclude_locale_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_locale)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_exclude_locale(::std::string&& value) {
|
|
exclude_locale_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_locale)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_exclude_locale(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_locale_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.exclude_locale)
|
|
}
|
|
inline void Study_Filter::add_exclude_locale(const char* value, size_t size) {
|
|
exclude_locale_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.exclude_locale)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::exclude_locale() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.exclude_locale)
|
|
return exclude_locale_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_exclude_locale() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.exclude_locale)
|
|
return &exclude_locale_;
|
|
}
|
|
|
|
// repeated .variations.Study.FormFactor form_factor = 7;
|
|
inline int Study_Filter::form_factor_size() const {
|
|
return form_factor_.size();
|
|
}
|
|
inline void Study_Filter::clear_form_factor() {
|
|
form_factor_.Clear();
|
|
}
|
|
inline ::variations::Study_FormFactor Study_Filter::form_factor(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.form_factor)
|
|
return static_cast< ::variations::Study_FormFactor >(form_factor_.Get(index));
|
|
}
|
|
inline void Study_Filter::set_form_factor(int index, ::variations::Study_FormFactor value) {
|
|
assert(::variations::Study_FormFactor_IsValid(value));
|
|
form_factor_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.form_factor)
|
|
}
|
|
inline void Study_Filter::add_form_factor(::variations::Study_FormFactor value) {
|
|
assert(::variations::Study_FormFactor_IsValid(value));
|
|
form_factor_.Add(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.form_factor)
|
|
}
|
|
inline const ::google::protobuf::RepeatedField<int>&
|
|
Study_Filter::form_factor() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.form_factor)
|
|
return form_factor_;
|
|
}
|
|
inline ::google::protobuf::RepeatedField<int>*
|
|
Study_Filter::mutable_form_factor() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.form_factor)
|
|
return &form_factor_;
|
|
}
|
|
|
|
// repeated .variations.Study.FormFactor exclude_form_factor = 14;
|
|
inline int Study_Filter::exclude_form_factor_size() const {
|
|
return exclude_form_factor_.size();
|
|
}
|
|
inline void Study_Filter::clear_exclude_form_factor() {
|
|
exclude_form_factor_.Clear();
|
|
}
|
|
inline ::variations::Study_FormFactor Study_Filter::exclude_form_factor(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.exclude_form_factor)
|
|
return static_cast< ::variations::Study_FormFactor >(exclude_form_factor_.Get(index));
|
|
}
|
|
inline void Study_Filter::set_exclude_form_factor(int index, ::variations::Study_FormFactor value) {
|
|
assert(::variations::Study_FormFactor_IsValid(value));
|
|
exclude_form_factor_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_form_factor)
|
|
}
|
|
inline void Study_Filter::add_exclude_form_factor(::variations::Study_FormFactor value) {
|
|
assert(::variations::Study_FormFactor_IsValid(value));
|
|
exclude_form_factor_.Add(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_form_factor)
|
|
}
|
|
inline const ::google::protobuf::RepeatedField<int>&
|
|
Study_Filter::exclude_form_factor() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.exclude_form_factor)
|
|
return exclude_form_factor_;
|
|
}
|
|
inline ::google::protobuf::RepeatedField<int>*
|
|
Study_Filter::mutable_exclude_form_factor() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.exclude_form_factor)
|
|
return &exclude_form_factor_;
|
|
}
|
|
|
|
// repeated string hardware_class = 8;
|
|
inline int Study_Filter::hardware_class_size() const {
|
|
return hardware_class_.size();
|
|
}
|
|
inline void Study_Filter::clear_hardware_class() {
|
|
hardware_class_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::hardware_class(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.hardware_class)
|
|
return hardware_class_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_hardware_class(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.hardware_class)
|
|
return hardware_class_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_hardware_class(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.hardware_class)
|
|
hardware_class_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_hardware_class(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.hardware_class)
|
|
hardware_class_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_hardware_class(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
hardware_class_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.hardware_class)
|
|
}
|
|
inline void Study_Filter::set_hardware_class(int index, const char* value, size_t size) {
|
|
hardware_class_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.hardware_class)
|
|
}
|
|
inline ::std::string* Study_Filter::add_hardware_class() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.hardware_class)
|
|
return hardware_class_.Add();
|
|
}
|
|
inline void Study_Filter::add_hardware_class(const ::std::string& value) {
|
|
hardware_class_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.hardware_class)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_hardware_class(::std::string&& value) {
|
|
hardware_class_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.hardware_class)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_hardware_class(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
hardware_class_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.hardware_class)
|
|
}
|
|
inline void Study_Filter::add_hardware_class(const char* value, size_t size) {
|
|
hardware_class_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.hardware_class)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::hardware_class() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.hardware_class)
|
|
return hardware_class_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_hardware_class() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.hardware_class)
|
|
return &hardware_class_;
|
|
}
|
|
|
|
// repeated string exclude_hardware_class = 9;
|
|
inline int Study_Filter::exclude_hardware_class_size() const {
|
|
return exclude_hardware_class_.size();
|
|
}
|
|
inline void Study_Filter::clear_exclude_hardware_class() {
|
|
exclude_hardware_class_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::exclude_hardware_class(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.exclude_hardware_class)
|
|
return exclude_hardware_class_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_exclude_hardware_class(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.exclude_hardware_class)
|
|
return exclude_hardware_class_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_exclude_hardware_class(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_hardware_class)
|
|
exclude_hardware_class_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_exclude_hardware_class(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_hardware_class)
|
|
exclude_hardware_class_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_exclude_hardware_class(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_hardware_class_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
inline void Study_Filter::set_exclude_hardware_class(int index, const char* value, size_t size) {
|
|
exclude_hardware_class_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
inline ::std::string* Study_Filter::add_exclude_hardware_class() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.exclude_hardware_class)
|
|
return exclude_hardware_class_.Add();
|
|
}
|
|
inline void Study_Filter::add_exclude_hardware_class(const ::std::string& value) {
|
|
exclude_hardware_class_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_exclude_hardware_class(::std::string&& value) {
|
|
exclude_hardware_class_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_exclude_hardware_class(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_hardware_class_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
inline void Study_Filter::add_exclude_hardware_class(const char* value, size_t size) {
|
|
exclude_hardware_class_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.exclude_hardware_class)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::exclude_hardware_class() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.exclude_hardware_class)
|
|
return exclude_hardware_class_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_exclude_hardware_class() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.exclude_hardware_class)
|
|
return &exclude_hardware_class_;
|
|
}
|
|
|
|
// repeated string country = 10;
|
|
inline int Study_Filter::country_size() const {
|
|
return country_.size();
|
|
}
|
|
inline void Study_Filter::clear_country() {
|
|
country_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::country(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.country)
|
|
return country_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_country(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.country)
|
|
return country_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_country(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.country)
|
|
country_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_country(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.country)
|
|
country_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_country(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
country_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.country)
|
|
}
|
|
inline void Study_Filter::set_country(int index, const char* value, size_t size) {
|
|
country_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.country)
|
|
}
|
|
inline ::std::string* Study_Filter::add_country() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.country)
|
|
return country_.Add();
|
|
}
|
|
inline void Study_Filter::add_country(const ::std::string& value) {
|
|
country_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.country)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_country(::std::string&& value) {
|
|
country_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.country)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_country(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
country_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.country)
|
|
}
|
|
inline void Study_Filter::add_country(const char* value, size_t size) {
|
|
country_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.country)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::country() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.country)
|
|
return country_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_country() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.country)
|
|
return &country_;
|
|
}
|
|
|
|
// repeated string exclude_country = 11;
|
|
inline int Study_Filter::exclude_country_size() const {
|
|
return exclude_country_.size();
|
|
}
|
|
inline void Study_Filter::clear_exclude_country() {
|
|
exclude_country_.Clear();
|
|
}
|
|
inline const ::std::string& Study_Filter::exclude_country(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.exclude_country)
|
|
return exclude_country_.Get(index);
|
|
}
|
|
inline ::std::string* Study_Filter::mutable_exclude_country(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.Filter.exclude_country)
|
|
return exclude_country_.Mutable(index);
|
|
}
|
|
inline void Study_Filter::set_exclude_country(int index, const ::std::string& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_country)
|
|
exclude_country_.Mutable(index)->assign(value);
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::set_exclude_country(int index, ::std::string&& value) {
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.exclude_country)
|
|
exclude_country_.Mutable(index)->assign(std::move(value));
|
|
}
|
|
#endif
|
|
inline void Study_Filter::set_exclude_country(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_country_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.Filter.exclude_country)
|
|
}
|
|
inline void Study_Filter::set_exclude_country(int index, const char* value, size_t size) {
|
|
exclude_country_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.Filter.exclude_country)
|
|
}
|
|
inline ::std::string* Study_Filter::add_exclude_country() {
|
|
// @@protoc_insertion_point(field_add_mutable:variations.Study.Filter.exclude_country)
|
|
return exclude_country_.Add();
|
|
}
|
|
inline void Study_Filter::add_exclude_country(const ::std::string& value) {
|
|
exclude_country_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_country)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study_Filter::add_exclude_country(::std::string&& value) {
|
|
exclude_country_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:variations.Study.Filter.exclude_country)
|
|
}
|
|
#endif
|
|
inline void Study_Filter::add_exclude_country(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
exclude_country_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:variations.Study.Filter.exclude_country)
|
|
}
|
|
inline void Study_Filter::add_exclude_country(const char* value, size_t size) {
|
|
exclude_country_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:variations.Study.Filter.exclude_country)
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
|
|
Study_Filter::exclude_country() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.Filter.exclude_country)
|
|
return exclude_country_;
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
|
|
Study_Filter::mutable_exclude_country() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.Filter.exclude_country)
|
|
return &exclude_country_;
|
|
}
|
|
|
|
// optional bool is_low_end_device = 15;
|
|
inline bool Study_Filter::has_is_low_end_device() const {
|
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
|
}
|
|
inline void Study_Filter::set_has_is_low_end_device() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
}
|
|
inline void Study_Filter::clear_has_is_low_end_device() {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline void Study_Filter::clear_is_low_end_device() {
|
|
is_low_end_device_ = false;
|
|
clear_has_is_low_end_device();
|
|
}
|
|
inline bool Study_Filter::is_low_end_device() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.Filter.is_low_end_device)
|
|
return is_low_end_device_;
|
|
}
|
|
inline void Study_Filter::set_is_low_end_device(bool value) {
|
|
set_has_is_low_end_device();
|
|
is_low_end_device_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.Filter.is_low_end_device)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Study
|
|
|
|
// required string name = 1;
|
|
inline bool Study::has_name() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
inline void Study::set_has_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
inline void Study::clear_has_name() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline void Study::clear_name() {
|
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_name();
|
|
}
|
|
inline const ::std::string& Study::name() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.name)
|
|
return name_.GetNoArena();
|
|
}
|
|
inline void Study::set_name(const ::std::string& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.name)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study::set_name(::std::string&& value) {
|
|
set_has_name();
|
|
name_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.name)
|
|
}
|
|
#endif
|
|
inline void Study::set_name(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.name)
|
|
}
|
|
inline void Study::set_name(const char* value, size_t size) {
|
|
set_has_name();
|
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.name)
|
|
}
|
|
inline ::std::string* Study::mutable_name() {
|
|
set_has_name();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.name)
|
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study::release_name() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.name)
|
|
clear_has_name();
|
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study::set_allocated_name(::std::string* name) {
|
|
if (name != NULL) {
|
|
set_has_name();
|
|
} else {
|
|
clear_has_name();
|
|
}
|
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.name)
|
|
}
|
|
|
|
// optional int64 expiry_date = 3;
|
|
inline bool Study::has_expiry_date() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
inline void Study::set_has_expiry_date() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
inline void Study::clear_has_expiry_date() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline void Study::clear_expiry_date() {
|
|
expiry_date_ = GOOGLE_LONGLONG(0);
|
|
clear_has_expiry_date();
|
|
}
|
|
inline ::google::protobuf::int64 Study::expiry_date() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.expiry_date)
|
|
return expiry_date_;
|
|
}
|
|
inline void Study::set_expiry_date(::google::protobuf::int64 value) {
|
|
set_has_expiry_date();
|
|
expiry_date_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.expiry_date)
|
|
}
|
|
|
|
// optional .variations.Study.Consistency consistency = 7 [default = SESSION];
|
|
inline bool Study::has_consistency() const {
|
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
|
}
|
|
inline void Study::set_has_consistency() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
}
|
|
inline void Study::clear_has_consistency() {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline void Study::clear_consistency() {
|
|
consistency_ = 0;
|
|
clear_has_consistency();
|
|
}
|
|
inline ::variations::Study_Consistency Study::consistency() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.consistency)
|
|
return static_cast< ::variations::Study_Consistency >(consistency_);
|
|
}
|
|
inline void Study::set_consistency(::variations::Study_Consistency value) {
|
|
assert(::variations::Study_Consistency_IsValid(value));
|
|
set_has_consistency();
|
|
consistency_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.consistency)
|
|
}
|
|
|
|
// optional string default_experiment_name = 8;
|
|
inline bool Study::has_default_experiment_name() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
inline void Study::set_has_default_experiment_name() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
inline void Study::clear_has_default_experiment_name() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline void Study::clear_default_experiment_name() {
|
|
default_experiment_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_default_experiment_name();
|
|
}
|
|
inline const ::std::string& Study::default_experiment_name() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.default_experiment_name)
|
|
return default_experiment_name_.GetNoArena();
|
|
}
|
|
inline void Study::set_default_experiment_name(const ::std::string& value) {
|
|
set_has_default_experiment_name();
|
|
default_experiment_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:variations.Study.default_experiment_name)
|
|
}
|
|
#if LANG_CXX11
|
|
inline void Study::set_default_experiment_name(::std::string&& value) {
|
|
set_has_default_experiment_name();
|
|
default_experiment_name_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:variations.Study.default_experiment_name)
|
|
}
|
|
#endif
|
|
inline void Study::set_default_experiment_name(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_default_experiment_name();
|
|
default_experiment_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:variations.Study.default_experiment_name)
|
|
}
|
|
inline void Study::set_default_experiment_name(const char* value, size_t size) {
|
|
set_has_default_experiment_name();
|
|
default_experiment_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:variations.Study.default_experiment_name)
|
|
}
|
|
inline ::std::string* Study::mutable_default_experiment_name() {
|
|
set_has_default_experiment_name();
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.default_experiment_name)
|
|
return default_experiment_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline ::std::string* Study::release_default_experiment_name() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.default_experiment_name)
|
|
clear_has_default_experiment_name();
|
|
return default_experiment_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
inline void Study::set_allocated_default_experiment_name(::std::string* default_experiment_name) {
|
|
if (default_experiment_name != NULL) {
|
|
set_has_default_experiment_name();
|
|
} else {
|
|
clear_has_default_experiment_name();
|
|
}
|
|
default_experiment_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), default_experiment_name);
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.default_experiment_name)
|
|
}
|
|
|
|
// repeated .variations.Study.Experiment experiment = 9;
|
|
inline int Study::experiment_size() const {
|
|
return experiment_.size();
|
|
}
|
|
inline void Study::clear_experiment() {
|
|
experiment_.Clear();
|
|
}
|
|
inline const ::variations::Study_Experiment& Study::experiment(int index) const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.experiment)
|
|
return experiment_.Get(index);
|
|
}
|
|
inline ::variations::Study_Experiment* Study::mutable_experiment(int index) {
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.experiment)
|
|
return experiment_.Mutable(index);
|
|
}
|
|
inline ::variations::Study_Experiment* Study::add_experiment() {
|
|
// @@protoc_insertion_point(field_add:variations.Study.experiment)
|
|
return experiment_.Add();
|
|
}
|
|
inline ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment >*
|
|
Study::mutable_experiment() {
|
|
// @@protoc_insertion_point(field_mutable_list:variations.Study.experiment)
|
|
return &experiment_;
|
|
}
|
|
inline const ::google::protobuf::RepeatedPtrField< ::variations::Study_Experiment >&
|
|
Study::experiment() const {
|
|
// @@protoc_insertion_point(field_list:variations.Study.experiment)
|
|
return experiment_;
|
|
}
|
|
|
|
// optional .variations.Study.Filter filter = 10;
|
|
inline bool Study::has_filter() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
inline void Study::set_has_filter() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
inline void Study::clear_has_filter() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline void Study::clear_filter() {
|
|
if (filter_ != NULL) filter_->::variations::Study_Filter::Clear();
|
|
clear_has_filter();
|
|
}
|
|
inline const ::variations::Study_Filter& Study::filter() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.filter)
|
|
return filter_ != NULL ? *filter_
|
|
: *::variations::Study_Filter::internal_default_instance();
|
|
}
|
|
inline ::variations::Study_Filter* Study::mutable_filter() {
|
|
set_has_filter();
|
|
if (filter_ == NULL) {
|
|
filter_ = new ::variations::Study_Filter;
|
|
}
|
|
// @@protoc_insertion_point(field_mutable:variations.Study.filter)
|
|
return filter_;
|
|
}
|
|
inline ::variations::Study_Filter* Study::release_filter() {
|
|
// @@protoc_insertion_point(field_release:variations.Study.filter)
|
|
clear_has_filter();
|
|
::variations::Study_Filter* temp = filter_;
|
|
filter_ = NULL;
|
|
return temp;
|
|
}
|
|
inline void Study::set_allocated_filter(::variations::Study_Filter* filter) {
|
|
delete filter_;
|
|
filter_ = filter;
|
|
if (filter) {
|
|
set_has_filter();
|
|
} else {
|
|
clear_has_filter();
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:variations.Study.filter)
|
|
}
|
|
|
|
// optional uint32 randomization_seed = 11;
|
|
inline bool Study::has_randomization_seed() const {
|
|
return (_has_bits_[0] & 0x00000020u) != 0;
|
|
}
|
|
inline void Study::set_has_randomization_seed() {
|
|
_has_bits_[0] |= 0x00000020u;
|
|
}
|
|
inline void Study::clear_has_randomization_seed() {
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline void Study::clear_randomization_seed() {
|
|
randomization_seed_ = 0u;
|
|
clear_has_randomization_seed();
|
|
}
|
|
inline ::google::protobuf::uint32 Study::randomization_seed() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.randomization_seed)
|
|
return randomization_seed_;
|
|
}
|
|
inline void Study::set_randomization_seed(::google::protobuf::uint32 value) {
|
|
set_has_randomization_seed();
|
|
randomization_seed_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.randomization_seed)
|
|
}
|
|
|
|
// optional .variations.Study.ActivationType activation_type = 12;
|
|
inline bool Study::has_activation_type() const {
|
|
return (_has_bits_[0] & 0x00000040u) != 0;
|
|
}
|
|
inline void Study::set_has_activation_type() {
|
|
_has_bits_[0] |= 0x00000040u;
|
|
}
|
|
inline void Study::clear_has_activation_type() {
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
inline void Study::clear_activation_type() {
|
|
activation_type_ = 0;
|
|
clear_has_activation_type();
|
|
}
|
|
inline ::variations::Study_ActivationType Study::activation_type() const {
|
|
// @@protoc_insertion_point(field_get:variations.Study.activation_type)
|
|
return static_cast< ::variations::Study_ActivationType >(activation_type_);
|
|
}
|
|
inline void Study::set_activation_type(::variations::Study_ActivationType value) {
|
|
assert(::variations::Study_ActivationType_IsValid(value));
|
|
set_has_activation_type();
|
|
activation_type_ = value;
|
|
// @@protoc_insertion_point(field_set:variations.Study.activation_type)
|
|
}
|
|
|
|
#endif // !PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
|
|
} // namespace variations
|
|
|
|
#ifndef SWIG
|
|
namespace google {
|
|
namespace protobuf {
|
|
|
|
template <> struct is_proto_enum< ::variations::Study_Experiment_Type> : ::google::protobuf::internal::true_type {};
|
|
template <> struct is_proto_enum< ::variations::Study_Consistency> : ::google::protobuf::internal::true_type {};
|
|
template <> struct is_proto_enum< ::variations::Study_Channel> : ::google::protobuf::internal::true_type {};
|
|
template <> struct is_proto_enum< ::variations::Study_Platform> : ::google::protobuf::internal::true_type {};
|
|
template <> struct is_proto_enum< ::variations::Study_FormFactor> : ::google::protobuf::internal::true_type {};
|
|
template <> struct is_proto_enum< ::variations::Study_ActivationType> : ::google::protobuf::internal::true_type {};
|
|
|
|
} // namespace protobuf
|
|
} // namespace google
|
|
#endif // SWIG
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#endif // PROTOBUF_study_2eproto__INCLUDED
|