blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
201
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 7
100
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 260
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 11.4k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 80
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 8
9.86M
| extension
stringclasses 52
values | content
stringlengths 8
9.86M
| authors
sequencelengths 1
1
| author
stringlengths 0
119
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b446f6035e1802b00d33aa1d5c05b7d019abed9c | 5308c651112761c26501037d7d3201042ff90758 | /src/Game.cpp | e985e48b99e9f9dad05bb65592a8f13d37eac879 | [] | no_license | Spoutnik87/Zoo_Engine | bf19c2732c82252ef7a66c2ae1778482a1388da4 | 7e492d1be20fd9943757e974b860a4d8189d158a | refs/heads/master | 2020-03-31T07:38:50.878789 | 2018-10-21T21:19:32 | 2018-10-21T21:19:32 | 152,029,286 | 0 | 3 | null | 2018-10-09T14:48:38 | 2018-10-08T06:31:48 | C++ | UTF-8 | C++ | false | false | 2,218 | cpp | #include <iostream>
#include "Game.h"
#include "Logger.h"
#include "InputHandler.h"
#include "ResourceManager.h"
#include "Configurator.h"
#include "MainMenuState.h"
Game *Game::game;
Game::Game() {
if (game == NULL) {
game = this;
logger = new Logger();
resourceManager = new ResourceManager();
inputHandler = new InputHandler();
configurator = new Configurator();
context = new Context();
currentState = new MainMenuState();
logger->info("Initialisation de 'Game'.");
} else {
game->getLogger()->warn("Une instance de 'Game' existe déjà.");
}
}
Game::~Game() {
delete logger;
delete resourceManager;
delete inputHandler;
delete configurator;
delete context;
}
void Game::run() {
context->open();
currentState->setup();
float t = 0.0;
float dt = 0.01;
float currentTime = sf::Time().asSeconds();
float accumulator = 0.0;
// Boucle de jeu à temps fixe + interpolation.
while (context->isOpen()) {
context->processEvents();
Command* command = game->getInputHandler()->handleInput();
float newTime = sf::Time().asSeconds();
float frameTime = newTime - currentTime;
if (frameTime > 0.25) {
frameTime = 0.25;
}
currentTime = newTime;
accumulator += frameTime;
while (accumulator >= dt) {
//previousState = currentState;
//integrate(currentState, t, dt);
t += dt;
accumulator -= dt;
}
const double alpha = accumulator / dt;
//State state = currentState * alpha + previousState * ( 1.0 - alpha );
//render(state);
currentState->update();
currentState->draw();
}
}
Logger* Game::getLogger() {
return logger;
}
InputHandler* Game::getInputHandler() {
return inputHandler;
}
ResourceManager* Game::getResourceManager() {
return resourceManager;
}
Configurator* Game::getConfigurator() {
return configurator;
}
Context* Game::getContext() {
return context;
}
State* Game::getCurrentState() {
return currentState;
}
Game* Game::instance() {
return game;
} | [
"[email protected]"
] | |
7b0d739dcde028682ee86c07e1a80c00895f3fa0 | ca0d65a2519697f1fab4d0467271e032f72feed5 | /darts-x86/omp2cd-examples/benchmarks/array_bench/common.output.darts.h | a632402b08f581f7e293b2c1a4209f7eafc1b66c | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | jandres742/omp2cd | fca943f38e77ff9d32d066c6713e4556cf30fd54 | 15f64d65c41a1b9238af81fe2627c1b8e12ceca7 | refs/heads/master | 2020-12-24T11:09:41.811053 | 2017-06-28T19:23:40 | 2017-06-28T19:23:40 | 73,186,762 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,086 | h | #ifndef _common_output_darts_h_
#define _common_output_darts_h_
#ifndef __DARTS_
#define __DARTS_
#endif
#include "common.h"
#include "darts.h"
#include "ompTP.h"
#include "tbb/concurrent_vector.h"
#include "utils.h"
#include <limits.h>
#include <math.h>
#include <mutex>
#include <numa.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
double getclock();
void delay(int delaylength);
void array_delay(int delaylength, double* a);
void intitest(char* name);
void finalisetest(char* name);
void finalisereference(char* name);
void usage(char* argv[]);
unsigned long getinnerreps(void (*test)(void));
void printfooter(char* name, double testtime, double testsd, double referencetime, double refsd);
void reference(char* name, void (*refer)(void));
void parse_args(int argc, char* argv[]);
void printreferencefooter(char* name, double referencetime, double referencesd);
void printheader(char* name);
void benchmark(char* name, void (*test)(void));
void finalise();
int returnfalse();
void initreference(char* name);
int getdelaylengthfromtime(double delaytime);
void stats(double* mtp, double* sdp);
void init(int argc, char** argv);
class TP270;
class TP272;
extern int DARTS_CODELETS_MULT;
extern int NUMTPS;
extern size_t numOfCUs;
extern darts::Codelet* RuntimeFinalCodelet;
extern darts::ThreadAffinity* affin;
extern bool affinMaskRes;
extern darts::Runtime* myDARTSRuntime;
extern std::vector<std::vector<void*> > threadFunctionStack;
extern size_t ompNumThreads;
extern int ompSchedulePolicy;
extern int ompScheduleChunk;
extern void omp_set_num_threads(unsigned long numThreadsToSet);
extern int omp_get_num_threads();
extern int omp_get_max_threads();
extern int omp_get_num_procs();
extern double omp_get_wtime();
extern void omp_init_lock(omp_lock_t* lock);
extern void omp_destroy_lock(omp_lock_t* lock);
extern void omp_set_lock(omp_lock_t* lock);
extern void omp_unset_lock(omp_lock_t* lock);
/*TP270: OMPParallelDirective*/
class TP270 : public darts::ThreadedProcedure {
public:
class _barrierCodelets270 : public darts::Codelet {
public:
TP270* inputsTPParent;
_barrierCodelets270()
: darts::Codelet()
{
}
_barrierCodelets270(uint32_t dep, uint32_t res, TP270* myTP, uint32_t id)
: darts::Codelet(dep, res, myTP, LONGWAIT, id)
, inputsTPParent(myTP->inputsTPParent)
{
}
void fire(void);
};
class _checkInCodelets272 : public darts::Codelet {
public:
TP270* myTP;
TP270* inputsTPParent;
_checkInCodelets272()
: darts::Codelet()
{
}
_checkInCodelets272(uint32_t dep, uint32_t res, TP270* myTP, uint32_t id)
: darts::Codelet(dep, res, myTP, LONGWAIT, id)
, myTP(myTP)
, inputsTPParent(myTP->inputsTPParent)
{
}
void fire(void);
};
darts::Codelet* nextCodelet;
TP270* TPParent;
TP270* controlTPParent;
TP270* inputsTPParent;
TP272* TP272Ptr;
size_t TP272_alreadyLaunched;
_barrierCodelets270* barrierCodelets270;
_checkInCodelets272* checkInCodelets272;
TP270(int in_numThreads, int in_mainCodeletID, darts::Codelet* in_nextCodelet);
~TP270();
};
/*TP272: OMPMasterDirective*/
class TP272 : public ompOMPMasterDirectiveTP {
public:
class _checkInCodelets274 : public darts::Codelet {
public:
TP272* myTP;
TP272* inputsTPParent;
_checkInCodelets274()
: darts::Codelet()
{
}
_checkInCodelets274(uint32_t dep, uint32_t res, TP272* myTP, uint32_t id)
: darts::Codelet(dep, res, myTP, LONGWAIT, id)
, myTP(myTP)
, inputsTPParent(myTP->inputsTPParent)
{
}
void fire(void);
};
TP270* TPParent;
TP272* controlTPParent;
TP272* inputsTPParent;
_checkInCodelets274 checkInCodelets274;
TP272(int in_numThreads, int in_mainCodeletID, TP270* in_TPParent);
~TP272();
};
#endif
| [
"[email protected]"
] | |
dda37f293825814087c076dba08787b4e93fb258 | 817b372277ba8c47cc9c6cadcc61d243fc276443 | /Plugins/OSC/Source/OSC/Private/Receive/OscReceiverInterface.cpp | 870124d8be9d3d156d3a88102f07ddbbab565459 | [] | no_license | parayc/FaceTrack_UE4 | 9eb7391bba779e3a3e741061cfbbf361081b2d8d | 30a1853583d85058bc8374642d391c330fae7b3e | refs/heads/master | 2020-05-03T04:59:49.826333 | 2015-02-15T17:45:08 | 2015-02-15T17:45:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 397 | cpp | #include "OscPrivatePCH.h"
#include "OscReceiverInterface.h"
UOscReceiverInterface::UOscReceiverInterface(const class FPostConstructInitializeProperties& PCIP)
: Super(PCIP)
{
}
const FString & IOscReceiverInterface::GetAddressFilter()
{
static FString defaultValue;
return defaultValue;
}
void IOscReceiverInterface::SendEvent(const FName & Address, const FOscDataStruct & Data)
{ }
| [
"[email protected]"
] | |
f08a8babe5ac8526aa1aa8972833d0b9b388ce95 | d8eb3ea7cf7571a12df657e79784ba746cfba512 | /TP 4 EJERCICIO 6.cpp | beb009c951a4184acee6226b40ab365f932064fe | [] | no_license | ReginaLaurentino/Primer-Cuatrimestre-while | eec1bf284b02161373f35f05a7d6e3e1a99d7abe | 20e5b2cd509d09d1fe216593be683fefbbf774d1 | refs/heads/master | 2022-11-18T02:39:59.502830 | 2020-07-08T23:10:59 | 2020-07-08T23:10:59 | 278,212,405 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 642 | cpp | /*
6) Hacer un programa para ingresar una lista de números que finaliza cuando se ingresa un cero,
luego informar cuántos son positivos y cuántos son negativos.
Ejemplo: 4, -3, 8, -5, 18, 20, 0. Se listará Positivos: 4 Negativos: 2.
*/
#include<iostream>
using namespace std;
int main () {
int n,p=0, ne=0;
cout << "Ingresar un numero: ";
cin >> n;
while (n!=0) {
if (n>0){
p++;
} else {
ne++;
}
cout << "Ingresar un numero: ";
cin >> n;
}
cout <<"La cantidad de positivos es: " << p;
cout << endl;
cout <<"La cantidad de negativos es: " << ne;
return 0;
}
| [
"[email protected]"
] | |
071ff8bc153e0b445098993b4b5ce9618afb2e77 | 83bacfbdb7ad17cbc2fc897b3460de1a6726a3b1 | /gen/blink/bindings/modules/v8/V8VRDevice.h | 463449404ccd8953a2906b5b23b143aa23688fa0 | [
"Apache-2.0"
] | permissive | cool2528/miniblink49 | d909e39012f2c5d8ab658dc2a8b314ad0050d8ea | 7f646289d8074f098cf1244adc87b95e34ab87a8 | refs/heads/master | 2020-06-05T03:18:43.211372 | 2019-06-01T08:57:37 | 2019-06-01T08:59:56 | 192,294,645 | 2 | 0 | Apache-2.0 | 2019-06-17T07:16:28 | 2019-06-17T07:16:27 | null | UTF-8 | C++ | false | false | 1,986 | h | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
#ifndef V8VRDevice_h
#define V8VRDevice_h
#include "bindings/core/v8/ScriptWrappable.h"
#include "bindings/core/v8/ToV8.h"
#include "bindings/core/v8/V8Binding.h"
#include "bindings/core/v8/V8DOMWrapper.h"
#include "bindings/core/v8/WrapperTypeInfo.h"
#include "modules/ModulesExport.h"
#include "modules/vr/VRDevice.h"
#include "platform/heap/Handle.h"
namespace blink {
class V8VRDevice {
public:
MODULES_EXPORT static bool hasInstance(v8::Local<v8::Value>, v8::Isolate*);
static v8::Local<v8::Object> findInstanceInPrototypeChain(v8::Local<v8::Value>, v8::Isolate*);
MODULES_EXPORT static v8::Local<v8::FunctionTemplate> domTemplate(v8::Isolate*);
static VRDevice* toImpl(v8::Local<v8::Object> object)
{
return toScriptWrappable(object)->toImpl<VRDevice>();
}
MODULES_EXPORT static VRDevice* toImplWithTypeCheck(v8::Isolate*, v8::Local<v8::Value>);
MODULES_EXPORT static const WrapperTypeInfo wrapperTypeInfo;
static void refObject(ScriptWrappable*);
static void derefObject(ScriptWrappable*);
template<typename VisitorDispatcher>
static void trace(VisitorDispatcher visitor, ScriptWrappable* scriptWrappable)
{
visitor->trace(scriptWrappable->toImpl<VRDevice>());
}
static const int internalFieldCount = v8DefaultWrapperInternalFieldCount + 0;
static void installConditionallyEnabledProperties(v8::Local<v8::Object>, v8::Isolate*) { }
static void preparePrototypeObject(v8::Isolate*, v8::Local<v8::Object> prototypeObject, v8::Local<v8::FunctionTemplate> interfaceTemplate) { }
};
template <>
struct V8TypeOf<VRDevice> {
typedef V8VRDevice Type;
};
} // namespace blink
#endif // V8VRDevice_h
| [
"[email protected]"
] | |
ac0f88f1145be06cd9983750682a0be1b368731e | 1baa341b32f689f73fc2661ec30d35b231b02cda | /test/GlobalFXCMConnection.h | f32bc629846531d1a6c0f3a320ed14dfc0c58835 | [] | no_license | JoeButler99/PyFXCM | 901f17bf3780ccfbcaf44bee2d7d0da3848ad75b | 1cf828162d2e15576fceb8acf7f876bb640fb1e1 | refs/heads/master | 2019-01-19T12:10:34.399252 | 2014-12-29T14:40:04 | 2014-12-29T14:40:04 | 27,457,654 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 754 | h | /*
* GlobalFXCMConnection.h
*
* Created on: 5 Dec 2014
* Author: joe
*/
#ifndef GLOBALFXCMCONNECTION_H_
#define GLOBALFXCMCONNECTION_H_
#include <stddef.h> // defines NULL
#include "../src/YamlConfigLoader.h"
#include "../src/SessionHandler.h"
class GlobalFXCMConnection {
public:
static GlobalFXCMConnection* Instance();
SessionHandler* getSessionHandler();
private:
GlobalFXCMConnection() : mSessionHandler(0), mLoginParams(0) {};
GlobalFXCMConnection(GlobalFXCMConnection const&) : mSessionHandler(0), mLoginParams(0) {};
GlobalFXCMConnection& operator=(GlobalFXCMConnection const&);
static GlobalFXCMConnection * instance;
SessionHandler * mSessionHandler;
LoginParams * mLoginParams;
};
#endif /* GLOBALFXCMCONNECTION_H_ */
| [
"[email protected]"
] | |
e910233487d06a9705e0bddf5edc2ff4f4e5025f | 50b7980236b960b133c91c6d653fb334d904252c | /SDK/BP_MonkCutMale02_classes.h | 72fc4d160300ae8b1d9c0c8991ecf783bbd786ca | [] | no_license | wyverns1/mordhau_sdk | c5fa2978203f6c3d405a011c06c39274f52549d1 | 43693f2102efc684c1d27fb5b4a0abfa67c1f596 | refs/heads/master | 2020-06-04T00:55:40.096978 | 2019-06-13T17:12:36 | 2019-06-13T17:12:36 | 191,802,239 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 637 | h | #pragma once
// Name: MORDHAU, Version: 1.0.0
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
// Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass BP_MonkCutMale02.BP_MonkCutMale02_C
// 0x0000 (0x0070 - 0x0070)
class UBP_MonkCutMale02_C : public UCharacterHair
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass BP_MonkCutMale02.BP_MonkCutMale02_C");
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"[email protected]"
] | |
9de8dd01a6995f8b96402acc74f44f885ddcc969 | d5cb0e3a8fc1f9522954e453e238481b9406d978 | /fyp-evolutionary-art/core/clGenerator.cpp | 8416dd4050d2d8fdef87e8f211aa91dda1e6bebf | [
"MIT"
] | permissive | baccka/fyp-evolutionary-art | 831c1acf761df6d028d5a5316101b4a1828a608e | dac828e229aee4e8975c297d2021a897a30737cc | refs/heads/master | 2016-08-11T23:10:13.172034 | 2016-04-17T22:33:50 | 2016-04-17T22:33:50 | 55,785,020 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 822 | cpp | #include "clGenerator.h"
#include <iostream>
namespace core {
CLTreeGenomeImageGenerator::CLTreeGenomeImageGenerator(const TreeGenomeImageGenerationOptions &options, CLComputeProvider &clProvider) : clProvider(clProvider), options(options) {
}
cl::Image2D &CLTreeGenomeImageGenerator::getImage() {
if (image) {
return *image;
}
cl::ImageFormat format(CL_RGBA, CL_UNORM_INT8);
image.reset(new cl::Image2D(clProvider.getContext(), CL_MEM_READ_WRITE, format, options.imageWidth, options.imageHeight));
return *image;
}
void CLTreeGenomeImageGenerator::clear() {
kernelSources.clear();
}
void CLTreeGenomeImageGenerator::build() {
std::cout << "Building the program\n";
program.reset(new cl::Program(clProvider.getContext(), kernelSources));
clProvider.build(*program);
std::cout << "Program done\n";
}
}
| [
"[email protected]"
] | |
c719b747841680e09e9de71e5934de77e97294d7 | 19600b8e5bbc2c293baee39a9659d136ea3f520c | /p3/src/palindrome_prod.cc | 954233503141eab14b4ef72085217d4bd88299c1 | [] | no_license | amarleo/CYA-Practicas | 60456b599f56970c1049c0331835f8ffe968a541 | 9f00bd19a81350823ba0490b114439fa73e6274e | refs/heads/main | 2023-02-13T06:15:52.968917 | 2021-01-13T09:15:54 | 2021-01-13T09:15:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,649 | cc | /*
Copyright 2020 Alejandro Martín de León
- Práctica 3: Productos capicúa
Centro: Escuela Superior de Ingeniería y Tecnología
Asignatura: Computabilidad y Algoritmia
Año: 2020/2021
Autor: Alejandro Martín de León
Contacto: [email protected]
Fichero: palindrome_prod.cc
Este programa contiene el código fuente de la practica.
Este fichero tiene como finalidad solucionar el problema planteado
de los productos capicua.
- Compilacion:
Situandonos en el directorio de la práctica, podemos hacer uso del
programa Make. Bastaria con escribir por pantalla:
make
Ademas de esta, tenemos la opcion de compilar:
$ g++ -std=c++14 -g -Wall -o palindrome_prod palindrome_prod.cc
- Ejecución:
Una vez compilado, procedemos a ejecutar el programa de la siguiente
manera:
./palindrome [N Cifras] [*.txt]
*/
#include <iostream>
#include <cctype>
#include <fstream>
#include <cmath>
// booleano que comprueba si un numero es capicua
bool IsPalindrome(int number) {
int digit, reverse = 0, number_initial = number;
do {
digit = number % 10;
reverse = (reverse * 10) + digit;
number = number / 10;
} while (number != 0);
if (number_initial == reverse) {
return true;
} else {
return false;
}
}
// funcion manejo de fichero. Abre y vuelva en el fichero los datos
std::ofstream OutputFile(char *outfile, int i, int j, int resultado) {
std::ofstream output;
output.open(outfile, std::fstream::out | std::fstream::app);
output << i << " * " << j << " = " << resultado << "\n";
return output;
}
// funcion ayuda, imprime por pantalla el formato correcto de ejecucion del programa
void help() {
std::cout << "--- AYUDA ---\nPara ejecutar el programa es necesario pasar los siguientes argumentos" << std::endl;
std::cout << "./palindrome [NUMERO CIFRAS] [FICHERO TXT]" << std::endl;
std::cout << "- [NUMERO CIFRAS]: Número > 0 a elegir el número de cifras" << std::endl;
std::cout << "- [FICHERO TXT]: Fichero con la extención .txt, por ejemplo: fichero.txt" << std::endl;
}
// funcion errores, comprueba si se ha producido algun error en la forma de ejecutar el programa
bool ProgramErrors(int number_digits, char *outfile) {
if (number_digits < 3) {
std::cout << "ERROR: Argumentos insuficientes" << std::endl;
help();
return true;
} else if (number_digits > 3) {
std::cout << "ERROR: Se han pasado demasiados argumentos." << std::endl;
help();
return true;
} else {
if (number_digits <= 0 || isdigit(number_digits) == 1) {
std::cout << "ERROR: el número introducido es erróneo. Por favor, introduzca un número entero en el rango N > 0" << std::endl;
return true;
}
return false;
}
}
// funcion que establece el rango minimo, dependiendo del numero de digitos
int MinimumLimit(int number) {
return pow(10, number-1);
}
// funcion que establece el rango maximo, dependiendo del numero de digitos
int MaximumLimit(int number) {
return pow(10, number);
}
int main(int argc, char *argv[]) {
int number_digits = std::atoi(argv[1]);
char *outfile = argv[2];
std::remove(outfile);
if (ProgramErrors(argc, outfile) == true) {
return 1;
}
int maximum_limit = MaximumLimit(number_digits);
int minimum_limit = MinimumLimit(number_digits);
int resultado = 0;
std::ofstream output;
for (int i = minimum_limit; i < maximum_limit; i++) {
for (int j = minimum_limit; j < maximum_limit; j++) {
resultado = i * j;
if ((IsPalindrome(resultado) == true) && (i <= j)) {
output = OutputFile(outfile, i, j, resultado);
}
}
}
output.close();
return 0;
}
| [
"[email protected]"
] | |
72d4293dfeb9116d06f5dee22d4863a5b1e74784 | 6ed471f36e5188f77dc61cca24daa41496a6d4a0 | /SDK/DinoColorSetGenericFemale_parameters.h | 5fe2592b25d5c071c1ad6eeca407f19e4bd60478 | [] | no_license | zH4x-SDK/zARKSotF-SDK | 77bfaf9b4b9b6a41951ee18db88f826dd720c367 | 714730f4bb79c07d065181caf360d168761223f6 | refs/heads/main | 2023-07-16T22:33:15.140456 | 2021-08-27T13:40:06 | 2021-08-27T13:40:06 | 400,521,086 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 706 | h | #pragma once
#include "../SDK.h"
// Name: ARKSotF, Version: 178.8.0
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
// Parameters
//---------------------------------------------------------------------------
// Function DinoColorSetGenericFemale.DinoColorSetGenericFemale_C.ExecuteUbergraph_DinoColorSetGenericFemale
struct UDinoColorSetGenericFemale_C_ExecuteUbergraph_DinoColorSetGenericFemale_Params
{
int EntryPoint; // (Parm, ZeroConstructor, IsPlainOldData)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"[email protected]"
] | |
6d6d9307ef7f698e1850c1ac8169611b9450e14d | 54d639ae3675b4000ef1d87b9db26b98c5c6da0c | /StanHatesBreaks/solution.cpp | a1f69297a1930e7167bce645192d1dd3fdb1d710 | [] | no_license | ishank99/ACM-Summer-Challenge-2019 | 7960c74c0fa964ee698ffb69d174d25b0042e9d6 | 55533166fe2d46abb8d40791317e52d0d7860f47 | refs/heads/master | 2020-08-13T20:47:21.274182 | 2019-07-12T13:35:36 | 2019-07-12T13:35:36 | 215,035,336 | 0 | 0 | null | 2019-10-14T12:14:09 | 2019-10-14T12:14:09 | null | UTF-8 | C++ | false | false | 364 | cpp | #include<iostream>
#include<string>
using namespace std;
int main() {
// freopen("input_10.txt", "r", stdin);
// freopen("output_10.txt", "w", stdout);
string str;
int l;
getline(cin, str);
l = str.length();
for(int i=0; i<l; i++) {
if(str.at(i) == ' ') cout<<"\\";
else cout<<str.at(i);
}
return 0;
}
| [
"[email protected]"
] | |
73bc7898dca4b7d19e351588d387fd7554e9654d | d7170c2a8234c947432ee1cbffe2eb22db31b221 | /transmission_model/src/TransmissionRunner.cpp | 555a8541d312ade895a0a0b1c35e79ff10c96764 | [] | no_license | khanna7/BARS | c3ab28354f4bb711c7d8307486194769454c86ff | 6829f0da638c0c839c40dd6f6b84a645c62f4446 | refs/heads/master | 2023-07-06T06:33:57.160645 | 2023-06-28T23:17:24 | 2023-06-28T23:17:24 | 40,013,171 | 6 | 2 | null | 2016-05-17T17:08:43 | 2015-07-31T16:01:07 | C | UTF-8 | C++ | false | false | 1,856 | cpp | /*
* TransmissionRunner.cpp
*
* Created on: Jan 19, 2016
* Author: nick
*/
#include "TransmissionRunner.h"
#include "Person.h"
namespace TransModel {
TransmissionRunner::TransmissionRunner(float circumcision_multiplier, float condom_multiplier, float infective_insertive_multiplier,
float duration) :
circumcision_multiplier_(circumcision_multiplier), condom_multiplier_(condom_multiplier),
infective_insertive_multiplier_(infective_insertive_multiplier),
duration_(duration) {
}
TransmissionRunner::~TransmissionRunner() {
}
bool TransmissionRunner::determineInfection(PersonPtr& infector, PersonPtr& infectee, bool condom_used, int edge_type) {
float infectivity = infector->infectivity();
if (condom_used) {
infectivity *= condom_multiplier_;
}
if (infectee->isOnPrep()) {
infectivity *= (1 - infectee->prepParameters().prepEffectiveness());
}
int infectee_role = edge_type == STEADY_NETWORK_TYPE ? infectee->steady_role() : infectee->casual_role();
int infector_role = edge_type == STEADY_NETWORK_TYPE ? infector->steady_role() : infector->casual_role();
if (infectee->isCircumcised() && (infectee_role == INSERTIVE || infectee_role == VERSATILE)
&& infector_role == RECEPTIVE && !condom_used) {
infectivity *= circumcision_multiplier_;
}
if ((infector_role == INSERTIVE || infector_role == VERSATILE) && infectee_role == RECEPTIVE) {
infectivity *= infective_insertive_multiplier_;
}
return infectivity >= repast::Random::instance()->nextDouble();
}
float TransmissionRunner::durationOfInfection() {
return duration_;
}
void TransmissionRunner::infect(PersonPtr infectee, float time) {
float dur_inf = durationOfInfection();
infectee->infect(dur_inf, time);
}
} /* namespace TransModel */
| [
"[email protected]"
] | |
6c31e13026a9880ca7b1441029c7903b060a7ad9 | f17233dad5f2585e15da6c78bb34ab63058c80a4 | /src/rpcprotocol.h | 36285faa45a4c5d431e29a37ac6f2b1bba59f3ac | [
"LicenseRef-scancode-other-permissive"
] | permissive | ventual-core/vntl | 6ba7fe48da60e701786befb3e21072b7a7c56d33 | 9408f2d7ea53e7191d0d72a13ad80c6472f4f1cf | refs/heads/master | 2020-03-27T07:06:20.326264 | 2018-08-26T11:22:55 | 2018-08-26T11:22:55 | 145,736,814 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,569 | h | // Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_RPCPROTOCOL_H
#define BITCOIN_RPCPROTOCOL_H
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>
#include <list>
#include <map>
#include <stdint.h>
#include <string>
#include "json/json_spirit_reader_template.h"
#include "json/json_spirit_utils.h"
#include "json/json_spirit_writer_template.h"
//! HTTP status codes
enum HTTPStatusCode {
HTTP_OK = 200,
HTTP_BAD_REQUEST = 400,
HTTP_UNAUTHORIZED = 401,
HTTP_FORBIDDEN = 403,
HTTP_NOT_FOUND = 404,
HTTP_INTERNAL_SERVER_ERROR = 500,
HTTP_SERVICE_UNAVAILABLE = 503,
};
//! Ventual RPC error codes
enum RPCErrorCode {
//! Standard JSON-RPC 2.0 errors
RPC_INVALID_REQUEST = -32600,
RPC_METHOD_NOT_FOUND = -32601,
RPC_INVALID_PARAMS = -32602,
RPC_INTERNAL_ERROR = -32603,
RPC_PARSE_ERROR = -32700,
//! General application defined errors
RPC_MISC_ERROR = -1, //! std::exception thrown in command handling
RPC_FORBIDDEN_BY_SAFE_MODE = -2, //! Server is in safe mode, and command is not allowed in safe mode
RPC_TYPE_ERROR = -3, //! Unexpected type was passed as parameter
RPC_INVALID_ADDRESS_OR_KEY = -5, //! Invalid address or key
RPC_OUT_OF_MEMORY = -7, //! Ran out of memory during operation
RPC_INVALID_PARAMETER = -8, //! Invalid, missing or duplicate parameter
RPC_DATABASE_ERROR = -20, //! Database error
RPC_DESERIALIZATION_ERROR = -22, //! Error parsing or validating structure in raw format
RPC_VERIFY_ERROR = -25, //! General error during transaction or block submission
RPC_VERIFY_REJECTED = -26, //! Transaction or block was rejected by network rules
RPC_VERIFY_ALREADY_IN_CHAIN = -27, //! Transaction already in chain
RPC_IN_WARMUP = -28, //! Client still warming up
//! Aliases for backward compatibility
RPC_TRANSACTION_ERROR = RPC_VERIFY_ERROR,
RPC_TRANSACTION_REJECTED = RPC_VERIFY_REJECTED,
RPC_TRANSACTION_ALREADY_IN_CHAIN = RPC_VERIFY_ALREADY_IN_CHAIN,
//! P2P client errors
RPC_CLIENT_NOT_CONNECTED = -9, //! Ventual is not connected
RPC_CLIENT_IN_INITIAL_DOWNLOAD = -10, //! Still downloading initial blocks
RPC_CLIENT_NODE_ALREADY_ADDED = -23, //! Node is already added
RPC_CLIENT_NODE_NOT_ADDED = -24, //! Node has not been added before
//! Wallet errors
RPC_WALLET_ERROR = -4, //! Unspecified problem with wallet (key not found etc.)
RPC_WALLET_INSUFFICIENT_FUNDS = -6, //! Not enough funds in wallet or account
RPC_WALLET_INVALID_ACCOUNT_NAME = -11, //! Invalid account name
RPC_WALLET_KEYPOOL_RAN_OUT = -12, //! Keypool ran out, call keypoolrefill first
RPC_WALLET_UNLOCK_NEEDED = -13, //! Enter the wallet passphrase with walletpassphrase first
RPC_WALLET_PASSVENTUALASE_INCORRECT = -14, //! The wallet passphrase entered was incorrect
RPC_WALLET_WRONG_ENC_STATE = -15, //! Command given in wrong wallet encryption state (encrypting an encrypted wallet etc.)
RPC_WALLET_ENCRYPTION_FAILED = -16, //! Failed to encrypt the wallet
RPC_WALLET_ALREADY_UNLOCKED = -17, //! Wallet is already unlocked
};
/**
* IOStream device that speaks SSL but can also speak non-SSL
*/
template <typename Protocol>
class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidirectional>
{
public:
SSLIOStreamDevice(boost::asio::ssl::stream<typename Protocol::socket>& streamIn, bool fUseSSLIn) : stream(streamIn)
{
fUseSSL = fUseSSLIn;
fNeedHandshake = fUseSSLIn;
}
void handshake(boost::asio::ssl::stream_base::handshake_type role)
{
if (!fNeedHandshake) return;
fNeedHandshake = false;
stream.handshake(role);
}
std::streamsize read(char* s, std::streamsize n)
{
handshake(boost::asio::ssl::stream_base::server); // HTTPS servers read first
if (fUseSSL) return stream.read_some(boost::asio::buffer(s, n));
return stream.next_layer().read_some(boost::asio::buffer(s, n));
}
std::streamsize write(const char* s, std::streamsize n)
{
handshake(boost::asio::ssl::stream_base::client); // HTTPS clients write first
if (fUseSSL) return boost::asio::write(stream, boost::asio::buffer(s, n));
return boost::asio::write(stream.next_layer(), boost::asio::buffer(s, n));
}
bool connect(const std::string& server, const std::string& port)
{
using namespace boost::asio::ip;
tcp::resolver resolver(stream.get_io_service());
tcp::resolver::iterator endpoint_iterator;
#if BOOST_VERSION >= 104300
try {
#endif
// The default query (flags address_configured) tries IPv6 if
// non-localhost IPv6 configured, and IPv4 if non-localhost IPv4
// configured.
tcp::resolver::query query(server.c_str(), port.c_str());
endpoint_iterator = resolver.resolve(query);
#if BOOST_VERSION >= 104300
} catch (boost::system::system_error& e) {
// If we at first don't succeed, try blanket lookup (IPv4+IPv6 independent of configured interfaces)
tcp::resolver::query query(server.c_str(), port.c_str(), resolver_query_base::flags());
endpoint_iterator = resolver.resolve(query);
}
#endif
boost::system::error_code error = boost::asio::error::host_not_found;
tcp::resolver::iterator end;
while (error && endpoint_iterator != end) {
stream.lowest_layer().close();
stream.lowest_layer().connect(*endpoint_iterator++, error);
}
if (error)
return false;
return true;
}
private:
bool fNeedHandshake;
bool fUseSSL;
boost::asio::ssl::stream<typename Protocol::socket>& stream;
};
std::string HTTPPost(const std::string& strMsg, const std::map<std::string, std::string>& mapRequestHeaders);
std::string HTTPError(int nStatus, bool keepalive, bool headerOnly = false);
std::string HTTPReplyHeader(int nStatus, bool keepalive, size_t contentLength, const char* contentType = "application/json");
std::string HTTPReply(int nStatus, const std::string& strMsg, bool keepalive, bool headerOnly = false, const char* contentType = "application/json");
bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int& proto, std::string& http_method, std::string& http_uri);
int ReadHTTPStatus(std::basic_istream<char>& stream, int& proto);
int ReadHTTPHeaders(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet);
int ReadHTTPMessage(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet, std::string& strMessageRet, int nProto, size_t max_size);
std::string JSONRPCRequest(const std::string& strMethod, const json_spirit::Array& params, const json_spirit::Value& id);
json_spirit::Object JSONRPCReplyObj(const json_spirit::Value& result, const json_spirit::Value& error, const json_spirit::Value& id);
std::string JSONRPCReply(const json_spirit::Value& result, const json_spirit::Value& error, const json_spirit::Value& id);
json_spirit::Object JSONRPCError(int code, const std::string& message);
#endif // BITCOIN_RPCPROTOCOL_H
| [
"[email protected]"
] | |
b0088e62534b8222a554cc205296c92843a73680 | 6b40e9dccf2edc767c44df3acd9b626fcd586b4d | /NT/shell/browseui/legacy/mnstatic.cpp | 14f852e1d81800aa3790889dc7f238131b19035d | [] | no_license | jjzhang166/WinNT5_src_20201004 | 712894fcf94fb82c49e5cd09d719da00740e0436 | b2db264153b80fbb91ef5fc9f57b387e223dbfc2 | refs/heads/Win2K3 | 2023-08-12T01:31:59.670176 | 2021-10-14T15:14:37 | 2021-10-14T15:14:37 | 586,134,273 | 1 | 0 | null | 2023-01-07T03:47:45 | 2023-01-07T03:47:44 | null | UTF-8 | C++ | false | false | 34,101 | cpp | #include "priv.h"
#include "sccls.h"
#include "mnstatic.h"
#include "menuband.h"
#include "itbar.h"
#include "dpastuff.h" // COrderList_*
#include "resource.h"
#include "mnbase.h"
#include "oleacc.h"
#include "apithk.h"
#include "menuisf.h"
HMENU g_hmenuStopWatch = NULL;
UINT g_idCmdStopWatch = 0;
//*** IDTTOIDM -- convert idtCmd to idmMenu
// NOTES
// as an optimization, we make the toolbar idtCmd the same as the menu idm.
// this macro (hopefully) makes things a bit clearer in the code by making
// the type conversion explicit.
#define IDTTOIDM(idtBtn) (idtBtn)
BOOL TBHasImage(HWND hwnd, int iImageIndex);
//------------------------------------------------------------------------
//
// CMenuStaticToolbar::CMenuStaticData class
//
//------------------------------------------------------------------------
CMenuStaticToolbar::CMenuStaticData::~CMenuStaticData()
{
ATOMICRELEASE(_punkSubMenu);
}
void CMenuStaticToolbar::CMenuStaticData::SetSubMenu(IUnknown* punk)
{
ATOMICRELEASE(_punkSubMenu);
_punkSubMenu = punk;
if (_punkSubMenu)
_punkSubMenu->AddRef();
}
HRESULT CMenuStaticToolbar::CMenuStaticData::GetSubMenu(const GUID* pguidService, REFIID riid, void** ppvObj)
{
if (_punkSubMenu)
{
if (pguidService)
{
return IUnknown_QueryService(_punkSubMenu, *pguidService, riid, ppvObj);
}
else
return _punkSubMenu->QueryInterface(riid, ppvObj);
}
else
return E_NOINTERFACE;
}
//------------------------------------------------------------------------
//
// CMenuStaticToolbar
//
//------------------------------------------------------------------------
CMenuStaticToolbar::CMenuStaticToolbar(CMenuBand* pmb, HMENU hmenu, HWND hwnd, UINT idCmd, DWORD dwFlags)
: CMenuToolbarBase(pmb, dwFlags)
{
_hmenu = hmenu;
_hwndMenuOwner = hwnd;
_idCmd = idCmd;
_iDragOverButton = -1;
_fDirty = TRUE;
}
CMenuStaticToolbar::~CMenuStaticToolbar()
{
if (!(_dwFlags & SMSET_DONTOWN))
{
DestroyMenu(_hmenu);
}
}
STDMETHODIMP CMenuStaticToolbar::QueryInterface(REFIID riid, void** ppvObj)
{
static const QITAB qit[] =
{
QITABENT(CMenuStaticToolbar, IDropTarget),
{ 0 },
};
// BUGBUG: If you QI MenuStatic for a drop target, you get a different
// one than if you QI MenuShellFolder. This breaks COM identity rules.
// Proper fix would be to implement a drop target that encapsulates both.
HRESULT hres = QISearch(this, qit, riid, ppvObj);
if (FAILED(hres))
hres = CMenuToolbarBase::QueryInterface(riid, ppvObj);
return hres;
}
void CMenuStaticToolbar::_CheckSeparators()
{
if (_fHasTopSep)
{
if (_pcmb->_pmtbTop->DontShowEmpty() )
{
if (!_fTopSepRemoved)
{
SendMessage(_hwndMB, TB_DELETEBUTTON, 0, 0);
_fTopSepRemoved = TRUE;
}
}
else
{
if (_fTopSepRemoved)
{
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(mii);
mii.fType = MFT_SEPARATOR;
_Insert(0, &mii);
_fTopSepRemoved = FALSE;
}
}
}
if (_fHasBottomSep)
{
if (_pcmb->_pmtbBottom->DontShowEmpty() )
{
if (!_fBottomSepRemoved)
{
SendMessage(_hwndMB, TB_DELETEBUTTON, ToolBar_ButtonCount(_hwndMB) - 1, 0);
_fBottomSepRemoved = TRUE;
}
}
else
{
if (_fBottomSepRemoved)
{
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(mii);
mii.fType = SMIT_SEPARATOR;
_Insert(-1, &mii);
_fBottomSepRemoved = FALSE;
}
}
}
}
void CMenuStaticToolbar::v_Show(BOOL fShow, BOOL fForceUpdate)
{
CMenuToolbarBase::v_Show(fShow, fForceUpdate);
_fShowMB = fShow;
if (fShow)
{
_fFirstTime = FALSE;
_fClickHandled = FALSE;
_FillToolbar();
_pcmb->SetTracked(NULL);
ToolBar_SetHotItem(_hwndMB, -1);
// Have the menubar think about changing its height
IUnknown_QueryServiceExec(_pcmb->_punkSite, SID_SMenuPopup, &CGID_MENUDESKBAR,
MBCID_SETEXPAND, (int)_pcmb->_fExpanded, NULL, NULL);
if (fForceUpdate)
v_UpdateButtons(FALSE);
#if 0
// need top level frame available for D&D if possible.
_hwndDD = GetParent(_hwndMB);
IOleWindow *pOleWindow;
HRESULT hr = IUnknown_QueryService(_pcmb->_punkSite, SID_STopLevelBrowser
, IID_IOleWindow, (void **)&pOleWindow);
if(SUCCEEDED(hr))
{
ASSERT(pOleWindow);
pOleWindow->GetWindow(&_hwndDD);
pOleWindow->Release();
}
#endif
CDelegateDropTarget::Init();
}
else
KillTimer(_hwndMB, MBTIMER_UEMTIMEOUT);
// n.b. for !fShow, we don't kill the tracked site chain. we
// count on this in startmnu.cpp!CStartMenuCallback::_OnExecItem,
// where we walk up the chain to find all hit 'nodes'. if we need
// to change this we could fire a 'pre-exec' event.
}
void CMenuStaticToolbar::_Insert(int iIndex, MENUITEMINFO* pmii)
{
CMenuStaticData* pmsd = new CMenuStaticData();
if (pmsd)
{
BYTE bTBStyle = TBSTYLE_BUTTON | TBSTYLE_DROPDOWN;
SMINFO sminfo = {0};
sminfo.dwMask = SMIM_TYPE | SMIM_FLAGS | SMIM_ICON;
// These are somethings that the callback does not fill in:
if ( pmii->hSubMenu )
sminfo.dwFlags |= SMIF_SUBMENU;
if ( pmii->fState & MFS_CHECKED)
sminfo.dwFlags |= SMIF_CHECKED;
if (pmii->fState & MFS_DISABLED || pmii->fState & MFS_GRAYED)
sminfo.dwFlags |= SMIF_DISABLED;
if ( pmii->fType & MFT_SEPARATOR)
{
sminfo.dwType = SMIT_SEPARATOR;
bTBStyle &= ~TBSTYLE_BUTTON;
bTBStyle |= TBSTYLE_SEP;
}
else
sminfo.dwType = SMIT_STRING;
if (!_fVerticalMB)
bTBStyle |= TBSTYLE_AUTOSIZE;
if (S_OK != CallCB(pmii->wID, SMC_GETINFO, 0, (LPARAM)&sminfo))
{
sminfo.iIcon = -1;
}
pmsd->_dwFlags = sminfo.dwFlags;
// Now add it to the toolbar
TBBUTTON tbb = {0};
tbb.iBitmap = sminfo.iIcon;
tbb.idCommand = pmii->wID;
tbb.dwData = (DWORD_PTR)pmsd;
tbb.fsState = (sminfo.dwFlags & SMIF_HIDDEN)?TBSTATE_HIDDEN : TBSTATE_ENABLED;
tbb.fsStyle = bTBStyle;
TCHAR szMenuString[MAX_PATH];
if (pmii->fType & MFT_OWNERDRAW)
{
// dwTypeData is user defined 32 bit value, not a string if MFT_OWNERDRAW is set
// then the (unicode) string is the very first element in a structure dwItemData
// points to
LPWSTR pwsz = (LPWSTR)pmii->dwItemData;
SHUnicodeToTChar(pwsz, szMenuString, ARRAYSIZE(szMenuString));
tbb.iString = (INT_PTR)(szMenuString);
}
else
tbb.iString = (INT_PTR)(LPTSTR)pmii->dwTypeData;
SendMessage(_hwndMB, TB_INSERTBUTTON, iIndex, (LPARAM)&tbb);
}
}
/*----------------------------------------------------------
Purpose: GetMenu method
*/
HRESULT CMenuStaticToolbar::GetMenu(HMENU* phmenu, HWND* phwnd, DWORD* pdwFlags)
{
if (phmenu)
*phmenu = _hmenu;
if (phwnd)
*phwnd = _hwndMenuOwner;
if (pdwFlags)
*pdwFlags = _dwFlags;
return NOERROR;
}
HRESULT CMenuStaticToolbar::SetMenu(HMENU hmenu, HWND hwnd, DWORD dwFlags)
{
// When we are merging in a new menu, we need to destroy the old one if we own it.
if (_hmenu && !(_dwFlags & SMSET_DONTOWN))
{
DestroyMenu(_hmenu);
}
_hmenu = hmenu;
// If we're processing a change notify, we cannot do anything that will modify state.
if (_pcmb->_pmbState &&
_pcmb->_pmbState->IsProcessingChangeNotify())
{
_fDirty = TRUE;
}
else
{
EmptyToolbar();
_pcmb->_fInSubMenu = FALSE;
IUnknown_SetSite(_pcmb->_pmpSubMenu, NULL);
ATOMICRELEASE(_pcmb->_pmpSubMenu);
if (_fShowMB)
_FillToolbar();
BOOL fSmooth = FALSE;
#ifdef CLEARTYPE // Don't use SPI_CLEARTYPE because it's defined because of APIThk, but not in NT.
SystemParametersInfo(SPI_GETCLEARTYPE, 0, &fSmooth, 0);
#endif
// This causes a paint to occur right away instead of waiting until the
// next message dispatch which could take a noticably long time.
RedrawWindow(_hwndMB, NULL, NULL, (fSmooth? RDW_ERASE: 0) | RDW_INVALIDATE | RDW_UPDATENOW);
}
return NOERROR;
}
CMenuStaticToolbar::CMenuStaticData* CMenuStaticToolbar::_IDToData(int idCmd)
{
CMenuStaticData* pmsd= NULL;
// Initialize to NULL in case the GetButtonInfo Fails. We won't fault because
// the lParam is just stack garbage.
TBBUTTONINFO tbbi = {0};
int iPos;
tbbi.cbSize = SIZEOF(tbbi);
tbbi.dwMask = TBIF_LPARAM;
iPos = ToolBar_GetButtonInfo(_hwndMB, idCmd, &tbbi);
if (iPos >= 0)
pmsd = (CMenuStaticData*)tbbi.lParam;
return pmsd;
}
HRESULT CMenuStaticToolbar::v_CreateTrackPopup(int idCmd, REFIID riid, void** ppvObj)
{
HRESULT hres = E_OUTOFMEMORY;
int iPos = (int)SendMessage(_hwndMB, TB_COMMANDTOINDEX, idCmd, 0);
if (iPos >= 0)
{
CTrackPopupBar* ptpb = new CTrackPopupBar(_pcmb->_pmbState->GetContext(), iPos, _hmenu, _hwndMenuOwner);
if (ptpb)
{
hres = ptpb->QueryInterface(riid, ppvObj);
if (SUCCEEDED(hres))
IUnknown_SetSite(SAFECAST(ptpb, IMenuPopup*), SAFECAST(_pcmb, IMenuPopup*));
PostMessage(_pcmb->_pmbState->GetSubclassedHWND(), g_nMBAutomation, (WPARAM)_hmenu, (LPARAM)iPos);
ptpb->Release();
}
}
return hres;
}
HRESULT CMenuStaticToolbar::v_GetSubMenu(int idCmd, const GUID* pguidService, REFIID riid, void** ppvObj)
{
HRESULT hres = E_FAIL;
CMenuStaticData* pmsd = _IDToData(idCmd);
ASSERT(IS_VALID_WRITE_PTR(ppvObj, void*));
*ppvObj = NULL;
if (pmsd)
{
// Get the cached submenu
hres = pmsd->GetSubMenu(pguidService, riid, ppvObj);
// Did that fail?
if (FAILED(hres) && (pmsd->_dwFlags & SMIF_SUBMENU) &&
IsEqualGUID(riid, IID_IShellMenu))
{
// Yes; ask the callback for it
hres = CallCB(idCmd, SMC_GETOBJECT, (WPARAM)&riid, (LPARAM)ppvObj);
if (S_OK != hres)
{
hres = E_OUTOFMEMORY; // Set to error case incase something happens
// Callback didn't handle it, try and see if we can get it
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_SUBMENU | MIIM_ID;
if (GetMenuItemInfoWrap(_hmenu, idCmd, MF_BYCOMMAND, &mii) && mii.hSubMenu)
{
IShellMenu* psm = (IShellMenu*)new CMenuBand();
if (psm)
{
UINT uIdAncestor = _pcmb->_uIdAncestor;
if (uIdAncestor == ANCESTORDEFAULT)
uIdAncestor = idCmd;
psm->Initialize(_pcmb->_psmcb, idCmd, uIdAncestor, SMINIT_VERTICAL);
psm->SetMenu(mii.hSubMenu, _hwndMenuOwner, SMSET_TOP | SMSET_DONTOWN);
hres = psm->QueryInterface(riid, ppvObj);
psm->Release();
}
}
}
if (*ppvObj)
{
// Cache it now
pmsd->SetSubMenu((IUnknown*)*ppvObj);
// Initialize the fonts
VARIANT Var;
Var.vt = VT_UNKNOWN;
Var.byref = SAFECAST(_pcmb->_pmbm, IUnknown*);
IUnknown_Exec((IUnknown*)*ppvObj, &CGID_MenuBand, MBANDCID_SETFONTS, 0, &Var, NULL);
// Set the CMenuBandState into the new menuband
Var.vt = VT_INT_PTR;
Var.byref = _pcmb->_pmbState;
IUnknown_Exec((IUnknown*)*ppvObj, &CGID_MenuBand, MBANDCID_SETSTATEOBJECT, 0, &Var, NULL);
}
}
}
return hres;
}
HRESULT CMenuStaticToolbar::v_GetInfoTip(int idCmd, LPTSTR psz, UINT cch)
{
return CallCB(idCmd, SMC_GETINFOTIP, (WPARAM)psz, (LPARAM)cch);
}
HRESULT CMenuStaticToolbar::v_ExecItem(int idCmd)
{
HRESULT hres = CallCB(idCmd, SMC_EXEC, 0, 0);
if (S_OK != hres && _hwndMenuOwner)
{
PostMessage(_hwndMenuOwner, WM_COMMAND, idCmd, 0);
hres = NOERROR;
}
return hres;
}
DWORD CMenuStaticToolbar::v_GetFlags(int idCmd)
{
CMenuStaticData* pmsd = _IDToData(idCmd);
// Toolbar is allowed to pass a bad command in the case of erasing the background
if (pmsd)
{
return pmsd->_dwFlags;
}
else
return 0;
}
void CMenuStaticToolbar::v_SendMenuNotification(UINT idCmd, BOOL fClear)
{
if (S_FALSE == CallCB(idCmd, SMC_SELECTITEM, (WPARAM)fClear, 0))
{
UINT uFlags = (UINT)-1;
if (v_GetFlags(idCmd) & SMIF_SUBMENU)
uFlags = MF_POPUP;
if (!fClear)
uFlags = MF_HILITE;
PostMessage(_pcmb->_pmbState->GetSubclassedHWND(), WM_MENUSELECT,
MAKEWPARAM(idCmd, uFlags), fClear? NULL : (LPARAM)_hmenu);
}
}
BOOL CMenuStaticToolbar::v_TrackingSubContextMenu()
{
return (_pcm != NULL);
}
void CMenuStaticToolbar::CreateToolbar(HWND hwndParent)
{
if (!_hwndMB)
{
_hwndMB = CreateWindowEx(WS_EX_TOOLWINDOW, TOOLBARCLASSNAME, TEXT("Menu"),
WS_VISIBLE | WS_CHILD | TBSTYLE_FLAT |
WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
CCS_NODIVIDER | CCS_NOPARENTALIGN |
CCS_NORESIZE | TBSTYLE_REGISTERDROP,
0, 0, 0, 0, hwndParent, (HMENU) 0, HINST_THISDLL, NULL);
if (!_hwndMB)
{
TraceMsg(TF_MENUBAND, "CMenuStaticToolbar::CreateToolbar: Failed to Create Toolbar");
return;
}
SendMessage(_hwndMB, TB_BUTTONSTRUCTSIZE, SIZEOF(TBBUTTON), 0);
SendMessage(_hwndMB, CCM_SETVERSION, COMCTL32_VERSION, 0);
// Set the format to ANSI or UNICODE as appropriate.
ToolBar_SetUnicodeFormat(_hwndMB, DLL_IS_UNICODE);
_SubclassWindow(_hwndMB);
_RegisterWindow(_hwndMB, NULL, SHCNE_UPDATEIMAGE);
SIZE size;
RECT rc;
SystemParametersInfoA(SPI_GETWORKAREA, SIZEOF(RECT), &rc, FALSE);
//HACKHACK: THIS WILL FORCE NO WRAP TO HAPPEN FOR PROPER WIDTH CALC WHEN PAGER IS PRESENT.
size.cx = RECTWIDTH(rc);
size.cy = 32000;
ToolBar_SetBoundingSize(_hwndMB, &size);
CMenuToolbarBase::CreateToolbar(hwndParent);
}
else if (GetParent(_hwndMB) != hwndParent)
{
::SetParent(_hwndMB, hwndParent);
}
}
STDMETHODIMP CMenuStaticToolbar::OnChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
if (SHCNE_UPDATEIMAGE == lEvent) // global
{
if (pidl1)
{
int iImage = *(int UNALIGNED *)((BYTE *)pidl1 + 2);
IEInvalidateImageList(); // We may need to use different icons.
if ( pidl2 )
{
iImage = SHHandleUpdateImage( pidl2 );
if ( iImage == -1 )
{
return E_FAIL;
}
}
if (iImage == -1 || TBHasImage(_hwndMB, iImage))
{
v_Refresh();
}
}
else
{
v_Refresh();
}
return S_OK;
}
return E_FAIL;
}
LRESULT CMenuStaticToolbar::_DefWindowProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
LRESULT lres = 0;
switch(uMessage)
{
case WM_TIMER:
if (_OnTimer(wParam))
return 1;
break;
case WM_GETOBJECT:
// Yet another poor design choice on the part of the accessibility team.
// Typically, if you do not answer a WM_* you return 0. They choose 0 as their success
// code.
return _DefWindowProcMB(hwnd, uMessage, wParam, lParam);
break;
}
return CNotifySubclassWndProc::_DefWindowProc(hwnd, uMessage, wParam, lParam);
}
//***
// NOTES
// idtCmd is currently always -1. we'll need other values when we're
// called from CallCB. however we can't do that until we fix mnfolder.cpp.
HRESULT CMenuStaticToolbar::v_GetState(int idtCmd, LPSMDATA psmd)
{
psmd->dwMask = SMDM_HMENU;
psmd->hmenu = _hmenu;
psmd->hwnd = _hwndMenuOwner;
psmd->uIdParent = _idCmd;
if (idtCmd == -1)
idtCmd = GetButtonCmd(_hwndMB, ToolBar_GetHotItem(_hwndMB));
psmd->uId = IDTTOIDM(idtCmd);
psmd->punk = SAFECAST(_pcmb, IShellMenu*);
psmd->punk->AddRef();
return S_OK;
}
HRESULT CMenuStaticToolbar::CallCB(UINT idCmd, DWORD dwMsg, WPARAM wParam, LPARAM lParam)
{
if (!_pcmb->_psmcb)
return S_FALSE;
SMDATA smd;
HRESULT hres = S_FALSE;
// todo: call v_GetState (but see comment in mnfolder.cpp)
smd.dwMask = SMDM_HMENU;
smd.hmenu = _hmenu;
smd.hwnd = _hwndMenuOwner;
smd.uIdParent = _idCmd;
smd.uIdAncestor = _pcmb->_uIdAncestor;
smd.uId = idCmd;
smd.punk = SAFECAST(_pcmb, IShellMenu*);
smd.pvUserData = _pcmb->_pvUserData;
hres = _pcmb->_psmcb->CallbackSM(&smd, dwMsg, wParam, lParam);
return hres;
}
HRESULT CMenuStaticToolbar::v_CallCBItem(int idtCmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
int idm;
idm = IDTTOIDM(idtCmd);
return CallCB(idm, uMsg, wParam, lParam);
}
void CMenuStaticToolbar::v_UpdateButtons(BOOL fNegotiateSize)
{
if (_hwndMB)
{
_SetToolbarState();
int cxMin, cxMax;
v_CalcWidth(&cxMin, &cxMax);
SendMessage(_hwndMB, TB_SETBUTTONWIDTH, 0, MAKELONG(cxMin, cxMax));
SendMessage(_hwndMB, TB_AUTOSIZE, 0, 0);
// Should we renegotiate size? AND are we vertical,
// because we cannot renegoitate when horizontal.
if (fNegotiateSize && _fVerticalMB)
NegotiateSize();
}
}
BOOL CMenuStaticToolbar::v_UpdateIconSize(UINT uIconSize, BOOL fUpdateButtons)
{
if (-1 == uIconSize)
uIconSize = _uIconSizeMB;
BOOL fChanged = (_uIconSizeMB != uIconSize);
_uIconSizeMB = uIconSize;
if (_hwndMB)
{
HIMAGELIST himl = NULL;
if (_fVerticalMB)
{
HIMAGELIST himlLarge, himlSmall;
// set the imagelist size
Shell_GetImageLists(&himlLarge, &himlSmall);
himl = (_uIconSizeMB == ISFBVIEWMODE_LARGEICONS ) ? himlLarge : himlSmall;
}
// sending a null himl is significant.. it means no image list
SendMessage(_hwndMB, TB_SETIMAGELIST, 0, (LPARAM)himl);
if (fUpdateButtons)
v_UpdateButtons(TRUE);
}
return fChanged;
}
void CMenuStaticToolbar::_OnGetDispInfo(LPNMHDR pnm, BOOL fUnicode)
{
LPNMTBDISPINFO pdi = (LPNMTBDISPINFO)pnm;
CMenuStaticData* pdata = (CMenuStaticData*)pdi->lParam;
if(pdi->dwMask & TBNF_IMAGE)
{
if (_fVerticalMB)
{
SMINFO smi;
smi.dwMask = SMIM_ICON;
if (CallCB(pdi->idCommand, SMC_GETINFO, 0, (LPARAM)&smi) == S_OK)
pdi->iImage = smi.iIcon;
else
pdi->iImage = -1;
}
else
pdi->iImage = -1;
}
if(pdi->dwMask & TBNF_TEXT)
{
if(pdi->pszText)
{
if(fUnicode)
{
pdi->pszText[0] = TEXT('\0');
}
else
{
pdi->pszText[0] = 0;
}
}
}
pdi->dwMask |= TBNF_DI_SETITEM;
return;
}
LRESULT CMenuStaticToolbar::_OnGetObject(NMOBJECTNOTIFY* pon)
{
pon->hResult = QueryInterface(*pon->piid, &pon->pObject);
return 1;
}
LRESULT CMenuStaticToolbar::_OnNotify(LPNMHDR pnm)
{
LRESULT lres = 0;
switch (pnm->code)
{
case TBN_DRAGOUT:
lres = 0;
break;
case TBN_DELETINGBUTTON:
{
if (!_fEmptyingToolbar)
{
TBNOTIFY *ptbn = (TBNOTIFY*)pnm;
CMenuStaticData* pmsd = (CMenuStaticData*)ptbn->tbButton.dwData;
if (pmsd)
delete pmsd;
}
break;
}
case NM_TOOLTIPSCREATED:
SHSetWindowBits(((NMTOOLTIPSCREATED*)pnm)->hwndToolTips, GWL_STYLE, TTS_ALWAYSTIP | TTS_TOPMOST, TTS_ALWAYSTIP | TTS_TOPMOST);
SendMessage(((NMTOOLTIPSCREATED*)pnm)->hwndToolTips, TTM_SETDELAYTIME, TTDT_AUTOPOP, (LPARAM)MAXSHORT);
break;
case NM_RCLICK:
lres = _OnContextMenu(NULL, GetMessagePos());
break;
case NM_CUSTOMDRAW:
lres = _OnCustomDraw((NMCUSTOMDRAW*)pnm);
g_hmenuStopWatch = _hmenu;
g_idCmdStopWatch = _idCmd;
break;
case TBN_GETDISPINFOA:
_OnGetDispInfo(pnm, FALSE);
break;
case TBN_GETDISPINFOW:
_OnGetDispInfo(pnm, TRUE);
break;
case TBN_GETOBJECT:
lres = _OnGetObject((NMOBJECTNOTIFY*)pnm);
break;
case TBN_MAPACCELERATOR:
lres = _OnAccelerator((NMCHAR*)pnm);
break;
default:
lres = CMenuToolbarBase::_OnNotify(pnm);
}
return(lres);
}
void CMenuStaticToolbar::_FillToolbar()
{
if (_fDirty && _hmenu && _hwndMB && !_pcmb->_fClosing)
{
EmptyToolbar();
BOOL_PTR fRedraw = SendMessage(_hwndMB, WM_SETREDRAW, FALSE, 0);
TCHAR szName[MAX_PATH];
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_SUBMENU | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
int iCount = GetMenuItemCount(_hmenu);
for (int i = 0; i < iCount; i++)
{
mii.dwTypeData = szName;
mii.cch = ARRAYSIZE(szName);
if (GetMenuItemInfoWrap(_hmenu, i, MF_BYPOSITION, &mii))
{
if (mii.fType & MFT_SEPARATOR)
{
if (i == 0)
_fHasTopSep = TRUE;
else if (i == iCount - 1)
_fHasBottomSep = TRUE;
}
_Insert(i, &mii);
}
}
if (iCount == 0)
_fEmpty = TRUE;
SendMessage(_hwndMB, WM_SETREDRAW, fRedraw, 0);
_fDirty = FALSE;
v_UpdateButtons(FALSE);
_pcmb->ResizeMenuBar();
}
}
void CMenuStaticToolbar::v_OnDeleteButton(LPVOID pData)
{
CMenuStaticData* pmsd = (CMenuStaticData*)pData;
if (pmsd)
delete pmsd;
}
void CMenuStaticToolbar::v_OnEmptyToolbar()
{
CMenuToolbarBase::v_OnEmptyToolbar();
_fDirty = TRUE;
_fHasTopSep = FALSE;
_fHasBottomSep = FALSE;
_fTopSepRemoved = FALSE;
_fBottomSepRemoved = FALSE;
}
void CMenuStaticToolbar::v_Close()
{
if (_hwndMB)
{
_UnregisterWindow(_hwndMB);
_UnsubclassWindow(_hwndMB);
}
CMenuToolbarBase::v_Close();
}
void CMenuStaticToolbar::v_Refresh()
{
EmptyToolbar();
_FillToolbar();
}
/*----------------------------------------------------------
Purpose: IWinEventHandler::IsWindowOwner method
Processes messages passed on from the menuband.
*/
STDMETHODIMP CMenuStaticToolbar::IsWindowOwner(HWND hwnd)
{
if ( hwnd == _hwndMB || hwnd == HWND_BROADCAST)
{
return S_OK;
}
else
{
return S_FALSE;
}
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::GetWindowsDDT
*/
HRESULT CMenuStaticToolbar::GetWindowsDDT (HWND * phwndLock, HWND * phwndScroll)
{
*phwndLock = _hwndMB;
*phwndScroll = _hwndMB;
return S_OK;
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::HitTestDDT
*/
HRESULT CMenuStaticToolbar::HitTestDDT (UINT nEvent, LPPOINT ppt, DWORD_PTR * pdwId, DWORD *pdwEffect)
{
switch (nEvent)
{
case HTDDT_ENTER:
// OLE is in its modal drag/drop loop, and it has the capture.
// We shouldn't take the capture back during this time.
if (!(_pcmb->_dwFlags & SMINIT_RESTRICT_DRAGDROP))
{
_pcmb->_pmbState->HasDrag(TRUE);
GetMessageFilter()->PreventCapture(TRUE);
if (_pcmb->_pmtbShellFolder &&
_pcmb->_pmtbShellFolder->DontShowEmpty())
{
DAD_ShowDragImage(FALSE);
_pcmb->_pmtbShellFolder->DontShowEmpty(FALSE);
_pcmb->ResizeMenuBar();
UpdateWindow(_hwndMB);
DAD_ShowDragImage(TRUE);
}
return S_OK;
}
else
return S_FALSE;
case HTDDT_OVER:
{
TBINSERTMARK tbim;
*pdwEffect = DROPEFFECT_NONE;
POINT pt = *ppt;
if (!ToolBar_InsertMarkHitTest(_hwndMB, &pt, &tbim))
{
int idCmd = GetButtonCmd(_hwndMB, tbim.iButton);
if (v_GetFlags(idCmd) & SMIF_DROPCASCADE &&
tbim.iButton != _iDragOverButton)
{
DAD_ShowDragImage(FALSE);
_pcmb->SetTracked(this);
_iDragOverButton = tbim.iButton;
SetTimer(_hwndMB, MBTIMER_DRAGOVER, MBTIMER_TIMEOUT, NULL);
_pcmb->_SiteOnSelect(MPOS_CHILDTRACKING);
BOOL_PTR fOldAnchor = ToolBar_SetAnchorHighlight(_hwndMB, FALSE);
ToolBar_SetHotItem(_hwndMB, _iDragOverButton);
ToolBar_SetAnchorHighlight(_hwndMB, fOldAnchor);
UpdateWindow(_hwndMB);
DAD_ShowDragImage(TRUE);
}
}
}
break;
case HTDDT_LEAVE:
// We can take the capture back anytime now
_pcmb->_pmbState->HasDrag(FALSE);
_SetTimer(MBTIMER_DRAGPOPDOWN);
GetMessageFilter()->PreventCapture(FALSE);
_iDragOverButton = -1;
#if 0
DAD_ShowDragImage(FALSE);
ToolBar_SetHotItem(_hwndMB, -1);
DAD_ShowDragImage(TRUE);
#endif
break;
}
return S_OK;
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::GetObjectDDT
*/
HRESULT CMenuStaticToolbar::GetObjectDDT (DWORD_PTR dwId, REFIID riid, LPVOID * ppvObj)
{
return E_NOTIMPL;
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::OnDropDDT
*/
HRESULT CMenuStaticToolbar::OnDropDDT (IDropTarget *pdt, IDataObject *pdtobj,
DWORD * pgrfKeyState, POINTL pt, DWORD *pdwEffect)
{
return E_NOTIMPL;
}
HRESULT CMenuStaticToolbar::v_InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
{
HRESULT hres = S_FALSE;
if (NULL == psmd)
{
if (dwFlags & SMINV_REFRESH)
{
// Refresh the whole thing
v_Refresh();
hres = TRUE;
}
}
// Are we dealing with an Hmenu?
// Have we filled it yet? (If not, then we can skip the invalidate
// here, because we'll catch it when we fill it.)
else if ((psmd->dwMask & SMDM_HMENU) && !_fDirty)
{
// Yes; What are they asking for?
int iPos = -1; // Assume this is a position
int idCmd = -1;
// Did they pass an ID instead of a position?
if (dwFlags & SMINV_ID)
{
// Yes; Crack out the position.
iPos = GetMenuPosFromID(_hmenu, psmd->uId);
idCmd = psmd->uId;
}
if (dwFlags & SMINV_POSITION)
{
iPos = psmd->uId;
idCmd = GetMenuItemID(_hmenu, iPos);
}
if (dwFlags & SMINV_REFRESH)
{
// Do they want to refresh a sepcific button?
if (idCmd >= 0)
{
// Yes;
// First delete the old one if it exists.
int iTBPos = ToolBar_CommandToIndex(_hwndMB, idCmd);
if (iTBPos >= 0)
SendMessage(_hwndMB, TB_DELETEBUTTON, iTBPos, 0);
// Now Insert a new one
MENUITEMINFO mii;
TCHAR szName[MAX_PATH];
mii.cbSize = sizeof(mii);
mii.cch = ARRAYSIZE(szName);
mii.dwTypeData = szName;
mii.fMask = MIIM_ID | MIIM_SUBMENU | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
// This can fail...
if (GetMenuItemInfoWrap(_hmenu, iPos, MF_BYPOSITION, &mii))
{
_Insert(iPos, &mii);
hres = S_OK;
}
}
else
{
// No; Refresh the whole thing
v_Refresh();
}
if (!_fShowMB)
_pcmb->_fForceButtonUpdate = TRUE;
_pcmb->ResizeMenuBar();
}
}
return hres;
}
void CMenuStaticToolbar::GetSize(SIZE* psize)
{
_CheckSeparators();
CMenuToolbarBase::GetSize(psize);
}
LRESULT CMenuStaticToolbar::_OnAccelerator(NMCHAR* pnmChar)
{
SMDATA smdOut = {0};
SMDATA smd = {0};
smd.punk = SAFECAST(_pcmb, IShellMenu*);
smd.uIdParent = _pcmb->_uId;
if (_pcmb->_psmcb &&
S_FALSE != _pcmb->_psmcb->CallbackSM(&smd, SMC_MAPACCELERATOR, (WPARAM)pnmChar->ch, (LPARAM)&smdOut))
{
pnmChar->dwItemNext = ToolBar_CommandToIndex(_hwndMB, smdOut.uId);;
return TRUE;
}
return FALSE;
}
LRESULT CMenuStaticToolbar::_OnContextMenu(WPARAM wParam, LPARAM lParam)
{
LRESULT lres = 0;
MyLockSetForegroundWindow(FALSE);
if (!(_pcmb->_dwFlags & SMINIT_RESTRICT_CONTEXTMENU))
{
RECT rc;
LPRECT prcExclude = NULL;
POINT pt;
int i;
if (lParam != (LPARAM)-1)
{
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
POINT pt2 = pt;
MapWindowPoints(HWND_DESKTOP, _hwndMB, &pt2, 1);
i = ToolBar_HitTest(_hwndMB, &pt2);
}
else
{
// keyboard context menu.
i = (int)SendMessage(_hwndMB, TB_GETHOTITEM, 0, 0);
if (i >= 0)
{
SendMessage(_hwndMB, TB_GETITEMRECT, i, (LPARAM)&rc);
MapWindowPoints(_hwndMB, HWND_DESKTOP, (LPPOINT)&rc, 2);
pt.x = rc.left;
pt.y = rc.bottom;
prcExclude = &rc;
}
}
if (i >= 0)
{
UINT idCmd = GetButtonCmd(_hwndMB, i);
if (S_OK == CallCB(idCmd, SMC_GETOBJECT, (WPARAM)(GUID*)&IID_IContextMenu, (LPARAM)(VOID**)(&_pcm)))
{
TPMPARAMS tpm;
TPMPARAMS * ptpm = NULL;
if (prcExclude)
{
tpm.cbSize = SIZEOF(tpm);
tpm.rcExclude = *((LPRECT)prcExclude);
ptpm = &tpm;
}
HMENU hmenu = CreatePopupMenu();
if (hmenu)
{
KillTimer(_hwndMB, MBTIMER_INFOTIP);
_pcmb->_pmbState->HideTooltip(FALSE);
_pcm->QueryContextMenu(hmenu, 0, 0, -1, 0);
idCmd = TrackPopupMenuEx(hmenu,
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
pt.x, pt.y, _hwndMB, ptpm);
CMINVOKECOMMANDINFO ici = {
SIZEOF(CMINVOKECOMMANDINFO),
0,
_hwndMB,
MAKEINTRESOURCEA(idCmd),
NULL, NULL,
SW_NORMAL,
};
_pcm->InvokeCommand(&ici);
DestroyMenu(hmenu);
}
ATOMICRELEASE(_pcm);
}
}
GetMessageFilter()->RetakeCapture();
}
return lres;
}
STDMETHODIMP CMenuStaticToolbar::OnWinEvent(HWND hwnd, UINT dwMsg, WPARAM wParam, LPARAM lParam, LRESULT *plres)
{
if (WM_CONTEXTMENU == dwMsg)
{
*plres = _OnContextMenu(wParam, lParam);
}
else
return CMenuToolbarBase::OnWinEvent(hwnd, dwMsg, wParam, lParam, plres);
return S_OK;
}
| [
"[email protected]"
] | |
9111efb7de0d6cfd4a3eb996a6aadd3d9f3fefbf | 52c01c8e5380603a715e45fdf8ce2f585f51e578 | /Source/FIT2097Week3/FIT2097Week3GameStateBase.cpp | 579a214375efdd5cb9bd4fe8c85f9b95b70c8e5b | [] | no_license | HeatHazeDaze/FIT2097Week3 | b9342140969751bf366f4ed125ccf35696d103b5 | a8a83b8f71b0e0fe7586a2b99206c7cf7965ec26 | refs/heads/master | 2023-04-13T04:34:48.314327 | 2020-11-11T08:39:03 | 2020-11-11T08:39:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 121 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "FIT2097Week3GameStateBase.h"
| [
"[email protected]"
] | |
862fae802d1997116b98778af997708c205a97f9 | fb7efe44f4d9f30d623f880d0eb620f3a81f0fbd | /ui/accessibility/ax_tree.cc | f8827172a6add9476e9e4516d4405a15e59d3385 | [
"BSD-3-Clause"
] | permissive | wzyy2/chromium-browser | 2644b0daf58f8b3caee8a6c09a2b448b2dfe059c | eb905f00a0f7e141e8d6c89be8fb26192a88c4b7 | refs/heads/master | 2022-11-23T20:25:08.120045 | 2018-01-16T06:41:26 | 2018-01-16T06:41:26 | 117,618,467 | 3 | 2 | BSD-3-Clause | 2022-11-20T22:03:57 | 2018-01-16T02:09:10 | null | UTF-8 | C++ | false | false | 23,364 | cc | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/accessibility/ax_tree.h"
#include <stddef.h>
#include <set>
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "ui/accessibility/ax_node.h"
#include "ui/gfx/transform.h"
namespace ui {
namespace {
std::string TreeToStringHelper(AXNode* node, int indent) {
std::string result = std::string(2 * indent, ' ');
result += node->data().ToString() + "\n";
for (int i = 0; i < node->child_count(); ++i)
result += TreeToStringHelper(node->ChildAtIndex(i), indent + 1);
return result;
}
template <typename K, typename V>
bool KeyValuePairsKeysMatch(std::vector<std::pair<K, V>> pairs1,
std::vector<std::pair<K, V>> pairs2) {
if (pairs1.size() != pairs2.size())
return false;
for (size_t i = 0; i < pairs1.size(); ++i) {
if (pairs1[i].first != pairs2[i].first)
return false;
}
return true;
}
template <typename K, typename V>
std::map<K, V> MapFromKeyValuePairs(std::vector<std::pair<K, V>> pairs) {
std::map<K, V> result;
for (size_t i = 0; i < pairs.size(); ++i)
result[pairs[i].first] = pairs[i].second;
return result;
}
// Given two vectors of <K, V> key, value pairs representing an "old" vs "new"
// state, or "before" vs "after", calls a callback function for each key that
// changed value.
template <typename K, typename V, typename F>
void CallIfAttributeValuesChanged(const std::vector<std::pair<K, V>>& pairs1,
const std::vector<std::pair<K, V>>& pairs2,
const V& empty_value,
F callback) {
// Fast path - if they both have the same keys in the same order.
if (KeyValuePairsKeysMatch(pairs1, pairs2)) {
for (size_t i = 0; i < pairs1.size(); ++i) {
if (pairs1[i].second != pairs2[i].second)
callback(pairs1[i].first, pairs1[i].second, pairs2[i].second);
}
return;
}
// Slower path - they don't have the same keys in the same order, so
// check all keys against each other, using maps to prevent this from
// becoming O(n^2) as the size grows.
auto map1 = MapFromKeyValuePairs(pairs1);
auto map2 = MapFromKeyValuePairs(pairs2);
for (size_t i = 0; i < pairs1.size(); ++i) {
const auto& new_iter = map2.find(pairs1[i].first);
if (pairs1[i].second != empty_value && new_iter == map2.end())
callback(pairs1[i].first, pairs1[i].second, empty_value);
}
for (size_t i = 0; i < pairs2.size(); ++i) {
const auto& iter = map1.find(pairs2[i].first);
if (iter == map1.end())
callback(pairs2[i].first, empty_value, pairs2[i].second);
else if (iter->second != pairs2[i].second)
callback(pairs2[i].first, iter->second, pairs2[i].second);
}
}
} // namespace
// Intermediate state to keep track of during a tree update.
struct AXTreeUpdateState {
AXTreeUpdateState() : new_root(nullptr) {}
// Returns whether this update changes |node|.
bool HasChangedNode(const AXNode* node) {
return changed_node_ids.find(node->id()) != changed_node_ids.end();
}
// Returns whether this update removes |node|.
bool HasRemovedNode(const AXNode* node) {
return removed_node_ids.find(node->id()) != removed_node_ids.end();
}
// During an update, this keeps track of all nodes that have been
// implicitly referenced as part of this update, but haven't been
// updated yet. It's an error if there are any pending nodes at the
// end of Unserialize.
std::set<AXNode*> pending_nodes;
// This is similar to above, but we store node ids here because this list gets
// generated before any nodes get created or re-used. Its purpose is to allow
// us to know what nodes will be updated so we can make more intelligent
// decisions about when to notify delegates of removals or reparenting.
std::set<int> changed_node_ids;
// Keeps track of new nodes created during this update.
std::set<AXNode*> new_nodes;
// The new root in this update, if any.
AXNode* new_root;
// Keeps track of any nodes removed. Used to identify re-parented nodes.
std::set<int> removed_node_ids;
};
AXTreeDelegate::AXTreeDelegate() {
}
AXTreeDelegate::~AXTreeDelegate() {
}
AXTree::AXTree()
: delegate_(NULL), root_(NULL) {
AXNodeData root;
root.id = -1;
AXTreeUpdate initial_state;
initial_state.root_id = -1;
initial_state.nodes.push_back(root);
CHECK(Unserialize(initial_state)) << error();
}
AXTree::AXTree(const AXTreeUpdate& initial_state)
: delegate_(NULL), root_(NULL) {
CHECK(Unserialize(initial_state)) << error();
}
AXTree::~AXTree() {
if (root_)
DestroyNodeAndSubtree(root_, nullptr);
}
void AXTree::SetDelegate(AXTreeDelegate* delegate) {
delegate_ = delegate;
}
AXNode* AXTree::GetFromId(int32_t id) const {
base::hash_map<int32_t, AXNode*>::const_iterator iter = id_map_.find(id);
return iter != id_map_.end() ? iter->second : NULL;
}
void AXTree::UpdateData(const AXTreeData& new_data) {
if (data_ == new_data)
return;
AXTreeData old_data = data_;
data_ = new_data;
if (delegate_)
delegate_->OnTreeDataChanged(this, old_data, new_data);
}
gfx::RectF AXTree::RelativeToTreeBounds(const AXNode* node,
gfx::RectF bounds,
bool* offscreen) const {
// If |bounds| is uninitialized, which is not the same as empty,
// start with the node bounds.
if (bounds.width() == 0 && bounds.height() == 0) {
bounds = node->data().location;
// If the node bounds is empty (either width or height is zero),
// try to compute good bounds from the children.
if (bounds.IsEmpty()) {
bool all_children_offscreen = true;
for (size_t i = 0; i < node->children().size(); i++) {
ui::AXNode* child = node->children()[i];
bool temp_offscreen = false;
bounds.Union(GetTreeBounds(child, &temp_offscreen));
if (!temp_offscreen)
// At least one child is on screen.
all_children_offscreen = false;
}
if (bounds.width() > 0 && bounds.height() > 0) {
// If all the children are offscreen, the node itself is offscreen.
if (offscreen != nullptr && all_children_offscreen)
*offscreen = true;
return bounds;
}
}
} else {
bounds.Offset(node->data().location.x(), node->data().location.y());
}
while (node != nullptr) {
if (node->data().transform)
node->data().transform->TransformRect(&bounds);
const AXNode* container;
// Normally we apply any transforms and offsets for each node and
// then walk up to its offset container - however, if the node has
// no width or height, walk up to its nearest ancestor until we find
// one that has bounds.
if (bounds.width() == 0 && bounds.height() == 0)
container = node->parent();
else
container = GetFromId(node->data().offset_container_id);
if (!container && container != root())
container = root();
if (!container || container == node)
break;
gfx::RectF container_bounds = container->data().location;
bounds.Offset(container_bounds.x(), container_bounds.y());
// If we don't have any size yet, take the size from this ancestor.
// The rationale is that it's not useful to the user for an object to
// have no width or height and it's probably a bug; it's better to
// reflect the bounds of the nearest ancestor rather than a 0x0 box.
if (bounds.width() == 0 && bounds.height() == 0)
bounds.set_size(container_bounds.size());
int scroll_x = 0;
int scroll_y = 0;
if (container->data().GetIntAttribute(ui::AX_ATTR_SCROLL_X, &scroll_x) &&
container->data().GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &scroll_y)) {
bounds.Offset(-scroll_x, -scroll_y);
}
node = container;
}
return bounds;
}
gfx::RectF AXTree::GetTreeBounds(const AXNode* node, bool* offscreen) const {
return RelativeToTreeBounds(node, gfx::RectF(), offscreen);
}
std::set<int32_t> AXTree::GetReverseRelations(AXIntAttribute attr,
int32_t dst_id) {
DCHECK(IsNodeIdIntAttribute(attr));
return int_reverse_relations_[attr][dst_id];
}
std::set<int32_t> AXTree::GetReverseRelations(AXIntListAttribute attr,
int32_t dst_id) {
DCHECK(IsNodeIdIntListAttribute(attr));
return intlist_reverse_relations_[attr][dst_id];
}
bool AXTree::Unserialize(const AXTreeUpdate& update) {
AXTreeUpdateState update_state;
int32_t old_root_id = root_ ? root_->id() : 0;
// First, make a note of any nodes we will touch as part of this update.
for (size_t i = 0; i < update.nodes.size(); ++i)
update_state.changed_node_ids.insert(update.nodes[i].id);
if (update.has_tree_data)
UpdateData(update.tree_data);
if (update.node_id_to_clear != 0) {
AXNode* node = GetFromId(update.node_id_to_clear);
if (!node) {
error_ = base::StringPrintf("Bad node_id_to_clear: %d",
update.node_id_to_clear);
return false;
}
if (node == root_) {
// Clear root_ before calling DestroySubtree so that root_ doesn't
// ever point to an invalid node.
AXNode* old_root = root_;
root_ = nullptr;
DestroySubtree(old_root, &update_state);
} else {
for (int i = 0; i < node->child_count(); ++i)
DestroySubtree(node->ChildAtIndex(i), &update_state);
std::vector<AXNode*> children;
node->SwapChildren(children);
update_state.pending_nodes.insert(node);
}
}
bool root_exists = GetFromId(update.root_id) != nullptr;
for (size_t i = 0; i < update.nodes.size(); ++i) {
bool is_new_root = !root_exists && update.nodes[i].id == update.root_id;
if (!UpdateNode(update.nodes[i], is_new_root, &update_state))
return false;
}
if (!root_) {
error_ = "Tree has no root.";
return false;
}
if (!update_state.pending_nodes.empty()) {
error_ = "Nodes left pending by the update:";
for (std::set<AXNode*>::iterator iter = update_state.pending_nodes.begin();
iter != update_state.pending_nodes.end(); ++iter) {
error_ += base::StringPrintf(" %d", (*iter)->id());
}
return false;
}
if (delegate_) {
std::set<AXNode*>& new_nodes = update_state.new_nodes;
std::vector<AXTreeDelegate::Change> changes;
changes.reserve(update.nodes.size());
for (size_t i = 0; i < update.nodes.size(); ++i) {
AXNode* node = GetFromId(update.nodes[i].id);
if (!node)
continue;
bool is_new_node = new_nodes.find(node) != new_nodes.end();
bool is_reparented_node =
is_new_node && update_state.HasRemovedNode(node);
AXTreeDelegate::ChangeType change = AXTreeDelegate::NODE_CHANGED;
if (is_new_node) {
if (is_reparented_node) {
// A reparented subtree is any new node whose parent either doesn't
// exist, or is not new.
bool is_subtree = !node->parent() ||
new_nodes.find(node->parent()) == new_nodes.end();
change = is_subtree ? AXTreeDelegate::SUBTREE_REPARENTED
: AXTreeDelegate::NODE_REPARENTED;
} else {
// A new subtree is any new node whose parent is either not new, or
// whose parent happens to be new only because it has been reparented.
bool is_subtree = !node->parent() ||
new_nodes.find(node->parent()) == new_nodes.end() ||
update_state.HasRemovedNode(node->parent());
change = is_subtree ? AXTreeDelegate::SUBTREE_CREATED
: AXTreeDelegate::NODE_CREATED;
}
}
changes.push_back(AXTreeDelegate::Change(node, change));
}
delegate_->OnAtomicUpdateFinished(
this, root_->id() != old_root_id, changes);
}
return true;
}
std::string AXTree::ToString() const {
return "AXTree" + data_.ToString() + "\n" + TreeToStringHelper(root_, 0);
}
AXNode* AXTree::CreateNode(AXNode* parent,
int32_t id,
int32_t index_in_parent,
AXTreeUpdateState* update_state) {
AXNode* new_node = new AXNode(parent, id, index_in_parent);
id_map_[new_node->id()] = new_node;
if (delegate_) {
if (update_state->HasChangedNode(new_node) &&
!update_state->HasRemovedNode(new_node))
delegate_->OnNodeCreated(this, new_node);
else
delegate_->OnNodeReparented(this, new_node);
}
return new_node;
}
bool AXTree::UpdateNode(const AXNodeData& src,
bool is_new_root,
AXTreeUpdateState* update_state) {
// This method updates one node in the tree based on serialized data
// received in an AXTreeUpdate. See AXTreeUpdate for pre and post
// conditions.
// Look up the node by id. If it's not found, then either the root
// of the tree is being swapped, or we're out of sync with the source
// and this is a serious error.
AXNode* node = GetFromId(src.id);
if (node) {
update_state->pending_nodes.erase(node);
if (update_state->new_nodes.find(node) == update_state->new_nodes.end())
CallNodeChangeCallbacks(node, src);
UpdateReverseRelations(node, src);
node->SetData(src);
} else {
if (!is_new_root) {
error_ = base::StringPrintf(
"%d is not in the tree and not the new root", src.id);
return false;
}
update_state->new_root = CreateNode(NULL, src.id, 0, update_state);
node = update_state->new_root;
update_state->new_nodes.insert(node);
UpdateReverseRelations(node, src);
node->SetData(src);
}
if (delegate_)
delegate_->OnNodeChanged(this, node);
// First, delete nodes that used to be children of this node but aren't
// anymore.
if (!DeleteOldChildren(node, src.child_ids, update_state)) {
// If DeleteOldChildren failed, we need to carefully clean up before
// returning false as well. In particular, if this node was a new root,
// we need to safely destroy the whole tree.
if (update_state->new_root) {
AXNode* old_root = root_;
root_ = nullptr;
DestroySubtree(old_root, update_state);
// Delete |node|'s subtree too as long as it wasn't already removed
// or added elsewhere in the tree.
if (update_state->removed_node_ids.find(src.id) ==
update_state->removed_node_ids.end() &&
update_state->new_nodes.find(node) != update_state->new_nodes.end()) {
DestroySubtree(node, update_state);
}
}
return false;
}
// Now build a new children vector, reusing nodes when possible,
// and swap it in.
std::vector<AXNode*> new_children;
bool success = CreateNewChildVector(
node, src.child_ids, &new_children, update_state);
node->SwapChildren(new_children);
// Update the root of the tree if needed.
if (is_new_root) {
// Make sure root_ always points to something valid or null_, even inside
// DestroySubtree.
AXNode* old_root = root_;
root_ = node;
if (old_root && old_root != node)
DestroySubtree(old_root, update_state);
}
return success;
}
void AXTree::CallNodeChangeCallbacks(AXNode* node, const AXNodeData& new_data) {
if (!delegate_)
return;
const AXNodeData& old_data = node->data();
delegate_->OnNodeDataWillChange(this, old_data, new_data);
if (old_data.role != new_data.role)
delegate_->OnRoleChanged(this, node, old_data.role, new_data.role);
if (old_data.state != new_data.state) {
for (int i = AX_STATE_NONE + 1; i <= AX_STATE_LAST; ++i) {
AXState state = static_cast<AXState>(i);
if (old_data.HasState(state) != new_data.HasState(state))
delegate_->OnStateChanged(this, node, state, new_data.HasState(state));
}
}
auto string_callback = [this, node](AXStringAttribute attr,
const std::string& old_string,
const std::string& new_string) {
delegate_->OnStringAttributeChanged(this, node, attr, old_string,
new_string);
};
CallIfAttributeValuesChanged(old_data.string_attributes,
new_data.string_attributes, std::string(),
string_callback);
auto bool_callback = [this, node](AXBoolAttribute attr, const bool& old_bool,
const bool& new_bool) {
delegate_->OnBoolAttributeChanged(this, node, attr, new_bool);
};
CallIfAttributeValuesChanged(old_data.bool_attributes,
new_data.bool_attributes, false, bool_callback);
auto float_callback = [this, node](AXFloatAttribute attr,
const float& old_float,
const float& new_float) {
delegate_->OnFloatAttributeChanged(this, node, attr, old_float, new_float);
};
CallIfAttributeValuesChanged(old_data.float_attributes,
new_data.float_attributes, 0.0f, float_callback);
auto int_callback = [this, node](AXIntAttribute attr, const int& old_int,
const int& new_int) {
delegate_->OnIntAttributeChanged(this, node, attr, old_int, new_int);
};
CallIfAttributeValuesChanged(old_data.int_attributes, new_data.int_attributes,
0, int_callback);
auto intlist_callback = [this, node](
AXIntListAttribute attr,
const std::vector<int32_t>& old_intlist,
const std::vector<int32_t>& new_intlist) {
delegate_->OnIntListAttributeChanged(this, node, attr, old_intlist,
new_intlist);
};
CallIfAttributeValuesChanged(old_data.intlist_attributes,
new_data.intlist_attributes,
std::vector<int32_t>(), intlist_callback);
auto stringlist_callback =
[this, node](AXStringListAttribute attr,
const std::vector<std::string>& old_stringlist,
const std::vector<std::string>& new_stringlist) {
delegate_->OnStringListAttributeChanged(this, node, attr,
old_stringlist, new_stringlist);
};
CallIfAttributeValuesChanged(old_data.stringlist_attributes,
new_data.stringlist_attributes,
std::vector<std::string>(), stringlist_callback);
}
void AXTree::UpdateReverseRelations(AXNode* node, const AXNodeData& new_data) {
const AXNodeData& old_data = node->data();
int id = new_data.id;
auto int_callback = [this, node, id](AXIntAttribute attr, const int& old_int,
const int& new_int) {
if (!IsNodeIdIntAttribute(attr))
return;
int_reverse_relations_[attr][old_int].erase(id);
int_reverse_relations_[attr][new_int].insert(id);
};
CallIfAttributeValuesChanged(old_data.int_attributes, new_data.int_attributes,
0, int_callback);
auto intlist_callback = [this, node, id](
AXIntListAttribute attr,
const std::vector<int32_t>& old_intlist,
const std::vector<int32_t>& new_intlist) {
if (!IsNodeIdIntListAttribute(attr))
return;
for (int32_t old_id : old_intlist)
intlist_reverse_relations_[attr][old_id].erase(id);
for (int32_t new_id : new_intlist)
intlist_reverse_relations_[attr][new_id].insert(id);
};
CallIfAttributeValuesChanged(old_data.intlist_attributes,
new_data.intlist_attributes,
std::vector<int32_t>(), intlist_callback);
}
void AXTree::DestroySubtree(AXNode* node,
AXTreeUpdateState* update_state) {
DCHECK(update_state);
if (delegate_) {
if (!update_state->HasChangedNode(node))
delegate_->OnSubtreeWillBeDeleted(this, node);
else
delegate_->OnSubtreeWillBeReparented(this, node);
}
DestroyNodeAndSubtree(node, update_state);
}
void AXTree::DestroyNodeAndSubtree(AXNode* node,
AXTreeUpdateState* update_state) {
if (delegate_) {
if (!update_state || !update_state->HasChangedNode(node))
delegate_->OnNodeWillBeDeleted(this, node);
else
delegate_->OnNodeWillBeReparented(this, node);
}
id_map_.erase(node->id());
for (int i = 0; i < node->child_count(); ++i)
DestroyNodeAndSubtree(node->ChildAtIndex(i), update_state);
if (update_state) {
update_state->pending_nodes.erase(node);
update_state->removed_node_ids.insert(node->id());
}
node->Destroy();
}
bool AXTree::DeleteOldChildren(AXNode* node,
const std::vector<int32_t>& new_child_ids,
AXTreeUpdateState* update_state) {
// Create a set of child ids in |src| for fast lookup, and return false
// if a duplicate is found;
std::set<int32_t> new_child_id_set;
for (size_t i = 0; i < new_child_ids.size(); ++i) {
if (new_child_id_set.find(new_child_ids[i]) != new_child_id_set.end()) {
error_ = base::StringPrintf("Node %d has duplicate child id %d",
node->id(), new_child_ids[i]);
return false;
}
new_child_id_set.insert(new_child_ids[i]);
}
// Delete the old children.
const std::vector<AXNode*>& old_children = node->children();
for (size_t i = 0; i < old_children.size(); ++i) {
int old_id = old_children[i]->id();
if (new_child_id_set.find(old_id) == new_child_id_set.end())
DestroySubtree(old_children[i], update_state);
}
return true;
}
bool AXTree::CreateNewChildVector(AXNode* node,
const std::vector<int32_t>& new_child_ids,
std::vector<AXNode*>* new_children,
AXTreeUpdateState* update_state) {
bool success = true;
for (size_t i = 0; i < new_child_ids.size(); ++i) {
int32_t child_id = new_child_ids[i];
int32_t index_in_parent = static_cast<int32_t>(i);
AXNode* child = GetFromId(child_id);
if (child) {
if (child->parent() != node) {
// This is a serious error - nodes should never be reparented.
// If this case occurs, continue so this node isn't left in an
// inconsistent state, but return failure at the end.
error_ = base::StringPrintf(
"Node %d reparented from %d to %d",
child->id(),
child->parent() ? child->parent()->id() : 0,
node->id());
success = false;
continue;
}
child->SetIndexInParent(index_in_parent);
} else {
child = CreateNode(node, child_id, index_in_parent, update_state);
update_state->pending_nodes.insert(child);
update_state->new_nodes.insert(child);
}
new_children->push_back(child);
}
return success;
}
} // namespace ui
| [
"[email protected]"
] | |
1656fbc6b73f0f864a2f1dbea9e6d4ee6f3b5598 | 7cd6706dac37c2a898a565b4dadacf369590e2f0 | /src/base58.h | 13b84f0cc39aa75a8ed68251a0445e442fd1a241 | [
"MIT"
] | permissive | occoin/OfferlibationCoin | be6c5d4992ad4a8988c4f488c895a6c5783f0acd | edd5baf7116f818b273219d69facbebbe1a05f1f | refs/heads/master | 2021-01-10T05:48:26.588869 | 2016-04-04T14:14:58 | 2016-04-04T14:14:58 | 55,416,891 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 13,122 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
//
// Why base-58 instead of standard base-64 encoding?
// - Don't want 0OIl characters that look the same in some fonts and
// could be used to create visually identical looking account numbers.
// - A string with non-alphanumeric characters is not as easily accepted as an account number.
// - E-mail usually won't line-break if there's no punctuation to break at.
// - Double-clicking selects the whole number as one word if it's all alphanumeric.
//
#ifndef BITCOIN_BASE58_H
#define BITCOIN_BASE58_H
#include <string>
#include <vector>
#include "bignum.h"
#include "key.h"
#include "script.h"
static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
// Encode a byte sequence as a base58-encoded string
inline std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
{
CAutoBN_CTX pctx;
CBigNum bn58 = 58;
CBigNum bn0 = 0;
// Convert big endian data to little endian
// Extra zero at the end make sure bignum will interpret as a positive number
std::vector<unsigned char> vchTmp(pend-pbegin+1, 0);
reverse_copy(pbegin, pend, vchTmp.begin());
// Convert little endian data to bignum
CBigNum bn;
bn.setvch(vchTmp);
// Convert bignum to std::string
std::string str;
// Expected size increase from base58 conversion is approximately 137%
// use 138% to be safe
str.reserve((pend - pbegin) * 138 / 100 + 1);
CBigNum dv;
CBigNum rem;
while (bn > bn0)
{
if (!BN_div(&dv, &rem, &bn, &bn58, pctx))
throw bignum_error("EncodeBase58 : BN_div failed");
bn = dv;
unsigned int c = rem.getulong();
str += pszBase58[c];
}
// Leading zeroes encoded as base58 zeros
for (const unsigned char* p = pbegin; p < pend && *p == 0; p++)
str += pszBase58[0];
// Convert little endian std::string to big endian
reverse(str.begin(), str.end());
return str;
}
// Encode a byte vector as a base58-encoded string
inline std::string EncodeBase58(const std::vector<unsigned char>& vch)
{
return EncodeBase58(&vch[0], &vch[0] + vch.size());
}
// Decode a base58-encoded string psz into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58(const char* psz, std::vector<unsigned char>& vchRet)
{
CAutoBN_CTX pctx;
vchRet.clear();
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
while (isspace(*psz))
psz++;
// Convert big endian string to bignum
for (const char* p = psz; *p; p++)
{
const char* p1 = strchr(pszBase58, *p);
if (p1 == NULL)
{
while (isspace(*p))
p++;
if (*p != '\0')
return false;
break;
}
bnChar.setulong(p1 - pszBase58);
if (!BN_mul(&bn, &bn, &bn58, pctx))
throw bignum_error("DecodeBase58 : BN_mul failed");
bn += bnChar;
}
// Get bignum as little endian data
std::vector<unsigned char> vchTmp = bn.getvch();
// Trim off sign byte if present
if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
vchTmp.erase(vchTmp.end()-1);
// Restore leading zeros
int nLeadingZeros = 0;
for (const char* p = psz; *p == pszBase58[0]; p++)
nLeadingZeros++;
vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
// Convert little endian data to big endian
reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
return true;
}
// Decode a base58-encoded string str into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58(str.c_str(), vchRet);
}
// Encode a byte vector to a base58-encoded string, including checksum
inline std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
{
// add 4-byte hash check to the end
std::vector<unsigned char> vch(vchIn);
uint256 hash = Hash(vch.begin(), vch.end());
vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
return EncodeBase58(vch);
}
// Decode a base58-encoded string psz that includes a checksum, into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
{
if (!DecodeBase58(psz, vchRet))
return false;
if (vchRet.size() < 4)
{
vchRet.clear();
return false;
}
uint256 hash = Hash(vchRet.begin(), vchRet.end()-4);
if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
{
vchRet.clear();
return false;
}
vchRet.resize(vchRet.size()-4);
return true;
}
// Decode a base58-encoded string str that includes a checksum, into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58Check(str.c_str(), vchRet);
}
/** Base class for all base58-encoded data */
class CBase58Data
{
protected:
// the version byte
unsigned char nVersion;
// the actually encoded data
std::vector<unsigned char> vchData;
CBase58Data()
{
nVersion = 0;
vchData.clear();
}
~CBase58Data()
{
// zero the memory, as it may contain sensitive data
if (!vchData.empty())
memset(&vchData[0], 0, vchData.size());
}
void SetData(int nVersionIn, const void* pdata, size_t nSize)
{
nVersion = nVersionIn;
vchData.resize(nSize);
if (!vchData.empty())
memcpy(&vchData[0], pdata, nSize);
}
void SetData(int nVersionIn, const unsigned char *pbegin, const unsigned char *pend)
{
SetData(nVersionIn, (void*)pbegin, pend - pbegin);
}
public:
bool SetString(const char* psz)
{
std::vector<unsigned char> vchTemp;
DecodeBase58Check(psz, vchTemp);
if (vchTemp.empty())
{
vchData.clear();
nVersion = 0;
return false;
}
nVersion = vchTemp[0];
vchData.resize(vchTemp.size() - 1);
if (!vchData.empty())
memcpy(&vchData[0], &vchTemp[1], vchData.size());
memset(&vchTemp[0], 0, vchTemp.size());
return true;
}
bool SetString(const std::string& str)
{
return SetString(str.c_str());
}
std::string ToString() const
{
std::vector<unsigned char> vch(1, nVersion);
vch.insert(vch.end(), vchData.begin(), vchData.end());
return EncodeBase58Check(vch);
}
int CompareTo(const CBase58Data& b58) const
{
if (nVersion < b58.nVersion) return -1;
if (nVersion > b58.nVersion) return 1;
if (vchData < b58.vchData) return -1;
if (vchData > b58.vchData) return 1;
return 0;
}
bool operator==(const CBase58Data& b58) const { return CompareTo(b58) == 0; }
bool operator<=(const CBase58Data& b58) const { return CompareTo(b58) <= 0; }
bool operator>=(const CBase58Data& b58) const { return CompareTo(b58) >= 0; }
bool operator< (const CBase58Data& b58) const { return CompareTo(b58) < 0; }
bool operator> (const CBase58Data& b58) const { return CompareTo(b58) > 0; }
};
/** base58-encoded Bitcoin addresses.
* Public-key-hash-addresses have version 0 (or 111 testnet).
* The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key.
* Script-hash-addresses have version 5 (or 196 testnet).
* The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
*/
class CBitcoinAddress;
class CBitcoinAddressVisitor : public boost::static_visitor<bool>
{
private:
CBitcoinAddress *addr;
public:
CBitcoinAddressVisitor(CBitcoinAddress *addrIn) : addr(addrIn) { }
bool operator()(const CKeyID &id) const;
bool operator()(const CScriptID &id) const;
bool operator()(const CNoDestination &no) const;
};
class CBitcoinAddress : public CBase58Data
{
public:
enum
{
PUBKEY_ADDRESS = 115, // OfferlibationCoin: address begin with 'o'
SCRIPT_ADDRESS = 110,
PUBKEY_ADDRESS_TEST = 111,
SCRIPT_ADDRESS_TEST = 196,
};
bool Set(const CKeyID &id) {
SetData(fTestNet ? PUBKEY_ADDRESS_TEST : PUBKEY_ADDRESS, &id, 20);
return true;
}
bool Set(const CScriptID &id) {
SetData(fTestNet ? SCRIPT_ADDRESS_TEST : SCRIPT_ADDRESS, &id, 20);
return true;
}
bool Set(const CTxDestination &dest)
{
return boost::apply_visitor(CBitcoinAddressVisitor(this), dest);
}
bool IsValid() const
{
unsigned int nExpectedSize = 20;
bool fExpectTestNet = false;
switch(nVersion)
{
case PUBKEY_ADDRESS:
nExpectedSize = 20; // Hash of public key
fExpectTestNet = false;
break;
case SCRIPT_ADDRESS:
nExpectedSize = 20; // Hash of CScript
fExpectTestNet = false;
break;
case PUBKEY_ADDRESS_TEST:
nExpectedSize = 20;
fExpectTestNet = true;
break;
case SCRIPT_ADDRESS_TEST:
nExpectedSize = 20;
fExpectTestNet = true;
break;
default:
return false;
}
return fExpectTestNet == fTestNet && vchData.size() == nExpectedSize;
}
CBitcoinAddress()
{
}
CBitcoinAddress(const CTxDestination &dest)
{
Set(dest);
}
CBitcoinAddress(const std::string& strAddress)
{
SetString(strAddress);
}
CBitcoinAddress(const char* pszAddress)
{
SetString(pszAddress);
}
CTxDestination Get() const {
if (!IsValid())
return CNoDestination();
switch (nVersion) {
case PUBKEY_ADDRESS:
case PUBKEY_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
return CKeyID(id);
}
case SCRIPT_ADDRESS:
case SCRIPT_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
return CScriptID(id);
}
}
return CNoDestination();
}
bool GetKeyID(CKeyID &keyID) const {
if (!IsValid())
return false;
switch (nVersion) {
case PUBKEY_ADDRESS:
case PUBKEY_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
keyID = CKeyID(id);
return true;
}
default: return false;
}
}
bool IsScript() const {
if (!IsValid())
return false;
switch (nVersion) {
case SCRIPT_ADDRESS:
case SCRIPT_ADDRESS_TEST: {
return true;
}
default: return false;
}
}
};
bool inline CBitcoinAddressVisitor::operator()(const CKeyID &id) const { return addr->Set(id); }
bool inline CBitcoinAddressVisitor::operator()(const CScriptID &id) const { return addr->Set(id); }
bool inline CBitcoinAddressVisitor::operator()(const CNoDestination &id) const { return false; }
/** A base58-encoded secret key */
class CBitcoinSecret : public CBase58Data
{
public:
void SetSecret(const CSecret& vchSecret, bool fCompressed)
{
assert(vchSecret.size() == 32);
SetData(128 + (fTestNet ? CBitcoinAddress::PUBKEY_ADDRESS_TEST : CBitcoinAddress::PUBKEY_ADDRESS), &vchSecret[0], vchSecret.size());
if (fCompressed)
vchData.push_back(1);
}
CSecret GetSecret(bool &fCompressedOut)
{
CSecret vchSecret;
vchSecret.resize(32);
memcpy(&vchSecret[0], &vchData[0], 32);
fCompressedOut = vchData.size() == 33;
return vchSecret;
}
bool IsValid() const
{
bool fExpectTestNet = false;
switch(nVersion)
{
case (128 + CBitcoinAddress::PUBKEY_ADDRESS):
break;
case (128 + CBitcoinAddress::PUBKEY_ADDRESS_TEST):
fExpectTestNet = true;
break;
default:
return false;
}
return fExpectTestNet == fTestNet && (vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1));
}
bool SetString(const char* pszSecret)
{
return CBase58Data::SetString(pszSecret) && IsValid();
}
bool SetString(const std::string& strSecret)
{
return SetString(strSecret.c_str());
}
CBitcoinSecret(const CSecret& vchSecret, bool fCompressed)
{
SetSecret(vchSecret, fCompressed);
}
CBitcoinSecret()
{
}
};
#endif
| [
"[email protected]"
] | |
b523aa35008567257d93fd3fc4ab9d54d3efc632 | 3e2ad41e5a69e0c768d1927f5876b228317e29a9 | /Encoder/2-Encoder-Uno__7_9__2_3_/2-Encoder-Uno__7_9__2_3_.ino | 306c98d3c35b6d7cb15b848d101a26cb59ee9b72 | [] | no_license | kshitizrai/Arduino | 41ae708cbfe73c27d7592fbafc005279099551b4 | ad61b009b504fb864e1e53523ef6bab893ea539d | refs/heads/master | 2020-03-18T17:36:00.581324 | 2018-05-27T11:09:41 | 2018-05-27T11:09:41 | 135,038,188 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,712 | ino | const int enc1A = 7;
const int enc1B = 9;
const int enc2A = 2 ;
const int enc2B = 3 ;
int pos1 = 0;
int ppr = 20000 ;
int lastpos1 = -5;
int newpos1 = 0;
int pos2 = 0;;
int lastpos2 = -5;
int newpos2 = 0;
void setup() {
// put your setup code here, to run once:
cli();
PCICR |= 0b00000101 ; // PortD and PortB
PCMSK0 |= 1 << PB1 ; //Pin 9;
PCMSK2 |= 1 << PD7 ; //Pin 7;
sei();
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(enc2A) , changeA , CHANGE);
attachInterrupt(digitalPinToInterrupt(enc2B) , changeB , CHANGE);
}
void changeA()
{
if(digitalRead(enc2B) == HIGH)
{
if(digitalRead(enc2A) == LOW)
pos2++;
else
pos2--;
}
else
{
if(digitalRead(enc2A) == HIGH)
pos2++;
else
pos2--;
}
}
void changeB()
{
if(digitalRead(enc2B) == HIGH)
{
if(digitalRead(enc2A) == HIGH)
pos2++;
else
pos2--;
}
else
{
if(digitalRead(enc2A) == LOW)
pos2++;
else
pos2--;
}
}
ISR(PCINT0_vect)
{
if(digitalRead(enc1B) == HIGH)
{
if(digitalRead(enc1A) == LOW)
pos1++;
else
pos1--;
}
else
{
if(digitalRead(enc1A) == HIGH)
pos1++;
else
pos1--;
}
}
ISR (PCINT2_vect)
{
if(digitalRead(enc1B) == HIGH)
{
if(digitalRead(enc1A) == HIGH)
pos1++;
else
pos1--;
}
else
{
if(digitalRead(enc1A) == LOW)
pos1++;
else
pos1--;
}
}
void loop() {
// put your main code here, to run repeatedly:
newpos1 = pos1;
if(newpos1!=lastpos1)
{
Serial.print("Pos1=");
Serial.println(pos1);
}
lastpos1=newpos1;
newpos2 = pos2;
if(newpos2!=lastpos2)
{
//Serial.print("Pos=");
//Serial.println(pos2);
}
lastpos2=newpos2;
}
| [
"[email protected]"
] | |
fec943d1086068b6a792355908636652b9217157 | 8080043688d572479a94a68b76af83cb29b4ffea | /hello_SMG.cpp | ae3ab22ee9be51808af2229c4c3d84b4638d1758 | [] | no_license | MarySam01/PMI2 | 7596b4e15671401e13a2a5106be3fa4a233aa9c5 | dd9e4c5a6742ce8b7b8a7c1f6f531b0f4f5235c3 | refs/heads/main | 2023-02-17T09:14:00.201495 | 2021-01-17T04:54:56 | 2021-01-17T04:54:56 | 330,165,709 | 0 | 0 | null | 2021-01-16T15:48:14 | 2021-01-16T13:12:35 | C++ | UTF-8 | C++ | false | false | 141 | cpp | #include <iostream>
#include "fio.h"
#include <string>
using namespace std;
string print_SMG()
{
return "Samoylova Marya Gennadievna";
} | [
"[email protected]"
] | |
bc8957a24e7bcd0d0a66a980d14b9bc28340babb | c702357d201235f5a76deb90133dbc3a13c64736 | /llvm/tools/clang/include/clang/AST/.svn/text-base/ASTContext.h.svn-base | 3fc5aabde32c75cffaab8a2c00c91333d0fce10d | [
"NCSA"
] | permissive | aaasz/SHP | ab77e5be297c2e23a462c385b9e7332e38765a14 | c03ee7a26a93b2396b7c4f9179b1b2deb81951d3 | refs/heads/master | 2021-01-18T11:00:14.367480 | 2010-01-17T23:10:18 | 2010-01-17T23:10:18 | 549,107 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 52,486 | //===--- ASTContext.h - Context to hold long-lived AST nodes ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ASTContext interface.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
#define LLVM_CLANG_AST_ASTCONTEXT_H
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
#include "clang/AST/CanonicalType.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/Support/Allocator.h"
#include <vector>
namespace llvm {
struct fltSemantics;
}
namespace clang {
class FileManager;
class ASTRecordLayout;
class BlockExpr;
class Expr;
class ExternalASTSource;
class IdentifierTable;
class SelectorTable;
class SourceManager;
class TargetInfo;
// Decls
class CXXMethodDecl;
class CXXRecordDecl;
class Decl;
class FieldDecl;
class ObjCIvarDecl;
class ObjCIvarRefExpr;
class ObjCPropertyDecl;
class RecordDecl;
class TagDecl;
class TemplateTypeParmDecl;
class TranslationUnitDecl;
class TypeDecl;
class TypedefDecl;
class UsingDecl;
class UsingShadowDecl;
namespace Builtin { class Context; }
/// ASTContext - This class holds long-lived AST nodes (such as types and
/// decls) that can be referred to throughout the semantic analysis of a file.
class ASTContext {
std::vector<Type*> Types;
llvm::FoldingSet<ExtQuals> ExtQualNodes;
llvm::FoldingSet<ComplexType> ComplexTypes;
llvm::FoldingSet<PointerType> PointerTypes;
llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
llvm::FoldingSet<ConstantArrayType> ConstantArrayTypes;
llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
std::vector<VariableArrayType*> VariableArrayTypes;
llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;
llvm::FoldingSet<DependentSizedExtVectorType> DependentSizedExtVectorTypes;
llvm::FoldingSet<VectorType> VectorTypes;
llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
llvm::FoldingSet<FunctionProtoType> FunctionProtoTypes;
llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
llvm::FoldingSet<SubstTemplateTypeParmType> SubstTemplateTypeParmTypes;
llvm::FoldingSet<TemplateSpecializationType> TemplateSpecializationTypes;
llvm::FoldingSet<QualifiedNameType> QualifiedNameTypes;
llvm::FoldingSet<TypenameType> TypenameTypes;
llvm::FoldingSet<ObjCInterfaceType> ObjCInterfaceTypes;
llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
/// \brief The set of nested name specifiers.
///
/// This set is managed by the NestedNameSpecifier class.
llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
NestedNameSpecifier *GlobalNestedNameSpecifier;
friend class NestedNameSpecifier;
/// ASTRecordLayouts - A cache mapping from RecordDecls to ASTRecordLayouts.
/// This is lazily created. This is intentionally not serialized.
llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*> ASTRecordLayouts;
llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*> ObjCLayouts;
/// KeyFunctions - A cache mapping from CXXRecordDecls to key functions.
llvm::DenseMap<const CXXRecordDecl*, const CXXMethodDecl*> KeyFunctions;
/// \brief Mapping from ObjCContainers to their ObjCImplementations.
llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;
llvm::DenseMap<unsigned, FixedWidthIntType*> SignedFixedWidthIntTypes;
llvm::DenseMap<unsigned, FixedWidthIntType*> UnsignedFixedWidthIntTypes;
/// BuiltinVaListType - built-in va list type.
/// This is initially null and set by Sema::LazilyCreateBuiltin when
/// a builtin that takes a valist is encountered.
QualType BuiltinVaListType;
/// ObjCIdType - a pseudo built-in typedef type (set by Sema).
QualType ObjCIdTypedefType;
/// ObjCSelType - another pseudo built-in typedef type (set by Sema).
QualType ObjCSelTypedefType;
/// ObjCProtoType - another pseudo built-in typedef type (set by Sema).
QualType ObjCProtoType;
const RecordType *ProtoStructType;
/// ObjCClassType - another pseudo built-in typedef type (set by Sema).
QualType ObjCClassTypedefType;
QualType ObjCConstantStringType;
RecordDecl *CFConstantStringTypeDecl;
RecordDecl *ObjCFastEnumerationStateTypeDecl;
/// \brief The type for the C FILE type.
TypeDecl *FILEDecl;
/// \brief The type for the C jmp_buf type.
TypeDecl *jmp_bufDecl;
/// \brief The type for the C sigjmp_buf type.
TypeDecl *sigjmp_bufDecl;
/// \brief Type for the Block descriptor for Blocks CodeGen.
RecordDecl *BlockDescriptorType;
/// \brief Type for the Block descriptor for Blocks CodeGen.
RecordDecl *BlockDescriptorExtendedType;
/// \brief Keeps track of all declaration attributes.
///
/// Since so few decls have attrs, we keep them in a hash map instead of
/// wasting space in the Decl class.
llvm::DenseMap<const Decl*, Attr*> DeclAttrs;
/// \brief Keeps track of the static data member templates from which
/// static data members of class template specializations were instantiated.
///
/// This data structure stores the mapping from instantiations of static
/// data members to the static data member representations within the
/// class template from which they were instantiated along with the kind
/// of instantiation or specialization (a TemplateSpecializationKind - 1).
///
/// Given the following example:
///
/// \code
/// template<typename T>
/// struct X {
/// static T value;
/// };
///
/// template<typename T>
/// T X<T>::value = T(17);
///
/// int *x = &X<int>::value;
/// \endcode
///
/// This mapping will contain an entry that maps from the VarDecl for
/// X<int>::value to the corresponding VarDecl for X<T>::value (within the
/// class template X) and will be marked TSK_ImplicitInstantiation.
llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>
InstantiatedFromStaticDataMember;
/// \brief Keeps track of the declaration from which a UsingDecl was
/// created during instantiation. The source declaration is always
/// a UsingDecl, an UnresolvedUsingValueDecl, or an
/// UnresolvedUsingTypenameDecl.
///
/// For example:
/// \code
/// template<typename T>
/// struct A {
/// void f();
/// };
///
/// template<typename T>
/// struct B : A<T> {
/// using A<T>::f;
/// };
///
/// template struct B<int>;
/// \endcode
///
/// This mapping will contain an entry that maps from the UsingDecl in
/// B<int> to the UnresolvedUsingDecl in B<T>.
llvm::DenseMap<UsingDecl *, NamedDecl *> InstantiatedFromUsingDecl;
llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
InstantiatedFromUsingShadowDecl;
llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;
TranslationUnitDecl *TUDecl;
/// SourceMgr - The associated SourceManager object.
SourceManager &SourceMgr;
/// LangOpts - The language options used to create the AST associated with
/// this ASTContext object.
LangOptions LangOpts;
/// \brief Whether we have already loaded comment source ranges from an
/// external source.
bool LoadedExternalComments;
/// MallocAlloc/BumpAlloc - The allocator objects used to create AST objects.
bool FreeMemory;
llvm::MallocAllocator MallocAlloc;
llvm::BumpPtrAllocator BumpAlloc;
/// \brief Mapping from declarations to their comments, once we have
/// already looked up the comment associated with a given declaration.
llvm::DenseMap<const Decl *, std::string> DeclComments;
public:
const TargetInfo &Target;
IdentifierTable &Idents;
SelectorTable &Selectors;
Builtin::Context &BuiltinInfo;
DeclarationNameTable DeclarationNames;
llvm::OwningPtr<ExternalASTSource> ExternalSource;
clang::PrintingPolicy PrintingPolicy;
// Typedefs which may be provided defining the structure of Objective-C
// pseudo-builtins
QualType ObjCIdRedefinitionType;
QualType ObjCClassRedefinitionType;
QualType ObjCSelRedefinitionType;
/// \brief Source ranges for all of the comments in the source file,
/// sorted in order of appearance in the translation unit.
std::vector<SourceRange> Comments;
SourceManager& getSourceManager() { return SourceMgr; }
const SourceManager& getSourceManager() const { return SourceMgr; }
void *Allocate(unsigned Size, unsigned Align = 8) {
return FreeMemory ? MallocAlloc.Allocate(Size, Align) :
BumpAlloc.Allocate(Size, Align);
}
void Deallocate(void *Ptr) {
if (FreeMemory)
MallocAlloc.Deallocate(Ptr);
}
const LangOptions& getLangOptions() const { return LangOpts; }
FullSourceLoc getFullLoc(SourceLocation Loc) const {
return FullSourceLoc(Loc,SourceMgr);
}
/// \brief Retrieve the attributes for the given declaration.
Attr*& getDeclAttrs(const Decl *D) { return DeclAttrs[D]; }
/// \brief Erase the attributes corresponding to the given declaration.
void eraseDeclAttrs(const Decl *D) { DeclAttrs.erase(D); }
/// \brief If this variable is an instantiated static data member of a
/// class template specialization, returns the templated static data member
/// from which it was instantiated.
MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
const VarDecl *Var);
/// \brief Note that the static data member \p Inst is an instantiation of
/// the static data member template \p Tmpl of a class template.
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
TemplateSpecializationKind TSK);
/// \brief If the given using decl is an instantiation of a
/// (possibly unresolved) using decl from a template instantiation,
/// return it.
NamedDecl *getInstantiatedFromUsingDecl(UsingDecl *Inst);
/// \brief Remember that the using decl \p Inst is an instantiation
/// of the using decl \p Pattern of a class template.
void setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern);
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
UsingShadowDecl *Pattern);
UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);
FieldDecl *getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field);
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl);
TranslationUnitDecl *getTranslationUnitDecl() const { return TUDecl; }
const char *getCommentForDecl(const Decl *D);
// Builtin Types.
CanQualType VoidTy;
CanQualType BoolTy;
CanQualType CharTy;
CanQualType WCharTy; // [C++ 3.9.1p5], integer type in C99.
CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
CanQualType FloatTy, DoubleTy, LongDoubleTy;
CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
CanQualType VoidPtrTy, NullPtrTy;
CanQualType OverloadTy;
CanQualType DependentTy;
CanQualType UndeducedAutoTy;
CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
ASTContext(const LangOptions& LOpts, SourceManager &SM, const TargetInfo &t,
IdentifierTable &idents, SelectorTable &sels,
Builtin::Context &builtins,
bool FreeMemory = true, unsigned size_reserve=0);
~ASTContext();
/// \brief Attach an external AST source to the AST context.
///
/// The external AST source provides the ability to load parts of
/// the abstract syntax tree as needed from some external storage,
/// e.g., a precompiled header.
void setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source);
/// \brief Retrieve a pointer to the external AST source associated
/// with this AST context, if any.
ExternalASTSource *getExternalSource() const { return ExternalSource.get(); }
void PrintStats() const;
const std::vector<Type*>& getTypes() const { return Types; }
//===--------------------------------------------------------------------===//
// Type Constructors
//===--------------------------------------------------------------------===//
private:
/// getExtQualType - Return a type with extended qualifiers.
QualType getExtQualType(const Type *Base, Qualifiers Quals);
public:
/// getAddSpaceQualType - Return the uniqued reference to the type for an
/// address space qualified type with the specified type and address space.
/// The resulting type has a union of the qualifiers from T and the address
/// space. If T already has an address space specifier, it is silently
/// replaced.
QualType getAddrSpaceQualType(QualType T, unsigned AddressSpace);
/// getObjCGCQualType - Returns the uniqued reference to the type for an
/// objc gc qualified type. The retulting type has a union of the qualifiers
/// from T and the gc attribute.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr);
/// getRestrictType - Returns the uniqued reference to the type for a
/// 'restrict' qualified type. The resulting type has a union of the
/// qualifiers from T and 'restrict'.
QualType getRestrictType(QualType T) {
return T.withFastQualifiers(Qualifiers::Restrict);
}
/// getVolatileType - Returns the uniqued reference to the type for a
/// 'volatile' qualified type. The resulting type has a union of the
/// qualifiers from T and 'volatile'.
QualType getVolatileType(QualType T);
/// getConstType - Returns the uniqued reference to the type for a
/// 'const' qualified type. The resulting type has a union of the
/// qualifiers from T and 'const'.
///
/// It can be reasonably expected that this will always be
/// equivalent to calling T.withConst().
QualType getConstType(QualType T) { return T.withConst(); }
/// getNoReturnType - Add or remove the noreturn attribute to the given type
/// which must be a FunctionType or a pointer to an allowable type or a
/// BlockPointer.
QualType getNoReturnType(QualType T, bool AddNoReturn = true);
/// getComplexType - Return the uniqued reference to the type for a complex
/// number with the specified element type.
QualType getComplexType(QualType T);
CanQualType getComplexType(CanQualType T) {
return CanQualType::CreateUnsafe(getComplexType((QualType) T));
}
/// getPointerType - Return the uniqued reference to the type for a pointer to
/// the specified type.
QualType getPointerType(QualType T);
CanQualType getPointerType(CanQualType T) {
return CanQualType::CreateUnsafe(getPointerType((QualType) T));
}
/// getBlockPointerType - Return the uniqued reference to the type for a block
/// of the specified type.
QualType getBlockPointerType(QualType T);
/// This gets the struct used to keep track of the descriptor for pointer to
/// blocks.
QualType getBlockDescriptorType();
// Set the type for a Block descriptor type.
void setBlockDescriptorType(QualType T);
/// Get the BlockDescriptorType type, or NULL if it hasn't yet been built.
QualType getRawBlockdescriptorType() {
if (BlockDescriptorType)
return getTagDeclType(BlockDescriptorType);
return QualType();
}
/// This gets the struct used to keep track of the extended descriptor for
/// pointer to blocks.
QualType getBlockDescriptorExtendedType();
// Set the type for a Block descriptor extended type.
void setBlockDescriptorExtendedType(QualType T);
/// Get the BlockDescriptorExtendedType type, or NULL if it hasn't yet been
/// built.
QualType getRawBlockdescriptorExtendedType() {
if (BlockDescriptorExtendedType)
return getTagDeclType(BlockDescriptorExtendedType);
return QualType();
}
/// This gets the struct used to keep track of pointer to blocks, complete
/// with captured variables.
QualType getBlockParmType(bool BlockHasCopyDispose,
llvm::SmallVector<const Expr *, 8> &BDRDs);
/// This builds the struct used for __block variables.
QualType BuildByRefType(const char *DeclName, QualType Ty);
/// Returns true iff we need copy/dispose helpers for the given type.
bool BlockRequiresCopying(QualType Ty);
/// getLValueReferenceType - Return the uniqued reference to the type for an
/// lvalue reference to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true);
/// getRValueReferenceType - Return the uniqued reference to the type for an
/// rvalue reference to the specified type.
QualType getRValueReferenceType(QualType T);
/// getMemberPointerType - Return the uniqued reference to the type for a
/// member pointer to the specified type in the specified class. The class
/// is a Type because it could be a dependent name.
QualType getMemberPointerType(QualType T, const Type *Cls);
/// getVariableArrayType - Returns a non-unique reference to the type for a
/// variable array of the specified element type.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts,
ArrayType::ArraySizeModifier ASM,
unsigned EltTypeQuals,
SourceRange Brackets);
/// getDependentSizedArrayType - Returns a non-unique reference to
/// the type for a dependently-sized array of the specified element
/// type. FIXME: We will need these to be uniqued, or at least
/// comparable, at some point.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,
ArrayType::ArraySizeModifier ASM,
unsigned EltTypeQuals,
SourceRange Brackets);
/// getIncompleteArrayType - Returns a unique reference to the type for a
/// incomplete array of the specified element type.
QualType getIncompleteArrayType(QualType EltTy,
ArrayType::ArraySizeModifier ASM,
unsigned EltTypeQuals);
/// getConstantArrayType - Return the unique reference to the type for a
/// constant array of the specified element type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
ArrayType::ArraySizeModifier ASM,
unsigned EltTypeQuals);
/// getVectorType - Return the unique reference to a vector type of
/// the specified element type and size. VectorType must be a built-in type.
QualType getVectorType(QualType VectorType, unsigned NumElts);
/// getExtVectorType - Return the unique reference to an extended vector type
/// of the specified element type and size. VectorType must be a built-in
/// type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts);
/// getDependentSizedExtVectorType - Returns a non-unique reference to
/// the type for a dependently-sized vector of the specified element
/// type. FIXME: We will need these to be uniqued, or at least
/// comparable, at some point.
QualType getDependentSizedExtVectorType(QualType VectorType,
Expr *SizeExpr,
SourceLocation AttrLoc);
/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
///
QualType getFunctionNoProtoType(QualType ResultTy, bool NoReturn = false);
/// getFunctionType - Return a normal function type with a typed argument
/// list. isVariadic indicates whether the argument list includes '...'.
QualType getFunctionType(QualType ResultTy, const QualType *ArgArray,
unsigned NumArgs, bool isVariadic,
unsigned TypeQuals, bool hasExceptionSpec = false,
bool hasAnyExceptionSpec = false,
unsigned NumExs = 0, const QualType *ExArray = 0,
bool NoReturn = false);
/// getTypeDeclType - Return the unique reference to the type for
/// the specified type declaration.
QualType getTypeDeclType(TypeDecl *Decl, TypeDecl* PrevDecl=0);
/// getTypedefType - Return the unique reference to the type for the
/// specified typename decl.
QualType getTypedefType(TypedefDecl *Decl);
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced,
QualType Replacement);
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index,
bool ParameterPack,
IdentifierInfo *Name = 0);
QualType getTemplateSpecializationType(TemplateName T,
const TemplateArgument *Args,
unsigned NumArgs,
QualType Canon = QualType());
QualType getTemplateSpecializationType(TemplateName T,
const TemplateArgumentListInfo &Args,
QualType Canon = QualType());
QualType getQualifiedNameType(NestedNameSpecifier *NNS,
QualType NamedType);
QualType getTypenameType(NestedNameSpecifier *NNS,
const IdentifierInfo *Name,
QualType Canon = QualType());
QualType getTypenameType(NestedNameSpecifier *NNS,
const TemplateSpecializationType *TemplateId,
QualType Canon = QualType());
QualType getElaboratedType(QualType UnderlyingType,
ElaboratedType::TagKind Tag);
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
ObjCProtocolDecl **Protocols = 0,
unsigned NumProtocols = 0);
/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for the
/// given interface decl and the conforming protocol list.
QualType getObjCObjectPointerType(QualType OIT,
ObjCProtocolDecl **ProtocolList = 0,
unsigned NumProtocols = 0);
/// getTypeOfType - GCC extension.
QualType getTypeOfExprType(Expr *e);
QualType getTypeOfType(QualType t);
/// getDecltypeType - C++0x decltype.
QualType getDecltypeType(Expr *e);
/// getTagDeclType - Return the unique reference to the type for the
/// specified TagDecl (struct/union/class/enum) decl.
QualType getTagDeclType(const TagDecl *Decl);
/// getSizeType - Return the unique type for "size_t" (C99 7.17), defined
/// in <stddef.h>. The sizeof operator requires this (C99 6.5.3.4p4).
CanQualType getSizeType() const;
/// getWCharType - In C++, this returns the unique wchar_t type. In C99, this
/// returns a type compatible with the type defined in <stddef.h> as defined
/// by the target.
QualType getWCharType() const { return WCharTy; }
/// getSignedWCharType - Return the type of "signed wchar_t".
/// Used when in C++, as a GCC extension.
QualType getSignedWCharType() const;
/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
/// Used when in C++, as a GCC extension.
QualType getUnsignedWCharType() const;
/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?)
/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
QualType getPointerDiffType() const;
// getCFConstantStringType - Return the C structure type used to represent
// constant CFStrings.
QualType getCFConstantStringType();
/// Get the structure type used to representation CFStrings, or NULL
/// if it hasn't yet been built.
QualType getRawCFConstantStringType() {
if (CFConstantStringTypeDecl)
return getTagDeclType(CFConstantStringTypeDecl);
return QualType();
}
void setCFConstantStringType(QualType T);
// This setter/getter represents the ObjC type for an NSConstantString.
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl);
QualType getObjCConstantStringInterface() const {
return ObjCConstantStringType;
}
//// This gets the struct used to keep track of fast enumerations.
QualType getObjCFastEnumerationStateType();
/// Get the ObjCFastEnumerationState type, or NULL if it hasn't yet
/// been built.
QualType getRawObjCFastEnumerationStateType() {
if (ObjCFastEnumerationStateTypeDecl)
return getTagDeclType(ObjCFastEnumerationStateTypeDecl);
return QualType();
}
void setObjCFastEnumerationStateType(QualType T);
/// \brief Set the type for the C FILE type.
void setFILEDecl(TypeDecl *FILEDecl) { this->FILEDecl = FILEDecl; }
/// \brief Retrieve the C FILE type.
QualType getFILEType() {
if (FILEDecl)
return getTypeDeclType(FILEDecl);
return QualType();
}
/// \brief Set the type for the C jmp_buf type.
void setjmp_bufDecl(TypeDecl *jmp_bufDecl) {
this->jmp_bufDecl = jmp_bufDecl;
}
/// \brief Retrieve the C jmp_buf type.
QualType getjmp_bufType() {
if (jmp_bufDecl)
return getTypeDeclType(jmp_bufDecl);
return QualType();
}
/// \brief Set the type for the C sigjmp_buf type.
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl) {
this->sigjmp_bufDecl = sigjmp_bufDecl;
}
/// \brief Retrieve the C sigjmp_buf type.
QualType getsigjmp_bufType() {
if (sigjmp_bufDecl)
return getTypeDeclType(sigjmp_bufDecl);
return QualType();
}
/// getObjCEncodingForType - Emit the ObjC type encoding for the
/// given type into \arg S. If \arg NameFields is specified then
/// record field names are also encoded.
void getObjCEncodingForType(QualType t, std::string &S,
const FieldDecl *Field=0);
void getLegacyIntegralTypeEncoding(QualType &t) const;
// Put the string version of type qualifiers into S.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
std::string &S) const;
/// getObjCEncodingForMethodDecl - Return the encoded type for this method
/// declaration.
void getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, std::string &S);
/// getObjCEncodingForBlockDecl - Return the encoded type for this block
/// declaration.
void getObjCEncodingForBlock(const BlockExpr *Expr, std::string& S);
/// getObjCEncodingForPropertyDecl - Return the encoded type for
/// this method declaration. If non-NULL, Container must be either
/// an ObjCCategoryImplDecl or ObjCImplementationDecl; it should
/// only be NULL when getting encodings for protocol properties.
void getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
const Decl *Container,
std::string &S);
bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
ObjCProtocolDecl *rProto);
/// getObjCEncodingTypeSize returns size of type for objective-c encoding
/// purpose.
int getObjCEncodingTypeSize(QualType t);
/// This setter/getter represents the ObjC 'id' type. It is setup lazily, by
/// Sema. id is always a (typedef for a) pointer type, a pointer to a struct.
QualType getObjCIdType() const { return ObjCIdTypedefType; }
void setObjCIdType(QualType T);
void setObjCSelType(QualType T);
QualType getObjCSelType() const { return ObjCSelTypedefType; }
void setObjCProtoType(QualType QT);
QualType getObjCProtoType() const { return ObjCProtoType; }
/// This setter/getter repreents the ObjC 'Class' type. It is setup lazily, by
/// Sema. 'Class' is always a (typedef for a) pointer type, a pointer to a
/// struct.
QualType getObjCClassType() const { return ObjCClassTypedefType; }
void setObjCClassType(QualType T);
void setBuiltinVaListType(QualType T);
QualType getBuiltinVaListType() const { return BuiltinVaListType; }
QualType getFixedWidthIntType(unsigned Width, bool Signed);
/// getCVRQualifiedType - Returns a type with additional const,
/// volatile, or restrict qualifiers.
QualType getCVRQualifiedType(QualType T, unsigned CVR) {
return getQualifiedType(T, Qualifiers::fromCVRMask(CVR));
}
/// getQualifiedType - Returns a type with additional qualifiers.
QualType getQualifiedType(QualType T, Qualifiers Qs) {
if (!Qs.hasNonFastQualifiers())
return T.withFastQualifiers(Qs.getFastQualifiers());
QualifierCollector Qc(Qs);
const Type *Ptr = Qc.strip(T);
return getExtQualType(Ptr, Qc);
}
/// getQualifiedType - Returns a type with additional qualifiers.
QualType getQualifiedType(const Type *T, Qualifiers Qs) {
if (!Qs.hasNonFastQualifiers())
return QualType(T, Qs.getFastQualifiers());
return getExtQualType(T, Qs);
}
DeclarationName getNameForTemplate(TemplateName Name);
TemplateName getOverloadedTemplateName(NamedDecl * const *Begin,
NamedDecl * const *End);
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,
bool TemplateKeyword,
TemplateDecl *Template);
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
const IdentifierInfo *Name);
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
OverloadedOperatorKind Operator);
enum GetBuiltinTypeError {
GE_None, //< No error
GE_Missing_stdio, //< Missing a type from <stdio.h>
GE_Missing_setjmp //< Missing a type from <setjmp.h>
};
/// GetBuiltinType - Return the type for the specified builtin.
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error);
private:
CanQualType getFromTargetType(unsigned Type) const;
//===--------------------------------------------------------------------===//
// Type Predicates.
//===--------------------------------------------------------------------===//
public:
/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
/// garbage collection attribute.
///
Qualifiers::GC getObjCGCAttrKind(const QualType &Ty) const;
/// isObjCNSObjectType - Return true if this is an NSObject object with
/// its NSObject attribute set.
bool isObjCNSObjectType(QualType Ty) const;
//===--------------------------------------------------------------------===//
// Type Sizing and Analysis
//===--------------------------------------------------------------------===//
/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
/// scalar floating point type.
const llvm::fltSemantics &getFloatTypeSemantics(QualType T) const;
/// getTypeInfo - Get the size and alignment of the specified complete type in
/// bits.
std::pair<uint64_t, unsigned> getTypeInfo(const Type *T);
std::pair<uint64_t, unsigned> getTypeInfo(QualType T) {
return getTypeInfo(T.getTypePtr());
}
/// getTypeSize - Return the size of the specified type, in bits. This method
/// does not work on incomplete types.
uint64_t getTypeSize(QualType T) {
return getTypeInfo(T).first;
}
uint64_t getTypeSize(const Type *T) {
return getTypeInfo(T).first;
}
/// getByteWidth - Return the size of a byte, in bits
uint64_t getByteSize() {
return getTypeSize(CharTy);
}
/// getTypeSizeInBytes - Return the size of the specified type, in bytes.
/// This method does not work on incomplete types.
uint64_t getTypeSizeInBytes(QualType T) {
return getTypeSize(T) / getByteSize();
}
uint64_t getTypeSizeInBytes(const Type *T) {
return getTypeSize(T) / getByteSize();
}
/// getTypeAlign - Return the ABI-specified alignment of a type, in bits.
/// This method does not work on incomplete types.
unsigned getTypeAlign(QualType T) {
return getTypeInfo(T).second;
}
unsigned getTypeAlign(const Type *T) {
return getTypeInfo(T).second;
}
/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
/// type for the current target in bits. This can be different than the ABI
/// alignment in cases where it is beneficial for performance to overalign
/// a data type.
unsigned getPreferredTypeAlign(const Type *T);
unsigned getDeclAlignInBytes(const Decl *D, bool RefAsPointee = false);
/// getASTRecordLayout - Get or compute information about the layout of the
/// specified record (struct/union/class), which indicates its size and field
/// position information.
const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D);
/// getASTObjCInterfaceLayout - Get or compute information about the
/// layout of the specified Objective-C interface.
const ASTRecordLayout &getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D);
/// getASTObjCImplementationLayout - Get or compute information about
/// the layout of the specified Objective-C implementation. This may
/// differ from the interface if synthesized ivars are present.
const ASTRecordLayout &
getASTObjCImplementationLayout(const ObjCImplementationDecl *D);
/// getKeyFunction - Get the key function for the given record decl.
/// The key function is, according to the Itanium C++ ABI section 5.2.3:
///
/// ...the first non-pure virtual function that is not inline at the point
/// of class definition.
const CXXMethodDecl *getKeyFunction(const CXXRecordDecl *RD);
void CollectObjCIvars(const ObjCInterfaceDecl *OI,
llvm::SmallVectorImpl<FieldDecl*> &Fields);
void ShallowCollectObjCIvars(const ObjCInterfaceDecl *OI,
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars,
bool CollectSynthesized = true);
void CollectSynthesizedIvars(const ObjCInterfaceDecl *OI,
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars);
void CollectProtocolSynthesizedIvars(const ObjCProtocolDecl *PD,
llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars);
unsigned CountSynthesizedIvars(const ObjCInterfaceDecl *OI);
unsigned CountProtocolSynthesizedIvars(const ObjCProtocolDecl *PD);
void CollectInheritedProtocols(const Decl *CDecl,
llvm::SmallVectorImpl<ObjCProtocolDecl*> &Protocols);
//===--------------------------------------------------------------------===//
// Type Operators
//===--------------------------------------------------------------------===//
/// getCanonicalType - Return the canonical (structural) type corresponding to
/// the specified potentially non-canonical type. The non-canonical version
/// of a type may have many "decorated" versions of types. Decorators can
/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed
/// to be free of any of these, allowing two canonical types to be compared
/// for exact equality with a simple pointer comparison.
CanQualType getCanonicalType(QualType T);
const Type *getCanonicalType(const Type *T) {
return T->getCanonicalTypeInternal().getTypePtr();
}
/// getCanonicalParamType - Return the canonical parameter type
/// corresponding to the specific potentially non-canonical one.
/// Qualifiers are stripped off, functions are turned into function
/// pointers, and arrays decay one level into pointers.
CanQualType getCanonicalParamType(QualType T);
/// \brief Determine whether the given types are equivalent.
bool hasSameType(QualType T1, QualType T2) {
return getCanonicalType(T1) == getCanonicalType(T2);
}
/// \brief Determine whether the given types are equivalent after
/// cvr-qualifiers have been removed.
bool hasSameUnqualifiedType(QualType T1, QualType T2) {
CanQualType CT1 = getCanonicalType(T1);
CanQualType CT2 = getCanonicalType(T2);
return CT1.getUnqualifiedType() == CT2.getUnqualifiedType();
}
/// \brief Retrieves the "canonical" declaration of
/// \brief Retrieves the "canonical" nested name specifier for a
/// given nested name specifier.
///
/// The canonical nested name specifier is a nested name specifier
/// that uniquely identifies a type or namespace within the type
/// system. For example, given:
///
/// \code
/// namespace N {
/// struct S {
/// template<typename T> struct X { typename T* type; };
/// };
/// }
///
/// template<typename T> struct Y {
/// typename N::S::X<T>::type member;
/// };
/// \endcode
///
/// Here, the nested-name-specifier for N::S::X<T>:: will be
/// S::X<template-param-0-0>, since 'S' and 'X' are uniquely defined
/// by declarations in the type system and the canonical type for
/// the template type parameter 'T' is template-param-0-0.
NestedNameSpecifier *
getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS);
/// \brief Retrieves the "canonical" template name that refers to a
/// given template.
///
/// The canonical template name is the simplest expression that can
/// be used to refer to a given template. For most templates, this
/// expression is just the template declaration itself. For example,
/// the template std::vector can be referred to via a variety of
/// names---std::vector, ::std::vector, vector (if vector is in
/// scope), etc.---but all of these names map down to the same
/// TemplateDecl, which is used to form the canonical template name.
///
/// Dependent template names are more interesting. Here, the
/// template name could be something like T::template apply or
/// std::allocator<T>::template rebind, where the nested name
/// specifier itself is dependent. In this case, the canonical
/// template name uses the shortest form of the dependent
/// nested-name-specifier, which itself contains all canonical
/// types, values, and templates.
TemplateName getCanonicalTemplateName(TemplateName Name);
/// \brief Determine whether the given template names refer to the same
/// template.
bool hasSameTemplateName(TemplateName X, TemplateName Y);
/// \brief Retrieve the "canonical" template argument.
///
/// The canonical template argument is the simplest template argument
/// (which may be a type, value, expression, or declaration) that
/// expresses the value of the argument.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg);
/// Type Query functions. If the type is an instance of the specified class,
/// return the Type pointer for the underlying maximally pretty type. This
/// is a member of ASTContext because this may need to do some amount of
/// canonicalization, e.g. to move type qualifiers into the element type.
const ArrayType *getAsArrayType(QualType T);
const ConstantArrayType *getAsConstantArrayType(QualType T) {
return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
}
const VariableArrayType *getAsVariableArrayType(QualType T) {
return dyn_cast_or_null<VariableArrayType>(getAsArrayType(T));
}
const IncompleteArrayType *getAsIncompleteArrayType(QualType T) {
return dyn_cast_or_null<IncompleteArrayType>(getAsArrayType(T));
}
/// getBaseElementType - Returns the innermost element type of an array type.
/// For example, will return "int" for int[m][n]
QualType getBaseElementType(const ArrayType *VAT);
/// getBaseElementType - Returns the innermost element type of a type
/// (which needn't actually be an array type).
QualType getBaseElementType(QualType QT);
/// getConstantArrayElementCount - Returns number of constant array elements.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const;
/// getArrayDecayedType - Return the properly qualified result of decaying the
/// specified array type to a pointer. This operation is non-trivial when
/// handling typedefs etc. The canonical type of "T" must be an array type,
/// this returns a pointer to a properly qualified element of the array.
///
/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
QualType getArrayDecayedType(QualType T);
/// getPromotedIntegerType - Returns the type that Promotable will
/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
/// integer type.
QualType getPromotedIntegerType(QualType PromotableType);
/// \brief Whether this is a promotable bitfield reference according
/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
///
/// \returns the type this bit-field will promote to, or NULL if no
/// promotion occurs.
QualType isPromotableBitField(Expr *E);
/// getIntegerTypeOrder - Returns the highest ranked integer type:
/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
/// LHS < RHS, return -1.
int getIntegerTypeOrder(QualType LHS, QualType RHS);
/// getFloatingTypeOrder - Compare the rank of the two specified floating
/// point types, ignoring the domain of the type (i.e. 'double' ==
/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
/// LHS < RHS, return -1.
int getFloatingTypeOrder(QualType LHS, QualType RHS);
/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
/// point or a complex type (based on typeDomain/typeSize).
/// 'typeDomain' is a real floating point or complex type.
/// 'typeSize' is a real floating point or complex type.
QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
QualType typeDomain) const;
private:
// Helper for integer ordering
unsigned getIntegerRank(Type* T);
public:
//===--------------------------------------------------------------------===//
// Type Compatibility Predicates
//===--------------------------------------------------------------------===//
/// Compatibility predicates used to check assignment expressions.
bool typesAreCompatible(QualType, QualType); // C99 6.2.7p1
bool isObjCIdType(QualType T) const {
return T == ObjCIdTypedefType;
}
bool isObjCClassType(QualType T) const {
return T == ObjCClassTypedefType;
}
bool isObjCSelType(QualType T) const {
return T == ObjCSelTypedefType;
}
bool QualifiedIdConformsQualifiedId(QualType LHS, QualType RHS);
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
bool ForCompare);
// Check the safety of assignment from LHS to RHS
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
const ObjCObjectPointerType *RHSOPT);
bool canAssignObjCInterfaces(const ObjCInterfaceType *LHS,
const ObjCInterfaceType *RHS);
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS);
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT,
const ObjCObjectPointerType *RHSOPT);
// Functions for calculating composite types
QualType mergeTypes(QualType, QualType);
QualType mergeFunctionTypes(QualType, QualType);
/// UsualArithmeticConversionsType - handles the various conversions
/// that are common to binary operators (C99 6.3.1.8, C++ [expr]p9)
/// and returns the result type of that conversion.
QualType UsualArithmeticConversionsType(QualType lhs, QualType rhs);
//===--------------------------------------------------------------------===//
// Integer Predicates
//===--------------------------------------------------------------------===//
// The width of an integer, as defined in C99 6.2.6.2. This is the number
// of bits in an integer type excluding any padding bits.
unsigned getIntWidth(QualType T);
// Per C99 6.2.5p6, for every signed integer type, there is a corresponding
// unsigned integer type. This method takes a signed type, and returns the
// corresponding unsigned integer type.
QualType getCorrespondingUnsignedType(QualType T);
//===--------------------------------------------------------------------===//
// Type Iterators.
//===--------------------------------------------------------------------===//
typedef std::vector<Type*>::iterator type_iterator;
typedef std::vector<Type*>::const_iterator const_type_iterator;
type_iterator types_begin() { return Types.begin(); }
type_iterator types_end() { return Types.end(); }
const_type_iterator types_begin() const { return Types.begin(); }
const_type_iterator types_end() const { return Types.end(); }
//===--------------------------------------------------------------------===//
// Integer Values
//===--------------------------------------------------------------------===//
/// MakeIntValue - Make an APSInt of the appropriate width and
/// signedness for the given \arg Value and integer \arg Type.
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) {
llvm::APSInt Res(getIntWidth(Type), !Type->isSignedIntegerType());
Res = Value;
return Res;
}
/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
ObjCImplementationDecl *getObjCImplementation(ObjCInterfaceDecl *D);
/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists.
ObjCCategoryImplDecl *getObjCImplementation(ObjCCategoryDecl *D);
/// \brief Set the implementation of ObjCInterfaceDecl.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD,
ObjCImplementationDecl *ImplD);
/// \brief Set the implementation of ObjCCategoryDecl.
void setObjCImplementation(ObjCCategoryDecl *CatD,
ObjCCategoryImplDecl *ImplD);
/// \brief Allocate an uninitialized TypeSourceInfo.
///
/// The caller should initialize the memory held by TypeSourceInfo using
/// the TypeLoc wrappers.
///
/// \param T the type that will be the basis for type source info. This type
/// should refer to how the declarator was written in source code, not to
/// what type semantic analysis resolved the declarator to.
///
/// \param Size the size of the type info to create, or 0 if the size
/// should be calculated based on the type.
TypeSourceInfo *CreateTypeSourceInfo(QualType T, unsigned Size = 0);
/// \brief Allocate a TypeSourceInfo where all locations have been
/// initialized to a given location, which defaults to the empty
/// location.
TypeSourceInfo *
getTrivialTypeSourceInfo(QualType T, SourceLocation Loc = SourceLocation());
private:
ASTContext(const ASTContext&); // DO NOT IMPLEMENT
void operator=(const ASTContext&); // DO NOT IMPLEMENT
void InitBuiltinTypes();
void InitBuiltinType(CanQualType &R, BuiltinType::Kind K);
// Return the ObjC type encoding for a given type.
void getObjCEncodingForTypeImpl(QualType t, std::string &S,
bool ExpandPointedToStructures,
bool ExpandStructures,
const FieldDecl *Field,
bool OutermostType = false,
bool EncodingProperty = false);
const ASTRecordLayout &getObjCLayout(const ObjCInterfaceDecl *D,
const ObjCImplementationDecl *Impl);
};
/// @brief Utility function for constructing a nullary selector.
static inline Selector GetNullarySelector(const char* name, ASTContext& Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(0, &II);
}
/// @brief Utility function for constructing an unary selector.
static inline Selector GetUnarySelector(const char* name, ASTContext& Ctx) {
IdentifierInfo* II = &Ctx.Idents.get(name);
return Ctx.Selectors.getSelector(1, &II);
}
} // end namespace clang
// operator new and delete aren't allowed inside namespaces.
// The throw specifications are mandated by the standard.
/// @brief Placement new for using the ASTContext's allocator.
///
/// This placement form of operator new uses the ASTContext's allocator for
/// obtaining memory. It is a non-throwing new, which means that it returns
/// null on error. (If that is what the allocator does. The current does, so if
/// this ever changes, this operator will have to be changed, too.)
/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
/// @code
/// // Default alignment (16)
/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
/// // Specific alignment
/// IntegerLiteral *Ex2 = new (Context, 8) IntegerLiteral(arguments);
/// @endcode
/// Please note that you cannot use delete on the pointer; it must be
/// deallocated using an explicit destructor call followed by
/// @c Context.Deallocate(Ptr).
///
/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
/// @param C The ASTContext that provides the allocator.
/// @param Alignment The alignment of the allocated memory (if the underlying
/// allocator supports it).
/// @return The allocated memory. Could be NULL.
inline void *operator new(size_t Bytes, clang::ASTContext &C,
size_t Alignment) throw () {
return C.Allocate(Bytes, Alignment);
}
/// @brief Placement delete companion to the new above.
///
/// This operator is just a companion to the new above. There is no way of
/// invoking it directly; see the new operator for more details. This operator
/// is called implicitly by the compiler if a placement new expression using
/// the ASTContext throws in the object constructor.
inline void operator delete(void *Ptr, clang::ASTContext &C, size_t)
throw () {
C.Deallocate(Ptr);
}
/// This placement form of operator new[] uses the ASTContext's allocator for
/// obtaining memory. It is a non-throwing new[], which means that it returns
/// null on error.
/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
/// @code
/// // Default alignment (16)
/// char *data = new (Context) char[10];
/// // Specific alignment
/// char *data = new (Context, 8) char[10];
/// @endcode
/// Please note that you cannot use delete on the pointer; it must be
/// deallocated using an explicit destructor call followed by
/// @c Context.Deallocate(Ptr).
///
/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
/// @param C The ASTContext that provides the allocator.
/// @param Alignment The alignment of the allocated memory (if the underlying
/// allocator supports it).
/// @return The allocated memory. Could be NULL.
inline void *operator new[](size_t Bytes, clang::ASTContext& C,
size_t Alignment = 16) throw () {
return C.Allocate(Bytes, Alignment);
}
/// @brief Placement delete[] companion to the new[] above.
///
/// This operator is just a companion to the new[] above. There is no way of
/// invoking it directly; see the new[] operator for more details. This operator
/// is called implicitly by the compiler if a placement new[] expression using
/// the ASTContext throws in the object constructor.
inline void operator delete[](void *Ptr, clang::ASTContext &C) throw () {
C.Deallocate(Ptr);
}
#endif
| [
"[email protected]"
] | ||
0a3a1fa14137419b3bdd95908c060e8aa57933ea | c024a8d406ab3556a8c5bf5d66256cf6ec5dc7d9 | /7/FindMaxEx/stdafx.h | cc756c3bbcfc6c2f1c6c232c089cdeb9ac5691d7 | [] | no_license | sergeythrees/Object-Oriented-Programming | 1fa17b5606360b4b6ef1dd6e470f7426fef649b6 | 77e227a64cb2cf00f429c090bc16ca6ec8aefa36 | refs/heads/master | 2021-09-04T09:49:56.837506 | 2018-01-17T20:02:33 | 2018-01-17T20:02:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 347 | h | // stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#pragma once
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include <vector>
#include <functional>
// TODO: reference additional headers your program requires here
| [
"[email protected]"
] | |
ce5dae88c3554d54fca24a5b8b0017b1dce1a6d9 | fc995bae9e98721abbb1e32dba221f2628ff0337 | /CEPC-I/creciente.cpp | 58b55a34ea9e1e719b9d8ab4e536191f3c66ef12 | [] | no_license | BL4CKS41L/Competitive-Programming | 9a09f057c6393210cf9309578f6998edf3e7463a | 05e1fbfd836037cf96e5377de1baff5b90c60042 | refs/heads/master | 2020-04-11T13:50:38.176398 | 2018-12-14T21:18:23 | 2018-12-14T21:18:23 | 161,831,871 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 362 | cpp | #include <iostream>
using namespace std;
int main(){
int N,i,array[N];
bool aux=false;
//int array[N];
cin >> N;
for( i = 0; i <N; i++) {
cin >> array[i];
}
for( i = 0; i < N; i++) {
if (array[i] >= array[i+1])
aux=false;;
break;
}
if (aux==true) {
cout << "YES";
}
else {
cout << "NO";
}
} | [
"[email protected]"
] | |
0eb9cc6bf70fed74174a5b87827d28ffbb0e5928 | 13771efbe4bd2803f21b75c0edb621a0d68d0f6c | /수학/GCD합_수학_9613.cpp | 3418c06e4baed366a006cf4ebb67ba19d551e07e | [] | no_license | Flare-k/Algorithm | f6e597bcb376d8c0f50e91556cadf2cceadd786c | 64ab13c5304712292c41a26a4347f010d70daf98 | refs/heads/master | 2023-04-08T21:05:08.130284 | 2023-04-03T13:57:01 | 2023-04-03T13:57:01 | 236,532,243 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 889 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
#define endl "\n"
using namespace std;
// 최대 공약수 GCD
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a%b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long num;
cin >> num;
while (num--) {
vector<long long> temp;
int turns;
cin >> turns;
for (int i = 0; i < turns; i++) {
long long tempNum;
cin >> tempNum;
temp.push_back(tempNum);
}
long long sum = 0; // long long 중요
for (int i = 0; i < temp.size()-1; i++) {
for (int j = i+1; j < temp.size(); j++) {
sum += gcd(temp[i], temp[j]);
}
}
cout << sum << endl;
}
return 0;
} | [
"[email protected]"
] | |
76327d6ea4d8a275af977f1266b84b91f804fec8 | dc9dff8195d13381c4a38cc8bed7840188004948 | /include/tools/text.h | b73f392b7a57d50f20f4dfac6dc5f21ff8593ebb | [] | no_license | MartinEmilEshack/Adobe-Illustrator | 6f4ce30d229b43de8eb9e963e690df8e06b1fe6b | c2953f8515afc5ac5371dd1f39ced26b42a8c175 | refs/heads/master | 2023-08-08T03:46:21.702500 | 2021-09-26T21:12:44 | 2021-09-26T21:12:44 | 267,392,750 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 698 | h | #ifndef _TEXT_H_
#define _TEXT_H_
#ifdef __APPLE__
#include<GLUT/glut.h>
#else
#include<GL/glut.h>
#endif
#include<string>
#include<cstring>
#include"point.h"
#include "drawable.h"
using namespace std;
class Label : public Drawable
{
private:
int text_size;
string text;
Point end_point = Point();
public:
Label();
~Label() {}
void draw();
bool save();
void set_start(Point start, Color color, bool fill);
void change(Point end, Color color, bool fill);
Drawable* make_new();
bool write(unsigned char letter);
};
void print_xy(float x,float y,const char* text,void* font);
Point print_file(Point boundaries,Point pixels_size,const string& text,void* font);
#endif | [
"[email protected]"
] | |
e832a50806b69f5d798e6709f1d29b5db9f40e5e | 84f627f52985c3862a5bdae4ada9c1e793ef7ab7 | /Source Files/ExpressionEvaluator.cpp | bd52d2d1af243f7db97121167fd075bf84bf8eb8 | [] | no_license | CoutaqStudies/cpp-lab-three | 18879808cd4a806639b4156fa9b65e12cdd28fde | f25cda32842f585a2487ccf2089c4eb0bd395794 | refs/heads/master | 2023-01-09T12:41:30.012958 | 2020-11-11T10:40:18 | 2020-11-11T10:40:18 | 310,770,701 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 718 | cpp | //
// Created by Michael on 07/11/2020.
//
#include "../Header Files/ExpressionEvaluator.h"
ExpressionEvaluator::ExpressionEvaluator(){
n = 20;
ops = new double[n];
for (int i = 0; i < n; ++i) {
ops[i] = 0;
}
}
ExpressionEvaluator::ExpressionEvaluator(int _n){
n = _n;
ops = new double[n];
for (int i = 0; i < n; ++i) {
ops[i] = 0;
}
}
ExpressionEvaluator::~ExpressionEvaluator(){
delete[] ops;
}
void ExpressionEvaluator::setOperand(size_t pos, double value){
ops[pos] = value;
}
void ExpressionEvaluator::setOperands(double _ops[], size_t _n){
for(int i = 0; i<_n; ++i){
ops[i] = _ops[i];
}
}
int ExpressionEvaluator::getN(){
return n;
}
| [
"[email protected]"
] | |
733b07624e8c01602db1733598d8aa0f32b8eb44 | 4f56126e2214f6f9da1e0fe4316d64bfdd7367f1 | /Include/google/protobuf/descriptor.pb.h | 8166ce07f06f54b398028ea0e4899972b6a01e54 | [] | no_license | danielkeller/VulkanTutorial | cf8a3e581df6b8df1e50a27b2a61b624ffcf67d8 | 766c88a51773748bae3c9d04164231147a10f794 | refs/heads/main | 2023-03-28T18:53:03.742472 | 2021-04-08T11:05:07 | 2021-04-08T11:05:07 | 350,025,284 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 540,611 | h | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/protobuf/descriptor.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#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 3015006 < 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/port_undef.inc>
#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/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fdescriptor_2eproto PROTOBUF_EXPORT
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[27]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(int index);
PROTOBUF_NAMESPACE_OPEN
class DescriptorProto;
struct DescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
class DescriptorProto_ExtensionRange;
struct DescriptorProto_ExtensionRangeDefaultTypeInternal;
PROTOBUF_EXPORT extern DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;
class DescriptorProto_ReservedRange;
struct DescriptorProto_ReservedRangeDefaultTypeInternal;
PROTOBUF_EXPORT extern DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
class EnumDescriptorProto;
struct EnumDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
class EnumDescriptorProto_EnumReservedRange;
struct EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal;
PROTOBUF_EXPORT extern EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;
class EnumOptions;
struct EnumOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;
class EnumValueDescriptorProto;
struct EnumValueDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
class EnumValueOptions;
struct EnumValueOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;
class ExtensionRangeOptions;
struct ExtensionRangeOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;
class FieldDescriptorProto;
struct FieldDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
class FieldOptions;
struct FieldOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
class FileDescriptorProto;
struct FileDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
class FileDescriptorSet;
struct FileDescriptorSetDefaultTypeInternal;
PROTOBUF_EXPORT extern FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
class FileOptions;
struct FileOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern FileOptionsDefaultTypeInternal _FileOptions_default_instance_;
class GeneratedCodeInfo;
struct GeneratedCodeInfoDefaultTypeInternal;
PROTOBUF_EXPORT extern GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
class GeneratedCodeInfo_Annotation;
struct GeneratedCodeInfo_AnnotationDefaultTypeInternal;
PROTOBUF_EXPORT extern GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;
class MessageOptions;
struct MessageOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;
class MethodDescriptorProto;
struct MethodDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;
class MethodOptions;
struct MethodOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;
class OneofDescriptorProto;
struct OneofDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
class OneofOptions;
struct OneofOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
class ServiceDescriptorProto;
struct ServiceDescriptorProtoDefaultTypeInternal;
PROTOBUF_EXPORT extern ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;
class ServiceOptions;
struct ServiceOptionsDefaultTypeInternal;
PROTOBUF_EXPORT extern ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;
class SourceCodeInfo;
struct SourceCodeInfoDefaultTypeInternal;
PROTOBUF_EXPORT extern SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;
class SourceCodeInfo_Location;
struct SourceCodeInfo_LocationDefaultTypeInternal;
PROTOBUF_EXPORT extern SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;
class UninterpretedOption;
struct UninterpretedOptionDefaultTypeInternal;
PROTOBUF_EXPORT extern UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
class UninterpretedOption_NamePart;
struct UninterpretedOption_NamePartDefaultTypeInternal;
PROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
template<> PROTOBUF_EXPORT PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
enum FieldDescriptorProto_Type : int {
FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
FieldDescriptorProto_Type_TYPE_FLOAT = 2,
FieldDescriptorProto_Type_TYPE_INT64 = 3,
FieldDescriptorProto_Type_TYPE_UINT64 = 4,
FieldDescriptorProto_Type_TYPE_INT32 = 5,
FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
FieldDescriptorProto_Type_TYPE_BOOL = 8,
FieldDescriptorProto_Type_TYPE_STRING = 9,
FieldDescriptorProto_Type_TYPE_GROUP = 10,
FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
FieldDescriptorProto_Type_TYPE_BYTES = 12,
FieldDescriptorProto_Type_TYPE_UINT32 = 13,
FieldDescriptorProto_Type_TYPE_ENUM = 14,
FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
FieldDescriptorProto_Type_TYPE_SINT32 = 17,
FieldDescriptorProto_Type_TYPE_SINT64 = 18
};
PROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);
constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64;
constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
template<typename T>
inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value) {
static_assert(::std::is_same<T, FieldDescriptorProto_Type>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FieldDescriptorProto_Type_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FieldDescriptorProto_Type_descriptor(), enum_t_value);
}
inline bool FieldDescriptorProto_Type_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Type* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
FieldDescriptorProto_Type_descriptor(), name, value);
}
enum FieldDescriptorProto_Label : int {
FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
FieldDescriptorProto_Label_LABEL_REPEATED = 3
};
PROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);
constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED;
constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
template<typename T>
inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value) {
static_assert(::std::is_same<T, FieldDescriptorProto_Label>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FieldDescriptorProto_Label_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FieldDescriptorProto_Label_descriptor(), enum_t_value);
}
inline bool FieldDescriptorProto_Label_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Label* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
FieldDescriptorProto_Label_descriptor(), name, value);
}
enum FileOptions_OptimizeMode : int {
FileOptions_OptimizeMode_SPEED = 1,
FileOptions_OptimizeMode_CODE_SIZE = 2,
FileOptions_OptimizeMode_LITE_RUNTIME = 3
};
PROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);
constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED;
constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME;
constexpr int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
template<typename T>
inline const std::string& FileOptions_OptimizeMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, FileOptions_OptimizeMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FileOptions_OptimizeMode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FileOptions_OptimizeMode_descriptor(), enum_t_value);
}
inline bool FileOptions_OptimizeMode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FileOptions_OptimizeMode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
FileOptions_OptimizeMode_descriptor(), name, value);
}
enum FieldOptions_CType : int {
FieldOptions_CType_STRING = 0,
FieldOptions_CType_CORD = 1,
FieldOptions_CType_STRING_PIECE = 2
};
PROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);
constexpr FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING;
constexpr FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE;
constexpr int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_CType_descriptor();
template<typename T>
inline const std::string& FieldOptions_CType_Name(T enum_t_value) {
static_assert(::std::is_same<T, FieldOptions_CType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FieldOptions_CType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FieldOptions_CType_descriptor(), enum_t_value);
}
inline bool FieldOptions_CType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_CType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_CType>(
FieldOptions_CType_descriptor(), name, value);
}
enum FieldOptions_JSType : int {
FieldOptions_JSType_JS_NORMAL = 0,
FieldOptions_JSType_JS_STRING = 1,
FieldOptions_JSType_JS_NUMBER = 2
};
PROTOBUF_EXPORT bool FieldOptions_JSType_IsValid(int value);
constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MIN = FieldOptions_JSType_JS_NORMAL;
constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MAX = FieldOptions_JSType_JS_NUMBER;
constexpr int FieldOptions_JSType_JSType_ARRAYSIZE = FieldOptions_JSType_JSType_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_JSType_descriptor();
template<typename T>
inline const std::string& FieldOptions_JSType_Name(T enum_t_value) {
static_assert(::std::is_same<T, FieldOptions_JSType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function FieldOptions_JSType_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
FieldOptions_JSType_descriptor(), enum_t_value);
}
inline bool FieldOptions_JSType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_JSType* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_JSType>(
FieldOptions_JSType_descriptor(), name, value);
}
enum MethodOptions_IdempotencyLevel : int {
MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
};
PROTOBUF_EXPORT bool MethodOptions_IdempotencyLevel_IsValid(int value);
constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN = MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX = MethodOptions_IdempotencyLevel_IDEMPOTENT;
constexpr int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX + 1;
PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MethodOptions_IdempotencyLevel_descriptor();
template<typename T>
inline const std::string& MethodOptions_IdempotencyLevel_Name(T enum_t_value) {
static_assert(::std::is_same<T, MethodOptions_IdempotencyLevel>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function MethodOptions_IdempotencyLevel_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
MethodOptions_IdempotencyLevel_descriptor(), enum_t_value);
}
inline bool MethodOptions_IdempotencyLevel_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MethodOptions_IdempotencyLevel* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(
MethodOptions_IdempotencyLevel_descriptor(), name, value);
}
// ===================================================================
class PROTOBUF_EXPORT FileDescriptorSet PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ {
public:
inline FileDescriptorSet() : FileDescriptorSet(nullptr) {}
virtual ~FileDescriptorSet();
explicit constexpr FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FileDescriptorSet(const FileDescriptorSet& from);
FileDescriptorSet(FileDescriptorSet&& from) noexcept
: FileDescriptorSet() {
*this = ::std::move(from);
}
inline FileDescriptorSet& operator=(const FileDescriptorSet& from) {
CopyFrom(from);
return *this;
}
inline FileDescriptorSet& operator=(FileDescriptorSet&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FileDescriptorSet& default_instance() {
return *internal_default_instance();
}
static inline const FileDescriptorSet* internal_default_instance() {
return reinterpret_cast<const FileDescriptorSet*>(
&_FileDescriptorSet_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(FileDescriptorSet& a, FileDescriptorSet& b) {
a.Swap(&b);
}
inline void Swap(FileDescriptorSet* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FileDescriptorSet* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FileDescriptorSet* New() const final {
return CreateMaybeMessage<FileDescriptorSet>(nullptr);
}
FileDescriptorSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FileDescriptorSet>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FileDescriptorSet& from);
void MergeFrom(const FileDescriptorSet& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FileDescriptorSet* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.FileDescriptorSet";
}
protected:
explicit FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kFileFieldNumber = 1,
};
// repeated .google.protobuf.FileDescriptorProto file = 1;
int file_size() const;
private:
int _internal_file_size() const;
public:
void clear_file();
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_file(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
mutable_file();
private:
const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_file(int index) const;
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_file();
public:
const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& file(int index) const;
PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_file();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
file() const;
// @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto > file_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT FileDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ {
public:
inline FileDescriptorProto() : FileDescriptorProto(nullptr) {}
virtual ~FileDescriptorProto();
explicit constexpr FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FileDescriptorProto(const FileDescriptorProto& from);
FileDescriptorProto(FileDescriptorProto&& from) noexcept
: FileDescriptorProto() {
*this = ::std::move(from);
}
inline FileDescriptorProto& operator=(const FileDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline FileDescriptorProto& operator=(FileDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FileDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const FileDescriptorProto* internal_default_instance() {
return reinterpret_cast<const FileDescriptorProto*>(
&_FileDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(FileDescriptorProto& a, FileDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(FileDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FileDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FileDescriptorProto* New() const final {
return CreateMaybeMessage<FileDescriptorProto>(nullptr);
}
FileDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FileDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FileDescriptorProto& from);
void MergeFrom(const FileDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FileDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.FileDescriptorProto";
}
protected:
explicit FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kDependencyFieldNumber = 3,
kMessageTypeFieldNumber = 4,
kEnumTypeFieldNumber = 5,
kServiceFieldNumber = 6,
kExtensionFieldNumber = 7,
kPublicDependencyFieldNumber = 10,
kWeakDependencyFieldNumber = 11,
kNameFieldNumber = 1,
kPackageFieldNumber = 2,
kSyntaxFieldNumber = 12,
kOptionsFieldNumber = 8,
kSourceCodeInfoFieldNumber = 9,
};
// repeated string dependency = 3;
int dependency_size() const;
private:
int _internal_dependency_size() const;
public:
void clear_dependency();
const std::string& dependency(int index) const;
std::string* mutable_dependency(int index);
void set_dependency(int index, const std::string& value);
void set_dependency(int index, std::string&& value);
void set_dependency(int index, const char* value);
void set_dependency(int index, const char* value, size_t size);
std::string* add_dependency();
void add_dependency(const std::string& value);
void add_dependency(std::string&& value);
void add_dependency(const char* value);
void add_dependency(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dependency() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dependency();
private:
const std::string& _internal_dependency(int index) const;
std::string* _internal_add_dependency();
public:
// repeated .google.protobuf.DescriptorProto message_type = 4;
int message_type_size() const;
private:
int _internal_message_type_size() const;
public:
void clear_message_type();
PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_message_type(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >*
mutable_message_type();
private:
const PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_message_type(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_message_type();
public:
const PROTOBUF_NAMESPACE_ID::DescriptorProto& message_type(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto* add_message_type();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >&
message_type() const;
// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
int enum_type_size() const;
private:
int _internal_enum_type_size() const;
public:
void clear_enum_type();
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
mutable_enum_type();
private:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
public:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
enum_type() const;
// repeated .google.protobuf.ServiceDescriptorProto service = 6;
int service_size() const;
private:
int _internal_service_size() const;
public:
void clear_service();
PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* mutable_service(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
mutable_service();
private:
const PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& _internal_service(int index) const;
PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _internal_add_service();
public:
const PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& service(int index) const;
PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* add_service();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
service() const;
// repeated .google.protobuf.FieldDescriptorProto extension = 7;
int extension_size() const;
private:
int _internal_extension_size() const;
public:
void clear_extension();
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
mutable_extension();
private:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
public:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
extension() const;
// repeated int32 public_dependency = 10;
int public_dependency_size() const;
private:
int _internal_public_dependency_size() const;
public:
void clear_public_dependency();
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_public_dependency(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_public_dependency() const;
void _internal_add_public_dependency(::PROTOBUF_NAMESPACE_ID::int32 value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_public_dependency();
public:
::PROTOBUF_NAMESPACE_ID::int32 public_dependency(int index) const;
void set_public_dependency(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
void add_public_dependency(::PROTOBUF_NAMESPACE_ID::int32 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
public_dependency() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_public_dependency();
// repeated int32 weak_dependency = 11;
int weak_dependency_size() const;
private:
int _internal_weak_dependency_size() const;
public:
void clear_weak_dependency();
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_weak_dependency(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_weak_dependency() const;
void _internal_add_weak_dependency(::PROTOBUF_NAMESPACE_ID::int32 value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_weak_dependency();
public:
::PROTOBUF_NAMESPACE_ID::int32 weak_dependency(int index) const;
void set_weak_dependency(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
void add_weak_dependency(::PROTOBUF_NAMESPACE_ID::int32 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
weak_dependency() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_weak_dependency();
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string package = 2;
bool has_package() const;
private:
bool _internal_has_package() const;
public:
void clear_package();
const std::string& package() const;
void set_package(const std::string& value);
void set_package(std::string&& value);
void set_package(const char* value);
void set_package(const char* value, size_t size);
std::string* mutable_package();
std::string* release_package();
void set_allocated_package(std::string* package);
private:
const std::string& _internal_package() const;
void _internal_set_package(const std::string& value);
std::string* _internal_mutable_package();
public:
// optional string syntax = 12;
bool has_syntax() const;
private:
bool _internal_has_syntax() const;
public:
void clear_syntax();
const std::string& syntax() const;
void set_syntax(const std::string& value);
void set_syntax(std::string&& value);
void set_syntax(const char* value);
void set_syntax(const char* value, size_t size);
std::string* mutable_syntax();
std::string* release_syntax();
void set_allocated_syntax(std::string* syntax);
private:
const std::string& _internal_syntax() const;
void _internal_set_syntax(const std::string& value);
std::string* _internal_mutable_syntax();
public:
// optional .google.protobuf.FileOptions options = 8;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::FileOptions& options() const;
PROTOBUF_NAMESPACE_ID::FileOptions* release_options();
PROTOBUF_NAMESPACE_ID::FileOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::FileOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::FileOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::FileOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::FileOptions* options);
PROTOBUF_NAMESPACE_ID::FileOptions* unsafe_arena_release_options();
// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
bool has_source_code_info() const;
private:
bool _internal_has_source_code_info() const;
public:
void clear_source_code_info();
const PROTOBUF_NAMESPACE_ID::SourceCodeInfo& source_code_info() const;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* release_source_code_info();
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* mutable_source_code_info();
void set_allocated_source_code_info(PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
private:
const PROTOBUF_NAMESPACE_ID::SourceCodeInfo& _internal_source_code_info() const;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _internal_mutable_source_code_info();
public:
void unsafe_arena_set_allocated_source_code_info(
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* unsafe_arena_release_source_code_info();
// @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dependency_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto > message_type_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto > service_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > public_dependency_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > weak_dependency_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr syntax_;
PROTOBUF_NAMESPACE_ID::FileOptions* options_;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto_ExtensionRange PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ {
public:
inline DescriptorProto_ExtensionRange() : DescriptorProto_ExtensionRange(nullptr) {}
virtual ~DescriptorProto_ExtensionRange();
explicit constexpr DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
DescriptorProto_ExtensionRange(DescriptorProto_ExtensionRange&& from) noexcept
: DescriptorProto_ExtensionRange() {
*this = ::std::move(from);
}
inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) {
CopyFrom(from);
return *this;
}
inline DescriptorProto_ExtensionRange& operator=(DescriptorProto_ExtensionRange&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const DescriptorProto_ExtensionRange& default_instance() {
return *internal_default_instance();
}
static inline const DescriptorProto_ExtensionRange* internal_default_instance() {
return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
&_DescriptorProto_ExtensionRange_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
friend void swap(DescriptorProto_ExtensionRange& a, DescriptorProto_ExtensionRange& b) {
a.Swap(&b);
}
inline void Swap(DescriptorProto_ExtensionRange* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DescriptorProto_ExtensionRange* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DescriptorProto_ExtensionRange* New() const final {
return CreateMaybeMessage<DescriptorProto_ExtensionRange>(nullptr);
}
DescriptorProto_ExtensionRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DescriptorProto_ExtensionRange>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const DescriptorProto_ExtensionRange& from);
void MergeFrom(const DescriptorProto_ExtensionRange& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DescriptorProto_ExtensionRange* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.DescriptorProto.ExtensionRange";
}
protected:
explicit DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOptionsFieldNumber = 3,
kStartFieldNumber = 1,
kEndFieldNumber = 2,
};
// optional .google.protobuf.ExtensionRangeOptions options = 3;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& options() const;
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* release_options();
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* unsafe_arena_release_options();
// optional int32 start = 1;
bool has_start() const;
private:
bool _internal_has_start() const;
public:
void clear_start();
::PROTOBUF_NAMESPACE_ID::int32 start() const;
void set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const;
void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 end = 2;
bool has_end() const;
private:
bool _internal_has_end() const;
public:
void clear_end();
::PROTOBUF_NAMESPACE_ID::int32 end() const;
void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options_;
::PROTOBUF_NAMESPACE_ID::int32 start_;
::PROTOBUF_NAMESPACE_ID::int32 end_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto_ReservedRange PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ {
public:
inline DescriptorProto_ReservedRange() : DescriptorProto_ReservedRange(nullptr) {}
virtual ~DescriptorProto_ReservedRange();
explicit constexpr DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from);
DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&& from) noexcept
: DescriptorProto_ReservedRange() {
*this = ::std::move(from);
}
inline DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange& from) {
CopyFrom(from);
return *this;
}
inline DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const DescriptorProto_ReservedRange& default_instance() {
return *internal_default_instance();
}
static inline const DescriptorProto_ReservedRange* internal_default_instance() {
return reinterpret_cast<const DescriptorProto_ReservedRange*>(
&_DescriptorProto_ReservedRange_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
friend void swap(DescriptorProto_ReservedRange& a, DescriptorProto_ReservedRange& b) {
a.Swap(&b);
}
inline void Swap(DescriptorProto_ReservedRange* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DescriptorProto_ReservedRange* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DescriptorProto_ReservedRange* New() const final {
return CreateMaybeMessage<DescriptorProto_ReservedRange>(nullptr);
}
DescriptorProto_ReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DescriptorProto_ReservedRange>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const DescriptorProto_ReservedRange& from);
void MergeFrom(const DescriptorProto_ReservedRange& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DescriptorProto_ReservedRange* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.DescriptorProto.ReservedRange";
}
protected:
explicit DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kStartFieldNumber = 1,
kEndFieldNumber = 2,
};
// optional int32 start = 1;
bool has_start() const;
private:
bool _internal_has_start() const;
public:
void clear_start();
::PROTOBUF_NAMESPACE_ID::int32 start() const;
void set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const;
void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 end = 2;
bool has_end() const;
private:
bool _internal_has_end() const;
public:
void clear_end();
::PROTOBUF_NAMESPACE_ID::int32 end() const;
void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ReservedRange)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::int32 start_;
::PROTOBUF_NAMESPACE_ID::int32 end_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT DescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ {
public:
inline DescriptorProto() : DescriptorProto(nullptr) {}
virtual ~DescriptorProto();
explicit constexpr DescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DescriptorProto(const DescriptorProto& from);
DescriptorProto(DescriptorProto&& from) noexcept
: DescriptorProto() {
*this = ::std::move(from);
}
inline DescriptorProto& operator=(const DescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline DescriptorProto& operator=(DescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const DescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const DescriptorProto* internal_default_instance() {
return reinterpret_cast<const DescriptorProto*>(
&_DescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
friend void swap(DescriptorProto& a, DescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(DescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(DescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline DescriptorProto* New() const final {
return CreateMaybeMessage<DescriptorProto>(nullptr);
}
DescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<DescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const DescriptorProto& from);
void MergeFrom(const DescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(DescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.DescriptorProto";
}
protected:
explicit DescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef DescriptorProto_ExtensionRange ExtensionRange;
typedef DescriptorProto_ReservedRange ReservedRange;
// accessors -------------------------------------------------------
enum : int {
kFieldFieldNumber = 2,
kNestedTypeFieldNumber = 3,
kEnumTypeFieldNumber = 4,
kExtensionRangeFieldNumber = 5,
kExtensionFieldNumber = 6,
kOneofDeclFieldNumber = 8,
kReservedRangeFieldNumber = 9,
kReservedNameFieldNumber = 10,
kNameFieldNumber = 1,
kOptionsFieldNumber = 7,
};
// repeated .google.protobuf.FieldDescriptorProto field = 2;
int field_size() const;
private:
int _internal_field_size() const;
public:
void clear_field();
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_field(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
mutable_field();
private:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_field(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_field();
public:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& field(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_field();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
field() const;
// repeated .google.protobuf.DescriptorProto nested_type = 3;
int nested_type_size() const;
private:
int _internal_nested_type_size() const;
public:
void clear_nested_type();
PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_nested_type(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >*
mutable_nested_type();
private:
const PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_nested_type(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_nested_type();
public:
const PROTOBUF_NAMESPACE_ID::DescriptorProto& nested_type(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto* add_nested_type();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >&
nested_type() const;
// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
int enum_type_size() const;
private:
int _internal_enum_type_size() const;
public:
void clear_enum_type();
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
mutable_enum_type();
private:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
public:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
enum_type() const;
// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
int extension_range_size() const;
private:
int _internal_extension_range_size() const;
public:
void clear_extension_range();
PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
mutable_extension_range();
private:
const PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& _internal_extension_range(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _internal_add_extension_range();
public:
const PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& extension_range(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* add_extension_range();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
extension_range() const;
// repeated .google.protobuf.FieldDescriptorProto extension = 6;
int extension_size() const;
private:
int _internal_extension_size() const;
public:
void clear_extension();
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
mutable_extension();
private:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
public:
const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
extension() const;
// repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
int oneof_decl_size() const;
private:
int _internal_oneof_decl_size() const;
public:
void clear_oneof_decl();
PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* mutable_oneof_decl(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
mutable_oneof_decl();
private:
const PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& _internal_oneof_decl(int index) const;
PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _internal_add_oneof_decl();
public:
const PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& oneof_decl(int index) const;
PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* add_oneof_decl();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
oneof_decl() const;
// repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
int reserved_range_size() const;
private:
int _internal_reserved_range_size() const;
public:
void clear_reserved_range();
PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* mutable_reserved_range(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
mutable_reserved_range();
private:
const PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& _internal_reserved_range(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _internal_add_reserved_range();
public:
const PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& reserved_range(int index) const;
PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* add_reserved_range();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
reserved_range() const;
// repeated string reserved_name = 10;
int reserved_name_size() const;
private:
int _internal_reserved_name_size() const;
public:
void clear_reserved_name();
const std::string& reserved_name(int index) const;
std::string* mutable_reserved_name(int index);
void set_reserved_name(int index, const std::string& value);
void set_reserved_name(int index, std::string&& value);
void set_reserved_name(int index, const char* value);
void set_reserved_name(int index, const char* value, size_t size);
std::string* add_reserved_name();
void add_reserved_name(const std::string& value);
void add_reserved_name(std::string&& value);
void add_reserved_name(const char* value);
void add_reserved_name(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
private:
const std::string& _internal_reserved_name(int index) const;
std::string* _internal_add_reserved_name();
public:
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .google.protobuf.MessageOptions options = 7;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::MessageOptions& options() const;
PROTOBUF_NAMESPACE_ID::MessageOptions* release_options();
PROTOBUF_NAMESPACE_ID::MessageOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::MessageOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::MessageOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::MessageOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::MessageOptions* options);
PROTOBUF_NAMESPACE_ID::MessageOptions* unsafe_arena_release_options();
// @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > field_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto > nested_type_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange > extension_range_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto > oneof_decl_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange > reserved_range_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
PROTOBUF_NAMESPACE_ID::MessageOptions* options_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT ExtensionRangeOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
public:
inline ExtensionRangeOptions() : ExtensionRangeOptions(nullptr) {}
virtual ~ExtensionRangeOptions();
explicit constexpr ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ExtensionRangeOptions(const ExtensionRangeOptions& from);
ExtensionRangeOptions(ExtensionRangeOptions&& from) noexcept
: ExtensionRangeOptions() {
*this = ::std::move(from);
}
inline ExtensionRangeOptions& operator=(const ExtensionRangeOptions& from) {
CopyFrom(from);
return *this;
}
inline ExtensionRangeOptions& operator=(ExtensionRangeOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const ExtensionRangeOptions& default_instance() {
return *internal_default_instance();
}
static inline const ExtensionRangeOptions* internal_default_instance() {
return reinterpret_cast<const ExtensionRangeOptions*>(
&_ExtensionRangeOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
friend void swap(ExtensionRangeOptions& a, ExtensionRangeOptions& b) {
a.Swap(&b);
}
inline void Swap(ExtensionRangeOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ExtensionRangeOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline ExtensionRangeOptions* New() const final {
return CreateMaybeMessage<ExtensionRangeOptions>(nullptr);
}
ExtensionRangeOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<ExtensionRangeOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const ExtensionRangeOptions& from);
void MergeFrom(const ExtensionRangeOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ExtensionRangeOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.ExtensionRangeOptions";
}
protected:
explicit ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ExtensionRangeOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.ExtensionRangeOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT FieldDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ {
public:
inline FieldDescriptorProto() : FieldDescriptorProto(nullptr) {}
virtual ~FieldDescriptorProto();
explicit constexpr FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FieldDescriptorProto(const FieldDescriptorProto& from);
FieldDescriptorProto(FieldDescriptorProto&& from) noexcept
: FieldDescriptorProto() {
*this = ::std::move(from);
}
inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline FieldDescriptorProto& operator=(FieldDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FieldDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const FieldDescriptorProto* internal_default_instance() {
return reinterpret_cast<const FieldDescriptorProto*>(
&_FieldDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
friend void swap(FieldDescriptorProto& a, FieldDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(FieldDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FieldDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FieldDescriptorProto* New() const final {
return CreateMaybeMessage<FieldDescriptorProto>(nullptr);
}
FieldDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FieldDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FieldDescriptorProto& from);
void MergeFrom(const FieldDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FieldDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.FieldDescriptorProto";
}
protected:
explicit FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef FieldDescriptorProto_Type Type;
static constexpr Type TYPE_DOUBLE =
FieldDescriptorProto_Type_TYPE_DOUBLE;
static constexpr Type TYPE_FLOAT =
FieldDescriptorProto_Type_TYPE_FLOAT;
static constexpr Type TYPE_INT64 =
FieldDescriptorProto_Type_TYPE_INT64;
static constexpr Type TYPE_UINT64 =
FieldDescriptorProto_Type_TYPE_UINT64;
static constexpr Type TYPE_INT32 =
FieldDescriptorProto_Type_TYPE_INT32;
static constexpr Type TYPE_FIXED64 =
FieldDescriptorProto_Type_TYPE_FIXED64;
static constexpr Type TYPE_FIXED32 =
FieldDescriptorProto_Type_TYPE_FIXED32;
static constexpr Type TYPE_BOOL =
FieldDescriptorProto_Type_TYPE_BOOL;
static constexpr Type TYPE_STRING =
FieldDescriptorProto_Type_TYPE_STRING;
static constexpr Type TYPE_GROUP =
FieldDescriptorProto_Type_TYPE_GROUP;
static constexpr Type TYPE_MESSAGE =
FieldDescriptorProto_Type_TYPE_MESSAGE;
static constexpr Type TYPE_BYTES =
FieldDescriptorProto_Type_TYPE_BYTES;
static constexpr Type TYPE_UINT32 =
FieldDescriptorProto_Type_TYPE_UINT32;
static constexpr Type TYPE_ENUM =
FieldDescriptorProto_Type_TYPE_ENUM;
static constexpr Type TYPE_SFIXED32 =
FieldDescriptorProto_Type_TYPE_SFIXED32;
static constexpr Type TYPE_SFIXED64 =
FieldDescriptorProto_Type_TYPE_SFIXED64;
static constexpr Type TYPE_SINT32 =
FieldDescriptorProto_Type_TYPE_SINT32;
static constexpr Type TYPE_SINT64 =
FieldDescriptorProto_Type_TYPE_SINT64;
static inline bool Type_IsValid(int value) {
return FieldDescriptorProto_Type_IsValid(value);
}
static constexpr Type Type_MIN =
FieldDescriptorProto_Type_Type_MIN;
static constexpr Type Type_MAX =
FieldDescriptorProto_Type_Type_MAX;
static constexpr int Type_ARRAYSIZE =
FieldDescriptorProto_Type_Type_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Type_descriptor() {
return FieldDescriptorProto_Type_descriptor();
}
template<typename T>
static inline const std::string& Type_Name(T enum_t_value) {
static_assert(::std::is_same<T, Type>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Type_Name.");
return FieldDescriptorProto_Type_Name(enum_t_value);
}
static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Type* value) {
return FieldDescriptorProto_Type_Parse(name, value);
}
typedef FieldDescriptorProto_Label Label;
static constexpr Label LABEL_OPTIONAL =
FieldDescriptorProto_Label_LABEL_OPTIONAL;
static constexpr Label LABEL_REQUIRED =
FieldDescriptorProto_Label_LABEL_REQUIRED;
static constexpr Label LABEL_REPEATED =
FieldDescriptorProto_Label_LABEL_REPEATED;
static inline bool Label_IsValid(int value) {
return FieldDescriptorProto_Label_IsValid(value);
}
static constexpr Label Label_MIN =
FieldDescriptorProto_Label_Label_MIN;
static constexpr Label Label_MAX =
FieldDescriptorProto_Label_Label_MAX;
static constexpr int Label_ARRAYSIZE =
FieldDescriptorProto_Label_Label_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
Label_descriptor() {
return FieldDescriptorProto_Label_descriptor();
}
template<typename T>
static inline const std::string& Label_Name(T enum_t_value) {
static_assert(::std::is_same<T, Label>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Label_Name.");
return FieldDescriptorProto_Label_Name(enum_t_value);
}
static inline bool Label_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Label* value) {
return FieldDescriptorProto_Label_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kExtendeeFieldNumber = 2,
kTypeNameFieldNumber = 6,
kDefaultValueFieldNumber = 7,
kJsonNameFieldNumber = 10,
kOptionsFieldNumber = 8,
kNumberFieldNumber = 3,
kOneofIndexFieldNumber = 9,
kProto3OptionalFieldNumber = 17,
kLabelFieldNumber = 4,
kTypeFieldNumber = 5,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string extendee = 2;
bool has_extendee() const;
private:
bool _internal_has_extendee() const;
public:
void clear_extendee();
const std::string& extendee() const;
void set_extendee(const std::string& value);
void set_extendee(std::string&& value);
void set_extendee(const char* value);
void set_extendee(const char* value, size_t size);
std::string* mutable_extendee();
std::string* release_extendee();
void set_allocated_extendee(std::string* extendee);
private:
const std::string& _internal_extendee() const;
void _internal_set_extendee(const std::string& value);
std::string* _internal_mutable_extendee();
public:
// optional string type_name = 6;
bool has_type_name() const;
private:
bool _internal_has_type_name() const;
public:
void clear_type_name();
const std::string& type_name() const;
void set_type_name(const std::string& value);
void set_type_name(std::string&& value);
void set_type_name(const char* value);
void set_type_name(const char* value, size_t size);
std::string* mutable_type_name();
std::string* release_type_name();
void set_allocated_type_name(std::string* type_name);
private:
const std::string& _internal_type_name() const;
void _internal_set_type_name(const std::string& value);
std::string* _internal_mutable_type_name();
public:
// optional string default_value = 7;
bool has_default_value() const;
private:
bool _internal_has_default_value() const;
public:
void clear_default_value();
const std::string& default_value() const;
void set_default_value(const std::string& value);
void set_default_value(std::string&& value);
void set_default_value(const char* value);
void set_default_value(const char* value, size_t size);
std::string* mutable_default_value();
std::string* release_default_value();
void set_allocated_default_value(std::string* default_value);
private:
const std::string& _internal_default_value() const;
void _internal_set_default_value(const std::string& value);
std::string* _internal_mutable_default_value();
public:
// optional string json_name = 10;
bool has_json_name() const;
private:
bool _internal_has_json_name() const;
public:
void clear_json_name();
const std::string& json_name() const;
void set_json_name(const std::string& value);
void set_json_name(std::string&& value);
void set_json_name(const char* value);
void set_json_name(const char* value, size_t size);
std::string* mutable_json_name();
std::string* release_json_name();
void set_allocated_json_name(std::string* json_name);
private:
const std::string& _internal_json_name() const;
void _internal_set_json_name(const std::string& value);
std::string* _internal_mutable_json_name();
public:
// optional .google.protobuf.FieldOptions options = 8;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::FieldOptions& options() const;
PROTOBUF_NAMESPACE_ID::FieldOptions* release_options();
PROTOBUF_NAMESPACE_ID::FieldOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::FieldOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::FieldOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::FieldOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::FieldOptions* options);
PROTOBUF_NAMESPACE_ID::FieldOptions* unsafe_arena_release_options();
// optional int32 number = 3;
bool has_number() const;
private:
bool _internal_has_number() const;
public:
void clear_number();
::PROTOBUF_NAMESPACE_ID::int32 number() const;
void set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_number() const;
void _internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 oneof_index = 9;
bool has_oneof_index() const;
private:
bool _internal_has_oneof_index() const;
public:
void clear_oneof_index();
::PROTOBUF_NAMESPACE_ID::int32 oneof_index() const;
void set_oneof_index(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_oneof_index() const;
void _internal_set_oneof_index(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional bool proto3_optional = 17;
bool has_proto3_optional() const;
private:
bool _internal_has_proto3_optional() const;
public:
void clear_proto3_optional();
bool proto3_optional() const;
void set_proto3_optional(bool value);
private:
bool _internal_proto3_optional() const;
void _internal_set_proto3_optional(bool value);
public:
// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
bool has_label() const;
private:
bool _internal_has_label() const;
public:
void clear_label();
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label label() const;
void set_label(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
private:
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label _internal_label() const;
void _internal_set_label(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
public:
// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
bool has_type() const;
private:
bool _internal_has_type() const;
public:
void clear_type();
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type type() const;
void set_type(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
private:
PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type _internal_type() const;
void _internal_set_type(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extendee_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
PROTOBUF_NAMESPACE_ID::FieldOptions* options_;
::PROTOBUF_NAMESPACE_ID::int32 number_;
::PROTOBUF_NAMESPACE_ID::int32 oneof_index_;
bool proto3_optional_;
int label_;
int type_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT OneofDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ {
public:
inline OneofDescriptorProto() : OneofDescriptorProto(nullptr) {}
virtual ~OneofDescriptorProto();
explicit constexpr OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
OneofDescriptorProto(const OneofDescriptorProto& from);
OneofDescriptorProto(OneofDescriptorProto&& from) noexcept
: OneofDescriptorProto() {
*this = ::std::move(from);
}
inline OneofDescriptorProto& operator=(const OneofDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline OneofDescriptorProto& operator=(OneofDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const OneofDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const OneofDescriptorProto* internal_default_instance() {
return reinterpret_cast<const OneofDescriptorProto*>(
&_OneofDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
friend void swap(OneofDescriptorProto& a, OneofDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(OneofDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(OneofDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline OneofDescriptorProto* New() const final {
return CreateMaybeMessage<OneofDescriptorProto>(nullptr);
}
OneofDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<OneofDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const OneofDescriptorProto& from);
void MergeFrom(const OneofDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(OneofDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.OneofDescriptorProto";
}
protected:
explicit OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kOptionsFieldNumber = 2,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .google.protobuf.OneofOptions options = 2;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::OneofOptions& options() const;
PROTOBUF_NAMESPACE_ID::OneofOptions* release_options();
PROTOBUF_NAMESPACE_ID::OneofOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::OneofOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::OneofOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::OneofOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::OneofOptions* options);
PROTOBUF_NAMESPACE_ID::OneofOptions* unsafe_arena_release_options();
// @@protoc_insertion_point(class_scope:google.protobuf.OneofDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
PROTOBUF_NAMESPACE_ID::OneofOptions* options_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ {
public:
inline EnumDescriptorProto_EnumReservedRange() : EnumDescriptorProto_EnumReservedRange(nullptr) {}
virtual ~EnumDescriptorProto_EnumReservedRange();
explicit constexpr EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EnumDescriptorProto_EnumReservedRange(const EnumDescriptorProto_EnumReservedRange& from);
EnumDescriptorProto_EnumReservedRange(EnumDescriptorProto_EnumReservedRange&& from) noexcept
: EnumDescriptorProto_EnumReservedRange() {
*this = ::std::move(from);
}
inline EnumDescriptorProto_EnumReservedRange& operator=(const EnumDescriptorProto_EnumReservedRange& from) {
CopyFrom(from);
return *this;
}
inline EnumDescriptorProto_EnumReservedRange& operator=(EnumDescriptorProto_EnumReservedRange&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const EnumDescriptorProto_EnumReservedRange& default_instance() {
return *internal_default_instance();
}
static inline const EnumDescriptorProto_EnumReservedRange* internal_default_instance() {
return reinterpret_cast<const EnumDescriptorProto_EnumReservedRange*>(
&_EnumDescriptorProto_EnumReservedRange_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
friend void swap(EnumDescriptorProto_EnumReservedRange& a, EnumDescriptorProto_EnumReservedRange& b) {
a.Swap(&b);
}
inline void Swap(EnumDescriptorProto_EnumReservedRange* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EnumDescriptorProto_EnumReservedRange* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline EnumDescriptorProto_EnumReservedRange* New() const final {
return CreateMaybeMessage<EnumDescriptorProto_EnumReservedRange>(nullptr);
}
EnumDescriptorProto_EnumReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<EnumDescriptorProto_EnumReservedRange>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const EnumDescriptorProto_EnumReservedRange& from);
void MergeFrom(const EnumDescriptorProto_EnumReservedRange& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EnumDescriptorProto_EnumReservedRange* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.EnumDescriptorProto.EnumReservedRange";
}
protected:
explicit EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kStartFieldNumber = 1,
kEndFieldNumber = 2,
};
// optional int32 start = 1;
bool has_start() const;
private:
bool _internal_has_start() const;
public:
void clear_start();
::PROTOBUF_NAMESPACE_ID::int32 start() const;
void set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const;
void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 end = 2;
bool has_end() const;
private:
bool _internal_has_end() const;
public:
void clear_end();
::PROTOBUF_NAMESPACE_ID::int32 end() const;
void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto.EnumReservedRange)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::int32 start_;
::PROTOBUF_NAMESPACE_ID::int32 end_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ {
public:
inline EnumDescriptorProto() : EnumDescriptorProto(nullptr) {}
virtual ~EnumDescriptorProto();
explicit constexpr EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EnumDescriptorProto(const EnumDescriptorProto& from);
EnumDescriptorProto(EnumDescriptorProto&& from) noexcept
: EnumDescriptorProto() {
*this = ::std::move(from);
}
inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline EnumDescriptorProto& operator=(EnumDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const EnumDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const EnumDescriptorProto* internal_default_instance() {
return reinterpret_cast<const EnumDescriptorProto*>(
&_EnumDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
friend void swap(EnumDescriptorProto& a, EnumDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(EnumDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EnumDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline EnumDescriptorProto* New() const final {
return CreateMaybeMessage<EnumDescriptorProto>(nullptr);
}
EnumDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<EnumDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const EnumDescriptorProto& from);
void MergeFrom(const EnumDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EnumDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.EnumDescriptorProto";
}
protected:
explicit EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef EnumDescriptorProto_EnumReservedRange EnumReservedRange;
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 2,
kReservedRangeFieldNumber = 4,
kReservedNameFieldNumber = 5,
kNameFieldNumber = 1,
kOptionsFieldNumber = 3,
};
// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
int value_size() const;
private:
int _internal_value_size() const;
public:
void clear_value();
PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* mutable_value(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
mutable_value();
private:
const PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& _internal_value(int index) const;
PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _internal_add_value();
public:
const PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& value(int index) const;
PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* add_value();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
value() const;
// repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
int reserved_range_size() const;
private:
int _internal_reserved_range_size() const;
public:
void clear_reserved_range();
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* mutable_reserved_range(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
mutable_reserved_range();
private:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& _internal_reserved_range(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _internal_add_reserved_range();
public:
const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& reserved_range(int index) const;
PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* add_reserved_range();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
reserved_range() const;
// repeated string reserved_name = 5;
int reserved_name_size() const;
private:
int _internal_reserved_name_size() const;
public:
void clear_reserved_name();
const std::string& reserved_name(int index) const;
std::string* mutable_reserved_name(int index);
void set_reserved_name(int index, const std::string& value);
void set_reserved_name(int index, std::string&& value);
void set_reserved_name(int index, const char* value);
void set_reserved_name(int index, const char* value, size_t size);
std::string* add_reserved_name();
void add_reserved_name(const std::string& value);
void add_reserved_name(std::string&& value);
void add_reserved_name(const char* value);
void add_reserved_name(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
private:
const std::string& _internal_reserved_name(int index) const;
std::string* _internal_add_reserved_name();
public:
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .google.protobuf.EnumOptions options = 3;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::EnumOptions& options() const;
PROTOBUF_NAMESPACE_ID::EnumOptions* release_options();
PROTOBUF_NAMESPACE_ID::EnumOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::EnumOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::EnumOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::EnumOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::EnumOptions* options);
PROTOBUF_NAMESPACE_ID::EnumOptions* unsafe_arena_release_options();
// @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto > value_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange > reserved_range_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
PROTOBUF_NAMESPACE_ID::EnumOptions* options_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumValueDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ {
public:
inline EnumValueDescriptorProto() : EnumValueDescriptorProto(nullptr) {}
virtual ~EnumValueDescriptorProto();
explicit constexpr EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
EnumValueDescriptorProto(EnumValueDescriptorProto&& from) noexcept
: EnumValueDescriptorProto() {
*this = ::std::move(from);
}
inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const EnumValueDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const EnumValueDescriptorProto* internal_default_instance() {
return reinterpret_cast<const EnumValueDescriptorProto*>(
&_EnumValueDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
friend void swap(EnumValueDescriptorProto& a, EnumValueDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(EnumValueDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EnumValueDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline EnumValueDescriptorProto* New() const final {
return CreateMaybeMessage<EnumValueDescriptorProto>(nullptr);
}
EnumValueDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<EnumValueDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const EnumValueDescriptorProto& from);
void MergeFrom(const EnumValueDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EnumValueDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.EnumValueDescriptorProto";
}
protected:
explicit EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kOptionsFieldNumber = 3,
kNumberFieldNumber = 2,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .google.protobuf.EnumValueOptions options = 3;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::EnumValueOptions& options() const;
PROTOBUF_NAMESPACE_ID::EnumValueOptions* release_options();
PROTOBUF_NAMESPACE_ID::EnumValueOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::EnumValueOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::EnumValueOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
PROTOBUF_NAMESPACE_ID::EnumValueOptions* unsafe_arena_release_options();
// optional int32 number = 2;
bool has_number() const;
private:
bool _internal_has_number() const;
public:
void clear_number();
::PROTOBUF_NAMESPACE_ID::int32 number() const;
void set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_number() const;
void _internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
PROTOBUF_NAMESPACE_ID::EnumValueOptions* options_;
::PROTOBUF_NAMESPACE_ID::int32 number_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT ServiceDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ {
public:
inline ServiceDescriptorProto() : ServiceDescriptorProto(nullptr) {}
virtual ~ServiceDescriptorProto();
explicit constexpr ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ServiceDescriptorProto(const ServiceDescriptorProto& from);
ServiceDescriptorProto(ServiceDescriptorProto&& from) noexcept
: ServiceDescriptorProto() {
*this = ::std::move(from);
}
inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline ServiceDescriptorProto& operator=(ServiceDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const ServiceDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const ServiceDescriptorProto* internal_default_instance() {
return reinterpret_cast<const ServiceDescriptorProto*>(
&_ServiceDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
friend void swap(ServiceDescriptorProto& a, ServiceDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(ServiceDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ServiceDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline ServiceDescriptorProto* New() const final {
return CreateMaybeMessage<ServiceDescriptorProto>(nullptr);
}
ServiceDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<ServiceDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const ServiceDescriptorProto& from);
void MergeFrom(const ServiceDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ServiceDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.ServiceDescriptorProto";
}
protected:
explicit ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kMethodFieldNumber = 2,
kNameFieldNumber = 1,
kOptionsFieldNumber = 3,
};
// repeated .google.protobuf.MethodDescriptorProto method = 2;
int method_size() const;
private:
int _internal_method_size() const;
public:
void clear_method();
PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* mutable_method(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
mutable_method();
private:
const PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& _internal_method(int index) const;
PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _internal_add_method();
public:
const PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& method(int index) const;
PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* add_method();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
method() const;
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional .google.protobuf.ServiceOptions options = 3;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::ServiceOptions& options() const;
PROTOBUF_NAMESPACE_ID::ServiceOptions* release_options();
PROTOBUF_NAMESPACE_ID::ServiceOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::ServiceOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::ServiceOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
PROTOBUF_NAMESPACE_ID::ServiceOptions* unsafe_arena_release_options();
// @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::MethodDescriptorProto > method_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
PROTOBUF_NAMESPACE_ID::ServiceOptions* options_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT MethodDescriptorProto PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ {
public:
inline MethodDescriptorProto() : MethodDescriptorProto(nullptr) {}
virtual ~MethodDescriptorProto();
explicit constexpr MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MethodDescriptorProto(const MethodDescriptorProto& from);
MethodDescriptorProto(MethodDescriptorProto&& from) noexcept
: MethodDescriptorProto() {
*this = ::std::move(from);
}
inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) {
CopyFrom(from);
return *this;
}
inline MethodDescriptorProto& operator=(MethodDescriptorProto&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const MethodDescriptorProto& default_instance() {
return *internal_default_instance();
}
static inline const MethodDescriptorProto* internal_default_instance() {
return reinterpret_cast<const MethodDescriptorProto*>(
&_MethodDescriptorProto_default_instance_);
}
static constexpr int kIndexInFileMessages =
12;
friend void swap(MethodDescriptorProto& a, MethodDescriptorProto& b) {
a.Swap(&b);
}
inline void Swap(MethodDescriptorProto* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MethodDescriptorProto* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MethodDescriptorProto* New() const final {
return CreateMaybeMessage<MethodDescriptorProto>(nullptr);
}
MethodDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MethodDescriptorProto>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const MethodDescriptorProto& from);
void MergeFrom(const MethodDescriptorProto& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MethodDescriptorProto* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.MethodDescriptorProto";
}
protected:
explicit MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 1,
kInputTypeFieldNumber = 2,
kOutputTypeFieldNumber = 3,
kOptionsFieldNumber = 4,
kClientStreamingFieldNumber = 5,
kServerStreamingFieldNumber = 6,
};
// optional string name = 1;
bool has_name() const;
private:
bool _internal_has_name() const;
public:
void clear_name();
const std::string& name() const;
void set_name(const std::string& value);
void set_name(std::string&& value);
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);
private:
const std::string& _internal_name() const;
void _internal_set_name(const std::string& value);
std::string* _internal_mutable_name();
public:
// optional string input_type = 2;
bool has_input_type() const;
private:
bool _internal_has_input_type() const;
public:
void clear_input_type();
const std::string& input_type() const;
void set_input_type(const std::string& value);
void set_input_type(std::string&& value);
void set_input_type(const char* value);
void set_input_type(const char* value, size_t size);
std::string* mutable_input_type();
std::string* release_input_type();
void set_allocated_input_type(std::string* input_type);
private:
const std::string& _internal_input_type() const;
void _internal_set_input_type(const std::string& value);
std::string* _internal_mutable_input_type();
public:
// optional string output_type = 3;
bool has_output_type() const;
private:
bool _internal_has_output_type() const;
public:
void clear_output_type();
const std::string& output_type() const;
void set_output_type(const std::string& value);
void set_output_type(std::string&& value);
void set_output_type(const char* value);
void set_output_type(const char* value, size_t size);
std::string* mutable_output_type();
std::string* release_output_type();
void set_allocated_output_type(std::string* output_type);
private:
const std::string& _internal_output_type() const;
void _internal_set_output_type(const std::string& value);
std::string* _internal_mutable_output_type();
public:
// optional .google.protobuf.MethodOptions options = 4;
bool has_options() const;
private:
bool _internal_has_options() const;
public:
void clear_options();
const PROTOBUF_NAMESPACE_ID::MethodOptions& options() const;
PROTOBUF_NAMESPACE_ID::MethodOptions* release_options();
PROTOBUF_NAMESPACE_ID::MethodOptions* mutable_options();
void set_allocated_options(PROTOBUF_NAMESPACE_ID::MethodOptions* options);
private:
const PROTOBUF_NAMESPACE_ID::MethodOptions& _internal_options() const;
PROTOBUF_NAMESPACE_ID::MethodOptions* _internal_mutable_options();
public:
void unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::MethodOptions* options);
PROTOBUF_NAMESPACE_ID::MethodOptions* unsafe_arena_release_options();
// optional bool client_streaming = 5 [default = false];
bool has_client_streaming() const;
private:
bool _internal_has_client_streaming() const;
public:
void clear_client_streaming();
bool client_streaming() const;
void set_client_streaming(bool value);
private:
bool _internal_client_streaming() const;
void _internal_set_client_streaming(bool value);
public:
// optional bool server_streaming = 6 [default = false];
bool has_server_streaming() const;
private:
bool _internal_has_server_streaming() const;
public:
void clear_server_streaming();
bool server_streaming() const;
void set_server_streaming(bool value);
private:
bool _internal_server_streaming() const;
void _internal_set_server_streaming(bool value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_type_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_type_;
PROTOBUF_NAMESPACE_ID::MethodOptions* options_;
bool client_streaming_;
bool server_streaming_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT FileOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ {
public:
inline FileOptions() : FileOptions(nullptr) {}
virtual ~FileOptions();
explicit constexpr FileOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FileOptions(const FileOptions& from);
FileOptions(FileOptions&& from) noexcept
: FileOptions() {
*this = ::std::move(from);
}
inline FileOptions& operator=(const FileOptions& from) {
CopyFrom(from);
return *this;
}
inline FileOptions& operator=(FileOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FileOptions& default_instance() {
return *internal_default_instance();
}
static inline const FileOptions* internal_default_instance() {
return reinterpret_cast<const FileOptions*>(
&_FileOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
13;
friend void swap(FileOptions& a, FileOptions& b) {
a.Swap(&b);
}
inline void Swap(FileOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FileOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FileOptions* New() const final {
return CreateMaybeMessage<FileOptions>(nullptr);
}
FileOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FileOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FileOptions& from);
void MergeFrom(const FileOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FileOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.FileOptions";
}
protected:
explicit FileOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef FileOptions_OptimizeMode OptimizeMode;
static constexpr OptimizeMode SPEED =
FileOptions_OptimizeMode_SPEED;
static constexpr OptimizeMode CODE_SIZE =
FileOptions_OptimizeMode_CODE_SIZE;
static constexpr OptimizeMode LITE_RUNTIME =
FileOptions_OptimizeMode_LITE_RUNTIME;
static inline bool OptimizeMode_IsValid(int value) {
return FileOptions_OptimizeMode_IsValid(value);
}
static constexpr OptimizeMode OptimizeMode_MIN =
FileOptions_OptimizeMode_OptimizeMode_MIN;
static constexpr OptimizeMode OptimizeMode_MAX =
FileOptions_OptimizeMode_OptimizeMode_MAX;
static constexpr int OptimizeMode_ARRAYSIZE =
FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
OptimizeMode_descriptor() {
return FileOptions_OptimizeMode_descriptor();
}
template<typename T>
static inline const std::string& OptimizeMode_Name(T enum_t_value) {
static_assert(::std::is_same<T, OptimizeMode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function OptimizeMode_Name.");
return FileOptions_OptimizeMode_Name(enum_t_value);
}
static inline bool OptimizeMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
OptimizeMode* value) {
return FileOptions_OptimizeMode_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kJavaPackageFieldNumber = 1,
kJavaOuterClassnameFieldNumber = 8,
kGoPackageFieldNumber = 11,
kObjcClassPrefixFieldNumber = 36,
kCsharpNamespaceFieldNumber = 37,
kSwiftPrefixFieldNumber = 39,
kPhpClassPrefixFieldNumber = 40,
kPhpNamespaceFieldNumber = 41,
kPhpMetadataNamespaceFieldNumber = 44,
kRubyPackageFieldNumber = 45,
kJavaMultipleFilesFieldNumber = 10,
kJavaGenerateEqualsAndHashFieldNumber = 20,
kJavaStringCheckUtf8FieldNumber = 27,
kCcGenericServicesFieldNumber = 16,
kJavaGenericServicesFieldNumber = 17,
kPyGenericServicesFieldNumber = 18,
kPhpGenericServicesFieldNumber = 42,
kDeprecatedFieldNumber = 23,
kOptimizeForFieldNumber = 9,
kCcEnableArenasFieldNumber = 31,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional string java_package = 1;
bool has_java_package() const;
private:
bool _internal_has_java_package() const;
public:
void clear_java_package();
const std::string& java_package() const;
void set_java_package(const std::string& value);
void set_java_package(std::string&& value);
void set_java_package(const char* value);
void set_java_package(const char* value, size_t size);
std::string* mutable_java_package();
std::string* release_java_package();
void set_allocated_java_package(std::string* java_package);
private:
const std::string& _internal_java_package() const;
void _internal_set_java_package(const std::string& value);
std::string* _internal_mutable_java_package();
public:
// optional string java_outer_classname = 8;
bool has_java_outer_classname() const;
private:
bool _internal_has_java_outer_classname() const;
public:
void clear_java_outer_classname();
const std::string& java_outer_classname() const;
void set_java_outer_classname(const std::string& value);
void set_java_outer_classname(std::string&& value);
void set_java_outer_classname(const char* value);
void set_java_outer_classname(const char* value, size_t size);
std::string* mutable_java_outer_classname();
std::string* release_java_outer_classname();
void set_allocated_java_outer_classname(std::string* java_outer_classname);
private:
const std::string& _internal_java_outer_classname() const;
void _internal_set_java_outer_classname(const std::string& value);
std::string* _internal_mutable_java_outer_classname();
public:
// optional string go_package = 11;
bool has_go_package() const;
private:
bool _internal_has_go_package() const;
public:
void clear_go_package();
const std::string& go_package() const;
void set_go_package(const std::string& value);
void set_go_package(std::string&& value);
void set_go_package(const char* value);
void set_go_package(const char* value, size_t size);
std::string* mutable_go_package();
std::string* release_go_package();
void set_allocated_go_package(std::string* go_package);
private:
const std::string& _internal_go_package() const;
void _internal_set_go_package(const std::string& value);
std::string* _internal_mutable_go_package();
public:
// optional string objc_class_prefix = 36;
bool has_objc_class_prefix() const;
private:
bool _internal_has_objc_class_prefix() const;
public:
void clear_objc_class_prefix();
const std::string& objc_class_prefix() const;
void set_objc_class_prefix(const std::string& value);
void set_objc_class_prefix(std::string&& value);
void set_objc_class_prefix(const char* value);
void set_objc_class_prefix(const char* value, size_t size);
std::string* mutable_objc_class_prefix();
std::string* release_objc_class_prefix();
void set_allocated_objc_class_prefix(std::string* objc_class_prefix);
private:
const std::string& _internal_objc_class_prefix() const;
void _internal_set_objc_class_prefix(const std::string& value);
std::string* _internal_mutable_objc_class_prefix();
public:
// optional string csharp_namespace = 37;
bool has_csharp_namespace() const;
private:
bool _internal_has_csharp_namespace() const;
public:
void clear_csharp_namespace();
const std::string& csharp_namespace() const;
void set_csharp_namespace(const std::string& value);
void set_csharp_namespace(std::string&& value);
void set_csharp_namespace(const char* value);
void set_csharp_namespace(const char* value, size_t size);
std::string* mutable_csharp_namespace();
std::string* release_csharp_namespace();
void set_allocated_csharp_namespace(std::string* csharp_namespace);
private:
const std::string& _internal_csharp_namespace() const;
void _internal_set_csharp_namespace(const std::string& value);
std::string* _internal_mutable_csharp_namespace();
public:
// optional string swift_prefix = 39;
bool has_swift_prefix() const;
private:
bool _internal_has_swift_prefix() const;
public:
void clear_swift_prefix();
const std::string& swift_prefix() const;
void set_swift_prefix(const std::string& value);
void set_swift_prefix(std::string&& value);
void set_swift_prefix(const char* value);
void set_swift_prefix(const char* value, size_t size);
std::string* mutable_swift_prefix();
std::string* release_swift_prefix();
void set_allocated_swift_prefix(std::string* swift_prefix);
private:
const std::string& _internal_swift_prefix() const;
void _internal_set_swift_prefix(const std::string& value);
std::string* _internal_mutable_swift_prefix();
public:
// optional string php_class_prefix = 40;
bool has_php_class_prefix() const;
private:
bool _internal_has_php_class_prefix() const;
public:
void clear_php_class_prefix();
const std::string& php_class_prefix() const;
void set_php_class_prefix(const std::string& value);
void set_php_class_prefix(std::string&& value);
void set_php_class_prefix(const char* value);
void set_php_class_prefix(const char* value, size_t size);
std::string* mutable_php_class_prefix();
std::string* release_php_class_prefix();
void set_allocated_php_class_prefix(std::string* php_class_prefix);
private:
const std::string& _internal_php_class_prefix() const;
void _internal_set_php_class_prefix(const std::string& value);
std::string* _internal_mutable_php_class_prefix();
public:
// optional string php_namespace = 41;
bool has_php_namespace() const;
private:
bool _internal_has_php_namespace() const;
public:
void clear_php_namespace();
const std::string& php_namespace() const;
void set_php_namespace(const std::string& value);
void set_php_namespace(std::string&& value);
void set_php_namespace(const char* value);
void set_php_namespace(const char* value, size_t size);
std::string* mutable_php_namespace();
std::string* release_php_namespace();
void set_allocated_php_namespace(std::string* php_namespace);
private:
const std::string& _internal_php_namespace() const;
void _internal_set_php_namespace(const std::string& value);
std::string* _internal_mutable_php_namespace();
public:
// optional string php_metadata_namespace = 44;
bool has_php_metadata_namespace() const;
private:
bool _internal_has_php_metadata_namespace() const;
public:
void clear_php_metadata_namespace();
const std::string& php_metadata_namespace() const;
void set_php_metadata_namespace(const std::string& value);
void set_php_metadata_namespace(std::string&& value);
void set_php_metadata_namespace(const char* value);
void set_php_metadata_namespace(const char* value, size_t size);
std::string* mutable_php_metadata_namespace();
std::string* release_php_metadata_namespace();
void set_allocated_php_metadata_namespace(std::string* php_metadata_namespace);
private:
const std::string& _internal_php_metadata_namespace() const;
void _internal_set_php_metadata_namespace(const std::string& value);
std::string* _internal_mutable_php_metadata_namespace();
public:
// optional string ruby_package = 45;
bool has_ruby_package() const;
private:
bool _internal_has_ruby_package() const;
public:
void clear_ruby_package();
const std::string& ruby_package() const;
void set_ruby_package(const std::string& value);
void set_ruby_package(std::string&& value);
void set_ruby_package(const char* value);
void set_ruby_package(const char* value, size_t size);
std::string* mutable_ruby_package();
std::string* release_ruby_package();
void set_allocated_ruby_package(std::string* ruby_package);
private:
const std::string& _internal_ruby_package() const;
void _internal_set_ruby_package(const std::string& value);
std::string* _internal_mutable_ruby_package();
public:
// optional bool java_multiple_files = 10 [default = false];
bool has_java_multiple_files() const;
private:
bool _internal_has_java_multiple_files() const;
public:
void clear_java_multiple_files();
bool java_multiple_files() const;
void set_java_multiple_files(bool value);
private:
bool _internal_java_multiple_files() const;
void _internal_set_java_multiple_files(bool value);
public:
// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
PROTOBUF_DEPRECATED bool has_java_generate_equals_and_hash() const;
private:
bool _internal_has_java_generate_equals_and_hash() const;
public:
PROTOBUF_DEPRECATED void clear_java_generate_equals_and_hash();
PROTOBUF_DEPRECATED bool java_generate_equals_and_hash() const;
PROTOBUF_DEPRECATED void set_java_generate_equals_and_hash(bool value);
private:
bool _internal_java_generate_equals_and_hash() const;
void _internal_set_java_generate_equals_and_hash(bool value);
public:
// optional bool java_string_check_utf8 = 27 [default = false];
bool has_java_string_check_utf8() const;
private:
bool _internal_has_java_string_check_utf8() const;
public:
void clear_java_string_check_utf8();
bool java_string_check_utf8() const;
void set_java_string_check_utf8(bool value);
private:
bool _internal_java_string_check_utf8() const;
void _internal_set_java_string_check_utf8(bool value);
public:
// optional bool cc_generic_services = 16 [default = false];
bool has_cc_generic_services() const;
private:
bool _internal_has_cc_generic_services() const;
public:
void clear_cc_generic_services();
bool cc_generic_services() const;
void set_cc_generic_services(bool value);
private:
bool _internal_cc_generic_services() const;
void _internal_set_cc_generic_services(bool value);
public:
// optional bool java_generic_services = 17 [default = false];
bool has_java_generic_services() const;
private:
bool _internal_has_java_generic_services() const;
public:
void clear_java_generic_services();
bool java_generic_services() const;
void set_java_generic_services(bool value);
private:
bool _internal_java_generic_services() const;
void _internal_set_java_generic_services(bool value);
public:
// optional bool py_generic_services = 18 [default = false];
bool has_py_generic_services() const;
private:
bool _internal_has_py_generic_services() const;
public:
void clear_py_generic_services();
bool py_generic_services() const;
void set_py_generic_services(bool value);
private:
bool _internal_py_generic_services() const;
void _internal_set_py_generic_services(bool value);
public:
// optional bool php_generic_services = 42 [default = false];
bool has_php_generic_services() const;
private:
bool _internal_has_php_generic_services() const;
public:
void clear_php_generic_services();
bool php_generic_services() const;
void set_php_generic_services(bool value);
private:
bool _internal_php_generic_services() const;
void _internal_set_php_generic_services(bool value);
public:
// optional bool deprecated = 23 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
bool has_optimize_for() const;
private:
bool _internal_has_optimize_for() const;
public:
void clear_optimize_for();
PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode optimize_for() const;
void set_optimize_for(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
private:
PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode _internal_optimize_for() const;
void _internal_set_optimize_for(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
public:
// optional bool cc_enable_arenas = 31 [default = true];
bool has_cc_enable_arenas() const;
private:
bool _internal_has_cc_enable_arenas() const;
public:
void clear_cc_enable_arenas();
bool cc_enable_arenas() const;
void set_cc_enable_arenas(bool value);
private:
bool _internal_cc_enable_arenas() const;
void _internal_set_cc_enable_arenas(bool value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_package_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_outer_classname_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr go_package_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr objc_class_prefix_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr csharp_namespace_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr swift_prefix_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_class_prefix_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_namespace_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_metadata_namespace_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ruby_package_;
bool java_multiple_files_;
bool java_generate_equals_and_hash_;
bool java_string_check_utf8_;
bool cc_generic_services_;
bool java_generic_services_;
bool py_generic_services_;
bool php_generic_services_;
bool deprecated_;
int optimize_for_;
bool cc_enable_arenas_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT MessageOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ {
public:
inline MessageOptions() : MessageOptions(nullptr) {}
virtual ~MessageOptions();
explicit constexpr MessageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MessageOptions(const MessageOptions& from);
MessageOptions(MessageOptions&& from) noexcept
: MessageOptions() {
*this = ::std::move(from);
}
inline MessageOptions& operator=(const MessageOptions& from) {
CopyFrom(from);
return *this;
}
inline MessageOptions& operator=(MessageOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const MessageOptions& default_instance() {
return *internal_default_instance();
}
static inline const MessageOptions* internal_default_instance() {
return reinterpret_cast<const MessageOptions*>(
&_MessageOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
friend void swap(MessageOptions& a, MessageOptions& b) {
a.Swap(&b);
}
inline void Swap(MessageOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MessageOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MessageOptions* New() const final {
return CreateMaybeMessage<MessageOptions>(nullptr);
}
MessageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MessageOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const MessageOptions& from);
void MergeFrom(const MessageOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MessageOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.MessageOptions";
}
protected:
explicit MessageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kMessageSetWireFormatFieldNumber = 1,
kNoStandardDescriptorAccessorFieldNumber = 2,
kDeprecatedFieldNumber = 3,
kMapEntryFieldNumber = 7,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional bool message_set_wire_format = 1 [default = false];
bool has_message_set_wire_format() const;
private:
bool _internal_has_message_set_wire_format() const;
public:
void clear_message_set_wire_format();
bool message_set_wire_format() const;
void set_message_set_wire_format(bool value);
private:
bool _internal_message_set_wire_format() const;
void _internal_set_message_set_wire_format(bool value);
public:
// optional bool no_standard_descriptor_accessor = 2 [default = false];
bool has_no_standard_descriptor_accessor() const;
private:
bool _internal_has_no_standard_descriptor_accessor() const;
public:
void clear_no_standard_descriptor_accessor();
bool no_standard_descriptor_accessor() const;
void set_no_standard_descriptor_accessor(bool value);
private:
bool _internal_no_standard_descriptor_accessor() const;
void _internal_set_no_standard_descriptor_accessor(bool value);
public:
// optional bool deprecated = 3 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
// optional bool map_entry = 7;
bool has_map_entry() const;
private:
bool _internal_has_map_entry() const;
public:
void clear_map_entry();
bool map_entry() const;
void set_map_entry(bool value);
private:
bool _internal_map_entry() const;
void _internal_set_map_entry(bool value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
bool message_set_wire_format_;
bool no_standard_descriptor_accessor_;
bool deprecated_;
bool map_entry_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT FieldOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ {
public:
inline FieldOptions() : FieldOptions(nullptr) {}
virtual ~FieldOptions();
explicit constexpr FieldOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
FieldOptions(const FieldOptions& from);
FieldOptions(FieldOptions&& from) noexcept
: FieldOptions() {
*this = ::std::move(from);
}
inline FieldOptions& operator=(const FieldOptions& from) {
CopyFrom(from);
return *this;
}
inline FieldOptions& operator=(FieldOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const FieldOptions& default_instance() {
return *internal_default_instance();
}
static inline const FieldOptions* internal_default_instance() {
return reinterpret_cast<const FieldOptions*>(
&_FieldOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
friend void swap(FieldOptions& a, FieldOptions& b) {
a.Swap(&b);
}
inline void Swap(FieldOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(FieldOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline FieldOptions* New() const final {
return CreateMaybeMessage<FieldOptions>(nullptr);
}
FieldOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<FieldOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const FieldOptions& from);
void MergeFrom(const FieldOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(FieldOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.FieldOptions";
}
protected:
explicit FieldOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef FieldOptions_CType CType;
static constexpr CType STRING =
FieldOptions_CType_STRING;
static constexpr CType CORD =
FieldOptions_CType_CORD;
static constexpr CType STRING_PIECE =
FieldOptions_CType_STRING_PIECE;
static inline bool CType_IsValid(int value) {
return FieldOptions_CType_IsValid(value);
}
static constexpr CType CType_MIN =
FieldOptions_CType_CType_MIN;
static constexpr CType CType_MAX =
FieldOptions_CType_CType_MAX;
static constexpr int CType_ARRAYSIZE =
FieldOptions_CType_CType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
CType_descriptor() {
return FieldOptions_CType_descriptor();
}
template<typename T>
static inline const std::string& CType_Name(T enum_t_value) {
static_assert(::std::is_same<T, CType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function CType_Name.");
return FieldOptions_CType_Name(enum_t_value);
}
static inline bool CType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
CType* value) {
return FieldOptions_CType_Parse(name, value);
}
typedef FieldOptions_JSType JSType;
static constexpr JSType JS_NORMAL =
FieldOptions_JSType_JS_NORMAL;
static constexpr JSType JS_STRING =
FieldOptions_JSType_JS_STRING;
static constexpr JSType JS_NUMBER =
FieldOptions_JSType_JS_NUMBER;
static inline bool JSType_IsValid(int value) {
return FieldOptions_JSType_IsValid(value);
}
static constexpr JSType JSType_MIN =
FieldOptions_JSType_JSType_MIN;
static constexpr JSType JSType_MAX =
FieldOptions_JSType_JSType_MAX;
static constexpr int JSType_ARRAYSIZE =
FieldOptions_JSType_JSType_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
JSType_descriptor() {
return FieldOptions_JSType_descriptor();
}
template<typename T>
static inline const std::string& JSType_Name(T enum_t_value) {
static_assert(::std::is_same<T, JSType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function JSType_Name.");
return FieldOptions_JSType_Name(enum_t_value);
}
static inline bool JSType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
JSType* value) {
return FieldOptions_JSType_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kCtypeFieldNumber = 1,
kPackedFieldNumber = 2,
kLazyFieldNumber = 5,
kDeprecatedFieldNumber = 3,
kWeakFieldNumber = 10,
kJstypeFieldNumber = 6,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
bool has_ctype() const;
private:
bool _internal_has_ctype() const;
public:
void clear_ctype();
PROTOBUF_NAMESPACE_ID::FieldOptions_CType ctype() const;
void set_ctype(PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
private:
PROTOBUF_NAMESPACE_ID::FieldOptions_CType _internal_ctype() const;
void _internal_set_ctype(PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
public:
// optional bool packed = 2;
bool has_packed() const;
private:
bool _internal_has_packed() const;
public:
void clear_packed();
bool packed() const;
void set_packed(bool value);
private:
bool _internal_packed() const;
void _internal_set_packed(bool value);
public:
// optional bool lazy = 5 [default = false];
bool has_lazy() const;
private:
bool _internal_has_lazy() const;
public:
void clear_lazy();
bool lazy() const;
void set_lazy(bool value);
private:
bool _internal_lazy() const;
void _internal_set_lazy(bool value);
public:
// optional bool deprecated = 3 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
// optional bool weak = 10 [default = false];
bool has_weak() const;
private:
bool _internal_has_weak() const;
public:
void clear_weak();
bool weak() const;
void set_weak(bool value);
private:
bool _internal_weak() const;
void _internal_set_weak(bool value);
public:
// optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
bool has_jstype() const;
private:
bool _internal_has_jstype() const;
public:
void clear_jstype();
PROTOBUF_NAMESPACE_ID::FieldOptions_JSType jstype() const;
void set_jstype(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
private:
PROTOBUF_NAMESPACE_ID::FieldOptions_JSType _internal_jstype() const;
void _internal_set_jstype(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
int ctype_;
bool packed_;
bool lazy_;
bool deprecated_;
bool weak_;
int jstype_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT OneofOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ {
public:
inline OneofOptions() : OneofOptions(nullptr) {}
virtual ~OneofOptions();
explicit constexpr OneofOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
OneofOptions(const OneofOptions& from);
OneofOptions(OneofOptions&& from) noexcept
: OneofOptions() {
*this = ::std::move(from);
}
inline OneofOptions& operator=(const OneofOptions& from) {
CopyFrom(from);
return *this;
}
inline OneofOptions& operator=(OneofOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const OneofOptions& default_instance() {
return *internal_default_instance();
}
static inline const OneofOptions* internal_default_instance() {
return reinterpret_cast<const OneofOptions*>(
&_OneofOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
friend void swap(OneofOptions& a, OneofOptions& b) {
a.Swap(&b);
}
inline void Swap(OneofOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(OneofOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline OneofOptions* New() const final {
return CreateMaybeMessage<OneofOptions>(nullptr);
}
OneofOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<OneofOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const OneofOptions& from);
void MergeFrom(const OneofOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(OneofOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.OneofOptions";
}
protected:
explicit OneofOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(OneofOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.OneofOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ {
public:
inline EnumOptions() : EnumOptions(nullptr) {}
virtual ~EnumOptions();
explicit constexpr EnumOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EnumOptions(const EnumOptions& from);
EnumOptions(EnumOptions&& from) noexcept
: EnumOptions() {
*this = ::std::move(from);
}
inline EnumOptions& operator=(const EnumOptions& from) {
CopyFrom(from);
return *this;
}
inline EnumOptions& operator=(EnumOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const EnumOptions& default_instance() {
return *internal_default_instance();
}
static inline const EnumOptions* internal_default_instance() {
return reinterpret_cast<const EnumOptions*>(
&_EnumOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
17;
friend void swap(EnumOptions& a, EnumOptions& b) {
a.Swap(&b);
}
inline void Swap(EnumOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EnumOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline EnumOptions* New() const final {
return CreateMaybeMessage<EnumOptions>(nullptr);
}
EnumOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<EnumOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const EnumOptions& from);
void MergeFrom(const EnumOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EnumOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.EnumOptions";
}
protected:
explicit EnumOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kAllowAliasFieldNumber = 2,
kDeprecatedFieldNumber = 3,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional bool allow_alias = 2;
bool has_allow_alias() const;
private:
bool _internal_has_allow_alias() const;
public:
void clear_allow_alias();
bool allow_alias() const;
void set_allow_alias(bool value);
private:
bool _internal_allow_alias() const;
void _internal_set_allow_alias(bool value);
public:
// optional bool deprecated = 3 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
bool allow_alias_;
bool deprecated_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT EnumValueOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ {
public:
inline EnumValueOptions() : EnumValueOptions(nullptr) {}
virtual ~EnumValueOptions();
explicit constexpr EnumValueOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
EnumValueOptions(const EnumValueOptions& from);
EnumValueOptions(EnumValueOptions&& from) noexcept
: EnumValueOptions() {
*this = ::std::move(from);
}
inline EnumValueOptions& operator=(const EnumValueOptions& from) {
CopyFrom(from);
return *this;
}
inline EnumValueOptions& operator=(EnumValueOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const EnumValueOptions& default_instance() {
return *internal_default_instance();
}
static inline const EnumValueOptions* internal_default_instance() {
return reinterpret_cast<const EnumValueOptions*>(
&_EnumValueOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
18;
friend void swap(EnumValueOptions& a, EnumValueOptions& b) {
a.Swap(&b);
}
inline void Swap(EnumValueOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(EnumValueOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline EnumValueOptions* New() const final {
return CreateMaybeMessage<EnumValueOptions>(nullptr);
}
EnumValueOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<EnumValueOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const EnumValueOptions& from);
void MergeFrom(const EnumValueOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(EnumValueOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.EnumValueOptions";
}
protected:
explicit EnumValueOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kDeprecatedFieldNumber = 1,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional bool deprecated = 1 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
bool deprecated_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT ServiceOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
public:
inline ServiceOptions() : ServiceOptions(nullptr) {}
virtual ~ServiceOptions();
explicit constexpr ServiceOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
ServiceOptions(const ServiceOptions& from);
ServiceOptions(ServiceOptions&& from) noexcept
: ServiceOptions() {
*this = ::std::move(from);
}
inline ServiceOptions& operator=(const ServiceOptions& from) {
CopyFrom(from);
return *this;
}
inline ServiceOptions& operator=(ServiceOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const ServiceOptions& default_instance() {
return *internal_default_instance();
}
static inline const ServiceOptions* internal_default_instance() {
return reinterpret_cast<const ServiceOptions*>(
&_ServiceOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
19;
friend void swap(ServiceOptions& a, ServiceOptions& b) {
a.Swap(&b);
}
inline void Swap(ServiceOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(ServiceOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline ServiceOptions* New() const final {
return CreateMaybeMessage<ServiceOptions>(nullptr);
}
ServiceOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<ServiceOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const ServiceOptions& from);
void MergeFrom(const ServiceOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(ServiceOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.ServiceOptions";
}
protected:
explicit ServiceOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kDeprecatedFieldNumber = 33,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional bool deprecated = 33 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
bool deprecated_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT MethodOptions PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ {
public:
inline MethodOptions() : MethodOptions(nullptr) {}
virtual ~MethodOptions();
explicit constexpr MethodOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
MethodOptions(const MethodOptions& from);
MethodOptions(MethodOptions&& from) noexcept
: MethodOptions() {
*this = ::std::move(from);
}
inline MethodOptions& operator=(const MethodOptions& from) {
CopyFrom(from);
return *this;
}
inline MethodOptions& operator=(MethodOptions&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const MethodOptions& default_instance() {
return *internal_default_instance();
}
static inline const MethodOptions* internal_default_instance() {
return reinterpret_cast<const MethodOptions*>(
&_MethodOptions_default_instance_);
}
static constexpr int kIndexInFileMessages =
20;
friend void swap(MethodOptions& a, MethodOptions& b) {
a.Swap(&b);
}
inline void Swap(MethodOptions* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(MethodOptions* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline MethodOptions* New() const final {
return CreateMaybeMessage<MethodOptions>(nullptr);
}
MethodOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<MethodOptions>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const MethodOptions& from);
void MergeFrom(const MethodOptions& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(MethodOptions* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.MethodOptions";
}
protected:
explicit MethodOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef MethodOptions_IdempotencyLevel IdempotencyLevel;
static constexpr IdempotencyLevel IDEMPOTENCY_UNKNOWN =
MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
static constexpr IdempotencyLevel NO_SIDE_EFFECTS =
MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
static constexpr IdempotencyLevel IDEMPOTENT =
MethodOptions_IdempotencyLevel_IDEMPOTENT;
static inline bool IdempotencyLevel_IsValid(int value) {
return MethodOptions_IdempotencyLevel_IsValid(value);
}
static constexpr IdempotencyLevel IdempotencyLevel_MIN =
MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN;
static constexpr IdempotencyLevel IdempotencyLevel_MAX =
MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX;
static constexpr int IdempotencyLevel_ARRAYSIZE =
MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE;
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
IdempotencyLevel_descriptor() {
return MethodOptions_IdempotencyLevel_descriptor();
}
template<typename T>
static inline const std::string& IdempotencyLevel_Name(T enum_t_value) {
static_assert(::std::is_same<T, IdempotencyLevel>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function IdempotencyLevel_Name.");
return MethodOptions_IdempotencyLevel_Name(enum_t_value);
}
static inline bool IdempotencyLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
IdempotencyLevel* value) {
return MethodOptions_IdempotencyLevel_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kUninterpretedOptionFieldNumber = 999,
kDeprecatedFieldNumber = 33,
kIdempotencyLevelFieldNumber = 34,
};
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
int uninterpreted_option_size() const;
private:
int _internal_uninterpreted_option_size() const;
public:
void clear_uninterpreted_option();
PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
mutable_uninterpreted_option();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
uninterpreted_option() const;
// optional bool deprecated = 33 [default = false];
bool has_deprecated() const;
private:
bool _internal_has_deprecated() const;
public:
void clear_deprecated();
bool deprecated() const;
void set_deprecated(bool value);
private:
bool _internal_deprecated() const;
void _internal_set_deprecated(bool value);
public:
// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
bool has_idempotency_level() const;
private:
bool _internal_has_idempotency_level() const;
public:
void clear_idempotency_level();
PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel idempotency_level() const;
void set_idempotency_level(PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
private:
PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel _internal_idempotency_level() const;
void _internal_set_idempotency_level(PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
public:
GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions)
// @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
bool deprecated_;
int idempotency_level_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT UninterpretedOption_NamePart PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {
public:
inline UninterpretedOption_NamePart() : UninterpretedOption_NamePart(nullptr) {}
virtual ~UninterpretedOption_NamePart();
explicit constexpr UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept
: UninterpretedOption_NamePart() {
*this = ::std::move(from);
}
inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {
CopyFrom(from);
return *this;
}
inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const UninterpretedOption_NamePart& default_instance() {
return *internal_default_instance();
}
static inline const UninterpretedOption_NamePart* internal_default_instance() {
return reinterpret_cast<const UninterpretedOption_NamePart*>(
&_UninterpretedOption_NamePart_default_instance_);
}
static constexpr int kIndexInFileMessages =
21;
friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b) {
a.Swap(&b);
}
inline void Swap(UninterpretedOption_NamePart* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(UninterpretedOption_NamePart* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline UninterpretedOption_NamePart* New() const final {
return CreateMaybeMessage<UninterpretedOption_NamePart>(nullptr);
}
UninterpretedOption_NamePart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<UninterpretedOption_NamePart>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const UninterpretedOption_NamePart& from);
void MergeFrom(const UninterpretedOption_NamePart& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(UninterpretedOption_NamePart* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.UninterpretedOption.NamePart";
}
protected:
explicit UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kNamePartFieldNumber = 1,
kIsExtensionFieldNumber = 2,
};
// required string name_part = 1;
bool has_name_part() const;
private:
bool _internal_has_name_part() const;
public:
void clear_name_part();
const std::string& name_part() const;
void set_name_part(const std::string& value);
void set_name_part(std::string&& value);
void set_name_part(const char* value);
void set_name_part(const char* value, size_t size);
std::string* mutable_name_part();
std::string* release_name_part();
void set_allocated_name_part(std::string* name_part);
private:
const std::string& _internal_name_part() const;
void _internal_set_name_part(const std::string& value);
std::string* _internal_mutable_name_part();
public:
// required bool is_extension = 2;
bool has_is_extension() const;
private:
bool _internal_has_is_extension() const;
public:
void clear_is_extension();
bool is_extension() const;
void set_is_extension(bool value);
private:
bool _internal_is_extension() const;
void _internal_set_is_extension(bool value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
private:
class _Internal;
// helper for ByteSizeLong()
size_t RequiredFieldsByteSizeFallback() const;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_part_;
bool is_extension_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT UninterpretedOption PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ {
public:
inline UninterpretedOption() : UninterpretedOption(nullptr) {}
virtual ~UninterpretedOption();
explicit constexpr UninterpretedOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
UninterpretedOption(const UninterpretedOption& from);
UninterpretedOption(UninterpretedOption&& from) noexcept
: UninterpretedOption() {
*this = ::std::move(from);
}
inline UninterpretedOption& operator=(const UninterpretedOption& from) {
CopyFrom(from);
return *this;
}
inline UninterpretedOption& operator=(UninterpretedOption&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const UninterpretedOption& default_instance() {
return *internal_default_instance();
}
static inline const UninterpretedOption* internal_default_instance() {
return reinterpret_cast<const UninterpretedOption*>(
&_UninterpretedOption_default_instance_);
}
static constexpr int kIndexInFileMessages =
22;
friend void swap(UninterpretedOption& a, UninterpretedOption& b) {
a.Swap(&b);
}
inline void Swap(UninterpretedOption* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(UninterpretedOption* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline UninterpretedOption* New() const final {
return CreateMaybeMessage<UninterpretedOption>(nullptr);
}
UninterpretedOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<UninterpretedOption>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const UninterpretedOption& from);
void MergeFrom(const UninterpretedOption& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(UninterpretedOption* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.UninterpretedOption";
}
protected:
explicit UninterpretedOption(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef UninterpretedOption_NamePart NamePart;
// accessors -------------------------------------------------------
enum : int {
kNameFieldNumber = 2,
kIdentifierValueFieldNumber = 3,
kStringValueFieldNumber = 7,
kAggregateValueFieldNumber = 8,
kPositiveIntValueFieldNumber = 4,
kNegativeIntValueFieldNumber = 5,
kDoubleValueFieldNumber = 6,
};
// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
int name_size() const;
private:
int _internal_name_size() const;
public:
void clear_name();
PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* mutable_name(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
mutable_name();
private:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& _internal_name(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _internal_add_name();
public:
const PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& name(int index) const;
PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* add_name();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
name() const;
// optional string identifier_value = 3;
bool has_identifier_value() const;
private:
bool _internal_has_identifier_value() const;
public:
void clear_identifier_value();
const std::string& identifier_value() const;
void set_identifier_value(const std::string& value);
void set_identifier_value(std::string&& value);
void set_identifier_value(const char* value);
void set_identifier_value(const char* value, size_t size);
std::string* mutable_identifier_value();
std::string* release_identifier_value();
void set_allocated_identifier_value(std::string* identifier_value);
private:
const std::string& _internal_identifier_value() const;
void _internal_set_identifier_value(const std::string& value);
std::string* _internal_mutable_identifier_value();
public:
// optional bytes string_value = 7;
bool has_string_value() const;
private:
bool _internal_has_string_value() const;
public:
void clear_string_value();
const std::string& string_value() const;
void set_string_value(const std::string& value);
void set_string_value(std::string&& value);
void set_string_value(const char* value);
void set_string_value(const void* value, size_t size);
std::string* mutable_string_value();
std::string* release_string_value();
void set_allocated_string_value(std::string* string_value);
private:
const std::string& _internal_string_value() const;
void _internal_set_string_value(const std::string& value);
std::string* _internal_mutable_string_value();
public:
// optional string aggregate_value = 8;
bool has_aggregate_value() const;
private:
bool _internal_has_aggregate_value() const;
public:
void clear_aggregate_value();
const std::string& aggregate_value() const;
void set_aggregate_value(const std::string& value);
void set_aggregate_value(std::string&& value);
void set_aggregate_value(const char* value);
void set_aggregate_value(const char* value, size_t size);
std::string* mutable_aggregate_value();
std::string* release_aggregate_value();
void set_allocated_aggregate_value(std::string* aggregate_value);
private:
const std::string& _internal_aggregate_value() const;
void _internal_set_aggregate_value(const std::string& value);
std::string* _internal_mutable_aggregate_value();
public:
// optional uint64 positive_int_value = 4;
bool has_positive_int_value() const;
private:
bool _internal_has_positive_int_value() const;
public:
void clear_positive_int_value();
::PROTOBUF_NAMESPACE_ID::uint64 positive_int_value() const;
void set_positive_int_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
private:
::PROTOBUF_NAMESPACE_ID::uint64 _internal_positive_int_value() const;
void _internal_set_positive_int_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
public:
// optional int64 negative_int_value = 5;
bool has_negative_int_value() const;
private:
bool _internal_has_negative_int_value() const;
public:
void clear_negative_int_value();
::PROTOBUF_NAMESPACE_ID::int64 negative_int_value() const;
void set_negative_int_value(::PROTOBUF_NAMESPACE_ID::int64 value);
private:
::PROTOBUF_NAMESPACE_ID::int64 _internal_negative_int_value() const;
void _internal_set_negative_int_value(::PROTOBUF_NAMESPACE_ID::int64 value);
public:
// optional double double_value = 6;
bool has_double_value() const;
private:
bool _internal_has_double_value() const;
public:
void clear_double_value();
double double_value() const;
void set_double_value(double value);
private:
double _internal_double_value() const;
void _internal_set_double_value(double value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart > name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregate_value_;
::PROTOBUF_NAMESPACE_ID::uint64 positive_int_value_;
::PROTOBUF_NAMESPACE_ID::int64 negative_int_value_;
double double_value_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT SourceCodeInfo_Location PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {
public:
inline SourceCodeInfo_Location() : SourceCodeInfo_Location(nullptr) {}
virtual ~SourceCodeInfo_Location();
explicit constexpr SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept
: SourceCodeInfo_Location() {
*this = ::std::move(from);
}
inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {
CopyFrom(from);
return *this;
}
inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const SourceCodeInfo_Location& default_instance() {
return *internal_default_instance();
}
static inline const SourceCodeInfo_Location* internal_default_instance() {
return reinterpret_cast<const SourceCodeInfo_Location*>(
&_SourceCodeInfo_Location_default_instance_);
}
static constexpr int kIndexInFileMessages =
23;
friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) {
a.Swap(&b);
}
inline void Swap(SourceCodeInfo_Location* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SourceCodeInfo_Location* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline SourceCodeInfo_Location* New() const final {
return CreateMaybeMessage<SourceCodeInfo_Location>(nullptr);
}
SourceCodeInfo_Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<SourceCodeInfo_Location>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const SourceCodeInfo_Location& from);
void MergeFrom(const SourceCodeInfo_Location& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SourceCodeInfo_Location* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.SourceCodeInfo.Location";
}
protected:
explicit SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPathFieldNumber = 1,
kSpanFieldNumber = 2,
kLeadingDetachedCommentsFieldNumber = 6,
kLeadingCommentsFieldNumber = 3,
kTrailingCommentsFieldNumber = 4,
};
// repeated int32 path = 1 [packed = true];
int path_size() const;
private:
int _internal_path_size() const;
public:
void clear_path();
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_path(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_path() const;
void _internal_add_path(::PROTOBUF_NAMESPACE_ID::int32 value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_path();
public:
::PROTOBUF_NAMESPACE_ID::int32 path(int index) const;
void set_path(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
void add_path(::PROTOBUF_NAMESPACE_ID::int32 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
path() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_path();
// repeated int32 span = 2 [packed = true];
int span_size() const;
private:
int _internal_span_size() const;
public:
void clear_span();
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_span(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_span() const;
void _internal_add_span(::PROTOBUF_NAMESPACE_ID::int32 value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_span();
public:
::PROTOBUF_NAMESPACE_ID::int32 span(int index) const;
void set_span(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
void add_span(::PROTOBUF_NAMESPACE_ID::int32 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
span() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_span();
// repeated string leading_detached_comments = 6;
int leading_detached_comments_size() const;
private:
int _internal_leading_detached_comments_size() const;
public:
void clear_leading_detached_comments();
const std::string& leading_detached_comments(int index) const;
std::string* mutable_leading_detached_comments(int index);
void set_leading_detached_comments(int index, const std::string& value);
void set_leading_detached_comments(int index, std::string&& value);
void set_leading_detached_comments(int index, const char* value);
void set_leading_detached_comments(int index, const char* value, size_t size);
std::string* add_leading_detached_comments();
void add_leading_detached_comments(const std::string& value);
void add_leading_detached_comments(std::string&& value);
void add_leading_detached_comments(const char* value);
void add_leading_detached_comments(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& leading_detached_comments() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_leading_detached_comments();
private:
const std::string& _internal_leading_detached_comments(int index) const;
std::string* _internal_add_leading_detached_comments();
public:
// optional string leading_comments = 3;
bool has_leading_comments() const;
private:
bool _internal_has_leading_comments() const;
public:
void clear_leading_comments();
const std::string& leading_comments() const;
void set_leading_comments(const std::string& value);
void set_leading_comments(std::string&& value);
void set_leading_comments(const char* value);
void set_leading_comments(const char* value, size_t size);
std::string* mutable_leading_comments();
std::string* release_leading_comments();
void set_allocated_leading_comments(std::string* leading_comments);
private:
const std::string& _internal_leading_comments() const;
void _internal_set_leading_comments(const std::string& value);
std::string* _internal_mutable_leading_comments();
public:
// optional string trailing_comments = 4;
bool has_trailing_comments() const;
private:
bool _internal_has_trailing_comments() const;
public:
void clear_trailing_comments();
const std::string& trailing_comments() const;
void set_trailing_comments(const std::string& value);
void set_trailing_comments(std::string&& value);
void set_trailing_comments(const char* value);
void set_trailing_comments(const char* value, size_t size);
std::string* mutable_trailing_comments();
std::string* release_trailing_comments();
void set_allocated_trailing_comments(std::string* trailing_comments);
private:
const std::string& _internal_trailing_comments() const;
void _internal_set_trailing_comments(const std::string& value);
std::string* _internal_mutable_trailing_comments();
public:
// @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > path_;
mutable std::atomic<int> _path_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > span_;
mutable std::atomic<int> _span_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> leading_detached_comments_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leading_comments_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trailing_comments_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT SourceCodeInfo PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ {
public:
inline SourceCodeInfo() : SourceCodeInfo(nullptr) {}
virtual ~SourceCodeInfo();
explicit constexpr SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
SourceCodeInfo(const SourceCodeInfo& from);
SourceCodeInfo(SourceCodeInfo&& from) noexcept
: SourceCodeInfo() {
*this = ::std::move(from);
}
inline SourceCodeInfo& operator=(const SourceCodeInfo& from) {
CopyFrom(from);
return *this;
}
inline SourceCodeInfo& operator=(SourceCodeInfo&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const SourceCodeInfo& default_instance() {
return *internal_default_instance();
}
static inline const SourceCodeInfo* internal_default_instance() {
return reinterpret_cast<const SourceCodeInfo*>(
&_SourceCodeInfo_default_instance_);
}
static constexpr int kIndexInFileMessages =
24;
friend void swap(SourceCodeInfo& a, SourceCodeInfo& b) {
a.Swap(&b);
}
inline void Swap(SourceCodeInfo* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(SourceCodeInfo* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline SourceCodeInfo* New() const final {
return CreateMaybeMessage<SourceCodeInfo>(nullptr);
}
SourceCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<SourceCodeInfo>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const SourceCodeInfo& from);
void MergeFrom(const SourceCodeInfo& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(SourceCodeInfo* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.SourceCodeInfo";
}
protected:
explicit SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef SourceCodeInfo_Location Location;
// accessors -------------------------------------------------------
enum : int {
kLocationFieldNumber = 1,
};
// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
int location_size() const;
private:
int _internal_location_size() const;
public:
void clear_location();
PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* mutable_location(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
mutable_location();
private:
const PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& _internal_location(int index) const;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _internal_add_location();
public:
const PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& location(int index) const;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* add_location();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
location() const;
// @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location > location_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ {
public:
inline GeneratedCodeInfo_Annotation() : GeneratedCodeInfo_Annotation(nullptr) {}
virtual ~GeneratedCodeInfo_Annotation();
explicit constexpr GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GeneratedCodeInfo_Annotation(const GeneratedCodeInfo_Annotation& from);
GeneratedCodeInfo_Annotation(GeneratedCodeInfo_Annotation&& from) noexcept
: GeneratedCodeInfo_Annotation() {
*this = ::std::move(from);
}
inline GeneratedCodeInfo_Annotation& operator=(const GeneratedCodeInfo_Annotation& from) {
CopyFrom(from);
return *this;
}
inline GeneratedCodeInfo_Annotation& operator=(GeneratedCodeInfo_Annotation&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const GeneratedCodeInfo_Annotation& default_instance() {
return *internal_default_instance();
}
static inline const GeneratedCodeInfo_Annotation* internal_default_instance() {
return reinterpret_cast<const GeneratedCodeInfo_Annotation*>(
&_GeneratedCodeInfo_Annotation_default_instance_);
}
static constexpr int kIndexInFileMessages =
25;
friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b) {
a.Swap(&b);
}
inline void Swap(GeneratedCodeInfo_Annotation* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(GeneratedCodeInfo_Annotation* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline GeneratedCodeInfo_Annotation* New() const final {
return CreateMaybeMessage<GeneratedCodeInfo_Annotation>(nullptr);
}
GeneratedCodeInfo_Annotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<GeneratedCodeInfo_Annotation>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const GeneratedCodeInfo_Annotation& from);
void MergeFrom(const GeneratedCodeInfo_Annotation& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(GeneratedCodeInfo_Annotation* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.GeneratedCodeInfo.Annotation";
}
protected:
explicit GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kPathFieldNumber = 1,
kSourceFileFieldNumber = 2,
kBeginFieldNumber = 3,
kEndFieldNumber = 4,
};
// repeated int32 path = 1 [packed = true];
int path_size() const;
private:
int _internal_path_size() const;
public:
void clear_path();
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_path(int index) const;
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
_internal_path() const;
void _internal_add_path(::PROTOBUF_NAMESPACE_ID::int32 value);
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
_internal_mutable_path();
public:
::PROTOBUF_NAMESPACE_ID::int32 path(int index) const;
void set_path(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
void add_path(::PROTOBUF_NAMESPACE_ID::int32 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
path() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
mutable_path();
// optional string source_file = 2;
bool has_source_file() const;
private:
bool _internal_has_source_file() const;
public:
void clear_source_file();
const std::string& source_file() const;
void set_source_file(const std::string& value);
void set_source_file(std::string&& value);
void set_source_file(const char* value);
void set_source_file(const char* value, size_t size);
std::string* mutable_source_file();
std::string* release_source_file();
void set_allocated_source_file(std::string* source_file);
private:
const std::string& _internal_source_file() const;
void _internal_set_source_file(const std::string& value);
std::string* _internal_mutable_source_file();
public:
// optional int32 begin = 3;
bool has_begin() const;
private:
bool _internal_has_begin() const;
public:
void clear_begin();
::PROTOBUF_NAMESPACE_ID::int32 begin() const;
void set_begin(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_begin() const;
void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// optional int32 end = 4;
bool has_end() const;
private:
bool _internal_has_end() const;
public:
void clear_end();
::PROTOBUF_NAMESPACE_ID::int32 end() const;
void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
private:
::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
public:
// @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo.Annotation)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > path_;
mutable std::atomic<int> _path_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_file_;
::PROTOBUF_NAMESPACE_ID::int32 begin_;
::PROTOBUF_NAMESPACE_ID::int32 end_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// -------------------------------------------------------------------
class PROTOBUF_EXPORT GeneratedCodeInfo PROTOBUF_FINAL :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ {
public:
inline GeneratedCodeInfo() : GeneratedCodeInfo(nullptr) {}
virtual ~GeneratedCodeInfo();
explicit constexpr GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
GeneratedCodeInfo(const GeneratedCodeInfo& from);
GeneratedCodeInfo(GeneratedCodeInfo&& from) noexcept
: GeneratedCodeInfo() {
*this = ::std::move(from);
}
inline GeneratedCodeInfo& operator=(const GeneratedCodeInfo& from) {
CopyFrom(from);
return *this;
}
inline GeneratedCodeInfo& operator=(GeneratedCodeInfo&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
}
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const GeneratedCodeInfo& default_instance() {
return *internal_default_instance();
}
static inline const GeneratedCodeInfo* internal_default_instance() {
return reinterpret_cast<const GeneratedCodeInfo*>(
&_GeneratedCodeInfo_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b) {
a.Swap(&b);
}
inline void Swap(GeneratedCodeInfo* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
} else {
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
void UnsafeArenaSwap(GeneratedCodeInfo* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline GeneratedCodeInfo* New() const final {
return CreateMaybeMessage<GeneratedCodeInfo>(nullptr);
}
GeneratedCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<GeneratedCodeInfo>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const GeneratedCodeInfo& from);
void MergeFrom(const GeneratedCodeInfo& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(GeneratedCodeInfo* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "google.protobuf.GeneratedCodeInfo";
}
protected:
explicit GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
return ::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto_metadata_getter(kIndexInFileMessages);
}
public:
// nested types ----------------------------------------------------
typedef GeneratedCodeInfo_Annotation Annotation;
// accessors -------------------------------------------------------
enum : int {
kAnnotationFieldNumber = 1,
};
// repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
int annotation_size() const;
private:
int _internal_annotation_size() const;
public:
void clear_annotation();
PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* mutable_annotation(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
mutable_annotation();
private:
const PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& _internal_annotation(int index) const;
PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _internal_add_annotation();
public:
const PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& annotation(int index) const;
PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* add_annotation();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
annotation() const;
// @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation > annotation_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// FileDescriptorSet
// repeated .google.protobuf.FileDescriptorProto file = 1;
inline int FileDescriptorSet::_internal_file_size() const {
return file_.size();
}
inline int FileDescriptorSet::file_size() const {
return _internal_file_size();
}
inline void FileDescriptorSet::clear_file() {
file_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorSet.file)
return file_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
FileDescriptorSet::mutable_file() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorSet.file)
return &file_;
}
inline const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::_internal_file(int index) const {
return file_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::file(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorSet.file)
return _internal_file(index);
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::_internal_add_file() {
return file_.Add();
}
inline PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::add_file() {
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorSet.file)
return _internal_add_file();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
FileDescriptorSet::file() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorSet.file)
return file_;
}
// -------------------------------------------------------------------
// FileDescriptorProto
// optional string name = 1;
inline bool FileDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FileDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void FileDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FileDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
return _internal_name();
}
inline void FileDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.name)
}
inline std::string* FileDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& FileDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void FileDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.name)
}
inline void FileDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.name)
}
inline void FileDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.name)
}
inline std::string* FileDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.name)
}
// optional string package = 2;
inline bool FileDescriptorProto::_internal_has_package() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FileDescriptorProto::has_package() const {
return _internal_has_package();
}
inline void FileDescriptorProto::clear_package() {
package_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& FileDescriptorProto::package() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
return _internal_package();
}
inline void FileDescriptorProto::set_package(const std::string& value) {
_internal_set_package(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.package)
}
inline std::string* FileDescriptorProto::mutable_package() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.package)
return _internal_mutable_package();
}
inline const std::string& FileDescriptorProto::_internal_package() const {
return package_.Get();
}
inline void FileDescriptorProto::_internal_set_package(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileDescriptorProto::set_package(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
package_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.package)
}
inline void FileDescriptorProto::set_package(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.package)
}
inline void FileDescriptorProto::set_package(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.package)
}
inline std::string* FileDescriptorProto::_internal_mutable_package() {
_has_bits_[0] |= 0x00000002u;
return package_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileDescriptorProto::release_package() {
// @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.package)
if (!_internal_has_package()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return package_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileDescriptorProto::set_allocated_package(std::string* package) {
if (package != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
package_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), package,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.package)
}
// repeated string dependency = 3;
inline int FileDescriptorProto::_internal_dependency_size() const {
return dependency_.size();
}
inline int FileDescriptorProto::dependency_size() const {
return _internal_dependency_size();
}
inline void FileDescriptorProto::clear_dependency() {
dependency_.Clear();
}
inline std::string* FileDescriptorProto::add_dependency() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.FileDescriptorProto.dependency)
return _internal_add_dependency();
}
inline const std::string& FileDescriptorProto::_internal_dependency(int index) const {
return dependency_.Get(index);
}
inline const std::string& FileDescriptorProto::dependency(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.dependency)
return _internal_dependency(index);
}
inline std::string* FileDescriptorProto::mutable_dependency(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.dependency)
return dependency_.Mutable(index);
}
inline void FileDescriptorProto::set_dependency(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
dependency_.Mutable(index)->assign(value);
}
inline void FileDescriptorProto::set_dependency(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
dependency_.Mutable(index)->assign(std::move(value));
}
inline void FileDescriptorProto::set_dependency(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
dependency_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.dependency)
}
inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {
dependency_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.dependency)
}
inline std::string* FileDescriptorProto::_internal_add_dependency() {
return dependency_.Add();
}
inline void FileDescriptorProto::add_dependency(const std::string& value) {
dependency_.Add()->assign(value);
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
}
inline void FileDescriptorProto::add_dependency(std::string&& value) {
dependency_.Add(std::move(value));
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
}
inline void FileDescriptorProto::add_dependency(const char* value) {
GOOGLE_DCHECK(value != nullptr);
dependency_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:google.protobuf.FileDescriptorProto.dependency)
}
inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {
dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:google.protobuf.FileDescriptorProto.dependency)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
FileDescriptorProto::dependency() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.dependency)
return dependency_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
FileDescriptorProto::mutable_dependency() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.dependency)
return &dependency_;
}
// repeated int32 public_dependency = 10;
inline int FileDescriptorProto::_internal_public_dependency_size() const {
return public_dependency_.size();
}
inline int FileDescriptorProto::public_dependency_size() const {
return _internal_public_dependency_size();
}
inline void FileDescriptorProto::clear_public_dependency() {
public_dependency_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FileDescriptorProto::_internal_public_dependency(int index) const {
return public_dependency_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FileDescriptorProto::public_dependency(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.public_dependency)
return _internal_public_dependency(index);
}
inline void FileDescriptorProto::set_public_dependency(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
public_dependency_.Set(index, value);
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.public_dependency)
}
inline void FileDescriptorProto::_internal_add_public_dependency(::PROTOBUF_NAMESPACE_ID::int32 value) {
public_dependency_.Add(value);
}
inline void FileDescriptorProto::add_public_dependency(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_add_public_dependency(value);
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.public_dependency)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
FileDescriptorProto::_internal_public_dependency() const {
return public_dependency_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
FileDescriptorProto::public_dependency() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.public_dependency)
return _internal_public_dependency();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
FileDescriptorProto::_internal_mutable_public_dependency() {
return &public_dependency_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
FileDescriptorProto::mutable_public_dependency() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.public_dependency)
return _internal_mutable_public_dependency();
}
// repeated int32 weak_dependency = 11;
inline int FileDescriptorProto::_internal_weak_dependency_size() const {
return weak_dependency_.size();
}
inline int FileDescriptorProto::weak_dependency_size() const {
return _internal_weak_dependency_size();
}
inline void FileDescriptorProto::clear_weak_dependency() {
weak_dependency_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FileDescriptorProto::_internal_weak_dependency(int index) const {
return weak_dependency_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FileDescriptorProto::weak_dependency(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.weak_dependency)
return _internal_weak_dependency(index);
}
inline void FileDescriptorProto::set_weak_dependency(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
weak_dependency_.Set(index, value);
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.weak_dependency)
}
inline void FileDescriptorProto::_internal_add_weak_dependency(::PROTOBUF_NAMESPACE_ID::int32 value) {
weak_dependency_.Add(value);
}
inline void FileDescriptorProto::add_weak_dependency(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_add_weak_dependency(value);
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.weak_dependency)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
FileDescriptorProto::_internal_weak_dependency() const {
return weak_dependency_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
FileDescriptorProto::weak_dependency() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.weak_dependency)
return _internal_weak_dependency();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
FileDescriptorProto::_internal_mutable_weak_dependency() {
return &weak_dependency_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
FileDescriptorProto::mutable_weak_dependency() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.weak_dependency)
return _internal_mutable_weak_dependency();
}
// repeated .google.protobuf.DescriptorProto message_type = 4;
inline int FileDescriptorProto::_internal_message_type_size() const {
return message_type_.size();
}
inline int FileDescriptorProto::message_type_size() const {
return _internal_message_type_size();
}
inline void FileDescriptorProto::clear_message_type() {
message_type_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.message_type)
return message_type_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >*
FileDescriptorProto::mutable_message_type() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.message_type)
return &message_type_;
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::_internal_message_type(int index) const {
return message_type_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::message_type(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.message_type)
return _internal_message_type(index);
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::_internal_add_message_type() {
return message_type_.Add();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::add_message_type() {
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.message_type)
return _internal_add_message_type();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >&
FileDescriptorProto::message_type() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
return message_type_;
}
// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
inline int FileDescriptorProto::_internal_enum_type_size() const {
return enum_type_.size();
}
inline int FileDescriptorProto::enum_type_size() const {
return _internal_enum_type_size();
}
inline void FileDescriptorProto::clear_enum_type() {
enum_type_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.enum_type)
return enum_type_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
FileDescriptorProto::mutable_enum_type() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.enum_type)
return &enum_type_;
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::_internal_enum_type(int index) const {
return enum_type_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.enum_type)
return _internal_enum_type(index);
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::_internal_add_enum_type() {
return enum_type_.Add();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.enum_type)
return _internal_add_enum_type();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
FileDescriptorProto::enum_type() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
return enum_type_;
}
// repeated .google.protobuf.ServiceDescriptorProto service = 6;
inline int FileDescriptorProto::_internal_service_size() const {
return service_.size();
}
inline int FileDescriptorProto::service_size() const {
return _internal_service_size();
}
inline void FileDescriptorProto::clear_service() {
service_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.service)
return service_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
FileDescriptorProto::mutable_service() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.service)
return &service_;
}
inline const PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::_internal_service(int index) const {
return service_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::service(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.service)
return _internal_service(index);
}
inline PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::_internal_add_service() {
return service_.Add();
}
inline PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::add_service() {
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.service)
return _internal_add_service();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
FileDescriptorProto::service() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
return service_;
}
// repeated .google.protobuf.FieldDescriptorProto extension = 7;
inline int FileDescriptorProto::_internal_extension_size() const {
return extension_.size();
}
inline int FileDescriptorProto::extension_size() const {
return _internal_extension_size();
}
inline void FileDescriptorProto::clear_extension() {
extension_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.extension)
return extension_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
FileDescriptorProto::mutable_extension() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.extension)
return &extension_;
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::_internal_extension(int index) const {
return extension_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.extension)
return _internal_extension(index);
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::_internal_add_extension() {
return extension_.Add();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::add_extension() {
// @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.extension)
return _internal_add_extension();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
FileDescriptorProto::extension() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
return extension_;
}
// optional .google.protobuf.FileOptions options = 8;
inline bool FileDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool FileDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void FileDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::FileOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::FileOptions&>(
PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.options)
return _internal_options();
}
inline void FileDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::FileOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000008u;
PROTOBUF_NAMESPACE_ID::FileOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.options)
_has_bits_[0] &= ~0x00000008u;
PROTOBUF_NAMESPACE_ID::FileOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000008u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FileOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.options)
return _internal_mutable_options();
}
inline void FileDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::FileOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.options)
}
// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
inline bool FileDescriptorProto::_internal_has_source_code_info() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
PROTOBUF_ASSUME(!value || source_code_info_ != nullptr);
return value;
}
inline bool FileDescriptorProto::has_source_code_info() const {
return _internal_has_source_code_info();
}
inline void FileDescriptorProto::clear_source_code_info() {
if (source_code_info_ != nullptr) source_code_info_->Clear();
_has_bits_[0] &= ~0x00000010u;
}
inline const PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::_internal_source_code_info() const {
const PROTOBUF_NAMESPACE_ID::SourceCodeInfo* p = source_code_info_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::SourceCodeInfo&>(
PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::source_code_info() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.source_code_info)
return _internal_source_code_info();
}
inline void FileDescriptorProto::unsafe_arena_set_allocated_source_code_info(
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_code_info_);
}
source_code_info_ = source_code_info;
if (source_code_info) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::release_source_code_info() {
_has_bits_[0] &= ~0x00000010u;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = source_code_info_;
source_code_info_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::unsafe_arena_release_source_code_info() {
// @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.source_code_info)
_has_bits_[0] &= ~0x00000010u;
PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = source_code_info_;
source_code_info_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::_internal_mutable_source_code_info() {
_has_bits_[0] |= 0x00000010u;
if (source_code_info_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(GetArena());
source_code_info_ = p;
}
return source_code_info_;
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.source_code_info)
return _internal_mutable_source_code_info();
}
inline void FileDescriptorProto::set_allocated_source_code_info(PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete source_code_info_;
}
if (source_code_info) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(source_code_info);
if (message_arena != submessage_arena) {
source_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, source_code_info, submessage_arena);
}
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
source_code_info_ = source_code_info;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
}
// optional string syntax = 12;
inline bool FileDescriptorProto::_internal_has_syntax() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FileDescriptorProto::has_syntax() const {
return _internal_has_syntax();
}
inline void FileDescriptorProto::clear_syntax() {
syntax_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& FileDescriptorProto::syntax() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.syntax)
return _internal_syntax();
}
inline void FileDescriptorProto::set_syntax(const std::string& value) {
_internal_set_syntax(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.syntax)
}
inline std::string* FileDescriptorProto::mutable_syntax() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.syntax)
return _internal_mutable_syntax();
}
inline const std::string& FileDescriptorProto::_internal_syntax() const {
return syntax_.Get();
}
inline void FileDescriptorProto::_internal_set_syntax(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
syntax_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileDescriptorProto::set_syntax(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
syntax_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.syntax)
}
inline void FileDescriptorProto::set_syntax(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
syntax_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.syntax)
}
inline void FileDescriptorProto::set_syntax(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000004u;
syntax_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.syntax)
}
inline std::string* FileDescriptorProto::_internal_mutable_syntax() {
_has_bits_[0] |= 0x00000004u;
return syntax_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileDescriptorProto::release_syntax() {
// @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.syntax)
if (!_internal_has_syntax()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return syntax_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileDescriptorProto::set_allocated_syntax(std::string* syntax) {
if (syntax != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
syntax_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), syntax,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.syntax)
}
// -------------------------------------------------------------------
// DescriptorProto_ExtensionRange
// optional int32 start = 1;
inline bool DescriptorProto_ExtensionRange::_internal_has_start() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DescriptorProto_ExtensionRange::has_start() const {
return _internal_has_start();
}
inline void DescriptorProto_ExtensionRange::clear_start() {
start_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ExtensionRange::_internal_start() const {
return start_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ExtensionRange::start() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.start)
return _internal_start();
}
inline void DescriptorProto_ExtensionRange::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000002u;
start_ = value;
}
inline void DescriptorProto_ExtensionRange::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_start(value);
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.start)
}
// optional int32 end = 2;
inline bool DescriptorProto_ExtensionRange::_internal_has_end() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool DescriptorProto_ExtensionRange::has_end() const {
return _internal_has_end();
}
inline void DescriptorProto_ExtensionRange::clear_end() {
end_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ExtensionRange::_internal_end() const {
return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ExtensionRange::end() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.end)
return _internal_end();
}
inline void DescriptorProto_ExtensionRange::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000004u;
end_ = value;
}
inline void DescriptorProto_ExtensionRange::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_end(value);
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.end)
}
// optional .google.protobuf.ExtensionRangeOptions options = 3;
inline bool DescriptorProto_ExtensionRange::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool DescriptorProto_ExtensionRange::has_options() const {
return _internal_has_options();
}
inline void DescriptorProto_ExtensionRange::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000001u;
}
inline const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions&>(
PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.options)
return _internal_options();
}
inline void DescriptorProto_ExtensionRange::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
}
inline PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::release_options() {
_has_bits_[0] &= ~0x00000001u;
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.ExtensionRange.options)
_has_bits_[0] &= ~0x00000001u;
PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::_internal_mutable_options() {
_has_bits_[0] |= 0x00000001u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.ExtensionRange.options)
return _internal_mutable_options();
}
inline void DescriptorProto_ExtensionRange::set_allocated_options(PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
}
// -------------------------------------------------------------------
// DescriptorProto_ReservedRange
// optional int32 start = 1;
inline bool DescriptorProto_ReservedRange::_internal_has_start() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DescriptorProto_ReservedRange::has_start() const {
return _internal_has_start();
}
inline void DescriptorProto_ReservedRange::clear_start() {
start_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ReservedRange::_internal_start() const {
return start_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ReservedRange::start() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.start)
return _internal_start();
}
inline void DescriptorProto_ReservedRange::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000001u;
start_ = value;
}
inline void DescriptorProto_ReservedRange::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_start(value);
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.start)
}
// optional int32 end = 2;
inline bool DescriptorProto_ReservedRange::_internal_has_end() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DescriptorProto_ReservedRange::has_end() const {
return _internal_has_end();
}
inline void DescriptorProto_ReservedRange::clear_end() {
end_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ReservedRange::_internal_end() const {
return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DescriptorProto_ReservedRange::end() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.end)
return _internal_end();
}
inline void DescriptorProto_ReservedRange::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000002u;
end_ = value;
}
inline void DescriptorProto_ReservedRange::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_end(value);
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.end)
}
// -------------------------------------------------------------------
// DescriptorProto
// optional string name = 1;
inline bool DescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DescriptorProto::has_name() const {
return _internal_has_name();
}
inline void DescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
return _internal_name();
}
inline void DescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.name)
}
inline std::string* DescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& DescriptorProto::_internal_name() const {
return name_.Get();
}
inline void DescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void DescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.DescriptorProto.name)
}
inline void DescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.name)
}
inline void DescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.name)
}
inline std::string* DescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* DescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void DescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.name)
}
// repeated .google.protobuf.FieldDescriptorProto field = 2;
inline int DescriptorProto::_internal_field_size() const {
return field_.size();
}
inline int DescriptorProto::field_size() const {
return _internal_field_size();
}
inline void DescriptorProto::clear_field() {
field_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.field)
return field_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
DescriptorProto::mutable_field() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.field)
return &field_;
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_field(int index) const {
return field_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::field(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.field)
return _internal_field(index);
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_field() {
return field_.Add();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_field() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.field)
return _internal_add_field();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
DescriptorProto::field() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.field)
return field_;
}
// repeated .google.protobuf.FieldDescriptorProto extension = 6;
inline int DescriptorProto::_internal_extension_size() const {
return extension_.size();
}
inline int DescriptorProto::extension_size() const {
return _internal_extension_size();
}
inline void DescriptorProto::clear_extension() {
extension_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension)
return extension_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
DescriptorProto::mutable_extension() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension)
return &extension_;
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_extension(int index) const {
return extension_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::extension(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension)
return _internal_extension(index);
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_extension() {
return extension_.Add();
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_extension() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension)
return _internal_add_extension();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
DescriptorProto::extension() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
return extension_;
}
// repeated .google.protobuf.DescriptorProto nested_type = 3;
inline int DescriptorProto::_internal_nested_type_size() const {
return nested_type_.size();
}
inline int DescriptorProto::nested_type_size() const {
return _internal_nested_type_size();
}
inline void DescriptorProto::clear_nested_type() {
nested_type_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.nested_type)
return nested_type_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >*
DescriptorProto::mutable_nested_type() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.nested_type)
return &nested_type_;
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::_internal_nested_type(int index) const {
return nested_type_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::nested_type(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.nested_type)
return _internal_nested_type(index);
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::_internal_add_nested_type() {
return nested_type_.Add();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::add_nested_type() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.nested_type)
return _internal_add_nested_type();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto >&
DescriptorProto::nested_type() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
return nested_type_;
}
// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
inline int DescriptorProto::_internal_enum_type_size() const {
return enum_type_.size();
}
inline int DescriptorProto::enum_type_size() const {
return _internal_enum_type_size();
}
inline void DescriptorProto::clear_enum_type() {
enum_type_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.enum_type)
return enum_type_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
DescriptorProto::mutable_enum_type() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.enum_type)
return &enum_type_;
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::_internal_enum_type(int index) const {
return enum_type_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.enum_type)
return _internal_enum_type(index);
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::_internal_add_enum_type() {
return enum_type_.Add();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::add_enum_type() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.enum_type)
return _internal_add_enum_type();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
DescriptorProto::enum_type() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.enum_type)
return enum_type_;
}
// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
inline int DescriptorProto::_internal_extension_range_size() const {
return extension_range_.size();
}
inline int DescriptorProto::extension_range_size() const {
return _internal_extension_range_size();
}
inline void DescriptorProto::clear_extension_range() {
extension_range_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension_range)
return extension_range_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
DescriptorProto::mutable_extension_range() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension_range)
return &extension_range_;
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::_internal_extension_range(int index) const {
return extension_range_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension_range)
return _internal_extension_range(index);
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::_internal_add_extension_range() {
return extension_range_.Add();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension_range)
return _internal_add_extension_range();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
DescriptorProto::extension_range() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension_range)
return extension_range_;
}
// repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
inline int DescriptorProto::_internal_oneof_decl_size() const {
return oneof_decl_.size();
}
inline int DescriptorProto::oneof_decl_size() const {
return _internal_oneof_decl_size();
}
inline void DescriptorProto::clear_oneof_decl() {
oneof_decl_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.oneof_decl)
return oneof_decl_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
DescriptorProto::mutable_oneof_decl() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.oneof_decl)
return &oneof_decl_;
}
inline const PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::_internal_oneof_decl(int index) const {
return oneof_decl_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.oneof_decl)
return _internal_oneof_decl(index);
}
inline PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::_internal_add_oneof_decl() {
return oneof_decl_.Add();
}
inline PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::add_oneof_decl() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.oneof_decl)
return _internal_add_oneof_decl();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
DescriptorProto::oneof_decl() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.oneof_decl)
return oneof_decl_;
}
// optional .google.protobuf.MessageOptions options = 7;
inline bool DescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool DescriptorProto::has_options() const {
return _internal_has_options();
}
inline void DescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::MessageOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::MessageOptions&>(
PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.options)
return _internal_options();
}
inline void DescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::MessageOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.options)
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::MessageOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000002u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::MessageOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.options)
return _internal_mutable_options();
}
inline void DescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.options)
}
// repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
inline int DescriptorProto::_internal_reserved_range_size() const {
return reserved_range_.size();
}
inline int DescriptorProto::reserved_range_size() const {
return _internal_reserved_range_size();
}
inline void DescriptorProto::clear_reserved_range() {
reserved_range_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_range)
return reserved_range_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
DescriptorProto::mutable_reserved_range() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_range)
return &reserved_range_;
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::_internal_reserved_range(int index) const {
return reserved_range_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_range)
return _internal_reserved_range(index);
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::_internal_add_reserved_range() {
return reserved_range_.Add();
}
inline PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() {
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_range)
return _internal_add_reserved_range();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
DescriptorProto::reserved_range() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_range)
return reserved_range_;
}
// repeated string reserved_name = 10;
inline int DescriptorProto::_internal_reserved_name_size() const {
return reserved_name_.size();
}
inline int DescriptorProto::reserved_name_size() const {
return _internal_reserved_name_size();
}
inline void DescriptorProto::clear_reserved_name() {
reserved_name_.Clear();
}
inline std::string* DescriptorProto::add_reserved_name() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.DescriptorProto.reserved_name)
return _internal_add_reserved_name();
}
inline const std::string& DescriptorProto::_internal_reserved_name(int index) const {
return reserved_name_.Get(index);
}
inline const std::string& DescriptorProto::reserved_name(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_name)
return _internal_reserved_name(index);
}
inline std::string* DescriptorProto::mutable_reserved_name(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_name)
return reserved_name_.Mutable(index);
}
inline void DescriptorProto::set_reserved_name(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
reserved_name_.Mutable(index)->assign(value);
}
inline void DescriptorProto::set_reserved_name(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
reserved_name_.Mutable(index)->assign(std::move(value));
}
inline void DescriptorProto::set_reserved_name(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
reserved_name_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.reserved_name)
}
inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
reserved_name_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.reserved_name)
}
inline std::string* DescriptorProto::_internal_add_reserved_name() {
return reserved_name_.Add();
}
inline void DescriptorProto::add_reserved_name(const std::string& value) {
reserved_name_.Add()->assign(value);
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
}
inline void DescriptorProto::add_reserved_name(std::string&& value) {
reserved_name_.Add(std::move(value));
// @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
}
inline void DescriptorProto::add_reserved_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
reserved_name_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:google.protobuf.DescriptorProto.reserved_name)
}
inline void DescriptorProto::add_reserved_name(const char* value, size_t size) {
reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:google.protobuf.DescriptorProto.reserved_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DescriptorProto::reserved_name() const {
// @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_name)
return reserved_name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DescriptorProto::mutable_reserved_name() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_name)
return &reserved_name_;
}
// -------------------------------------------------------------------
// ExtensionRangeOptions
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int ExtensionRangeOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int ExtensionRangeOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void ExtensionRangeOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
ExtensionRangeOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
ExtensionRangeOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// FieldDescriptorProto
// optional string name = 1;
inline bool FieldDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void FieldDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FieldDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.name)
return _internal_name();
}
inline void FieldDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.name)
}
inline std::string* FieldDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& FieldDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void FieldDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FieldDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.name)
}
inline void FieldDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.name)
}
inline void FieldDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.name)
}
inline std::string* FieldDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FieldDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FieldDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.name)
}
// optional int32 number = 3;
inline bool FieldDescriptorProto::_internal_has_number() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_number() const {
return _internal_has_number();
}
inline void FieldDescriptorProto::clear_number() {
number_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldDescriptorProto::_internal_number() const {
return number_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldDescriptorProto::number() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.number)
return _internal_number();
}
inline void FieldDescriptorProto::_internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000040u;
number_ = value;
}
inline void FieldDescriptorProto::set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_number(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.number)
}
// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
inline bool FieldDescriptorProto::_internal_has_label() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_label() const {
return _internal_has_label();
}
inline void FieldDescriptorProto::clear_label() {
label_ = 1;
_has_bits_[0] &= ~0x00000200u;
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::_internal_label() const {
return static_cast< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label >(label_);
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::label() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.label)
return _internal_label();
}
inline void FieldDescriptorProto::_internal_set_label(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
assert(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(value));
_has_bits_[0] |= 0x00000200u;
label_ = value;
}
inline void FieldDescriptorProto::set_label(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
_internal_set_label(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.label)
}
// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
inline bool FieldDescriptorProto::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_type() const {
return _internal_has_type();
}
inline void FieldDescriptorProto::clear_type() {
type_ = 1;
_has_bits_[0] &= ~0x00000400u;
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::_internal_type() const {
return static_cast< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type >(type_);
}
inline PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::type() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type)
return _internal_type();
}
inline void FieldDescriptorProto::_internal_set_type(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
assert(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(value));
_has_bits_[0] |= 0x00000400u;
type_ = value;
}
inline void FieldDescriptorProto::set_type(PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
_internal_set_type(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type)
}
// optional string type_name = 6;
inline bool FieldDescriptorProto::_internal_has_type_name() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_type_name() const {
return _internal_has_type_name();
}
inline void FieldDescriptorProto::clear_type_name() {
type_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& FieldDescriptorProto::type_name() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type_name)
return _internal_type_name();
}
inline void FieldDescriptorProto::set_type_name(const std::string& value) {
_internal_set_type_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type_name)
}
inline std::string* FieldDescriptorProto::mutable_type_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.type_name)
return _internal_mutable_type_name();
}
inline const std::string& FieldDescriptorProto::_internal_type_name() const {
return type_name_.Get();
}
inline void FieldDescriptorProto::_internal_set_type_name(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
type_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FieldDescriptorProto::set_type_name(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
type_name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.type_name)
}
inline void FieldDescriptorProto::set_type_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
type_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.type_name)
}
inline void FieldDescriptorProto::set_type_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000004u;
type_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.type_name)
}
inline std::string* FieldDescriptorProto::_internal_mutable_type_name() {
_has_bits_[0] |= 0x00000004u;
return type_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FieldDescriptorProto::release_type_name() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.type_name)
if (!_internal_has_type_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return type_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FieldDescriptorProto::set_allocated_type_name(std::string* type_name) {
if (type_name != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
type_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type_name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
}
// optional string extendee = 2;
inline bool FieldDescriptorProto::_internal_has_extendee() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_extendee() const {
return _internal_has_extendee();
}
inline void FieldDescriptorProto::clear_extendee() {
extendee_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& FieldDescriptorProto::extendee() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.extendee)
return _internal_extendee();
}
inline void FieldDescriptorProto::set_extendee(const std::string& value) {
_internal_set_extendee(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.extendee)
}
inline std::string* FieldDescriptorProto::mutable_extendee() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.extendee)
return _internal_mutable_extendee();
}
inline const std::string& FieldDescriptorProto::_internal_extendee() const {
return extendee_.Get();
}
inline void FieldDescriptorProto::_internal_set_extendee(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
extendee_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FieldDescriptorProto::set_extendee(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
extendee_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.extendee)
}
inline void FieldDescriptorProto::set_extendee(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
extendee_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.extendee)
}
inline void FieldDescriptorProto::set_extendee(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
extendee_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.extendee)
}
inline std::string* FieldDescriptorProto::_internal_mutable_extendee() {
_has_bits_[0] |= 0x00000002u;
return extendee_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FieldDescriptorProto::release_extendee() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.extendee)
if (!_internal_has_extendee()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return extendee_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FieldDescriptorProto::set_allocated_extendee(std::string* extendee) {
if (extendee != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
extendee_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extendee,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
}
// optional string default_value = 7;
inline bool FieldDescriptorProto::_internal_has_default_value() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_default_value() const {
return _internal_has_default_value();
}
inline void FieldDescriptorProto::clear_default_value() {
default_value_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& FieldDescriptorProto::default_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.default_value)
return _internal_default_value();
}
inline void FieldDescriptorProto::set_default_value(const std::string& value) {
_internal_set_default_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.default_value)
}
inline std::string* FieldDescriptorProto::mutable_default_value() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.default_value)
return _internal_mutable_default_value();
}
inline const std::string& FieldDescriptorProto::_internal_default_value() const {
return default_value_.Get();
}
inline void FieldDescriptorProto::_internal_set_default_value(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FieldDescriptorProto::set_default_value(std::string&& value) {
_has_bits_[0] |= 0x00000008u;
default_value_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.default_value)
}
inline void FieldDescriptorProto::set_default_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000008u;
default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.default_value)
}
inline void FieldDescriptorProto::set_default_value(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000008u;
default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.default_value)
}
inline std::string* FieldDescriptorProto::_internal_mutable_default_value() {
_has_bits_[0] |= 0x00000008u;
return default_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FieldDescriptorProto::release_default_value() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.default_value)
if (!_internal_has_default_value()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
return default_value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FieldDescriptorProto::set_allocated_default_value(std::string* default_value) {
if (default_value != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
default_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), default_value,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
}
// optional int32 oneof_index = 9;
inline bool FieldDescriptorProto::_internal_has_oneof_index() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_oneof_index() const {
return _internal_has_oneof_index();
}
inline void FieldDescriptorProto::clear_oneof_index() {
oneof_index_ = 0;
_has_bits_[0] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldDescriptorProto::_internal_oneof_index() const {
return oneof_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 FieldDescriptorProto::oneof_index() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.oneof_index)
return _internal_oneof_index();
}
inline void FieldDescriptorProto::_internal_set_oneof_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000080u;
oneof_index_ = value;
}
inline void FieldDescriptorProto::set_oneof_index(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_oneof_index(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.oneof_index)
}
// optional string json_name = 10;
inline bool FieldDescriptorProto::_internal_has_json_name() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_json_name() const {
return _internal_has_json_name();
}
inline void FieldDescriptorProto::clear_json_name() {
json_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& FieldDescriptorProto::json_name() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.json_name)
return _internal_json_name();
}
inline void FieldDescriptorProto::set_json_name(const std::string& value) {
_internal_set_json_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.json_name)
}
inline std::string* FieldDescriptorProto::mutable_json_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.json_name)
return _internal_mutable_json_name();
}
inline const std::string& FieldDescriptorProto::_internal_json_name() const {
return json_name_.Get();
}
inline void FieldDescriptorProto::_internal_set_json_name(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
json_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FieldDescriptorProto::set_json_name(std::string&& value) {
_has_bits_[0] |= 0x00000010u;
json_name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.json_name)
}
inline void FieldDescriptorProto::set_json_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000010u;
json_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.json_name)
}
inline void FieldDescriptorProto::set_json_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000010u;
json_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.json_name)
}
inline std::string* FieldDescriptorProto::_internal_mutable_json_name() {
_has_bits_[0] |= 0x00000010u;
return json_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FieldDescriptorProto::release_json_name() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.json_name)
if (!_internal_has_json_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
return json_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FieldDescriptorProto::set_allocated_json_name(std::string* json_name) {
if (json_name != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
json_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), json_name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
}
// optional .google.protobuf.FieldOptions options = 8;
inline bool FieldDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool FieldDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void FieldDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000020u;
}
inline const PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::FieldOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::FieldOptions&>(
PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.options)
return _internal_options();
}
inline void FieldDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000020u;
PROTOBUF_NAMESPACE_ID::FieldOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.options)
_has_bits_[0] &= ~0x00000020u;
PROTOBUF_NAMESPACE_ID::FieldOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000020u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::FieldOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.options)
return _internal_mutable_options();
}
inline void FieldDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.options)
}
// optional bool proto3_optional = 17;
inline bool FieldDescriptorProto::_internal_has_proto3_optional() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool FieldDescriptorProto::has_proto3_optional() const {
return _internal_has_proto3_optional();
}
inline void FieldDescriptorProto::clear_proto3_optional() {
proto3_optional_ = false;
_has_bits_[0] &= ~0x00000100u;
}
inline bool FieldDescriptorProto::_internal_proto3_optional() const {
return proto3_optional_;
}
inline bool FieldDescriptorProto::proto3_optional() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.proto3_optional)
return _internal_proto3_optional();
}
inline void FieldDescriptorProto::_internal_set_proto3_optional(bool value) {
_has_bits_[0] |= 0x00000100u;
proto3_optional_ = value;
}
inline void FieldDescriptorProto::set_proto3_optional(bool value) {
_internal_set_proto3_optional(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.proto3_optional)
}
// -------------------------------------------------------------------
// OneofDescriptorProto
// optional string name = 1;
inline bool OneofDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool OneofDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void OneofDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& OneofDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.name)
return _internal_name();
}
inline void OneofDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.OneofDescriptorProto.name)
}
inline std::string* OneofDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& OneofDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void OneofDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void OneofDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.OneofDescriptorProto.name)
}
inline void OneofDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.OneofDescriptorProto.name)
}
inline void OneofDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.OneofDescriptorProto.name)
}
inline std::string* OneofDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* OneofDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void OneofDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.name)
}
// optional .google.protobuf.OneofOptions options = 2;
inline bool OneofDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool OneofDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void OneofDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::OneofOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::OneofOptions&>(
PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.options)
return _internal_options();
}
inline void OneofDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.OneofDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::OneofOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.options)
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::OneofOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000002u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::OneofOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.options)
return _internal_mutable_options();
}
inline void OneofDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.options)
}
// -------------------------------------------------------------------
// EnumDescriptorProto_EnumReservedRange
// optional int32 start = 1;
inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_start() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EnumDescriptorProto_EnumReservedRange::has_start() const {
return _internal_has_start();
}
inline void EnumDescriptorProto_EnumReservedRange::clear_start() {
start_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumDescriptorProto_EnumReservedRange::_internal_start() const {
return start_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumDescriptorProto_EnumReservedRange::start() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
return _internal_start();
}
inline void EnumDescriptorProto_EnumReservedRange::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000001u;
start_ = value;
}
inline void EnumDescriptorProto_EnumReservedRange::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_start(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
}
// optional int32 end = 2;
inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_end() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool EnumDescriptorProto_EnumReservedRange::has_end() const {
return _internal_has_end();
}
inline void EnumDescriptorProto_EnumReservedRange::clear_end() {
end_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumDescriptorProto_EnumReservedRange::_internal_end() const {
return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumDescriptorProto_EnumReservedRange::end() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
return _internal_end();
}
inline void EnumDescriptorProto_EnumReservedRange::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000002u;
end_ = value;
}
inline void EnumDescriptorProto_EnumReservedRange::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_end(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
}
// -------------------------------------------------------------------
// EnumDescriptorProto
// optional string name = 1;
inline bool EnumDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EnumDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void EnumDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& EnumDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
return _internal_name();
}
inline void EnumDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.name)
}
inline std::string* EnumDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& EnumDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void EnumDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void EnumDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.EnumDescriptorProto.name)
}
inline void EnumDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.name)
}
inline void EnumDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.name)
}
inline std::string* EnumDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* EnumDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void EnumDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.name)
}
// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
inline int EnumDescriptorProto::_internal_value_size() const {
return value_.size();
}
inline int EnumDescriptorProto::value_size() const {
return _internal_value_size();
}
inline void EnumDescriptorProto::clear_value() {
value_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.value)
return value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
EnumDescriptorProto::mutable_value() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.value)
return &value_;
}
inline const PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::_internal_value(int index) const {
return value_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.value)
return _internal_value(index);
}
inline PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::_internal_add_value() {
return value_.Add();
}
inline PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {
// @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.value)
return _internal_add_value();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
EnumDescriptorProto::value() const {
// @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.value)
return value_;
}
// optional .google.protobuf.EnumOptions options = 3;
inline bool EnumDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool EnumDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void EnumDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::EnumOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::EnumOptions&>(
PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.options)
return _internal_options();
}
inline void EnumDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::EnumOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.options)
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::EnumOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000002u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.options)
return _internal_mutable_options();
}
inline void EnumDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.options)
}
// repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
inline int EnumDescriptorProto::_internal_reserved_range_size() const {
return reserved_range_.size();
}
inline int EnumDescriptorProto::reserved_range_size() const {
return _internal_reserved_range_size();
}
inline void EnumDescriptorProto::clear_reserved_range() {
reserved_range_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::mutable_reserved_range(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_range)
return reserved_range_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
EnumDescriptorProto::mutable_reserved_range() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_range)
return &reserved_range_;
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::_internal_reserved_range(int index) const {
return reserved_range_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::reserved_range(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_range)
return _internal_reserved_range(index);
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::_internal_add_reserved_range() {
return reserved_range_.Add();
}
inline PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::add_reserved_range() {
// @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_range)
return _internal_add_reserved_range();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
EnumDescriptorProto::reserved_range() const {
// @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_range)
return reserved_range_;
}
// repeated string reserved_name = 5;
inline int EnumDescriptorProto::_internal_reserved_name_size() const {
return reserved_name_.size();
}
inline int EnumDescriptorProto::reserved_name_size() const {
return _internal_reserved_name_size();
}
inline void EnumDescriptorProto::clear_reserved_name() {
reserved_name_.Clear();
}
inline std::string* EnumDescriptorProto::add_reserved_name() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
return _internal_add_reserved_name();
}
inline const std::string& EnumDescriptorProto::_internal_reserved_name(int index) const {
return reserved_name_.Get(index);
}
inline const std::string& EnumDescriptorProto::reserved_name(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_name)
return _internal_reserved_name(index);
}
inline std::string* EnumDescriptorProto::mutable_reserved_name(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
return reserved_name_.Mutable(index);
}
inline void EnumDescriptorProto::set_reserved_name(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
reserved_name_.Mutable(index)->assign(value);
}
inline void EnumDescriptorProto::set_reserved_name(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
reserved_name_.Mutable(index)->assign(std::move(value));
}
inline void EnumDescriptorProto::set_reserved_name(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
reserved_name_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
reserved_name_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline std::string* EnumDescriptorProto::_internal_add_reserved_name() {
return reserved_name_.Add();
}
inline void EnumDescriptorProto::add_reserved_name(const std::string& value) {
reserved_name_.Add()->assign(value);
// @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline void EnumDescriptorProto::add_reserved_name(std::string&& value) {
reserved_name_.Add(std::move(value));
// @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline void EnumDescriptorProto::add_reserved_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
reserved_name_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size) {
reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
EnumDescriptorProto::reserved_name() const {
// @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_name)
return reserved_name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
EnumDescriptorProto::mutable_reserved_name() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_name)
return &reserved_name_;
}
// -------------------------------------------------------------------
// EnumValueDescriptorProto
// optional string name = 1;
inline bool EnumValueDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EnumValueDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void EnumValueDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& EnumValueDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.name)
return _internal_name();
}
inline void EnumValueDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.name)
}
inline std::string* EnumValueDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& EnumValueDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void EnumValueDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void EnumValueDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.EnumValueDescriptorProto.name)
}
inline void EnumValueDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.EnumValueDescriptorProto.name)
}
inline void EnumValueDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumValueDescriptorProto.name)
}
inline std::string* EnumValueDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* EnumValueDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void EnumValueDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
}
// optional int32 number = 2;
inline bool EnumValueDescriptorProto::_internal_has_number() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool EnumValueDescriptorProto::has_number() const {
return _internal_has_number();
}
inline void EnumValueDescriptorProto::clear_number() {
number_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumValueDescriptorProto::_internal_number() const {
return number_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 EnumValueDescriptorProto::number() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.number)
return _internal_number();
}
inline void EnumValueDescriptorProto::_internal_set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000004u;
number_ = value;
}
inline void EnumValueDescriptorProto::set_number(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_number(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.number)
}
// optional .google.protobuf.EnumValueOptions options = 3;
inline bool EnumValueDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool EnumValueDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void EnumValueDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::EnumValueOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::EnumValueOptions&>(
PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.options)
return _internal_options();
}
inline void EnumValueDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.options)
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000002u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::EnumValueOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.options)
return _internal_mutable_options();
}
inline void EnumValueDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
}
// -------------------------------------------------------------------
// ServiceDescriptorProto
// optional string name = 1;
inline bool ServiceDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ServiceDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void ServiceDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ServiceDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.name)
return _internal_name();
}
inline void ServiceDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.ServiceDescriptorProto.name)
}
inline std::string* ServiceDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& ServiceDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void ServiceDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ServiceDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.ServiceDescriptorProto.name)
}
inline void ServiceDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.ServiceDescriptorProto.name)
}
inline void ServiceDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.ServiceDescriptorProto.name)
}
inline std::string* ServiceDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ServiceDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ServiceDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.name)
}
// repeated .google.protobuf.MethodDescriptorProto method = 2;
inline int ServiceDescriptorProto::_internal_method_size() const {
return method_.size();
}
inline int ServiceDescriptorProto::method_size() const {
return _internal_method_size();
}
inline void ServiceDescriptorProto::clear_method() {
method_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.method)
return method_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
ServiceDescriptorProto::mutable_method() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceDescriptorProto.method)
return &method_;
}
inline const PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::_internal_method(int index) const {
return method_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.method)
return _internal_method(index);
}
inline PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::_internal_add_method() {
return method_.Add();
}
inline PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::add_method() {
// @@protoc_insertion_point(field_add:google.protobuf.ServiceDescriptorProto.method)
return _internal_add_method();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
ServiceDescriptorProto::method() const {
// @@protoc_insertion_point(field_list:google.protobuf.ServiceDescriptorProto.method)
return method_;
}
// optional .google.protobuf.ServiceOptions options = 3;
inline bool ServiceDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool ServiceDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void ServiceDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000002u;
}
inline const PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::ServiceOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::ServiceOptions&>(
PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.options)
return _internal_options();
}
inline void ServiceDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.ServiceDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.options)
_has_bits_[0] &= ~0x00000002u;
PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000002u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::ServiceOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.options)
return _internal_mutable_options();
}
inline void ServiceDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.options)
}
// -------------------------------------------------------------------
// MethodDescriptorProto
// optional string name = 1;
inline bool MethodDescriptorProto::_internal_has_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MethodDescriptorProto::has_name() const {
return _internal_has_name();
}
inline void MethodDescriptorProto::clear_name() {
name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MethodDescriptorProto::name() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.name)
return _internal_name();
}
inline void MethodDescriptorProto::set_name(const std::string& value) {
_internal_set_name(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.name)
}
inline std::string* MethodDescriptorProto::mutable_name() {
// @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.name)
return _internal_mutable_name();
}
inline const std::string& MethodDescriptorProto::_internal_name() const {
return name_.Get();
}
inline void MethodDescriptorProto::_internal_set_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void MethodDescriptorProto::set_name(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.name)
}
inline void MethodDescriptorProto::set_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.name)
}
inline void MethodDescriptorProto::set_name(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.name)
}
inline std::string* MethodDescriptorProto::_internal_mutable_name() {
_has_bits_[0] |= 0x00000001u;
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* MethodDescriptorProto::release_name() {
// @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.name)
if (!_internal_has_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MethodDescriptorProto::set_allocated_name(std::string* name) {
if (name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.name)
}
// optional string input_type = 2;
inline bool MethodDescriptorProto::_internal_has_input_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MethodDescriptorProto::has_input_type() const {
return _internal_has_input_type();
}
inline void MethodDescriptorProto::clear_input_type() {
input_type_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MethodDescriptorProto::input_type() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.input_type)
return _internal_input_type();
}
inline void MethodDescriptorProto::set_input_type(const std::string& value) {
_internal_set_input_type(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.input_type)
}
inline std::string* MethodDescriptorProto::mutable_input_type() {
// @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.input_type)
return _internal_mutable_input_type();
}
inline const std::string& MethodDescriptorProto::_internal_input_type() const {
return input_type_.Get();
}
inline void MethodDescriptorProto::_internal_set_input_type(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
input_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void MethodDescriptorProto::set_input_type(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
input_type_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.input_type)
}
inline void MethodDescriptorProto::set_input_type(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
input_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.input_type)
}
inline void MethodDescriptorProto::set_input_type(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
input_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.input_type)
}
inline std::string* MethodDescriptorProto::_internal_mutable_input_type() {
_has_bits_[0] |= 0x00000002u;
return input_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* MethodDescriptorProto::release_input_type() {
// @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.input_type)
if (!_internal_has_input_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return input_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MethodDescriptorProto::set_allocated_input_type(std::string* input_type) {
if (input_type != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
input_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), input_type,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
}
// optional string output_type = 3;
inline bool MethodDescriptorProto::_internal_has_output_type() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MethodDescriptorProto::has_output_type() const {
return _internal_has_output_type();
}
inline void MethodDescriptorProto::clear_output_type() {
output_type_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& MethodDescriptorProto::output_type() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.output_type)
return _internal_output_type();
}
inline void MethodDescriptorProto::set_output_type(const std::string& value) {
_internal_set_output_type(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.output_type)
}
inline std::string* MethodDescriptorProto::mutable_output_type() {
// @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.output_type)
return _internal_mutable_output_type();
}
inline const std::string& MethodDescriptorProto::_internal_output_type() const {
return output_type_.Get();
}
inline void MethodDescriptorProto::_internal_set_output_type(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
output_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void MethodDescriptorProto::set_output_type(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
output_type_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.output_type)
}
inline void MethodDescriptorProto::set_output_type(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
output_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.output_type)
}
inline void MethodDescriptorProto::set_output_type(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000004u;
output_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.output_type)
}
inline std::string* MethodDescriptorProto::_internal_mutable_output_type() {
_has_bits_[0] |= 0x00000004u;
return output_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* MethodDescriptorProto::release_output_type() {
// @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.output_type)
if (!_internal_has_output_type()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return output_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MethodDescriptorProto::set_allocated_output_type(std::string* output_type) {
if (output_type != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
output_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_type,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
}
// optional .google.protobuf.MethodOptions options = 4;
inline bool MethodDescriptorProto::_internal_has_options() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
PROTOBUF_ASSUME(!value || options_ != nullptr);
return value;
}
inline bool MethodDescriptorProto::has_options() const {
return _internal_has_options();
}
inline void MethodDescriptorProto::clear_options() {
if (options_ != nullptr) options_->Clear();
_has_bits_[0] &= ~0x00000008u;
}
inline const PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::_internal_options() const {
const PROTOBUF_NAMESPACE_ID::MethodOptions* p = options_;
return p != nullptr ? *p : reinterpret_cast<const PROTOBUF_NAMESPACE_ID::MethodOptions&>(
PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_);
}
inline const PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::options() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.options)
return _internal_options();
}
inline void MethodDescriptorProto::unsafe_arena_set_allocated_options(
PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
if (GetArena() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
}
options_ = options;
if (options) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.options)
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::release_options() {
_has_bits_[0] &= ~0x00000008u;
PROTOBUF_NAMESPACE_ID::MethodOptions* temp = options_;
options_ = nullptr;
if (GetArena() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
return temp;
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::unsafe_arena_release_options() {
// @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.options)
_has_bits_[0] &= ~0x00000008u;
PROTOBUF_NAMESPACE_ID::MethodOptions* temp = options_;
options_ = nullptr;
return temp;
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::_internal_mutable_options() {
_has_bits_[0] |= 0x00000008u;
if (options_ == nullptr) {
auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::MethodOptions>(GetArena());
options_ = p;
}
return options_;
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::mutable_options() {
// @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.options)
return _internal_mutable_options();
}
inline void MethodDescriptorProto::set_allocated_options(PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
if (message_arena == nullptr) {
delete options_;
}
if (options) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(options);
if (message_arena != submessage_arena) {
options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, options, submessage_arena);
}
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
options_ = options;
// @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.options)
}
// optional bool client_streaming = 5 [default = false];
inline bool MethodDescriptorProto::_internal_has_client_streaming() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool MethodDescriptorProto::has_client_streaming() const {
return _internal_has_client_streaming();
}
inline void MethodDescriptorProto::clear_client_streaming() {
client_streaming_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool MethodDescriptorProto::_internal_client_streaming() const {
return client_streaming_;
}
inline bool MethodDescriptorProto::client_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.client_streaming)
return _internal_client_streaming();
}
inline void MethodDescriptorProto::_internal_set_client_streaming(bool value) {
_has_bits_[0] |= 0x00000010u;
client_streaming_ = value;
}
inline void MethodDescriptorProto::set_client_streaming(bool value) {
_internal_set_client_streaming(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.client_streaming)
}
// optional bool server_streaming = 6 [default = false];
inline bool MethodDescriptorProto::_internal_has_server_streaming() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool MethodDescriptorProto::has_server_streaming() const {
return _internal_has_server_streaming();
}
inline void MethodDescriptorProto::clear_server_streaming() {
server_streaming_ = false;
_has_bits_[0] &= ~0x00000020u;
}
inline bool MethodDescriptorProto::_internal_server_streaming() const {
return server_streaming_;
}
inline bool MethodDescriptorProto::server_streaming() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.server_streaming)
return _internal_server_streaming();
}
inline void MethodDescriptorProto::_internal_set_server_streaming(bool value) {
_has_bits_[0] |= 0x00000020u;
server_streaming_ = value;
}
inline void MethodDescriptorProto::set_server_streaming(bool value) {
_internal_set_server_streaming(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.server_streaming)
}
// -------------------------------------------------------------------
// FileOptions
// optional string java_package = 1;
inline bool FileOptions::_internal_has_java_package() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FileOptions::has_java_package() const {
return _internal_has_java_package();
}
inline void FileOptions::clear_java_package() {
java_package_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& FileOptions::java_package() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_package)
return _internal_java_package();
}
inline void FileOptions::set_java_package(const std::string& value) {
_internal_set_java_package(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_package)
}
inline std::string* FileOptions::mutable_java_package() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_package)
return _internal_mutable_java_package();
}
inline const std::string& FileOptions::_internal_java_package() const {
return java_package_.Get();
}
inline void FileOptions::_internal_set_java_package(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
java_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_java_package(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
java_package_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.java_package)
}
inline void FileOptions::set_java_package(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
java_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.java_package)
}
inline void FileOptions::set_java_package(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
java_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.java_package)
}
inline std::string* FileOptions::_internal_mutable_java_package() {
_has_bits_[0] |= 0x00000001u;
return java_package_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_java_package() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_package)
if (!_internal_has_java_package()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return java_package_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_java_package(std::string* java_package) {
if (java_package != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
java_package_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), java_package,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_package)
}
// optional string java_outer_classname = 8;
inline bool FileOptions::_internal_has_java_outer_classname() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FileOptions::has_java_outer_classname() const {
return _internal_has_java_outer_classname();
}
inline void FileOptions::clear_java_outer_classname() {
java_outer_classname_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& FileOptions::java_outer_classname() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_outer_classname)
return _internal_java_outer_classname();
}
inline void FileOptions::set_java_outer_classname(const std::string& value) {
_internal_set_java_outer_classname(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_outer_classname)
}
inline std::string* FileOptions::mutable_java_outer_classname() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_outer_classname)
return _internal_mutable_java_outer_classname();
}
inline const std::string& FileOptions::_internal_java_outer_classname() const {
return java_outer_classname_.Get();
}
inline void FileOptions::_internal_set_java_outer_classname(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
java_outer_classname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_java_outer_classname(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
java_outer_classname_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.java_outer_classname)
}
inline void FileOptions::set_java_outer_classname(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
java_outer_classname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.java_outer_classname)
}
inline void FileOptions::set_java_outer_classname(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
java_outer_classname_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.java_outer_classname)
}
inline std::string* FileOptions::_internal_mutable_java_outer_classname() {
_has_bits_[0] |= 0x00000002u;
return java_outer_classname_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_java_outer_classname() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_outer_classname)
if (!_internal_has_java_outer_classname()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return java_outer_classname_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_java_outer_classname(std::string* java_outer_classname) {
if (java_outer_classname != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
java_outer_classname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), java_outer_classname,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_outer_classname)
}
// optional bool java_multiple_files = 10 [default = false];
inline bool FileOptions::_internal_has_java_multiple_files() const {
bool value = (_has_bits_[0] & 0x00000400u) != 0;
return value;
}
inline bool FileOptions::has_java_multiple_files() const {
return _internal_has_java_multiple_files();
}
inline void FileOptions::clear_java_multiple_files() {
java_multiple_files_ = false;
_has_bits_[0] &= ~0x00000400u;
}
inline bool FileOptions::_internal_java_multiple_files() const {
return java_multiple_files_;
}
inline bool FileOptions::java_multiple_files() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_multiple_files)
return _internal_java_multiple_files();
}
inline void FileOptions::_internal_set_java_multiple_files(bool value) {
_has_bits_[0] |= 0x00000400u;
java_multiple_files_ = value;
}
inline void FileOptions::set_java_multiple_files(bool value) {
_internal_set_java_multiple_files(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_multiple_files)
}
// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
inline bool FileOptions::_internal_has_java_generate_equals_and_hash() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
return value;
}
inline bool FileOptions::has_java_generate_equals_and_hash() const {
return _internal_has_java_generate_equals_and_hash();
}
inline void FileOptions::clear_java_generate_equals_and_hash() {
java_generate_equals_and_hash_ = false;
_has_bits_[0] &= ~0x00000800u;
}
inline bool FileOptions::_internal_java_generate_equals_and_hash() const {
return java_generate_equals_and_hash_;
}
inline bool FileOptions::java_generate_equals_and_hash() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generate_equals_and_hash)
return _internal_java_generate_equals_and_hash();
}
inline void FileOptions::_internal_set_java_generate_equals_and_hash(bool value) {
_has_bits_[0] |= 0x00000800u;
java_generate_equals_and_hash_ = value;
}
inline void FileOptions::set_java_generate_equals_and_hash(bool value) {
_internal_set_java_generate_equals_and_hash(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generate_equals_and_hash)
}
// optional bool java_string_check_utf8 = 27 [default = false];
inline bool FileOptions::_internal_has_java_string_check_utf8() const {
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool FileOptions::has_java_string_check_utf8() const {
return _internal_has_java_string_check_utf8();
}
inline void FileOptions::clear_java_string_check_utf8() {
java_string_check_utf8_ = false;
_has_bits_[0] &= ~0x00001000u;
}
inline bool FileOptions::_internal_java_string_check_utf8() const {
return java_string_check_utf8_;
}
inline bool FileOptions::java_string_check_utf8() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_string_check_utf8)
return _internal_java_string_check_utf8();
}
inline void FileOptions::_internal_set_java_string_check_utf8(bool value) {
_has_bits_[0] |= 0x00001000u;
java_string_check_utf8_ = value;
}
inline void FileOptions::set_java_string_check_utf8(bool value) {
_internal_set_java_string_check_utf8(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_string_check_utf8)
}
// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
inline bool FileOptions::_internal_has_optimize_for() const {
bool value = (_has_bits_[0] & 0x00040000u) != 0;
return value;
}
inline bool FileOptions::has_optimize_for() const {
return _internal_has_optimize_for();
}
inline void FileOptions::clear_optimize_for() {
optimize_for_ = 1;
_has_bits_[0] &= ~0x00040000u;
}
inline PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::_internal_optimize_for() const {
return static_cast< PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode >(optimize_for_);
}
inline PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::optimize_for() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.optimize_for)
return _internal_optimize_for();
}
inline void FileOptions::_internal_set_optimize_for(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
assert(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(value));
_has_bits_[0] |= 0x00040000u;
optimize_for_ = value;
}
inline void FileOptions::set_optimize_for(PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
_internal_set_optimize_for(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.optimize_for)
}
// optional string go_package = 11;
inline bool FileOptions::_internal_has_go_package() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FileOptions::has_go_package() const {
return _internal_has_go_package();
}
inline void FileOptions::clear_go_package() {
go_package_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& FileOptions::go_package() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.go_package)
return _internal_go_package();
}
inline void FileOptions::set_go_package(const std::string& value) {
_internal_set_go_package(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.go_package)
}
inline std::string* FileOptions::mutable_go_package() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.go_package)
return _internal_mutable_go_package();
}
inline const std::string& FileOptions::_internal_go_package() const {
return go_package_.Get();
}
inline void FileOptions::_internal_set_go_package(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
go_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_go_package(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
go_package_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.go_package)
}
inline void FileOptions::set_go_package(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
go_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.go_package)
}
inline void FileOptions::set_go_package(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000004u;
go_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.go_package)
}
inline std::string* FileOptions::_internal_mutable_go_package() {
_has_bits_[0] |= 0x00000004u;
return go_package_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_go_package() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.go_package)
if (!_internal_has_go_package()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return go_package_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_go_package(std::string* go_package) {
if (go_package != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
go_package_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), go_package,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.go_package)
}
// optional bool cc_generic_services = 16 [default = false];
inline bool FileOptions::_internal_has_cc_generic_services() const {
bool value = (_has_bits_[0] & 0x00002000u) != 0;
return value;
}
inline bool FileOptions::has_cc_generic_services() const {
return _internal_has_cc_generic_services();
}
inline void FileOptions::clear_cc_generic_services() {
cc_generic_services_ = false;
_has_bits_[0] &= ~0x00002000u;
}
inline bool FileOptions::_internal_cc_generic_services() const {
return cc_generic_services_;
}
inline bool FileOptions::cc_generic_services() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_generic_services)
return _internal_cc_generic_services();
}
inline void FileOptions::_internal_set_cc_generic_services(bool value) {
_has_bits_[0] |= 0x00002000u;
cc_generic_services_ = value;
}
inline void FileOptions::set_cc_generic_services(bool value) {
_internal_set_cc_generic_services(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_generic_services)
}
// optional bool java_generic_services = 17 [default = false];
inline bool FileOptions::_internal_has_java_generic_services() const {
bool value = (_has_bits_[0] & 0x00004000u) != 0;
return value;
}
inline bool FileOptions::has_java_generic_services() const {
return _internal_has_java_generic_services();
}
inline void FileOptions::clear_java_generic_services() {
java_generic_services_ = false;
_has_bits_[0] &= ~0x00004000u;
}
inline bool FileOptions::_internal_java_generic_services() const {
return java_generic_services_;
}
inline bool FileOptions::java_generic_services() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generic_services)
return _internal_java_generic_services();
}
inline void FileOptions::_internal_set_java_generic_services(bool value) {
_has_bits_[0] |= 0x00004000u;
java_generic_services_ = value;
}
inline void FileOptions::set_java_generic_services(bool value) {
_internal_set_java_generic_services(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generic_services)
}
// optional bool py_generic_services = 18 [default = false];
inline bool FileOptions::_internal_has_py_generic_services() const {
bool value = (_has_bits_[0] & 0x00008000u) != 0;
return value;
}
inline bool FileOptions::has_py_generic_services() const {
return _internal_has_py_generic_services();
}
inline void FileOptions::clear_py_generic_services() {
py_generic_services_ = false;
_has_bits_[0] &= ~0x00008000u;
}
inline bool FileOptions::_internal_py_generic_services() const {
return py_generic_services_;
}
inline bool FileOptions::py_generic_services() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.py_generic_services)
return _internal_py_generic_services();
}
inline void FileOptions::_internal_set_py_generic_services(bool value) {
_has_bits_[0] |= 0x00008000u;
py_generic_services_ = value;
}
inline void FileOptions::set_py_generic_services(bool value) {
_internal_set_py_generic_services(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.py_generic_services)
}
// optional bool php_generic_services = 42 [default = false];
inline bool FileOptions::_internal_has_php_generic_services() const {
bool value = (_has_bits_[0] & 0x00010000u) != 0;
return value;
}
inline bool FileOptions::has_php_generic_services() const {
return _internal_has_php_generic_services();
}
inline void FileOptions::clear_php_generic_services() {
php_generic_services_ = false;
_has_bits_[0] &= ~0x00010000u;
}
inline bool FileOptions::_internal_php_generic_services() const {
return php_generic_services_;
}
inline bool FileOptions::php_generic_services() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_generic_services)
return _internal_php_generic_services();
}
inline void FileOptions::_internal_set_php_generic_services(bool value) {
_has_bits_[0] |= 0x00010000u;
php_generic_services_ = value;
}
inline void FileOptions::set_php_generic_services(bool value) {
_internal_set_php_generic_services(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_generic_services)
}
// optional bool deprecated = 23 [default = false];
inline bool FileOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00020000u) != 0;
return value;
}
inline bool FileOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void FileOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00020000u;
}
inline bool FileOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool FileOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.deprecated)
return _internal_deprecated();
}
inline void FileOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00020000u;
deprecated_ = value;
}
inline void FileOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.deprecated)
}
// optional bool cc_enable_arenas = 31 [default = true];
inline bool FileOptions::_internal_has_cc_enable_arenas() const {
bool value = (_has_bits_[0] & 0x00080000u) != 0;
return value;
}
inline bool FileOptions::has_cc_enable_arenas() const {
return _internal_has_cc_enable_arenas();
}
inline void FileOptions::clear_cc_enable_arenas() {
cc_enable_arenas_ = true;
_has_bits_[0] &= ~0x00080000u;
}
inline bool FileOptions::_internal_cc_enable_arenas() const {
return cc_enable_arenas_;
}
inline bool FileOptions::cc_enable_arenas() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_enable_arenas)
return _internal_cc_enable_arenas();
}
inline void FileOptions::_internal_set_cc_enable_arenas(bool value) {
_has_bits_[0] |= 0x00080000u;
cc_enable_arenas_ = value;
}
inline void FileOptions::set_cc_enable_arenas(bool value) {
_internal_set_cc_enable_arenas(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_enable_arenas)
}
// optional string objc_class_prefix = 36;
inline bool FileOptions::_internal_has_objc_class_prefix() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool FileOptions::has_objc_class_prefix() const {
return _internal_has_objc_class_prefix();
}
inline void FileOptions::clear_objc_class_prefix() {
objc_class_prefix_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& FileOptions::objc_class_prefix() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.objc_class_prefix)
return _internal_objc_class_prefix();
}
inline void FileOptions::set_objc_class_prefix(const std::string& value) {
_internal_set_objc_class_prefix(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.objc_class_prefix)
}
inline std::string* FileOptions::mutable_objc_class_prefix() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.objc_class_prefix)
return _internal_mutable_objc_class_prefix();
}
inline const std::string& FileOptions::_internal_objc_class_prefix() const {
return objc_class_prefix_.Get();
}
inline void FileOptions::_internal_set_objc_class_prefix(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
objc_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_objc_class_prefix(std::string&& value) {
_has_bits_[0] |= 0x00000008u;
objc_class_prefix_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.objc_class_prefix)
}
inline void FileOptions::set_objc_class_prefix(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000008u;
objc_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.objc_class_prefix)
}
inline void FileOptions::set_objc_class_prefix(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000008u;
objc_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.objc_class_prefix)
}
inline std::string* FileOptions::_internal_mutable_objc_class_prefix() {
_has_bits_[0] |= 0x00000008u;
return objc_class_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_objc_class_prefix() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.objc_class_prefix)
if (!_internal_has_objc_class_prefix()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
return objc_class_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_objc_class_prefix(std::string* objc_class_prefix) {
if (objc_class_prefix != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
objc_class_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), objc_class_prefix,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
}
// optional string csharp_namespace = 37;
inline bool FileOptions::_internal_has_csharp_namespace() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool FileOptions::has_csharp_namespace() const {
return _internal_has_csharp_namespace();
}
inline void FileOptions::clear_csharp_namespace() {
csharp_namespace_.ClearToEmpty();
_has_bits_[0] &= ~0x00000010u;
}
inline const std::string& FileOptions::csharp_namespace() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.csharp_namespace)
return _internal_csharp_namespace();
}
inline void FileOptions::set_csharp_namespace(const std::string& value) {
_internal_set_csharp_namespace(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.csharp_namespace)
}
inline std::string* FileOptions::mutable_csharp_namespace() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.csharp_namespace)
return _internal_mutable_csharp_namespace();
}
inline const std::string& FileOptions::_internal_csharp_namespace() const {
return csharp_namespace_.Get();
}
inline void FileOptions::_internal_set_csharp_namespace(const std::string& value) {
_has_bits_[0] |= 0x00000010u;
csharp_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_csharp_namespace(std::string&& value) {
_has_bits_[0] |= 0x00000010u;
csharp_namespace_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.csharp_namespace)
}
inline void FileOptions::set_csharp_namespace(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000010u;
csharp_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.csharp_namespace)
}
inline void FileOptions::set_csharp_namespace(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000010u;
csharp_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.csharp_namespace)
}
inline std::string* FileOptions::_internal_mutable_csharp_namespace() {
_has_bits_[0] |= 0x00000010u;
return csharp_namespace_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_csharp_namespace() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.csharp_namespace)
if (!_internal_has_csharp_namespace()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000010u;
return csharp_namespace_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_csharp_namespace(std::string* csharp_namespace) {
if (csharp_namespace != nullptr) {
_has_bits_[0] |= 0x00000010u;
} else {
_has_bits_[0] &= ~0x00000010u;
}
csharp_namespace_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), csharp_namespace,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.csharp_namespace)
}
// optional string swift_prefix = 39;
inline bool FileOptions::_internal_has_swift_prefix() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool FileOptions::has_swift_prefix() const {
return _internal_has_swift_prefix();
}
inline void FileOptions::clear_swift_prefix() {
swift_prefix_.ClearToEmpty();
_has_bits_[0] &= ~0x00000020u;
}
inline const std::string& FileOptions::swift_prefix() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.swift_prefix)
return _internal_swift_prefix();
}
inline void FileOptions::set_swift_prefix(const std::string& value) {
_internal_set_swift_prefix(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.swift_prefix)
}
inline std::string* FileOptions::mutable_swift_prefix() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.swift_prefix)
return _internal_mutable_swift_prefix();
}
inline const std::string& FileOptions::_internal_swift_prefix() const {
return swift_prefix_.Get();
}
inline void FileOptions::_internal_set_swift_prefix(const std::string& value) {
_has_bits_[0] |= 0x00000020u;
swift_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_swift_prefix(std::string&& value) {
_has_bits_[0] |= 0x00000020u;
swift_prefix_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.swift_prefix)
}
inline void FileOptions::set_swift_prefix(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000020u;
swift_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.swift_prefix)
}
inline void FileOptions::set_swift_prefix(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000020u;
swift_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.swift_prefix)
}
inline std::string* FileOptions::_internal_mutable_swift_prefix() {
_has_bits_[0] |= 0x00000020u;
return swift_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_swift_prefix() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.swift_prefix)
if (!_internal_has_swift_prefix()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000020u;
return swift_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_swift_prefix(std::string* swift_prefix) {
if (swift_prefix != nullptr) {
_has_bits_[0] |= 0x00000020u;
} else {
_has_bits_[0] &= ~0x00000020u;
}
swift_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), swift_prefix,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.swift_prefix)
}
// optional string php_class_prefix = 40;
inline bool FileOptions::_internal_has_php_class_prefix() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool FileOptions::has_php_class_prefix() const {
return _internal_has_php_class_prefix();
}
inline void FileOptions::clear_php_class_prefix() {
php_class_prefix_.ClearToEmpty();
_has_bits_[0] &= ~0x00000040u;
}
inline const std::string& FileOptions::php_class_prefix() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_class_prefix)
return _internal_php_class_prefix();
}
inline void FileOptions::set_php_class_prefix(const std::string& value) {
_internal_set_php_class_prefix(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_class_prefix)
}
inline std::string* FileOptions::mutable_php_class_prefix() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_class_prefix)
return _internal_mutable_php_class_prefix();
}
inline const std::string& FileOptions::_internal_php_class_prefix() const {
return php_class_prefix_.Get();
}
inline void FileOptions::_internal_set_php_class_prefix(const std::string& value) {
_has_bits_[0] |= 0x00000040u;
php_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_php_class_prefix(std::string&& value) {
_has_bits_[0] |= 0x00000040u;
php_class_prefix_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.php_class_prefix)
}
inline void FileOptions::set_php_class_prefix(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000040u;
php_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.php_class_prefix)
}
inline void FileOptions::set_php_class_prefix(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000040u;
php_class_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.php_class_prefix)
}
inline std::string* FileOptions::_internal_mutable_php_class_prefix() {
_has_bits_[0] |= 0x00000040u;
return php_class_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_php_class_prefix() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_class_prefix)
if (!_internal_has_php_class_prefix()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000040u;
return php_class_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_php_class_prefix(std::string* php_class_prefix) {
if (php_class_prefix != nullptr) {
_has_bits_[0] |= 0x00000040u;
} else {
_has_bits_[0] &= ~0x00000040u;
}
php_class_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), php_class_prefix,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_class_prefix)
}
// optional string php_namespace = 41;
inline bool FileOptions::_internal_has_php_namespace() const {
bool value = (_has_bits_[0] & 0x00000080u) != 0;
return value;
}
inline bool FileOptions::has_php_namespace() const {
return _internal_has_php_namespace();
}
inline void FileOptions::clear_php_namespace() {
php_namespace_.ClearToEmpty();
_has_bits_[0] &= ~0x00000080u;
}
inline const std::string& FileOptions::php_namespace() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_namespace)
return _internal_php_namespace();
}
inline void FileOptions::set_php_namespace(const std::string& value) {
_internal_set_php_namespace(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_namespace)
}
inline std::string* FileOptions::mutable_php_namespace() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_namespace)
return _internal_mutable_php_namespace();
}
inline const std::string& FileOptions::_internal_php_namespace() const {
return php_namespace_.Get();
}
inline void FileOptions::_internal_set_php_namespace(const std::string& value) {
_has_bits_[0] |= 0x00000080u;
php_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_php_namespace(std::string&& value) {
_has_bits_[0] |= 0x00000080u;
php_namespace_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.php_namespace)
}
inline void FileOptions::set_php_namespace(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000080u;
php_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.php_namespace)
}
inline void FileOptions::set_php_namespace(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000080u;
php_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.php_namespace)
}
inline std::string* FileOptions::_internal_mutable_php_namespace() {
_has_bits_[0] |= 0x00000080u;
return php_namespace_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_php_namespace() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_namespace)
if (!_internal_has_php_namespace()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000080u;
return php_namespace_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_php_namespace(std::string* php_namespace) {
if (php_namespace != nullptr) {
_has_bits_[0] |= 0x00000080u;
} else {
_has_bits_[0] &= ~0x00000080u;
}
php_namespace_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), php_namespace,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_namespace)
}
// optional string php_metadata_namespace = 44;
inline bool FileOptions::_internal_has_php_metadata_namespace() const {
bool value = (_has_bits_[0] & 0x00000100u) != 0;
return value;
}
inline bool FileOptions::has_php_metadata_namespace() const {
return _internal_has_php_metadata_namespace();
}
inline void FileOptions::clear_php_metadata_namespace() {
php_metadata_namespace_.ClearToEmpty();
_has_bits_[0] &= ~0x00000100u;
}
inline const std::string& FileOptions::php_metadata_namespace() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_metadata_namespace)
return _internal_php_metadata_namespace();
}
inline void FileOptions::set_php_metadata_namespace(const std::string& value) {
_internal_set_php_metadata_namespace(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_metadata_namespace)
}
inline std::string* FileOptions::mutable_php_metadata_namespace() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_metadata_namespace)
return _internal_mutable_php_metadata_namespace();
}
inline const std::string& FileOptions::_internal_php_metadata_namespace() const {
return php_metadata_namespace_.Get();
}
inline void FileOptions::_internal_set_php_metadata_namespace(const std::string& value) {
_has_bits_[0] |= 0x00000100u;
php_metadata_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_php_metadata_namespace(std::string&& value) {
_has_bits_[0] |= 0x00000100u;
php_metadata_namespace_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.php_metadata_namespace)
}
inline void FileOptions::set_php_metadata_namespace(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000100u;
php_metadata_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.php_metadata_namespace)
}
inline void FileOptions::set_php_metadata_namespace(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000100u;
php_metadata_namespace_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.php_metadata_namespace)
}
inline std::string* FileOptions::_internal_mutable_php_metadata_namespace() {
_has_bits_[0] |= 0x00000100u;
return php_metadata_namespace_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_php_metadata_namespace() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_metadata_namespace)
if (!_internal_has_php_metadata_namespace()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000100u;
return php_metadata_namespace_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_php_metadata_namespace(std::string* php_metadata_namespace) {
if (php_metadata_namespace != nullptr) {
_has_bits_[0] |= 0x00000100u;
} else {
_has_bits_[0] &= ~0x00000100u;
}
php_metadata_namespace_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), php_metadata_namespace,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_metadata_namespace)
}
// optional string ruby_package = 45;
inline bool FileOptions::_internal_has_ruby_package() const {
bool value = (_has_bits_[0] & 0x00000200u) != 0;
return value;
}
inline bool FileOptions::has_ruby_package() const {
return _internal_has_ruby_package();
}
inline void FileOptions::clear_ruby_package() {
ruby_package_.ClearToEmpty();
_has_bits_[0] &= ~0x00000200u;
}
inline const std::string& FileOptions::ruby_package() const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.ruby_package)
return _internal_ruby_package();
}
inline void FileOptions::set_ruby_package(const std::string& value) {
_internal_set_ruby_package(value);
// @@protoc_insertion_point(field_set:google.protobuf.FileOptions.ruby_package)
}
inline std::string* FileOptions::mutable_ruby_package() {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.ruby_package)
return _internal_mutable_ruby_package();
}
inline const std::string& FileOptions::_internal_ruby_package() const {
return ruby_package_.Get();
}
inline void FileOptions::_internal_set_ruby_package(const std::string& value) {
_has_bits_[0] |= 0x00000200u;
ruby_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void FileOptions::set_ruby_package(std::string&& value) {
_has_bits_[0] |= 0x00000200u;
ruby_package_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.ruby_package)
}
inline void FileOptions::set_ruby_package(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000200u;
ruby_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.ruby_package)
}
inline void FileOptions::set_ruby_package(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000200u;
ruby_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.ruby_package)
}
inline std::string* FileOptions::_internal_mutable_ruby_package() {
_has_bits_[0] |= 0x00000200u;
return ruby_package_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* FileOptions::release_ruby_package() {
// @@protoc_insertion_point(field_release:google.protobuf.FileOptions.ruby_package)
if (!_internal_has_ruby_package()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000200u;
return ruby_package_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void FileOptions::set_allocated_ruby_package(std::string* ruby_package) {
if (ruby_package != nullptr) {
_has_bits_[0] |= 0x00000200u;
} else {
_has_bits_[0] &= ~0x00000200u;
}
ruby_package_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ruby_package,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.ruby_package)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int FileOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int FileOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void FileOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
FileOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FileOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FileOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.FileOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
FileOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.FileOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// MessageOptions
// optional bool message_set_wire_format = 1 [default = false];
inline bool MessageOptions::_internal_has_message_set_wire_format() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MessageOptions::has_message_set_wire_format() const {
return _internal_has_message_set_wire_format();
}
inline void MessageOptions::clear_message_set_wire_format() {
message_set_wire_format_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool MessageOptions::_internal_message_set_wire_format() const {
return message_set_wire_format_;
}
inline bool MessageOptions::message_set_wire_format() const {
// @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.message_set_wire_format)
return _internal_message_set_wire_format();
}
inline void MessageOptions::_internal_set_message_set_wire_format(bool value) {
_has_bits_[0] |= 0x00000001u;
message_set_wire_format_ = value;
}
inline void MessageOptions::set_message_set_wire_format(bool value) {
_internal_set_message_set_wire_format(value);
// @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.message_set_wire_format)
}
// optional bool no_standard_descriptor_accessor = 2 [default = false];
inline bool MessageOptions::_internal_has_no_standard_descriptor_accessor() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MessageOptions::has_no_standard_descriptor_accessor() const {
return _internal_has_no_standard_descriptor_accessor();
}
inline void MessageOptions::clear_no_standard_descriptor_accessor() {
no_standard_descriptor_accessor_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool MessageOptions::_internal_no_standard_descriptor_accessor() const {
return no_standard_descriptor_accessor_;
}
inline bool MessageOptions::no_standard_descriptor_accessor() const {
// @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
return _internal_no_standard_descriptor_accessor();
}
inline void MessageOptions::_internal_set_no_standard_descriptor_accessor(bool value) {
_has_bits_[0] |= 0x00000002u;
no_standard_descriptor_accessor_ = value;
}
inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) {
_internal_set_no_standard_descriptor_accessor(value);
// @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
}
// optional bool deprecated = 3 [default = false];
inline bool MessageOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool MessageOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void MessageOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool MessageOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool MessageOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.deprecated)
return _internal_deprecated();
}
inline void MessageOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000004u;
deprecated_ = value;
}
inline void MessageOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.deprecated)
}
// optional bool map_entry = 7;
inline bool MessageOptions::_internal_has_map_entry() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool MessageOptions::has_map_entry() const {
return _internal_has_map_entry();
}
inline void MessageOptions::clear_map_entry() {
map_entry_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool MessageOptions::_internal_map_entry() const {
return map_entry_;
}
inline bool MessageOptions::map_entry() const {
// @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry)
return _internal_map_entry();
}
inline void MessageOptions::_internal_set_map_entry(bool value) {
_has_bits_[0] |= 0x00000008u;
map_entry_ = value;
}
inline void MessageOptions::set_map_entry(bool value) {
_internal_set_map_entry(value);
// @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.map_entry)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int MessageOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int MessageOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void MessageOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.MessageOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
MessageOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.MessageOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.MessageOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
MessageOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.MessageOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// FieldOptions
// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
inline bool FieldOptions::_internal_has_ctype() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool FieldOptions::has_ctype() const {
return _internal_has_ctype();
}
inline void FieldOptions::clear_ctype() {
ctype_ = 0;
_has_bits_[0] &= ~0x00000001u;
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::_internal_ctype() const {
return static_cast< PROTOBUF_NAMESPACE_ID::FieldOptions_CType >(ctype_);
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::ctype() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.ctype)
return _internal_ctype();
}
inline void FieldOptions::_internal_set_ctype(PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
assert(PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(value));
_has_bits_[0] |= 0x00000001u;
ctype_ = value;
}
inline void FieldOptions::set_ctype(PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
_internal_set_ctype(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.ctype)
}
// optional bool packed = 2;
inline bool FieldOptions::_internal_has_packed() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool FieldOptions::has_packed() const {
return _internal_has_packed();
}
inline void FieldOptions::clear_packed() {
packed_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool FieldOptions::_internal_packed() const {
return packed_;
}
inline bool FieldOptions::packed() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.packed)
return _internal_packed();
}
inline void FieldOptions::_internal_set_packed(bool value) {
_has_bits_[0] |= 0x00000002u;
packed_ = value;
}
inline void FieldOptions::set_packed(bool value) {
_internal_set_packed(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.packed)
}
// optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
inline bool FieldOptions::_internal_has_jstype() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool FieldOptions::has_jstype() const {
return _internal_has_jstype();
}
inline void FieldOptions::clear_jstype() {
jstype_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::_internal_jstype() const {
return static_cast< PROTOBUF_NAMESPACE_ID::FieldOptions_JSType >(jstype_);
}
inline PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::jstype() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.jstype)
return _internal_jstype();
}
inline void FieldOptions::_internal_set_jstype(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
assert(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(value));
_has_bits_[0] |= 0x00000020u;
jstype_ = value;
}
inline void FieldOptions::set_jstype(PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
_internal_set_jstype(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.jstype)
}
// optional bool lazy = 5 [default = false];
inline bool FieldOptions::_internal_has_lazy() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool FieldOptions::has_lazy() const {
return _internal_has_lazy();
}
inline void FieldOptions::clear_lazy() {
lazy_ = false;
_has_bits_[0] &= ~0x00000004u;
}
inline bool FieldOptions::_internal_lazy() const {
return lazy_;
}
inline bool FieldOptions::lazy() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.lazy)
return _internal_lazy();
}
inline void FieldOptions::_internal_set_lazy(bool value) {
_has_bits_[0] |= 0x00000004u;
lazy_ = value;
}
inline void FieldOptions::set_lazy(bool value) {
_internal_set_lazy(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.lazy)
}
// optional bool deprecated = 3 [default = false];
inline bool FieldOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool FieldOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void FieldOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000008u;
}
inline bool FieldOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool FieldOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.deprecated)
return _internal_deprecated();
}
inline void FieldOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000008u;
deprecated_ = value;
}
inline void FieldOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.deprecated)
}
// optional bool weak = 10 [default = false];
inline bool FieldOptions::_internal_has_weak() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool FieldOptions::has_weak() const {
return _internal_has_weak();
}
inline void FieldOptions::clear_weak() {
weak_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool FieldOptions::_internal_weak() const {
return weak_;
}
inline bool FieldOptions::weak() const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.weak)
return _internal_weak();
}
inline void FieldOptions::_internal_set_weak(bool value) {
_has_bits_[0] |= 0x00000010u;
weak_ = value;
}
inline void FieldOptions::set_weak(bool value) {
_internal_set_weak(value);
// @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.weak)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int FieldOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int FieldOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void FieldOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.FieldOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
FieldOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.FieldOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
FieldOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.FieldOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// OneofOptions
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int OneofOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int OneofOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void OneofOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.OneofOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
OneofOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.OneofOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.OneofOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.OneofOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
OneofOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.OneofOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// EnumOptions
// optional bool allow_alias = 2;
inline bool EnumOptions::_internal_has_allow_alias() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EnumOptions::has_allow_alias() const {
return _internal_has_allow_alias();
}
inline void EnumOptions::clear_allow_alias() {
allow_alias_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool EnumOptions::_internal_allow_alias() const {
return allow_alias_;
}
inline bool EnumOptions::allow_alias() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.allow_alias)
return _internal_allow_alias();
}
inline void EnumOptions::_internal_set_allow_alias(bool value) {
_has_bits_[0] |= 0x00000001u;
allow_alias_ = value;
}
inline void EnumOptions::set_allow_alias(bool value) {
_internal_set_allow_alias(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.allow_alias)
}
// optional bool deprecated = 3 [default = false];
inline bool EnumOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool EnumOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void EnumOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool EnumOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool EnumOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.deprecated)
return _internal_deprecated();
}
inline void EnumOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000002u;
deprecated_ = value;
}
inline void EnumOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.deprecated)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int EnumOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int EnumOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void EnumOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
EnumOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.EnumOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
EnumOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.EnumOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// EnumValueOptions
// optional bool deprecated = 1 [default = false];
inline bool EnumValueOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool EnumValueOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void EnumValueOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool EnumValueOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool EnumValueOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.deprecated)
return _internal_deprecated();
}
inline void EnumValueOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000001u;
deprecated_ = value;
}
inline void EnumValueOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.EnumValueOptions.deprecated)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int EnumValueOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int EnumValueOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void EnumValueOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
EnumValueOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValueOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.EnumValueOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
EnumValueOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.EnumValueOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// ServiceOptions
// optional bool deprecated = 33 [default = false];
inline bool ServiceOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ServiceOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void ServiceOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool ServiceOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool ServiceOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.deprecated)
return _internal_deprecated();
}
inline void ServiceOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000001u;
deprecated_ = value;
}
inline void ServiceOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.ServiceOptions.deprecated)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int ServiceOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int ServiceOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void ServiceOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.ServiceOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
ServiceOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.ServiceOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
ServiceOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.ServiceOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// MethodOptions
// optional bool deprecated = 33 [default = false];
inline bool MethodOptions::_internal_has_deprecated() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool MethodOptions::has_deprecated() const {
return _internal_has_deprecated();
}
inline void MethodOptions::clear_deprecated() {
deprecated_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool MethodOptions::_internal_deprecated() const {
return deprecated_;
}
inline bool MethodOptions::deprecated() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.deprecated)
return _internal_deprecated();
}
inline void MethodOptions::_internal_set_deprecated(bool value) {
_has_bits_[0] |= 0x00000001u;
deprecated_ = value;
}
inline void MethodOptions::set_deprecated(bool value) {
_internal_set_deprecated(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.deprecated)
}
// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
inline bool MethodOptions::_internal_has_idempotency_level() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool MethodOptions::has_idempotency_level() const {
return _internal_has_idempotency_level();
}
inline void MethodOptions::clear_idempotency_level() {
idempotency_level_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::_internal_idempotency_level() const {
return static_cast< PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel >(idempotency_level_);
}
inline PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::idempotency_level() const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.idempotency_level)
return _internal_idempotency_level();
}
inline void MethodOptions::_internal_set_idempotency_level(PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
assert(PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_IsValid(value));
_has_bits_[0] |= 0x00000002u;
idempotency_level_ = value;
}
inline void MethodOptions::set_idempotency_level(PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
_internal_set_idempotency_level(value);
// @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.idempotency_level)
}
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
inline int MethodOptions::_internal_uninterpreted_option_size() const {
return uninterpreted_option_.size();
}
inline int MethodOptions::uninterpreted_option_size() const {
return _internal_uninterpreted_option_size();
}
inline void MethodOptions::clear_uninterpreted_option() {
uninterpreted_option_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.MethodOptions.uninterpreted_option)
return uninterpreted_option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
MethodOptions::mutable_uninterpreted_option() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.MethodOptions.uninterpreted_option)
return &uninterpreted_option_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::_internal_uninterpreted_option(int index) const {
return uninterpreted_option_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.uninterpreted_option)
return _internal_uninterpreted_option(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::_internal_add_uninterpreted_option() {
return uninterpreted_option_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::add_uninterpreted_option() {
// @@protoc_insertion_point(field_add:google.protobuf.MethodOptions.uninterpreted_option)
return _internal_add_uninterpreted_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
MethodOptions::uninterpreted_option() const {
// @@protoc_insertion_point(field_list:google.protobuf.MethodOptions.uninterpreted_option)
return uninterpreted_option_;
}
// -------------------------------------------------------------------
// UninterpretedOption_NamePart
// required string name_part = 1;
inline bool UninterpretedOption_NamePart::_internal_has_name_part() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool UninterpretedOption_NamePart::has_name_part() const {
return _internal_has_name_part();
}
inline void UninterpretedOption_NamePart::clear_name_part() {
name_part_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UninterpretedOption_NamePart::name_part() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.name_part)
return _internal_name_part();
}
inline void UninterpretedOption_NamePart::set_name_part(const std::string& value) {
_internal_set_name_part(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.name_part)
}
inline std::string* UninterpretedOption_NamePart::mutable_name_part() {
// @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.NamePart.name_part)
return _internal_mutable_name_part();
}
inline const std::string& UninterpretedOption_NamePart::_internal_name_part() const {
return name_part_.Get();
}
inline void UninterpretedOption_NamePart::_internal_set_name_part(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
name_part_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void UninterpretedOption_NamePart::set_name_part(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
name_part_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.NamePart.name_part)
}
inline void UninterpretedOption_NamePart::set_name_part(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
name_part_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.NamePart.name_part)
}
inline void UninterpretedOption_NamePart::set_name_part(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
name_part_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.NamePart.name_part)
}
inline std::string* UninterpretedOption_NamePart::_internal_mutable_name_part() {
_has_bits_[0] |= 0x00000001u;
return name_part_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* UninterpretedOption_NamePart::release_name_part() {
// @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.NamePart.name_part)
if (!_internal_has_name_part()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return name_part_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UninterpretedOption_NamePart::set_allocated_name_part(std::string* name_part) {
if (name_part != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
name_part_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name_part,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
}
// required bool is_extension = 2;
inline bool UninterpretedOption_NamePart::_internal_has_is_extension() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool UninterpretedOption_NamePart::has_is_extension() const {
return _internal_has_is_extension();
}
inline void UninterpretedOption_NamePart::clear_is_extension() {
is_extension_ = false;
_has_bits_[0] &= ~0x00000002u;
}
inline bool UninterpretedOption_NamePart::_internal_is_extension() const {
return is_extension_;
}
inline bool UninterpretedOption_NamePart::is_extension() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.is_extension)
return _internal_is_extension();
}
inline void UninterpretedOption_NamePart::_internal_set_is_extension(bool value) {
_has_bits_[0] |= 0x00000002u;
is_extension_ = value;
}
inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
_internal_set_is_extension(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.is_extension)
}
// -------------------------------------------------------------------
// UninterpretedOption
// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
inline int UninterpretedOption::_internal_name_size() const {
return name_.size();
}
inline int UninterpretedOption::name_size() const {
return _internal_name_size();
}
inline void UninterpretedOption::clear_name() {
name_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.name)
return name_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
UninterpretedOption::mutable_name() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.UninterpretedOption.name)
return &name_;
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::_internal_name(int index) const {
return name_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.name)
return _internal_name(index);
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::_internal_add_name() {
return name_.Add();
}
inline PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::add_name() {
// @@protoc_insertion_point(field_add:google.protobuf.UninterpretedOption.name)
return _internal_add_name();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
UninterpretedOption::name() const {
// @@protoc_insertion_point(field_list:google.protobuf.UninterpretedOption.name)
return name_;
}
// optional string identifier_value = 3;
inline bool UninterpretedOption::_internal_has_identifier_value() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool UninterpretedOption::has_identifier_value() const {
return _internal_has_identifier_value();
}
inline void UninterpretedOption::clear_identifier_value() {
identifier_value_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UninterpretedOption::identifier_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.identifier_value)
return _internal_identifier_value();
}
inline void UninterpretedOption::set_identifier_value(const std::string& value) {
_internal_set_identifier_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.identifier_value)
}
inline std::string* UninterpretedOption::mutable_identifier_value() {
// @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.identifier_value)
return _internal_mutable_identifier_value();
}
inline const std::string& UninterpretedOption::_internal_identifier_value() const {
return identifier_value_.Get();
}
inline void UninterpretedOption::_internal_set_identifier_value(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
identifier_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void UninterpretedOption::set_identifier_value(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
identifier_value_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.identifier_value)
}
inline void UninterpretedOption::set_identifier_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
identifier_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.identifier_value)
}
inline void UninterpretedOption::set_identifier_value(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
identifier_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.identifier_value)
}
inline std::string* UninterpretedOption::_internal_mutable_identifier_value() {
_has_bits_[0] |= 0x00000001u;
return identifier_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* UninterpretedOption::release_identifier_value() {
// @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.identifier_value)
if (!_internal_has_identifier_value()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return identifier_value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UninterpretedOption::set_allocated_identifier_value(std::string* identifier_value) {
if (identifier_value != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
identifier_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identifier_value,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
}
// optional uint64 positive_int_value = 4;
inline bool UninterpretedOption::_internal_has_positive_int_value() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool UninterpretedOption::has_positive_int_value() const {
return _internal_has_positive_int_value();
}
inline void UninterpretedOption::clear_positive_int_value() {
positive_int_value_ = PROTOBUF_ULONGLONG(0);
_has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 UninterpretedOption::_internal_positive_int_value() const {
return positive_int_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 UninterpretedOption::positive_int_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.positive_int_value)
return _internal_positive_int_value();
}
inline void UninterpretedOption::_internal_set_positive_int_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
_has_bits_[0] |= 0x00000008u;
positive_int_value_ = value;
}
inline void UninterpretedOption::set_positive_int_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
_internal_set_positive_int_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.positive_int_value)
}
// optional int64 negative_int_value = 5;
inline bool UninterpretedOption::_internal_has_negative_int_value() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool UninterpretedOption::has_negative_int_value() const {
return _internal_has_negative_int_value();
}
inline void UninterpretedOption::clear_negative_int_value() {
negative_int_value_ = PROTOBUF_LONGLONG(0);
_has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 UninterpretedOption::_internal_negative_int_value() const {
return negative_int_value_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 UninterpretedOption::negative_int_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.negative_int_value)
return _internal_negative_int_value();
}
inline void UninterpretedOption::_internal_set_negative_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
_has_bits_[0] |= 0x00000010u;
negative_int_value_ = value;
}
inline void UninterpretedOption::set_negative_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
_internal_set_negative_int_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.negative_int_value)
}
// optional double double_value = 6;
inline bool UninterpretedOption::_internal_has_double_value() const {
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool UninterpretedOption::has_double_value() const {
return _internal_has_double_value();
}
inline void UninterpretedOption::clear_double_value() {
double_value_ = 0;
_has_bits_[0] &= ~0x00000020u;
}
inline double UninterpretedOption::_internal_double_value() const {
return double_value_;
}
inline double UninterpretedOption::double_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.double_value)
return _internal_double_value();
}
inline void UninterpretedOption::_internal_set_double_value(double value) {
_has_bits_[0] |= 0x00000020u;
double_value_ = value;
}
inline void UninterpretedOption::set_double_value(double value) {
_internal_set_double_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.double_value)
}
// optional bytes string_value = 7;
inline bool UninterpretedOption::_internal_has_string_value() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool UninterpretedOption::has_string_value() const {
return _internal_has_string_value();
}
inline void UninterpretedOption::clear_string_value() {
string_value_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& UninterpretedOption::string_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.string_value)
return _internal_string_value();
}
inline void UninterpretedOption::set_string_value(const std::string& value) {
_internal_set_string_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.string_value)
}
inline std::string* UninterpretedOption::mutable_string_value() {
// @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.string_value)
return _internal_mutable_string_value();
}
inline const std::string& UninterpretedOption::_internal_string_value() const {
return string_value_.Get();
}
inline void UninterpretedOption::_internal_set_string_value(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
string_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void UninterpretedOption::set_string_value(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
string_value_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.string_value)
}
inline void UninterpretedOption::set_string_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
string_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.string_value)
}
inline void UninterpretedOption::set_string_value(const void* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
string_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.string_value)
}
inline std::string* UninterpretedOption::_internal_mutable_string_value() {
_has_bits_[0] |= 0x00000002u;
return string_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* UninterpretedOption::release_string_value() {
// @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.string_value)
if (!_internal_has_string_value()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return string_value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UninterpretedOption::set_allocated_string_value(std::string* string_value) {
if (string_value != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
string_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_value,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.string_value)
}
// optional string aggregate_value = 8;
inline bool UninterpretedOption::_internal_has_aggregate_value() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool UninterpretedOption::has_aggregate_value() const {
return _internal_has_aggregate_value();
}
inline void UninterpretedOption::clear_aggregate_value() {
aggregate_value_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& UninterpretedOption::aggregate_value() const {
// @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.aggregate_value)
return _internal_aggregate_value();
}
inline void UninterpretedOption::set_aggregate_value(const std::string& value) {
_internal_set_aggregate_value(value);
// @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.aggregate_value)
}
inline std::string* UninterpretedOption::mutable_aggregate_value() {
// @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.aggregate_value)
return _internal_mutable_aggregate_value();
}
inline const std::string& UninterpretedOption::_internal_aggregate_value() const {
return aggregate_value_.Get();
}
inline void UninterpretedOption::_internal_set_aggregate_value(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
aggregate_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void UninterpretedOption::set_aggregate_value(std::string&& value) {
_has_bits_[0] |= 0x00000004u;
aggregate_value_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.aggregate_value)
}
inline void UninterpretedOption::set_aggregate_value(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000004u;
aggregate_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.aggregate_value)
}
inline void UninterpretedOption::set_aggregate_value(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000004u;
aggregate_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.aggregate_value)
}
inline std::string* UninterpretedOption::_internal_mutable_aggregate_value() {
_has_bits_[0] |= 0x00000004u;
return aggregate_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* UninterpretedOption::release_aggregate_value() {
// @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.aggregate_value)
if (!_internal_has_aggregate_value()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
return aggregate_value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggregate_value) {
if (aggregate_value != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
aggregate_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), aggregate_value,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
}
// -------------------------------------------------------------------
// SourceCodeInfo_Location
// repeated int32 path = 1 [packed = true];
inline int SourceCodeInfo_Location::_internal_path_size() const {
return path_.size();
}
inline int SourceCodeInfo_Location::path_size() const {
return _internal_path_size();
}
inline void SourceCodeInfo_Location::clear_path() {
path_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SourceCodeInfo_Location::_internal_path(int index) const {
return path_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SourceCodeInfo_Location::path(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.path)
return _internal_path(index);
}
inline void SourceCodeInfo_Location::set_path(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
path_.Set(index, value);
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.path)
}
inline void SourceCodeInfo_Location::_internal_add_path(::PROTOBUF_NAMESPACE_ID::int32 value) {
path_.Add(value);
}
inline void SourceCodeInfo_Location::add_path(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_add_path(value);
// @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.path)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
SourceCodeInfo_Location::_internal_path() const {
return path_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
SourceCodeInfo_Location::path() const {
// @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.path)
return _internal_path();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
SourceCodeInfo_Location::_internal_mutable_path() {
return &path_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
SourceCodeInfo_Location::mutable_path() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.path)
return _internal_mutable_path();
}
// repeated int32 span = 2 [packed = true];
inline int SourceCodeInfo_Location::_internal_span_size() const {
return span_.size();
}
inline int SourceCodeInfo_Location::span_size() const {
return _internal_span_size();
}
inline void SourceCodeInfo_Location::clear_span() {
span_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SourceCodeInfo_Location::_internal_span(int index) const {
return span_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SourceCodeInfo_Location::span(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.span)
return _internal_span(index);
}
inline void SourceCodeInfo_Location::set_span(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
span_.Set(index, value);
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.span)
}
inline void SourceCodeInfo_Location::_internal_add_span(::PROTOBUF_NAMESPACE_ID::int32 value) {
span_.Add(value);
}
inline void SourceCodeInfo_Location::add_span(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_add_span(value);
// @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.span)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
SourceCodeInfo_Location::_internal_span() const {
return span_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
SourceCodeInfo_Location::span() const {
// @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.span)
return _internal_span();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
SourceCodeInfo_Location::_internal_mutable_span() {
return &span_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
SourceCodeInfo_Location::mutable_span() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.span)
return _internal_mutable_span();
}
// optional string leading_comments = 3;
inline bool SourceCodeInfo_Location::_internal_has_leading_comments() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool SourceCodeInfo_Location::has_leading_comments() const {
return _internal_has_leading_comments();
}
inline void SourceCodeInfo_Location::clear_leading_comments() {
leading_comments_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SourceCodeInfo_Location::leading_comments() const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_comments)
return _internal_leading_comments();
}
inline void SourceCodeInfo_Location::set_leading_comments(const std::string& value) {
_internal_set_leading_comments(value);
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_comments)
}
inline std::string* SourceCodeInfo_Location::mutable_leading_comments() {
// @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_comments)
return _internal_mutable_leading_comments();
}
inline const std::string& SourceCodeInfo_Location::_internal_leading_comments() const {
return leading_comments_.Get();
}
inline void SourceCodeInfo_Location::_internal_set_leading_comments(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
leading_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SourceCodeInfo_Location::set_leading_comments(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
leading_comments_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.SourceCodeInfo.Location.leading_comments)
}
inline void SourceCodeInfo_Location::set_leading_comments(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
leading_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_comments)
}
inline void SourceCodeInfo_Location::set_leading_comments(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
leading_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_comments)
}
inline std::string* SourceCodeInfo_Location::_internal_mutable_leading_comments() {
_has_bits_[0] |= 0x00000001u;
return leading_comments_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SourceCodeInfo_Location::release_leading_comments() {
// @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
if (!_internal_has_leading_comments()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return leading_comments_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SourceCodeInfo_Location::set_allocated_leading_comments(std::string* leading_comments) {
if (leading_comments != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
leading_comments_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), leading_comments,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
}
// optional string trailing_comments = 4;
inline bool SourceCodeInfo_Location::_internal_has_trailing_comments() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool SourceCodeInfo_Location::has_trailing_comments() const {
return _internal_has_trailing_comments();
}
inline void SourceCodeInfo_Location::clear_trailing_comments() {
trailing_comments_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SourceCodeInfo_Location::trailing_comments() const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.trailing_comments)
return _internal_trailing_comments();
}
inline void SourceCodeInfo_Location::set_trailing_comments(const std::string& value) {
_internal_set_trailing_comments(value);
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.trailing_comments)
}
inline std::string* SourceCodeInfo_Location::mutable_trailing_comments() {
// @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.trailing_comments)
return _internal_mutable_trailing_comments();
}
inline const std::string& SourceCodeInfo_Location::_internal_trailing_comments() const {
return trailing_comments_.Get();
}
inline void SourceCodeInfo_Location::_internal_set_trailing_comments(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
trailing_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SourceCodeInfo_Location::set_trailing_comments(std::string&& value) {
_has_bits_[0] |= 0x00000002u;
trailing_comments_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.SourceCodeInfo.Location.trailing_comments)
}
inline void SourceCodeInfo_Location::set_trailing_comments(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000002u;
trailing_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.trailing_comments)
}
inline void SourceCodeInfo_Location::set_trailing_comments(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000002u;
trailing_comments_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.trailing_comments)
}
inline std::string* SourceCodeInfo_Location::_internal_mutable_trailing_comments() {
_has_bits_[0] |= 0x00000002u;
return trailing_comments_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SourceCodeInfo_Location::release_trailing_comments() {
// @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
if (!_internal_has_trailing_comments()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
return trailing_comments_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SourceCodeInfo_Location::set_allocated_trailing_comments(std::string* trailing_comments) {
if (trailing_comments != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
trailing_comments_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), trailing_comments,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
}
// repeated string leading_detached_comments = 6;
inline int SourceCodeInfo_Location::_internal_leading_detached_comments_size() const {
return leading_detached_comments_.size();
}
inline int SourceCodeInfo_Location::leading_detached_comments_size() const {
return _internal_leading_detached_comments_size();
}
inline void SourceCodeInfo_Location::clear_leading_detached_comments() {
leading_detached_comments_.Clear();
}
inline std::string* SourceCodeInfo_Location::add_leading_detached_comments() {
// @@protoc_insertion_point(field_add_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
return _internal_add_leading_detached_comments();
}
inline const std::string& SourceCodeInfo_Location::_internal_leading_detached_comments(int index) const {
return leading_detached_comments_.Get(index);
}
inline const std::string& SourceCodeInfo_Location::leading_detached_comments(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
return _internal_leading_detached_comments(index);
}
inline std::string* SourceCodeInfo_Location::mutable_leading_detached_comments(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
return leading_detached_comments_.Mutable(index);
}
inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
leading_detached_comments_.Mutable(index)->assign(value);
}
inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
leading_detached_comments_.Mutable(index)->assign(std::move(value));
}
inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
leading_detached_comments_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value, size_t size) {
leading_detached_comments_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline std::string* SourceCodeInfo_Location::_internal_add_leading_detached_comments() {
return leading_detached_comments_.Add();
}
inline void SourceCodeInfo_Location::add_leading_detached_comments(const std::string& value) {
leading_detached_comments_.Add()->assign(value);
// @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline void SourceCodeInfo_Location::add_leading_detached_comments(std::string&& value) {
leading_detached_comments_.Add(std::move(value));
// @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value) {
GOOGLE_DCHECK(value != nullptr);
leading_detached_comments_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value, size_t size) {
leading_detached_comments_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SourceCodeInfo_Location::leading_detached_comments() const {
// @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
return leading_detached_comments_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SourceCodeInfo_Location::mutable_leading_detached_comments() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
return &leading_detached_comments_;
}
// -------------------------------------------------------------------
// SourceCodeInfo
// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
inline int SourceCodeInfo::_internal_location_size() const {
return location_.size();
}
inline int SourceCodeInfo::location_size() const {
return _internal_location_size();
}
inline void SourceCodeInfo::clear_location() {
location_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.location)
return location_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
SourceCodeInfo::mutable_location() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.location)
return &location_;
}
inline const PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::_internal_location(int index) const {
return location_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.location)
return _internal_location(index);
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::_internal_add_location() {
return location_.Add();
}
inline PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::add_location() {
// @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.location)
return _internal_add_location();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
SourceCodeInfo::location() const {
// @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.location)
return location_;
}
// -------------------------------------------------------------------
// GeneratedCodeInfo_Annotation
// repeated int32 path = 1 [packed = true];
inline int GeneratedCodeInfo_Annotation::_internal_path_size() const {
return path_.size();
}
inline int GeneratedCodeInfo_Annotation::path_size() const {
return _internal_path_size();
}
inline void GeneratedCodeInfo_Annotation::clear_path() {
path_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::_internal_path(int index) const {
return path_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::path(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.path)
return _internal_path(index);
}
inline void GeneratedCodeInfo_Annotation::set_path(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
path_.Set(index, value);
// @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.path)
}
inline void GeneratedCodeInfo_Annotation::_internal_add_path(::PROTOBUF_NAMESPACE_ID::int32 value) {
path_.Add(value);
}
inline void GeneratedCodeInfo_Annotation::add_path(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_add_path(value);
// @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.Annotation.path)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
GeneratedCodeInfo_Annotation::_internal_path() const {
return path_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
GeneratedCodeInfo_Annotation::path() const {
// @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
return _internal_path();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
GeneratedCodeInfo_Annotation::_internal_mutable_path() {
return &path_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
GeneratedCodeInfo_Annotation::mutable_path() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
return _internal_mutable_path();
}
// optional string source_file = 2;
inline bool GeneratedCodeInfo_Annotation::_internal_has_source_file() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool GeneratedCodeInfo_Annotation::has_source_file() const {
return _internal_has_source_file();
}
inline void GeneratedCodeInfo_Annotation::clear_source_file() {
source_file_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GeneratedCodeInfo_Annotation::source_file() const {
// @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
return _internal_source_file();
}
inline void GeneratedCodeInfo_Annotation::set_source_file(const std::string& value) {
_internal_set_source_file(value);
// @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
}
inline std::string* GeneratedCodeInfo_Annotation::mutable_source_file() {
// @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
return _internal_mutable_source_file();
}
inline const std::string& GeneratedCodeInfo_Annotation::_internal_source_file() const {
return source_file_.Get();
}
inline void GeneratedCodeInfo_Annotation::_internal_set_source_file(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
source_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void GeneratedCodeInfo_Annotation::set_source_file(std::string&& value) {
_has_bits_[0] |= 0x00000001u;
source_file_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
// @@protoc_insertion_point(field_set_rvalue:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
}
inline void GeneratedCodeInfo_Annotation::set_source_file(const char* value) {
GOOGLE_DCHECK(value != nullptr);
_has_bits_[0] |= 0x00000001u;
source_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
// @@protoc_insertion_point(field_set_char:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
}
inline void GeneratedCodeInfo_Annotation::set_source_file(const char* value,
size_t size) {
_has_bits_[0] |= 0x00000001u;
source_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
// @@protoc_insertion_point(field_set_pointer:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
}
inline std::string* GeneratedCodeInfo_Annotation::_internal_mutable_source_file() {
_has_bits_[0] |= 0x00000001u;
return source_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* GeneratedCodeInfo_Annotation::release_source_file() {
// @@protoc_insertion_point(field_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
if (!_internal_has_source_file()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
return source_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void GeneratedCodeInfo_Annotation::set_allocated_source_file(std::string* source_file) {
if (source_file != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
source_file_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source_file,
GetArena());
// @@protoc_insertion_point(field_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
}
// optional int32 begin = 3;
inline bool GeneratedCodeInfo_Annotation::_internal_has_begin() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool GeneratedCodeInfo_Annotation::has_begin() const {
return _internal_has_begin();
}
inline void GeneratedCodeInfo_Annotation::clear_begin() {
begin_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::_internal_begin() const {
return begin_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::begin() const {
// @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.begin)
return _internal_begin();
}
inline void GeneratedCodeInfo_Annotation::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000002u;
begin_ = value;
}
inline void GeneratedCodeInfo_Annotation::set_begin(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_begin(value);
// @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.begin)
}
// optional int32 end = 4;
inline bool GeneratedCodeInfo_Annotation::_internal_has_end() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool GeneratedCodeInfo_Annotation::has_end() const {
return _internal_has_end();
}
inline void GeneratedCodeInfo_Annotation::clear_end() {
end_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::_internal_end() const {
return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GeneratedCodeInfo_Annotation::end() const {
// @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.end)
return _internal_end();
}
inline void GeneratedCodeInfo_Annotation::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_has_bits_[0] |= 0x00000004u;
end_ = value;
}
inline void GeneratedCodeInfo_Annotation::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
_internal_set_end(value);
// @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.end)
}
// -------------------------------------------------------------------
// GeneratedCodeInfo
// repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
inline int GeneratedCodeInfo::_internal_annotation_size() const {
return annotation_.size();
}
inline int GeneratedCodeInfo::annotation_size() const {
return _internal_annotation_size();
}
inline void GeneratedCodeInfo::clear_annotation() {
annotation_.Clear();
}
inline PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::mutable_annotation(int index) {
// @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.annotation)
return annotation_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
GeneratedCodeInfo::mutable_annotation() {
// @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.annotation)
return &annotation_;
}
inline const PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::_internal_annotation(int index) const {
return annotation_.Get(index);
}
inline const PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::annotation(int index) const {
// @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.annotation)
return _internal_annotation(index);
}
inline PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::_internal_add_annotation() {
return annotation_.Add();
}
inline PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::add_annotation() {
// @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.annotation)
return _internal_add_annotation();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
GeneratedCodeInfo::annotation() const {
// @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.annotation)
return annotation_;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_CLOSE
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>() {
return PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_descriptor();
}
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>() {
return PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_descriptor();
}
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>() {
return PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_descriptor();
}
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::FieldOptions_CType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::FieldOptions_CType>() {
return PROTOBUF_NAMESPACE_ID::FieldOptions_CType_descriptor();
}
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::FieldOptions_JSType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>() {
return PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_descriptor();
}
template <> struct is_proto_enum< PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel>() {
return PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
| [
"[email protected]"
] | |
2bd924b61132a9462d59feae907d06c71cb088e4 | 2f3372d8929d69e149574865140fb4f6be6f5994 | /main.1213988406138591467.cpp | 4f3356b884a58383fe2dad44d1637cdf80e16388 | [] | no_license | huynguy97/IP-Week2 | 7a6c45a72d2428218f92cc516b3f356f01ea7071 | e18da0c27cea68cae146e1288fcc7a4b395b12e6 | refs/heads/master | 2020-05-22T07:52:25.897780 | 2019-05-12T17:20:49 | 2019-05-12T17:20:49 | 186,273,762 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,860 | cpp | #include "Robot.h"
#include <algorithm>
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
/*
*/
//
//
//
void steps ( int no_of_steps )
{
while (no_of_steps > 0)
{
step () ;
no_of_steps-- ;
}
}
//
void safe_put_ball ()
{
if (!on_ball())
put_ball () ;
}
//
void balls (int no_of_balls)
{
while (no_of_balls > 0)
{
safe_put_ball () ;
no_of_balls-- ;
if (no_of_balls > 0)
step () ;
}
}
//
void make_grandstand ()
{
const int FIELD_WIDTH = 5 + rand () % (WORLDWIDTH / 5) ;
const int NO_OF_STAIRS = 1 + rand () % (WORLDHEIGHT / 4) ;
place_walls (1, WORLDHEIGHT / 2, FIELD_WIDTH, true) ;
for (int stair = 0 ; stair < NO_OF_STAIRS ; stair++)
{
place_walls (1+FIELD_WIDTH+stair, WORLDHEIGHT / 2 + stair, 1, false) ;
place_walls (1+FIELD_WIDTH+stair, WORLDHEIGHT / 2 + stair+1,1,true) ;
}
place_walls (1+FIELD_WIDTH+NO_OF_STAIRS, WORLDHEIGHT / 2 + NO_OF_STAIRS,1,true) ;
}
//
void make_path_with_balls ()
{
const int L1 = WORLDWIDTH * 6 / 10 + rand () % (WORLDWIDTH/3) ;
const int L2 = WORLDHEIGHT / 2 - 2 - rand () % (WORLDHEIGHT/6) ;
const int L3 = WORLDWIDTH / 3 + rand () % (WORLDWIDTH/5) ;
const int L4 = 2 * L2 ;
const int L5 = (L1-L3)/2 ;
const int L6 = L4 * 4 / 5 ;
place_balls (1,WORLDHEIGHT-2,2,true) ;
place_balls (1,WORLDHEIGHT-2,2,true) ;
place_balls (3,WORLDHEIGHT/2,WORLDHEIGHT/2-3,false) ;
place_balls (3,WORLDHEIGHT/2,L1,true) ;
place_balls (L1+4,WORLDHEIGHT/2,L2,false) ;
place_balls (L1-L3+4,WORLDHEIGHT/2+L2,L3,true) ;
place_balls (L1-L3+4,WORLDHEIGHT/2+L2-L4,L4,false) ;
place_balls (L1-L3-L5+4,WORLDHEIGHT/2+L2-L4,L5,true) ;
place_balls (L1-L3-L5+4,WORLDHEIGHT/2+L2-L4,L6,false) ;
}
void make_cave_wall (bool at_north_edge)
{
const int MARGIN = WORLDHEIGHT / 3 ;
const int MAX_WIDTH = WORLDWIDTH / 10 ;
for (int ix = 2; ix <= WORLDWIDTH-3; )
{
const int WIDTH = rand() % (min (MAX_WIDTH, WORLDWIDTH - ix - 2)) + 1 ;
const int DY = rand() % MARGIN + 2 ;
int y ;
if (at_north_edge)
y = DY ;
else
y = WORLDHEIGHT - DY - 1 ;
place_walls (ix,y,WIDTH-1,true) ;
ix += WIDTH ;
}
}
void make_cave ()
{
make_cave_wall (true) ;
make_cave_wall (false) ;
}
int shamrock_length (int dimension, int margin)
{
return (dimension / 4) - margin ;//
}
//
//
void make_shamrock ()
{
const int NO_OF_LEAVES = rand () % 4 + 1 ;
const int MARGIN = 4 ;
const int MW = WORLDWIDTH / 2 ;
const int MH = WORLDHEIGHT / 2 ;
const int NW = shamrock_length (WORLDWIDTH, MARGIN) ;
const int SW = shamrock_length (WORLDWIDTH, MARGIN) ;
const int WW = shamrock_length (WORLDWIDTH, MARGIN) ;
const int EW = shamrock_length (WORLDWIDTH, MARGIN) ;
const int NH = shamrock_length (WORLDHEIGHT, MARGIN) ;
const int SH = shamrock_length (WORLDHEIGHT, MARGIN) ;
const int WH = shamrock_length (WORLDHEIGHT, MARGIN) ;
const int EH = shamrock_length (WORLDHEIGHT, MARGIN) ;
if (NO_OF_LEAVES != 2)
{
place_rectangle (MW-NW/2,MH+max(WH,EH)/2+MARGIN,NW,NH) ;
place_walls (MW,MH,max(WH,EH)/2+MARGIN,false) ;
}
if (NO_OF_LEAVES != 1)
{
place_rectangle (MW-max(NW,SW)/2-MARGIN-WW,MH-WH/2,WW,WH) ;
place_rectangle (MW+max(NW,SW)/2+MARGIN, MH-EH/2,EW,EH) ;
}
if (NO_OF_LEAVES == 4)
place_rectangle (MW-SW/2,MH-max(WH,EH)/2-MARGIN-SH,SW,SH) ;
if (NO_OF_LEAVES != 1)
place_walls (MW-max(NW,SW)/2-MARGIN,MH,max(NW,SW)+2*MARGIN,true) ;
place_walls (MW,MH-max(WH,EH)/2-MARGIN,max(WH,EH)/2+MARGIN,false) ;
if (NO_OF_LEAVES == 1)
create_ball (MW-NW/2+rand () % NW,WORLDHEIGHT-2) ;
else
create_ball (MW-max(NW,SW)/2-MARGIN-WW+rand () % (WW+max(NW,SW)+EW+2*MARGIN),WORLDHEIGHT-2) ;
}
//
//
void turn_around ()
{
turn_left() ;
turn_left() ;
}
//
void walk_to_wall ()
{
while (!in_front_of_wall())
step () ;
}
//
//
//
//
void climb_one_step ()
{
turn_left () ;
step () ;
turn_right () ;
step () ;
}
//
//
//
void climb_all_steps ()
{
while (in_front_of_wall ())
climb_one_step () ;
}
//
//
//
void have_a_seat ()
{
step () ;
step () ;
turn_left () ;
turn_left () ;
}
//
//
//
void charles_goes_to_his_seat ()
{
walk_to_wall () ;
climb_all_steps () ;
have_a_seat () ;
}
//
void walk_to_field ()
{
turn_right () ;
walk_to_wall () ;
turn_left () ;
}
//
void rectangle ( int width, int height )
{
balls ( width ) ;
turn_right ( ) ;
balls ( height ) ;
turn_right ( ) ;
balls ( width ) ;
turn_right ( ) ;
balls ( height ) ;
turn_right ( ) ;
}
void art ()
{
rectangle ( 3, 2 ) ;
rectangle ( 5, 4 ) ;
rectangle ( 7, 6 ) ;
}
//
//
//
//
//
//
void follow_beyond_ball()
{
while (on_ball() && !in_front_of_wall()) {
step();
}
}
void turn_east()
{
while (!north()) {
turn_right();
}
turn_right();
}
//
void turn_around2()
{
turn_right();
turn_right();
}
//
bool check_left()
{
turn_left();
//
//
if (in_front_of_wall()) {
turn_right();
return false;
}
step();
//
//
if (!on_ball()) {
turn_around2();
step();
turn_left();
return false;
}
//
//
//
return true;
}
//
bool check_right()
{
turn_right();
if (in_front_of_wall()) {
turn_left();
return false;
}
step();
if (!on_ball()) {
turn_around2();
step();
turn_right();
return false;
}
return true;
}
//
//
bool reorient()
{
turn_around2();
if (!on_ball()) {
step();
}
if (!check_left()) {
if (!check_right()) {
return false;
}
}
return true;
}
//
//
void hansl_and_gretl ()
{
do {
follow_beyond_ball();
}
while (reorient());
turn_east();
}
//
//
void walk_to_wall (bool fill)
{
while (!in_front_of_wall()) {
if (fill) {
put_ball();
}
step();
}
if (fill) {
put_ball();
}
}
void fill_cave_with_balls ()
{
step();
//
while (!in_front_of_wall()) {
//
turn_right();
walk_to_wall(true);
//
turn_around2();
walk_to_wall(false);
//
turn_right();
step();
}
//
//
//
turn_right();
walk_to_wall(false);
turn_right();
}
//
void cave ()
{
//
fill_cave_with_balls () ;
fill_cave_with_balls () ;
}
//
void shamrock ()
{
//
}
//
//
void quick () { rest(FAST_STEP_TIME); };
void normal () { rest(INITIAL_STEP_TIME); };
void slow () { rest(SLOW_STEP_TIME); };
void very_slow () { rest(VERY_SLOW_STEP_TIME); };
void start_step ()
{
store_world () ;
try {step (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_turn_left ()
{
store_world () ;
try {turn_left (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_turn_right ()
{
store_world () ;
try {turn_right (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_put_ball ()
{
store_world () ;
try {put_ball (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_get_ball ()
{
store_world () ;
try {get_ball (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_watch_match ()
{
reset () ;
make_grandstand () ; //
store_world () ;
try {
walk_to_field () ;
charles_goes_to_his_seat(); } //
catch (...) {} //
retrieve_world () ;
start_replay_for_timer () ; //
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_art ()
{
reset () ;
store_world () ;
try {
art(); } //
catch (...) {} //
retrieve_world () ;
start_replay_for_timer () ; //
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_hansl_and_gretl ()
{
reset () ;
make_path_with_balls () ;
store_world () ;
try {hansl_and_gretl ();}
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_cave ()
{
reset () ;
make_cave () ;
store_world () ;
try {cave ();}
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer(FAST_STEP_TIME) ;
}
void start_shamrock ()
{
reset () ;
make_shamrock () ;
store_world () ;
try {shamrock (); }
catch (...) {}
retrieve_world () ;
start_replay_for_timer () ;
charles_world().startTimer (FAST_STEP_TIME) ;
}
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
Menu charles_menu ((char*)"Charles") ;
charles_menu.add ((char*)"Reset", reset)
.add ((char*)"Stop", stop) ;
Menu ch_menu ((char*)"Basic Charles Actions") ;
ch_menu.add ((char*)"step ()", start_step)
.add ((char*)"turn_left ()", start_turn_left)
.add ((char*)"turn_right ()", start_turn_right)
.add ((char*)"put_ball ()", start_put_ball)
.add ((char*)"get_ball ()", start_get_ball);
Menu l2_menu ((char*)"Examples Lecture 2");
l2_menu.add ((char*)"Watch match", start_watch_match)
.add ((char*)"Art",start_art);
Menu a2_menu ((char*)"Assignment 2");
a2_menu.add ((char*)"Hansl and Gretl", start_hansl_and_gretl )
.add ((char*)"Cave", start_cave )
.add ((char*)"Bonus: follow shamrock...", start_shamrock );
Menu sn_menu ((char*)"Velocity");
sn_menu.add ((char*)"Quick", quick)
.add ((char*)"Normal",normal)
.add ((char*)"Slow",slow)
.add ((char*)"Very slow",very_slow);
try
{
charles_world().Run (charles_menu,WINARGS(hInstance, hPrevInstance, szCmdLine, iCmdShow));
}
catch (IllegalAction thisIllegalAction )
{
thisIllegalAction.report ();
}
catch (...)
{
makeAlert ("Something went terribly wrong!");
}
return 0;
}
| [
"[email protected]"
] | |
38903a9eaaf93bb00d817b36debd0f8e4ddbf504 | e0c53aaf160928a4b53bee6b136c4cc36b8d57a4 | /066/TargetDataEntity/Box.h | 925f248d15248512fa291e61a21425b69acf95cc | [] | no_license | MisYue/DeseaVrsoft | f7b0999f687a2f7299077bcfdfef13b4be0acf94 | 95843597b74f926fa793963e255c6ff6855e4831 | refs/heads/master | 2021-01-19T05:03:32.165534 | 2017-04-06T09:28:26 | 2017-04-06T09:28:26 | 87,411,092 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 117 | h | #pragma once
#include "regulargeom.h"
class Box :
public RegularGeom
{
public:
Box(void);
virtual ~Box(void);
};
| [
"[email protected]"
] | |
83e51caec4dcb5e29bba58b32db3fba0a0f26f16 | 89c361333077bd2fca2a9294c80eaa610f482963 | /yosuke/icpc/1100/aa.cpp | 11366b75d7f204130480ce1642f57af1010ee2eb | [] | no_license | Wasapon7763/Freshman | b7f8ec4a527f8665bad41600b345a730ada6435a | 7ea859e7f9dd634c862e60253a4b58876b0475be | refs/heads/master | 2021-01-16T21:29:14.893447 | 2016-08-02T06:56:10 | 2016-08-02T06:56:10 | 64,732,036 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 430 | cpp | #include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main(){
int n,count=0;
while (cin>>n,n|n!=0){
count++;
int x[n];
int y[n];
for (int i=0;i<n;i++){
cin>>x[i]>>y[i];
}
double area=0;
for(int i=0;i<n;i++){
area=area+(x[i]-x[(i+1)%n])*(y[i]+y[(i+1)%n]);
}
area=abs((double)(0.5*area));
cout<<count<<" "<<fixed<<setprecision(1)<<area<<endl;
}
}
| [
"[email protected]"
] | |
aef20143d522dfb5d84a0f805868407250183e59 | 75609634c137c1b457209f64b816258e98435768 | /Model/mark.cpp | 1d360c706e8bcaecd6981f6316f641b234f472dc | [] | no_license | nzxxavier/MarkTool | 4f9878ab4a0af1eafde13eeab65fbb0ebdeec879 | 81039629d99e1244afd5073fa42188c652b9b55a | refs/heads/master | 2021-02-04T15:48:21.016246 | 2020-05-18T09:12:14 | 2020-05-18T09:12:14 | 243,682,723 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,756 | cpp | #include "mark.h"
Mark::Mark()
{
}
Mark::Mark(QString markId, QString userId, QString commentId, qint32 markClass, QString addTime, QString changeTime, qint32 markCredit, QString markContent, QString markNote)
{
this->markId = markId;
this->userId = userId;
this->commentId = commentId;
this->markClass = markClass;
this->addTime = addTime;
this->changeTime = changeTime;
this->markCredit = markCredit;
this->markContent = markContent;
this->markNote = markNote;
}
QString Mark::getMarkId()
{
return this->markId;
}
QString Mark::getUserId()
{
return this->userId;
}
QString Mark::getCommentId()
{
return this->commentId;
}
qint32 Mark::getMarkClass()
{
return this->markClass;
}
QString Mark::getAddTime()
{
return this->addTime;
}
QString Mark::getChangeTime()
{
return this->changeTime;
}
qint32 Mark::getMarkCredit()
{
return this->markCredit;
}
QString Mark::getMarkContent()
{
return this->markContent;
}
QString Mark::getMarkNode()
{
return this->markNote;
}
void Mark::setMarkId(QString markId)
{
this->markId = markId;
}
void Mark::setUserId(QString userId)
{
this->userId = userId;
}
void Mark::setCommentId(QString commentId)
{
this->commentId = commentId;
}
void Mark::setMarkClass(qint32 markClass)
{
this->markClass = markClass;
}
void Mark::setAddTime(QString addTime)
{
this->addTime = addTime;
}
void Mark::setChangeTime(QString changeTime)
{
this->changeTime = changeTime;
}
void Mark::setMarkCredit(qint32 markCredit)
{
this->markCredit = markCredit;
}
void Mark::setMarkContent(QString markContent)
{
this->markContent = markContent;
}
void Mark::setMarkNode(QString markNote)
{
this->markNote = markNote;
}
| [
"[email protected]"
] | |
ea6933f4c511b7067540bcae3141863e768cb9b4 | 0921a35bbc156789597260295d376bab2a214aa2 | /src/qt/askpassphrasedialog.cpp | 752cd6bd772ab37ab0aa1532e3365a24bf95580b | [
"MIT"
] | permissive | thecryptokeepers/Dibz-master | d47040cfc3778eeadf573388437271af939fd719 | af19bc2235df016a458aaa56df2faa1f7beb0dbc | refs/heads/master | 2020-05-17T13:27:22.584976 | 2014-08-31T17:55:26 | 2014-08-31T17:55:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,933 | cpp | #include "askpassphrasedialog.h"
#include "ui_askpassphrasedialog.h"
#include "guiconstants.h"
#include "walletmodel.h"
#include <QMessageBox>
#include <QPushButton>
#include <QKeyEvent>
AskPassphraseDialog::AskPassphraseDialog(Mode mode, QWidget *parent) :
QDialog(parent),
ui(new Ui::AskPassphraseDialog),
mode(mode),
model(0),
fCapsLock(false)
{
ui->setupUi(this);
ui->passEdit1->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit2->setMaxLength(MAX_PASSPHRASE_SIZE);
ui->passEdit3->setMaxLength(MAX_PASSPHRASE_SIZE);
// Setup Caps Lock detection.
ui->passEdit1->installEventFilter(this);
ui->passEdit2->installEventFilter(this);
ui->passEdit3->installEventFilter(this);
switch(mode)
{
case Encrypt: // Ask passphrase x2
ui->passLabel1->hide();
ui->passEdit1->hide();
ui->warningLabel->setText(tr("Enter the new passphrase to the wallet.<br/>Please use a passphrase of <b>10 or more random characters</b>, or <b>eight or more words</b>."));
setWindowTitle(tr("Encrypt wallet"));
break;
case Unlock: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to unlock the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Unlock wallet"));
break;
case Decrypt: // Ask passphrase
ui->warningLabel->setText(tr("This operation needs your wallet passphrase to decrypt the wallet."));
ui->passLabel2->hide();
ui->passEdit2->hide();
ui->passLabel3->hide();
ui->passEdit3->hide();
setWindowTitle(tr("Decrypt wallet"));
break;
case ChangePass: // Ask old passphrase + new passphrase x2
setWindowTitle(tr("Change passphrase"));
ui->warningLabel->setText(tr("Enter the old and new passphrase to the wallet."));
break;
}
textChanged();
connect(ui->passEdit1, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit2, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
connect(ui->passEdit3, SIGNAL(textChanged(QString)), this, SLOT(textChanged()));
}
AskPassphraseDialog::~AskPassphraseDialog()
{
// Attempt to overwrite text so that they do not linger around in memory
ui->passEdit1->setText(QString(" ").repeated(ui->passEdit1->text().size()));
ui->passEdit2->setText(QString(" ").repeated(ui->passEdit2->text().size()));
ui->passEdit3->setText(QString(" ").repeated(ui->passEdit3->text().size()));
delete ui;
}
void AskPassphraseDialog::setModel(WalletModel *model)
{
this->model = model;
}
void AskPassphraseDialog::accept()
{
SecureString oldpass, newpass1, newpass2;
if(!model)
return;
oldpass.reserve(MAX_PASSPHRASE_SIZE);
newpass1.reserve(MAX_PASSPHRASE_SIZE);
newpass2.reserve(MAX_PASSPHRASE_SIZE);
// TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
// Alternately, find a way to make this input mlock()'d to begin with.
oldpass.assign(ui->passEdit1->text().toStdString().c_str());
newpass1.assign(ui->passEdit2->text().toStdString().c_str());
newpass2.assign(ui->passEdit3->text().toStdString().c_str());
switch(mode)
{
case Encrypt: {
if(newpass1.empty() || newpass2.empty())
{
// Cannot encrypt with empty passphrase
break;
}
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm wallet encryption"),
tr("WARNING: If you encrypt your wallet and lose your passphrase, you will <b>LOSE ALL OF YOUR DibzcoinS</b>!\nAre you sure you wish to encrypt your wallet?"),
QMessageBox::Yes|QMessageBox::Cancel,
QMessageBox::Cancel);
if(retval == QMessageBox::Yes)
{
if(newpass1 == newpass2)
{
if(model->setWalletEncrypted(true, newpass1))
{
QMessageBox::warning(this, tr("Wallet encrypted"),
tr("DibzCoin will close now to finish the encryption process. Remember that encrypting your wallet cannot fully protect your Dibzcoin from being stolen by malware infecting your computer."));
QApplication::quit();
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("Wallet encryption failed due to an internal error. Your wallet was not encrypted."));
}
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
}
else
{
QDialog::reject(); // Cancelled
}
} break;
case Unlock:
if(!model->setWalletLocked(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet unlock failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case Decrypt:
if(!model->setWalletEncrypted(false, oldpass))
{
QMessageBox::critical(this, tr("Wallet decryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
else
{
QDialog::accept(); // Success
}
break;
case ChangePass:
if(newpass1 == newpass2)
{
if(model->changePassphrase(oldpass, newpass1))
{
QMessageBox::information(this, tr("Wallet encrypted"),
tr("Wallet passphrase was successfully changed."));
QDialog::accept(); // Success
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The passphrase entered for the wallet decryption was incorrect."));
}
}
else
{
QMessageBox::critical(this, tr("Wallet encryption failed"),
tr("The supplied passphrases do not match."));
}
break;
}
}
void AskPassphraseDialog::textChanged()
{
// Validate input, set Ok button to enabled when accepable
bool acceptable = false;
switch(mode)
{
case Encrypt: // New passphrase x2
acceptable = !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
case Unlock: // Old passphrase x1
case Decrypt:
acceptable = !ui->passEdit1->text().isEmpty();
break;
case ChangePass: // Old passphrase x1, new passphrase x2
acceptable = !ui->passEdit1->text().isEmpty() && !ui->passEdit2->text().isEmpty() && !ui->passEdit3->text().isEmpty();
break;
}
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(acceptable);
}
bool AskPassphraseDialog::event(QEvent *event)
{
// Detect Caps Lock key press.
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_CapsLock) {
fCapsLock = !fCapsLock;
}
if (fCapsLock) {
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on."));
} else {
ui->capsLabel->clear();
}
}
return QWidget::event(event);
}
bool AskPassphraseDialog::eventFilter(QObject *, QEvent *event)
{
/* Detect Caps Lock.
* There is no good OS-independent way to check a key state in Qt, but we
* can detect Caps Lock by checking for the following condition:
* Shift key is down and the result is a lower case character, or
* Shift key is not down and the result is an upper case character.
*/
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QString str = ke->text();
if (str.length() != 0) {
const QChar *psz = str.unicode();
bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
if ((fShift && psz->isLower()) || (!fShift && psz->isUpper())) {
fCapsLock = true;
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on."));
} else if (psz->isLetter()) {
fCapsLock = false;
ui->capsLabel->clear();
}
}
}
return false;
}
| [
"[email protected]"
] | |
65b74030f6ce1546f35f5759f49daf86d02e6794 | f2755feac91ab323e12e2da37fbac82eb0988e1e | /LaCrosseITPlusReader10/WS1080.cpp | bb67ff317794208837720afaa997a0233523d9af | [] | no_license | baumrasen/LacrossITPlusReader | e1dceb12946dd34b35dd1fa1e1d83205193f2305 | 17b0e2a64a988e67f104af153f322f768e59511a | refs/heads/master | 2020-07-17T00:40:51.007714 | 2019-07-26T15:51:57 | 2019-07-26T15:51:57 | 205,903,905 | 2 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,765 | cpp | #include "WS1080.h"
/*
WS 1080 17.241 kbps 868.3 MHz
-------------------------------
A8 C0 58 5E 00 00 00 86 0A D8
ID: 8C, T= 8.8`C, relH= 94%, Wvel= 0.0m/s, Wmax= 0.0m/s, Wdir=SW , Rain= 40.2mm
A8 C0 55 5E 00 00 00 86 04 06
ID: 8C, T= 8.5`C, relH= 94%, Wvel= 0.0m/s, Wmax= 0.0m/s, Wdir=E , Rain= 40.2mm
A8 C0 50 60 00 00 00 86 04 BF
ID: 8C, T= 8.0`C, relH= 96%, Wvel= 0.0m/s, Wmax= 0.0m/s, Wdir=E , Rain= 40.2mm
*/
byte WS1080::CalculateCRC(byte data[]) {
return SensorBase::CalculateCRC(data, WS1080::FRAME_LENGTH -1);
}
void WS1080::DecodeFrame(byte *bytes, struct Frame *frame) {
frame->IsValid = true;
frame->ID = 0;
frame->NewBatteryFlag = false;
frame->LowBatteryFlag = false;
frame->ErrorFlag = false;
frame->HasTemperature = true;
frame->HasHumidity = true;
frame->HasRain = true;
frame->HasWindSpeed = true;
frame->HasWindDirection = true;
frame->HasWindGust = true;
frame->HasPressure = false;
frame->CRC = bytes[WS1080::FRAME_LENGTH - 1];
if (frame->CRC != CalculateCRC(bytes)) {
frame->IsValid = false;
}
frame->Header = bytes[0] >> 4;
if (frame->Header != 0xA) {
frame->IsValid = false;
}
if (frame->IsValid) {
frame->ID = ((bytes[0] & 0xF) << 4) | ((bytes[1] & 0xF0) >> 4);
frame->NewBatteryFlag = false;
frame->ErrorFlag = false;
frame->LowBatteryFlag = false;
// Temperature (°C)
byte sign = (bytes[1] >> 3) & 1;
int temp = ((bytes[1] & 0x07) << 8) | bytes[2];
if (sign) {
temp = (~temp) + sign;
}
frame->Temperature = temp * 0.1;
// Humidity (%rH)
frame->Humidity = bytes[3] & 0x7F;
// Wind speed (m/s)
frame->WindSpeed = bytes[4] * 0.34;
// Wind gust (m/s)
frame->WindGust = bytes[5] * 0.34;
// Rain (0.5 mm steps)
frame->Rain = (((bytes[6] & 0x0F) << 8) | bytes[7]) * 0.6;
// Wind direction (degree N=0, NNE=22.5, S=180, ... )
frame->WindDirection = 22.5 * (bytes[8] & 0x0F);
}
}
String WS1080::AnalyzeFrame(byte *data) {
struct Frame frame;
DecodeFrame(data, &frame);
byte frameLength = WS1080::FRAME_LENGTH;
return WSBase::AnalyzeFrame(data, &frame, frameLength, "WS1080");
}
String WS1080::GetFhemDataString(byte *data) {
String fhemString = "";
if ((data[0] >> 4) == 0x0A) {
struct Frame frame;
DecodeFrame(data, &frame);
if (frame.IsValid) {
fhemString = BuildFhemDataString(&frame, 3);
}
}
return fhemString;
}
bool WS1080::TryHandleData(byte *data) {
String fhemString = GetFhemDataString(data);
if (fhemString.length() > 0) {
Serial.println(fhemString);
}
return fhemString.length() > 0;
}
bool WS1080::IsValidDataRate(unsigned long dataRate) {
return dataRate == 17241ul;
} | [
"[email protected]"
] | |
5088601dff4c6cb1f11c5f5f967709a2f9637a35 | 7ddd8c504d5481f65394e975050c9a52fd35ba32 | /Libs/UI/UiPosition/uiposition.h | db57e8d9264abdc5ed7b505ea3162d475e3d0ab9 | [] | no_license | yisea123/ServoDriveTech | 31cc64195b78197fe6e141a6701f2dbe1205f5de | 09c3deeea5021cbbe10a45fb979bd0ad258c5346 | refs/heads/master | 2020-06-15T00:56:58.947418 | 2018-01-30T07:04:30 | 2018-01-30T07:04:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 739 | h | #ifndef UIPOSITION_H
#define UIPOSITION_H
#include "uiposition_global.h"
#include "iuiwidget.h"
namespace Ui {
class UiPosition;
}
class QWidget;
class UiPositionPrivate;
class UIPOSITIONSHARED_EXPORT UiPosition:public IUiWidget
{
Q_OBJECT
Q_DECLARE_PRIVATE(UiPosition)
public:
explicit UiPosition(QWidget *parent = 0);
~UiPosition();
void accept(QWidget*w) Q_DECL_OVERRIDE;
private:
QStackedWidget *getUiStackedWidget(void)Q_DECL_OVERRIDE;
QVBoxLayout *getVBoxLayout(void)Q_DECL_OVERRIDE;
void setDefaultUi()Q_DECL_OVERRIDE;
void setQmlContext()Q_DECL_OVERRIDE;
void setQmlSignalSlot()Q_DECL_OVERRIDE;
void addQmlWidget()Q_DECL_OVERRIDE;
private:
Ui::UiPosition *ui;
};
#endif // UIPOSITION_H
| [
"[email protected]"
] | |
3737c2a5f9a53fcb5ecb8a2d194fa90e0ba0767d | 355a7b7183169de9305dfbf2bc167ea22b533abf | /Src/Edislab/Include/Bcg/BCGPEdit.h | 782bb296fa446d0965a03eee864dbf2db6f62aa0 | [] | no_license | vbtang/DevSoft | beda6c01e34dd3c86a4cbd155ead2541d6f479e2 | 023ffa59987c00f466eaf58c2388bfb9baa6ffd5 | refs/heads/master | 2020-05-25T19:18:45.893420 | 2017-07-02T11:18:00 | 2017-07-02T11:18:00 | 84,955,829 | 1 | 0 | null | 2017-07-02T05:13:24 | 2017-03-14T14:02:57 | C++ | UTF-8 | C++ | false | false | 9,939 | h | //*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2016 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions
// of the accompanying license agreement.
//*******************************************************************************
#if !defined(AFX_BCGPEDIT_H__A7B40464_1C05_4981_A5F2_E21D74058A09__INCLUDED_)
#define AFX_BCGPEDIT_H__A7B40464_1C05_4981_A5F2_E21D74058A09__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// BCGPEdit.h : header file
//
#include "BCGCBPro.h"
#include "BCGPScrollBar.h"
#if (!defined _BCGSUITE_) && (!defined _BCGSUITE_INC_)
#include "BCGPToolBarImages.h"
#include "BCGPDropDownList.h"
extern BCGCBPRODLLEXPORT UINT BCGM_EDIT_ON_FILL_AUTOCOMPLETE_LIST;
class CBCGPEdit;
class CBCGPComboBox;
/////////////////////////////////////////////////////////////////////////////
// CBCGPEditDropDownList
class BCGCBPRODLLEXPORT CBCGPEditDropDownList : public CBCGPDropDownList
{
DECLARE_DYNAMIC(CBCGPEditDropDownList)
friend class CBCGPEdit;
public:
// Construction
CBCGPEditDropDownList(CBCGPEdit* pEdit);
// Overrides
public:
virtual void OnChooseItem (UINT uidCmdID);
virtual BOOL Compare(const CStringList& lstStrings) const;
// Attributes
protected:
CBCGPEdit* m_pEdit;
};
#endif
class CBCGPCalculatorPopup;
class CBCGPCalculator;
class CBCGPDialog;
/////////////////////////////////////////////////////////////////////////////
// CBCGPEditColors
struct BCGCBPRODLLEXPORT CBCGPEditColors
{
CBCGPEditColors()
{
m_clrBackground = (COLORREF)-1;
m_clrText = (COLORREF)-1;
m_clrPrompt = (COLORREF)-1;
m_clrBorder = (COLORREF)-1;
m_clrBorderFocused = (COLORREF)-1;
}
CBCGPEditColors(const CBCGPEditColors& src)
{
CopyFrom(src);
}
void CopyFrom(const CBCGPEditColors& src)
{
m_clrBackground = src.m_clrBackground;
m_clrText = src.m_clrText;
m_clrPrompt = src.m_clrPrompt;
m_clrBorder = src.m_clrBorder;
m_clrBorderFocused = src.m_clrBorderFocused;
}
COLORREF m_clrBackground;
COLORREF m_clrText;
COLORREF m_clrPrompt;
COLORREF m_clrBorder;
COLORREF m_clrBorderFocused;
};
/////////////////////////////////////////////////////////////////////////////
// CBCGPEdit window
class BCGCBPRODLLEXPORT CBCGPEdit : public TBCGPInternalScrollBarWrapperWnd<CEdit>
{
DECLARE_DYNAMIC(CBCGPEdit)
friend class CBCGPCalculator;
friend class CBCGPEditDropDownList;
friend class CBCGPParentEditPtr;
friend class CBCGPComboBox;
friend class CBCGPSpinButtonCtrl;
// Construction
public:
CBCGPEdit();
// Attributes
public:
enum BrowseMode
{
BrowseMode_None,
BrowseMode_Default,
BrowseMode_Calculator,
BrowseMode_File,
BrowseMode_Folder,
BrowseMode_PopupDialog,
BrowseMode_PasswordPreview,
};
CBCGPEdit::BrowseMode GetMode () const
{
return m_Mode;
}
BOOL m_bVisualManagerStyle;
BOOL m_bOnGlass;
void SetPrompt(LPCTSTR lpszPrompt, COLORREF clrText = (COLORREF)-1, BOOL bRedraw = TRUE);
void EnableSearchMode(BOOL bEnable, LPCTSTR lpszPrompt, COLORREF clrText = (COLORREF)-1, BOOL bRedraw = TRUE);
BOOL IsSearchMode() const
{
return m_bSearchMode;
}
CString GetSearchPrompt () const
{
return GetPrompt();
};
CString GetPrompt() const
{
return m_strSearchPrompt;
};
void SetErrorMessage(LPCTSTR lpszMessage, COLORREF clrText = (COLORREF)-1, BOOL bRedraw = TRUE);
CString GetErrorMessage() const
{
return m_strErrorMessage;
}
void SetColorTheme(const CBCGPEditColors& colors, BOOL bRedraw = TRUE);
const CBCGPEditColors& GetColorTheme() const
{
return m_ColorTheme;
}
void SetDisableBrowseButtonInReadOnlyMode(BOOL bDisable = TRUE);
BOOL IsDisableBrowseButtonInReadOnlyMode() const
{
return m_bDisableBrowseButtonInReadOnlyMode;
}
#if (!defined _BCGSUITE_) && (!defined _BCGSUITE_INC_)
BOOL IsDroppedDown() const
{
return ::IsWindow(m_pDropDownPopup->GetSafeHwnd());
}
#endif
protected:
CBCGPEditColors m_ColorTheme;
CBrush m_brBackground;
CRect m_rectBtn;
BOOL m_bIsButtonPressed;
BOOL m_bIsButtonHighlighted;
BOOL m_bIsButtonCaptured;
BrowseMode m_Mode;
CBCGPToolBarImages m_ImageBrowse;
BOOL m_bDefaultImage;
CSize m_sizeImage;
CString m_strLabel;
CString m_strDefFileExt;
CString m_strFileFilter;
CString m_strInitialFolder;
DWORD m_dwFileDialogFlags;
CString m_strFolderBrowseTitle;
UINT m_nFolderBrowseFlags;
int m_nBrowseButtonWidth;
BOOL m_bSearchMode;
BOOL m_bHasPrompt;
CString m_strSearchPrompt;
COLORREF m_clrPrompt;
CString m_strErrorMessage;
COLORREF m_clrErrorText;
CBCGPToolBarImages m_ImageSearch;
CBCGPToolBarImages m_ImageClear;
BOOL m_bTextIsEmpty;
CToolTipCtrl* m_pToolTip;
BOOL m_bShowToolTip;
BOOL m_bDefaultPrintClient;
BOOL m_bDisableBrowseButtonInReadOnlyMode;
BOOL m_bIsLastPrintableCharacter;
BOOL m_bIsDelayedLayout;
CBCGPCalculatorPopup* m_pCalcPopup;
CStringList m_lstCalcAdditionalCommands;
CList<UINT, UINT> m_lstCalcExtCommands;
CString m_strCalcDisplayFormat;
CRuntimeClass* m_pRTIPopupDlg;
LPCTSTR m_lpszPopupDlgTemplateName;
CBCGPDialog* m_pPopupDlg;
BOOL m_bIsResizablePopup;
BOOL m_bIsRightAlignedPopup;
BOOL m_bComboBoxMode;
CRect m_rectClick;
BOOL m_bHasSpinButton;
BOOL m_bAllowEditingInPasswordPreview;
TCHAR m_cPassword;
CBCGPComboBox* m_pAutoCompleteCombo;
#if (!defined _BCGSUITE_) && (!defined _BCGSUITE_INC_)
CBCGPEditDropDownList* m_pDropDownPopup;
BOOL m_bInAutoComplete;
#endif
// Operations
public:
void EnableBrowseButton (BOOL bEnable = TRUE, LPCTSTR szLabel = _T("..."));
void EnableFileBrowseButton (LPCTSTR lpszDefExt = NULL, LPCTSTR lpszFilter = NULL, LPCTSTR lpszInitialFolder = NULL, DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT);
void EnableFolderBrowseButton (LPCTSTR lpszTitle = NULL, UINT ulFlags = BIF_RETURNONLYFSDIRS);
void EnableCalculatorButton (const CStringList* plstAdditionalCommands = NULL,
const CList<UINT, UINT>* plstExtCommands = NULL,
LPCTSTR lpszDisplayFormat = NULL);
void EnablePopupDialog(CRuntimeClass* pRTI, UINT nIDTemplate, BOOL bIsResizable = FALSE, BOOL bComboBoxMode = FALSE, BOOL bIsRightAligned = FALSE);
void EnablePopupDialog(CRuntimeClass* pRTI, LPCTSTR lpszTemplateName, BOOL bIsResizable = FALSE, BOOL bComboBoxMode = FALSE, BOOL bIsRightAligned = FALSE);
void EnablePasswordPreview(BOOL bEnable = TRUE, BOOL bAllowEditingInPreview = FALSE);
void SetBrowseButtonImage (HICON hIcon, BOOL bAutoDestroy = TRUE, BOOL bAlphaBlend = FALSE);
void SetBrowseButtonImage (HBITMAP hBitmap, BOOL bAutoDestroy = TRUE);
void SetBrowseButtonImage (UINT uiBmpResId);
virtual void OnBeforeShowPopupDlg(CBCGPDialog* pDlg)
{
UNREFERENCED_PARAMETER(pDlg);
}
virtual void ClosePopupDlg(BOOL bOK, DWORD_PTR dwUserData = 0);
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CBCGPEdit)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
protected:
virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
virtual void PreSubclassWindow();
//}}AFX_VIRTUAL
virtual void OnBrowse ();
virtual void OnDrawBrowseButton (CDC* pDC, CRect rect, BOOL bIsButtonPressed, BOOL bIsButtonHot);
virtual void OnChangeLayout ();
virtual void OnAfterUpdate ();
virtual BOOL FilterCalcKey (int nChar);
virtual void OnCalculatorUserCommand (CBCGPCalculator* pCalculator, UINT uiCmd);
virtual BOOL OnIllegalFileName (CString& strFileName);
virtual BOOL IsDrawPrompt();
virtual void DoPaint(CDC* pDC, BOOL bDrawPrompt, BOOL bIsPrint);
virtual void DoNcPaint(CDC* pDC, BOOL bIsPrint);
virtual void DoEraseBrowseButton(CDC* pDC, CRect rect);
#if (!defined _BCGSUITE_) && (!defined _BCGSUITE_INC_)
virtual BOOL OnGetAutoCompleteList(const CString& strEditText, CStringList& lstAutocomplete);
#endif
virtual BOOL IsInternalScrollBarThemed() const;
virtual BOOL IsBrowseButtonEnabled() const;
// Implementation
public:
virtual ~CBCGPEdit();
// Generated message map functions
protected:
//{{AFX_MSG(CBCGPEdit)
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp);
afx_msg void OnNcPaint();
afx_msg void OnNcLButtonDblClk(UINT nHitTest, CPoint point);
afx_msg void OnNcMouseMove(UINT nHitTest, CPoint point);
afx_msg void OnCancelMode();
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnPaint();
afx_msg BOOL OnChange();
afx_msg HBRUSH CtlColor(CDC* pDC, UINT nCtlColor);
afx_msg void OnDestroy();
afx_msg void OnKillFocus(CWnd* pNewWnd);
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
afx_msg void OnSetFocus(CWnd* pOldWnd);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
//}}AFX_MSG
afx_msg BCGNcHitTestType OnNcHitTest(CPoint point);
afx_msg LRESULT OnBCGSetControlVMMode (WPARAM, LPARAM);
afx_msg LRESULT OnBCGSetControlAero (WPARAM, LPARAM);
afx_msg BOOL OnNeedTipText(UINT id, NMHDR* pNMH, LRESULT* pResult);
afx_msg LRESULT OnPrintClient(WPARAM wParam, LPARAM lp);
afx_msg LRESULT OnPrint(WPARAM wParam, LPARAM lp);
afx_msg LRESULT OnRedrawFrame(WPARAM, LPARAM);
DECLARE_MESSAGE_MAP()
void CreateAutocompleteList(const CStringList& lstAutocomplete);
void CloseAutocompleteList();
void SetIntenalImage ();
void SetupPasswordChar();
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_BCGPEDIT_H__A7B40464_1C05_4981_A5F2_E21D74058A09__INCLUDED_)
| [
"[email protected]"
] | |
25b3bdae320a46d337ddd7f780e0d005261f3f05 | f74cf39ef3f4a06bf22f504d3acc9b3f62acdcee | /tema2/ejer4/main.cpp | d1f8805ccbea420c5c85b9217b3732ac97dea461 | [] | no_license | samus24/Practicas-TAIS | 18969370f20e2262add0ff7c3be1616008b07573 | c1d9ab97ba4bd74f8295a037fc748af5da01a22a | refs/heads/master | 2021-05-31T21:18:29.962496 | 2016-03-17T10:44:01 | 2016-03-17T10:44:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,036 | cpp | /*
* Grupo TAIS16, Samuel Lapuente Jiménez, Alvar David Soler Rus
*
* Ejercicio 9. Tema 2.
*
*/
#include <fstream>
#include <cstdlib>
#include "ColaMedianas.h"
/**
* Complejidad O(nlogn). Logarítmica al insertar y n al recorrer, siendo n el número de parejas de pájaros.
*/
void resolverCaso() {
unsigned long long int n;
std::cin >> n;
unsigned int m;
std::cin >> m;
while (m != 0) {
ColaMedianas cola;
cola.inserta(n);
for (unsigned int i = 0; i < m; ++i) {
std::cin >> n;
cola.inserta(n);
std::cin >> n;
cola.inserta(n);
std::cout << cola.mediana();
if (i + 1 < m) std::cout << " ";
}
std::cin >> n;
std::cin >> m;
std::cout << std::endl;
}
}
int main() {
#ifndef DOMJUDGE
std::ifstream in("casos.txt");
auto cinbuf = std::cin.rdbuf(in.rdbuf()); //save old buf and redirect std::cin to casos.txt
#endif
resolverCaso();
#ifndef DOMJUDGE
std::cin.rdbuf(cinbuf); //reset to standard input again
system("PAUSE");
#endif
return 0;
} | [
"[email protected]"
] | |
52c2c02a3f772c96e67c2df4b0f14acf1ddd21a6 | 25471e3ea2ac7577108b1e7f05178578cd96b11d | /cpp/static-template-member-spec.cpp | e128a3187e033adfe1957c7138419be66779377d | [
"MIT"
] | permissive | lindsayad/misc_programming | 30c1626b6eaafc39dfd06f5e84c8404b44a7f979 | 06d759aa83cadeb32a3f33f52f1ed7528764ea11 | refs/heads/master | 2023-07-06T13:18:03.467838 | 2023-06-22T19:33:04 | 2023-06-22T19:33:04 | 42,606,159 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 984 | cpp | #include <iostream>
// template <typename X>
// struct Test
// {
// }; // to simulate type dependency
// struct X // class declaration: only generic
// {
// template <typename T>
// static void f(Test<T>);
// };
// // template definition:
// template <typename T>
// void X::f(Test<T>)
// {
// std::cout << "generic" << std::endl;
// }
// template <>
// void X::f<void>(Test<void>)
// {
// std::cout << "specific" << std::endl;
// }
typedef double Real;
class A
{
template <typename T>
static std::string f(const T & value);
template <>
std::string f(const std::vector<Real> & value);
}
template <typename T>
std::string
A::f(const T &)
{
std::cout << "generic\n";
return "";
}
template <>
inline std::string
A::f(const std::vector<Real> &)
{
std::cout << "specific\n";
return "";
}
int
main()
{
A::f(int());
A::f(std::vector<Real>{});
// Test<int> ti;
// Test<void> tv;
// X::f(ti); // prints 'generic'
// X::f(tv); // prints 'specific'
}
| [
"[email protected]"
] | |
b48d82304d9de44ee79437e8d5832f1e1497a602 | 0c84b1e8ae0b50bb98a9ef3ca15770cd136c2f2c | /data_structures/week4/is_bst.cpp | 5141222fe3ed7dba18907339545081b1f1f2ad33 | [
"MIT"
] | permissive | denysav/algorithms | bef6cf093bc59ed302b55462728150e74cbce669 | 93b4f4538ecfe2060be57d3f461e6525f8e55732 | refs/heads/master | 2020-12-04T04:07:06.447538 | 2020-07-02T23:30:15 | 2020-07-02T23:30:15 | 231,603,820 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,092 | cpp | #include <iostream>
#include <vector>
#include <limits.h>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
struct Node {
int key;
int left;
int right;
Node() : key(0), left(-1), right(-1) {}
Node(int key_, int left_, int right_) : key(key_), left(left_), right(right_) {}
};
bool isBST(const vector<Node>& tree, int idx, int max, int min) {
if (idx == -1) {
return true;
}
const auto& node = tree[idx];
if (node.key > max || node.key < min) {
return false;
}
return isBST(tree, node.left, node.key, min) && isBST(tree, node.right, max, node.key);
}
bool IsBinarySearchTree(const vector<Node>& tree) {
if (!tree.size()) return true;
return isBST(tree, 0, INT_MAX, INT_MIN);
}
int main() {
int nodes;
cin >> nodes;
vector<Node> tree;
for (int i = 0; i < nodes; ++i) {
int key, left, right;
cin >> key >> left >> right;
tree.push_back(Node(key, left, right));
}
if (IsBinarySearchTree(tree)) {
cout << "CORRECT" << endl;
} else {
cout << "INCORRECT" << endl;
}
return 0;
}
| [
"[email protected]"
] | |
4e2d1dfc85ca8793c26d5760e71f86cc3de07280 | 08b8cf38e1936e8cec27f84af0d3727321cec9c4 | /data/crawl/wget/hunk_2482.cpp | 7c01032fdad1291a0f434eae4a30425f8fa194a7 | [] | no_license | ccdxc/logSurvey | eaf28e9c2d6307140b17986d5c05106d1fd8e943 | 6b80226e1667c1e0760ab39160893ee19b0e9fb1 | refs/heads/master | 2022-01-07T21:31:55.446839 | 2018-04-21T14:12:43 | 2018-04-21T14:12:43 | null | 0 | 0 | null | null | null | null | ISO-8859-16 | C++ | false | false | 7,495 | cpp | #. No luck.
#. #### This message SUCKS. We should see what was the
#. reason that nothing was retrieved.
-#: src/ftp.c:1698
+#: src/ftp.c:1753
#, c-format
msgid "No matches on pattern `%s'.\n"
msgstr "Nu s-au găsit potriviri pentru tiparul `%s'.\n"
-#: src/ftp.c:1764
-#, c-format
-msgid "Wrote HTML-ized index to `%s' [%ld].\n"
+#: src/ftp.c:1819
+#, fuzzy, c-format
+msgid "Wrote HTML-ized index to `%s' [%s].\n"
msgstr "S-a scris indexul HTML în `%s' [%ld].\n"
-#: src/ftp.c:1769
+#: src/ftp.c:1824
#, c-format
msgid "Wrote HTML-ized index to `%s'.\n"
msgstr "S-a scris indexul HTML în `%s'\n"
-#: src/gen_sslfunc.c:117
-msgid "Could not seed OpenSSL PRNG; disabling SSL.\n"
-msgstr "Nu s-a selectat OpenSSL PRNG; dezactivare SSL.\n"
-
-#: src/getopt.c:675
+#: src/getopt.c:670
#, c-format
msgid "%s: option `%s' is ambiguous\n"
msgstr "%s: opțiunea `%s' este ambiguă\n"
-#: src/getopt.c:700
+#: src/getopt.c:695
#, c-format
msgid "%s: option `--%s' doesn't allow an argument\n"
msgstr "%s: opțiunea `--%s' nu permite un parametru\n"
-#: src/getopt.c:705
+#: src/getopt.c:700
#, c-format
msgid "%s: option `%c%s' doesn't allow an argument\n"
msgstr "%s: opțiunea `%c%s' nu permite un parametru\n"
-#: src/getopt.c:723 src/getopt.c:896
+#: src/getopt.c:718 src/getopt.c:891
#, c-format
msgid "%s: option `%s' requires an argument\n"
msgstr "%s: opțiunea `%s' necesită un parametru\n"
#. --option
-#: src/getopt.c:752
+#: src/getopt.c:747
#, c-format
msgid "%s: unrecognized option `--%s'\n"
msgstr "%s: opțiune nerecunoscută `--%s'\n"
#. +option or -option
-#: src/getopt.c:756
+#: src/getopt.c:751
#, c-format
msgid "%s: unrecognized option `%c%s'\n"
msgstr "%s: opțiune nerecunoscută `%c%s'\n"
#. 1003.2 specifies the format of this message.
-#: src/getopt.c:782
+#: src/getopt.c:777
#, c-format
msgid "%s: illegal option -- %c\n"
msgstr "%s: opțiune ilegală -- %c\n"
-#: src/getopt.c:785
+#: src/getopt.c:780
#, c-format
msgid "%s: invalid option -- %c\n"
msgstr "%s: opțiune invalidă -- %c\n"
#. 1003.2 specifies the format of this message.
-#: src/getopt.c:815 src/getopt.c:945
+#: src/getopt.c:810 src/getopt.c:940
#, c-format
msgid "%s: option requires an argument -- %c\n"
msgstr "%s: opțiunea necesită un parametru -- %c\n"
-#: src/getopt.c:862
+#: src/getopt.c:857
#, c-format
msgid "%s: option `-W %s' is ambiguous\n"
msgstr "%s: opțiunea `W %s' este ambiguă\n"
-#: src/getopt.c:880
+#: src/getopt.c:875
#, c-format
msgid "%s: option `-W %s' doesn't allow an argument\n"
msgstr "%s: opțiunea `-W %s' nu permite parametri\n"
-#: src/host.c:636
+#: src/host.c:347
+#, fuzzy
+msgid "Unknown host"
+msgstr "Eroare necunoscută"
+
+#. Message modeled after what gai_strerror returns in similar
+#. circumstances.
+#: src/host.c:351
+msgid "Temporary failure in name resolution"
+msgstr ""
+
+#: src/host.c:353
+msgid "Unknown error"
+msgstr "Eroare necunoscută"
+
+#: src/host.c:714
#, c-format
msgid "Resolving %s... "
msgstr "Rezolvare %s... "
-#: src/host.c:656 src/host.c:672
-#, c-format
-msgid "failed: %s.\n"
-msgstr "eșuare: %s.\n"
+#: src/host.c:761
+msgid "failed: No IPv4/IPv6 addresses for host.\n"
+msgstr ""
-#: src/host.c:674
+#: src/host.c:784
msgid "failed: timed out.\n"
msgstr "eșuare: .expirat(ă)\n"
-#: src/host.c:762
-msgid "Host not found"
-msgstr "Host negăsit"
-
-#: src/host.c:764
-msgid "Unknown error"
-msgstr "Eroare necunoscută"
-
-#: src/html-url.c:293
+#: src/html-url.c:288
#, c-format
msgid "%s: Cannot resolve incomplete link %s.\n"
msgstr "%s: Nu s-a rezolvat linkul incomplet %s.\n"
-#. this is fatal
-#: src/http.c:674
-msgid "Failed to set up an SSL context\n"
-msgstr "S-a eșuat în setarea contextului SSL\n"
+#: src/html-url.c:695
+#, fuzzy, c-format
+msgid "%s: Invalid URL %s: %s\n"
+msgstr "%s: %s: Valoare invalidă `%s'.\n"
-#: src/http.c:680
+#: src/http.c:367
#, c-format
-msgid "Failed to load certificates from %s\n"
-msgstr "S-a eșuat în încărcarea certificatelor din %s\n"
-
-#: src/http.c:684 src/http.c:692
-msgid "Trying without the specified certificate\n"
-msgstr "Se încearcă fără certificatele specificate\n"
+msgid "Failed writing HTTP request: %s.\n"
+msgstr "Scriere cerere HTTP eșuată: %s.\n"
-#: src/http.c:688
-#, c-format
-msgid "Failed to get certificate key from %s\n"
-msgstr "Nu s-a putut primi codul(key) certificatului de la %s\n"
+#: src/http.c:736
+msgid "No headers, assuming HTTP/0.9"
+msgstr ""
-#: src/http.c:761 src/http.c:1809
-msgid "Unable to establish SSL connection.\n"
-msgstr "Nu s-a putut stabili o conexiune SSL.\n"
+#: src/http.c:1413
+msgid "Disabling SSL due to encountered errors.\n"
+msgstr ""
-#: src/http.c:770
+#: src/http.c:1566
#, c-format
-msgid "Reusing connection to %s:%hu.\n"
+msgid "POST data file `%s' missing: %s\n"
+msgstr ""
+
+#: src/http.c:1615
+#, fuzzy, c-format
+msgid "Reusing existing connection to %s:%d.\n"
msgstr "Reutilizare conexiune către %s:%hu.\n"
-#: src/http.c:1034
-#, c-format
-msgid "Failed writing HTTP request: %s.\n"
+#: src/http.c:1684
+#, fuzzy, c-format
+msgid "Failed reading proxy response: %s\n"
msgstr "Scriere cerere HTTP eșuată: %s.\n"
-#: src/http.c:1039
+#: src/http.c:1704
+#, c-format
+msgid "Proxy tunneling failed: %s"
+msgstr ""
+
+#: src/http.c:1749
#, c-format
msgid "%s request sent, awaiting response... "
msgstr "Cerere %s trimisă, se așteaptă răspuns... "
-#: src/http.c:1083
-msgid "End of file while parsing headers.\n"
-msgstr "Sfârșit fișier la analiza headerelor.\n"
+#: src/http.c:1760
+#, fuzzy
+msgid "No data received.\n"
+msgstr "Nici o dată recepționată"
-#: src/http.c:1093
+#: src/http.c:1767
#, c-format
msgid "Read error (%s) in headers.\n"
msgstr "Eroare de citire (%s) în headere.\n"
-#: src/http.c:1128
-msgid "No data received"
-msgstr "Nici o dată recepționată"
+#. If opt.noclobber is turned on and file already exists, do not
+#. retrieve the file
+#: src/http.c:1813
+#, fuzzy, c-format
+msgid ""
+"File `%s' already there; not retrieving.\n"
+"\n"
+msgstr "Fișierul `%s' există deja, nu se mai aduce.\n"
+
+#. If the authentication header is missing or
+#. unrecognized, there's no sense in retrying.
+#: src/http.c:1966
+msgid "Unknown authentication scheme.\n"
+msgstr "Schemă autentificare necunoscută.\n"
+
+#: src/http.c:1997
+msgid "Authorization failed.\n"
+msgstr "Autorizare eșuată.\n"
-#: src/http.c:1130
+#: src/http.c:2011
msgid "Malformed status line"
msgstr "Linie de stare malformată"
-#: src/http.c:1135
+#: src/http.c:2013
msgid "(no description)"
msgstr "(fără descriere)"
-#: src/http.c:1267
-msgid "Authorization failed.\n"
-msgstr "Autorizare eșuată.\n"
-
-#: src/http.c:1274
-msgid "Unknown authentication scheme.\n"
-msgstr "Schemă autentificare necunoscută.\n"
-
-#: src/http.c:1314
+#: src/http.c:2076
#, c-format
msgid "Location: %s%s\n"
msgstr "Locație: %s%s\n"
-#: src/http.c:1315 src/http.c:1454
+#: src/http.c:2077 src/http.c:2184
msgid "unspecified"
msgstr "nespecificat(ă)"
-#: src/http.c:1316
+#: src/http.c:2078
msgid " [following]"
msgstr " [urmează]"
-#: src/http.c:1383
+#. If `-c' is in use and the file has been fully downloaded (or
+#. the remote file has shrunk), Wget effectively requests bytes
+#. after the end of file and the server response with 416.
+#: src/http.c:2134
msgid ""
"\n"
" The file is already fully retrieved; nothing to do.\n"
| [
"[email protected]"
] | |
b7a1357bd6d5f41040a2ff636c8aba4747df469e | 3b697c35393527df7e0dad17dbd63668b2706b6b | /PC3/main.cpp | a9fa7d2c7a42d6d64799227c3896fac029b8e1fd | [] | no_license | anquisbarr/POO2-PC3 | 011965407de3e0524564110dd2fae34cac2397ed | db89f1cd55c297208b7d5abebbbf5afdd3f811f9 | refs/heads/master | 2020-09-07T07:08:33.620333 | 2019-11-09T23:19:59 | 2019-11-09T23:19:59 | 220,698,098 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 122 | cpp | #include "Repo.h"
int main() {
cout << "Hello world!"<<endl;
auto* repo = new Repo<Country>(",");
return 0;
} | [
"[email protected]"
] | |
7ff7d3772767bca6b17cfb76c32a0c3af26b277d | 392f3cdf7c2624661a09b2bacb50b215fed77e5e | /OgreGUI/ogUtilities.h | 4c03e6b77946a28d08668ef457dceb0e5fe5fc2c | [] | no_license | whztt07/OgreGui | 07b3f47c1a078c75eda2f2026f92627bdd75307e | 6a5daa238d9ae72c196f6f5984347a8edee8edbe | refs/heads/master | 2020-04-05T19:04:09.684643 | 2011-08-01T04:02:20 | 2011-08-01T04:02:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 458 | h | #pragma once
#include <Ogre.h>
#include <vector>
#include <string>
namespace OgreGUI {
ref class ogUtilities
{
public:
ogUtilities(void);
};
class ogUtilitiesUM
{
public:
ogUtilitiesUM(void);
static void createConsole();
static Ogre::SceneNode *loadObj(Ogre::SceneManager *mgr,Ogre::String fileName,Ogre::String meshName);
static std::vector<std::string> ogUtilitiesUM::tokenize(const std::string& str,const std::string& delimiters);
};
}; | [
"[email protected]"
] | |
3d802760cd31f3a59e6b1373b118492f288f24ba | 6c85d1e06af1fac59163596c0f47898614177a22 | /eburc/Search/Match.cpp | f169455c6abd726f94f0cbf7916afe859619ddb1 | [
"MIT",
"BSD-3-Clause"
] | permissive | tgckpg/libeburc | 834f9c207176ee169f7028738a6bcae2c8c3032b | 5dd62ae7c1d08a85e59fa30b478d3813928f1bcc | refs/heads/master | 2020-12-31T04:41:17.961800 | 2020-11-01T22:57:46 | 2020-11-01T22:57:46 | 49,869,376 | 6 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 7,434 | cpp | #include "pch.h"
#include "eburc/Search/Match.h"
using namespace libeburc;
int Match::Word( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
result = 0;
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::PreWord( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = 0;
break;
}
if ( *word_p == '\0' )
{
result = 0;
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::ExactWordJIS( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
/* ignore spaces in the tail of the pattern */
while ( i < length && *pattern_p == '\0' )
{
pattern_p++;
i++;
}
result = ( i - length );
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::ExactPreWordJIS( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = 0;
break;
}
if ( *word_p == '\0' )
{
/* ignore spaces in the tail of the pattern */
while ( i < length && *pattern_p == '\0' )
{
pattern_p++;
i++;
}
result = ( i - length );
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::ExactWordLatin( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
/* ignore spaces in the tail of the pattern */
while ( i < length && ( *pattern_p == ' ' || *pattern_p == '\0' ) )
{
pattern_p++;
i++;
}
result = ( i - length );
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::ExactPreWordLatin( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
int result;
for ( ;;)
{
if ( length <= i )
{
result = 0;
break;
}
if ( *word_p == '\0' )
{
/* ignore spaces in the tail of the pattern */
while ( i < length && ( *pattern_p == ' ' || *pattern_p == '\0' ) )
{
pattern_p++;
i++;
}
result = ( i - length );
break;
}
if ( *word_p != *pattern_p )
{
result = *word_p - *pattern_p;
break;
}
word_p++;
pattern_p++;
i++;
}
return result;
}
int Match::WordKanaGroup( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
unsigned char wc0, wc1, pc0, pc1;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
result = 0;
break;
}
if ( length <= i + 1 || *( word_p + 1 ) == '\0' )
{
result = *word_p - *pattern_p;
break;
}
wc0 = *word_p;
wc1 = *( word_p + 1 );
pc0 = *pattern_p;
pc1 = *( pattern_p + 1 );
if ( ( wc0 == 0x24 || wc0 == 0x25 ) && ( pc0 == 0x24 || pc0 == 0x25 ) )
{
if ( wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
else
{
if ( wc0 != pc0 || wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
word_p += 2;
pattern_p += 2;
i += 2;
}
return result;
}
int Match::WordKanaSingle( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
unsigned char wc0, wc1, pc0, pc1;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
result = 0;
break;
}
if ( length <= i + 1 || *( word_p + 1 ) == '\0' )
{
result = *word_p - *pattern_p;
break;
}
wc0 = *word_p;
wc1 = *( word_p + 1 );
pc0 = *pattern_p;
pc1 = *( pattern_p + 1 );
if ( ( wc0 == 0x24 || wc0 == 0x25 ) && ( pc0 == 0x24 || pc0 == 0x25 ) )
{
if ( wc1 != pc1 )
{
result = wc1 - pc1;
break;
}
}
else
{
if ( wc0 != pc0 || wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
word_p += 2;
pattern_p += 2;
i += 2;
}
return result;
}
int Match::ExactWordKanaGroup( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
unsigned char wc0, wc1, pc0, pc1;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
result = -*pattern_p;
break;
}
if ( length <= i + 1 || *( word_p + 1 ) == '\0' )
{
result = *word_p - *pattern_p;
break;
}
wc0 = *word_p;
wc1 = *( word_p + 1 );
pc0 = *pattern_p;
pc1 = *( pattern_p + 1 );
if ( ( wc0 == 0x24 || wc0 == 0x25 ) && ( pc0 == 0x24 || pc0 == 0x25 ) )
{
if ( wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
else
{
if ( wc0 != pc0 || wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
word_p += 2;
pattern_p += 2;
i += 2;
}
return result;
}
int Match::ExactWordKanaSingle( const char *word, const char *pattern, size_t length )
{
int i = 0;
unsigned char *word_p = ( unsigned char * ) word;
unsigned char *pattern_p = ( unsigned char * ) pattern;
unsigned char wc0, wc1, pc0, pc1;
int result;
for ( ;;)
{
if ( length <= i )
{
result = *word_p;
break;
}
if ( *word_p == '\0' )
{
result = -*pattern_p;
break;
}
if ( length <= i + 1 || *( word_p + 1 ) == '\0' )
{
result = *word_p - *pattern_p;
break;
}
wc0 = *word_p;
wc1 = *( word_p + 1 );
pc0 = *pattern_p;
pc1 = *( pattern_p + 1 );
if ( ( wc0 == 0x24 || wc0 == 0x25 ) && ( pc0 == 0x24 || pc0 == 0x25 ) )
{
if ( wc1 != pc1 )
{
result = wc1 - pc1;
break;
}
}
else
{
if ( wc0 != pc0 || wc1 != pc1 )
{
result = ( ( wc0 << 8 ) + wc1 ) - ( ( pc0 << 8 ) + pc1 );
break;
}
}
word_p += 2;
pattern_p += 2;
i += 2;
}
return result;
}
| [
"[email protected]"
] | |
0659f9b79836ba18dd7537c37174a6f0de47553c | 44412b0dd6e8d0f9868e1c905381b90a2c062628 | /1. FCFS Q1.txt.cpp | a580239800c2334e12ac55d36bca523d60df4d1c | [] | no_license | panjiara/os-lab | 71935a1a36a702326fae1b7be076d291d83c5ea9 | a92f48215343d1a96c30071ab081d6adba6182f2 | refs/heads/master | 2021-01-11T09:30:32.903980 | 2017-04-05T04:52:03 | 2017-04-05T04:52:03 | 81,229,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,443 | cpp | #include <iostream>
using namespace std;
struct node
{
int arr;
int cpu;
int cumu;
int wait;
int turn;
node *next;
};
node* ins(node *start, int t1, int t2)
{
node *temp=new node;
temp->arr=t1;
temp->cpu=t2;
if(start==NULL)
{
temp->next=NULL;
start=temp;
}
else
{
node *q=start;
while(q->next!=NULL)
{
q=q->next;
}
temp->next=NULL;
q->next=temp;
}
return start;
}
node* calFCFS(node *start)
{
node *temp=start;
if(start==NULL)
{
cout<<"No jobs were added to the queue.\n";
return start;
}
int t=0;
while(temp!=NULL)
{
temp->cumu=t+temp->cpu;
if(t>=temp->arr) temp->wait=t-temp->arr;
else temp->wait=0;
temp->turn=temp->wait+temp->cpu;
t=temp->cumu;
temp=temp->next;
}
return start;
}
/*node* calSJF(node *start)
{
node *temp=start;
if(start==NULL)
{
cout<<"No jobs were added to the queue.\n";
return start;
}
int t=0;
while(temp!=NULL)
{
temp->cumu=t+temp->cpu;
if(t>=temp->arr) temp->wait=t-temp->arr;
else temp->wait=0;
temp->turn=temp->wait+temp->cpu;
t=temp->cumu;
temp=temp->next;
}
return start;
}
node *insB(node *start, node *key)
{
node *temp=start;
int flag=false;
while(temp->next!=NULL)
{
if(temp->next->cpu > key->cpu)
{
key->next=temp->next;
temp->next=key;
flag=true;
break;
}
}
if(flag==false)
{
key->next=NULL;
temp->next=key;
}
return start;
}
node* sort(node *start)
{
node *temp=start;
if(start==NULL)
{
cout<<"No jobs were added to the queue.\n";
return start;
}
node *sorted=start;
while(temp!=NULL)
{
sorted=insB(sorted,temp);
temp=temp->next;
}
return sorted;
}*/
void show(node *start)
{
node *temp=start;
if(start==NULL)
{
cout<<"No jobs were added to the queue.\n";
return;
}
cout<<"\nJob ID\tWaiting time\tTurnaround Time\n";
int i=0,wait=0,turn=0;
while(temp!=NULL)
{
cout<<i+1<<"\t"<<temp->wait<<"\t"<<temp->turn<<"\n";
wait+=temp->wait;
turn+=temp->turn;
i++;
temp=temp->next;
}
cout<<"\nAverage waiting time: "<<(float)wait/i;
cout<<"\nAverage turnaround time: "<<(float)turn/i;
}
int main()
{
node *start=NULL;
int op,n;
do
{
cout<<"\nChoose:\n1.FCFS\n2.SJF\n3.SRT\n4.Round Robin\n5.Exit\n";
cin>>op;
cout<<"Number of jobs: ";
cin>>n;
int t1,t2;
cout<<"Enter arrival time and CPU cycle (in ms):\n";
for(int j=1; j<=n; ++j)
{
cout<<"Job "<<j<<": ";
cin>>t1>>t2;
start=ins(start,t1,t2);
}
switch(op)
{
case 1: start=calFCFS(start);
show(start);
start=NULL;
break;
/*case 2: start=sort(start);
start=calSJF(start);*/
}
}while(op!=5);
return 0;
}
| [
"[email protected]"
] | |
1ac259a56accc4ef6016c4871ab41d52d767bc84 | 1d59b77c3643889107fbdc6fe92cd258c40465ba | /Enemy.h | 4aba3c51eb705c33cca58c102cc01091ba327a47 | [] | no_license | F74046535/pd2-Taiko | 9e75cab9a43e06337545496bdb6813c1f6d804f9 | 90333413a850b26dd76b9eb475c0aa541770d905 | refs/heads/master | 2021-01-01T05:24:32.393056 | 2016-05-15T15:41:03 | 2016-05-15T15:41:03 | 58,866,170 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 412 | h | #ifndef ENEMY
#define ENEMY
#include<QGraphicsPixmapItem>
#include<QObject>
#include<QGraphicsItem>
#include<time.h>
#include<QKeyEvent>
class Enemy:public QObject,public QGraphicsPixmapItem{
Q_OBJECT
public:
Enemy(QGraphicsItem *parent=0);
//Enemy * enemy;
/*void keyPressEvent(QKeyEvent *event);*/
public slots:
void move();
void spawn();
};
#endif // ENEMY
| [
"[email protected]"
] | |
40e32674f26649e8bda365701b2c33f5306ef3a1 | f9fa279de2294ff483f3d0c9bc08bb052fc5eda2 | /external/chromium/media/filters/shell_mp4_parser.cc | 6280d99ef5fee612a1454526d39370949c4fa205 | [
"BSD-3-Clause"
] | permissive | rajeshvv/h5vcc | 964d1c2d6ea308413dae1527525f8937ac58808f | 1e0b8ac00d494d3ed56513d1e1725a063add7f31 | refs/heads/master | 2021-01-15T09:38:25.999021 | 2013-07-22T22:53:30 | 2013-07-22T22:53:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,001 | cc | /*
* Copyright 2012 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "media/filters/shell_mp4_parser.h"
#include <inttypes.h>
#include "base/stringprintf.h"
#include "media/base/shell_buffer_factory.h"
#include "media/base/shell_filter_graph_log.h"
#include "media/mp4/es_descriptor.h"
#include "lb_platform.h"
#if SHELL_MP4_PARSER_DUMP_ATOMS
#include <string>
extern const std::string *global_game_content_path;
#endif
namespace media {
// how many bytes to skip within an avc1 before the config atoms start?
static const int kSkipBytes_avc1 = 78;
// what's the smallest meaningful mp4 atom size?
static const int kAtomMinSize = 8;
// Full Box has a one byte version and three bytes flags after the header
static const int kFullBoxHeaderAndFlagSize = 4;
// how much to download of an hdlr to get the trak type?
static const int kDesiredBytes_hdlr = 12;
static const uint32 kAudioSubtype_hdlr_soun = 0x736f756e;
static const uint32 kVideoSubtype_hdlr_vide = 0x76696465;
// how much to download of an mp4a to determine version number?
static const int kDesiredBytes_mp4a = 2;
// how big is the mp4a atom before optional extension atoms?
static const int kTotalSize_mp4a_v0 = 28;
static const int kTotalSize_mp4a_v1 = 44;
static const int kTotalSize_mp4a_v2 = 64;
// how many bytes should we download from an mdhd?
static const int kDesiredBytes_mdhd = 20;
// how many bytes should we download from an mvhd?
static const int kDesiredBytes_mvhd = 20;
// how many bytes to skip within an stsd before the config atoms start?
static const int kSkipBytes_stsd = 8;
// use average values of mp4 metadata tables plus 2 standard deviations to
// hold most metadata atoms entirely in memory.
static const int kMapTableAtomCacheEntries_stsz = 260591 / kEntrySize_stsz;
static const int kMapTableAtomCacheEntries_stco = 22859 / kEntrySize_stco;
static const int kMapTableAtomCacheEntries_stss = 3786 / kEntrySize_stss;
static const int kMapTableAtomCacheEntries_stts = 164915 / kEntrySize_stts;
static const int kMapTableAtomCacheEntries_stsc = 32199 / kEntrySize_stsc;
static const int kMapTableAtomCacheEntries_co64 = 740212 / kEntrySize_co64;
static const int kMapTableAtomCacheEntries_ctts = 51543 / kEntrySize_ctts;
// static
scoped_refptr<ShellParser> ShellMP4Parser::Construct(
scoped_refptr<ShellDataSourceReader> reader,
const uint8 *construction_header,
const PipelineStatusCB &status_cb,
scoped_refptr<ShellFilterGraphLog> filter_graph_log) {
// detect mp4 stream by looking for ftyp atom at top of file
uint32 ftyp = LB::Platform::load_uint32_big_endian(construction_header + 4);
if (ftyp != kAtomType_ftyp) {
// not an mp4
return NULL;
}
// first 4 bytes will be the size of the ftyp atom
uint32 ftyp_atom_size =
LB::Platform::load_uint32_big_endian(construction_header);
if (ftyp_atom_size < kAtomMinSize) {
status_cb.Run(DEMUXER_ERROR_COULD_NOT_PARSE);
return NULL;
}
// construct and return new mp4 parser
return scoped_refptr<ShellParser>(new ShellMP4Parser(reader,
ftyp_atom_size,
filter_graph_log));
}
ShellMP4Parser::ShellMP4Parser(
scoped_refptr<ShellDataSourceReader> reader,
uint32 ftyp_atom_size,
scoped_refptr<ShellFilterGraphLog> filter_graph_log)
: ShellAVCParser(reader, filter_graph_log)
, atom_offset_(ftyp_atom_size) // start at next atom, skipping over ftyp
, current_trak_is_video_(false)
, current_trak_is_audio_(false)
, current_trak_time_scale_(0)
, video_time_scale_hz_(0)
, audio_time_scale_hz_(0)
, audio_map_(new ShellMP4Map(reader, filter_graph_log))
, video_map_(new ShellMP4Map(reader, filter_graph_log))
, audio_sample_(0)
, video_sample_(0)
, first_audio_hole_ticks_(0)
, first_audio_hole_(base::TimeDelta::FromSeconds(0)) {
}
ShellMP4Parser::~ShellMP4Parser() {
}
// For MP4 we traverse the file's atom structure attempting to find the audio
// and video configuration information and the locations in the file of the
// various stbl subatoms which detail the position of the audio and video
// NALUs in the file. As some of the stbl subatoms can be quite large we cache
// a fixed maximum quantity of each stbl subatom and update the cache only on
// miss.
bool ShellMP4Parser::ParseConfig() {
while (!IsConfigComplete() ||
!audio_map_->IsComplete() ||
!video_map_->IsComplete()) {
if (!ParseNextAtom()) {
return false;
}
}
return true;
}
scoped_refptr<ShellAU> ShellMP4Parser::GetNextAU(DemuxerStream::Type type) {
uint32 size = 0;
uint32 duration_ticks = 0;
uint64 timestamp_ticks = 0;
uint64 offset = 0;
bool is_keyframe = false;
base::TimeDelta timestamp;
base::TimeDelta duration;
if (type == DemuxerStream::AUDIO) {
if (!audio_map_->GetSize(audio_sample_, size) ||
!audio_map_->GetOffset(audio_sample_, offset) ||
!audio_map_->GetDuration(audio_sample_, duration_ticks) ||
!audio_map_->GetTimestamp(audio_sample_, timestamp_ticks)) {
// determine if EOS or error
if (audio_map_->IsEOS(audio_sample_)) {
return ShellAU::CreateEndOfStreamAU(DemuxerStream::AUDIO,
audio_track_duration_);
} else {
DLOG(ERROR) << "parsed bad audio AU";
return NULL;
}
}
// all aac frames are random-access, so all are keyframes
is_keyframe = true;
audio_sample_++;
timestamp = TicksToTime(timestamp_ticks, audio_time_scale_hz_);
duration = TicksToTime(duration_ticks, audio_time_scale_hz_);
// It would be very unusual to encounter non-contiguous audio
// in an mp4, but you never know. Make sure this timestamp is
// contiguous in ticks from the last one
if (first_audio_hole_ticks_ == timestamp_ticks) {
// Much of the audio stack assumes that audio timestamps are
// contiguous. While the timestamps coming out of the map are
// normally continuous, they are on a different time scale. Due
// to roundoff error in conversion the timestamps produced may
// be discontinuous. To correct this we correct the timestamp
// to the one the system is expecting for continuity, then modify
// the duration by the negative of that same (small) value,
// so as to not accumulate roundoff error over time.
base::TimeDelta time_difference = timestamp - first_audio_hole_;
timestamp = first_audio_hole_;
duration += time_difference;
first_audio_hole_ = timestamp + duration;
first_audio_hole_ticks_ += duration_ticks;
} else {
DLOG(WARNING) << "parsed non-contiguous mp4 audio timestamp";
// reset hole tracking past gap
first_audio_hole_ticks_ = timestamp_ticks + duration_ticks;
first_audio_hole_ = timestamp + duration;
}
} else if (type == DemuxerStream::VIDEO) {
if (!video_map_->GetSize(video_sample_, size) ||
!video_map_->GetOffset(video_sample_, offset) ||
!video_map_->GetDuration(video_sample_, duration_ticks) ||
!video_map_->GetTimestamp(video_sample_, timestamp_ticks) ||
!video_map_->GetIsKeyframe(video_sample_, is_keyframe)) {
if (video_map_->IsEOS(video_sample_)) {
return ShellAU::CreateEndOfStreamAU(DemuxerStream::VIDEO,
video_track_duration_);
} else {
DLOG(ERROR) << "parsed bad video AU";
return NULL;
}
}
video_sample_++;
timestamp = TicksToTime(timestamp_ticks, video_time_scale_hz_);
duration = TicksToTime(duration_ticks, video_time_scale_hz_);
// due to b-frames it's much more likely we'll encounter discontinuous
// video buffers. As a result we add a small duration to each video
// buffer, equal in value to one full tick at the video timescale. The
// showing of video frames is actually keyed on the audio clock, so this
// shouldn't create too much jitter in the output.
duration += one_video_tick_;
} else {
NOTREACHED() << "unsupported stream type";
return NULL;
}
size_t prepend_size = CalculatePrependSize(type, is_keyframe);
if (type == DemuxerStream::AUDIO)
return ShellAU::CreateAudioAU(offset, size, prepend_size, is_keyframe,
timestamp, duration, this);
return ShellAU::CreateVideoAU(offset, size, prepend_size, nal_header_size_,
is_keyframe, timestamp, duration, this);
}
bool ShellMP4Parser::SeekTo(base::TimeDelta timestamp) {
// get video timestamp in video time units
uint64 video_ticks = TimeToTicks(timestamp, video_time_scale_hz_);
// find nearest keyframe from map, make it our next video sample
if (!video_map_->GetKeyframe(video_ticks, video_sample_)) {
return false;
}
// get the timestamp for this video keyframe
uint64 video_keyframe_time_ticks = 0;
if (!video_map_->GetTimestamp(video_sample_, video_keyframe_time_ticks)) {
return false;
}
base::TimeDelta video_keyframe_time =
TicksToTime(video_keyframe_time_ticks, video_time_scale_hz_);
// find the closest audio frame that bounds that timestamp
uint64 audio_ticks = TimeToTicks(video_keyframe_time, audio_time_scale_hz_);
if (!audio_map_->GetKeyframe(audio_ticks, audio_sample_)) {
return false;
}
DLOG(INFO) << base::StringPrintf(
"seeking to timestamp: %"PRId64", video sample: %d, audio sample: %d",
timestamp.InMilliseconds(), video_sample_, audio_sample_);
// cheat our buffer continuity system
if (!audio_map_->GetTimestamp(audio_sample_, first_audio_hole_ticks_)) {
return false;
}
first_audio_hole_ = TicksToTime(first_audio_hole_ticks_, audio_time_scale_hz_);
return true;
}
// parse the atom starting at atom_offset_, update appropriate internal state,
// return false on fatal error. General structure of an MP4 atom is:
// field | type | comment
// ------------------+--------+---------
// atom size | uint32 | if 0 means "rest of file", if 1 means extended
// fourCC code | ASCII | four-byte ASCII code we treat as uint32
// extended size | uint64 | optional size field, only here if atom size is 1
// <--- rest of atom body starts here
bool ShellMP4Parser::ParseNextAtom() {
uint8 atom[kAtomDownload];
int bytes_read = reader_->BlockingRead(atom_offset_,
kAtomDownload,
atom);
if (bytes_read < kAtomDownload) {
return false;
}
// first 4 bytes are size of atom uint32
uint64 atom_size = (uint64)LB::Platform::load_uint32_big_endian(atom);
// normally atom body starts just past fourCC code
uint32 atom_body = kAtomMinSize;
// if 1 we need to load the extended size which will be appended just past
// the fourCC code
if (atom_size == 1) {
atom_size = LB::Platform::load_uint64_big_endian(atom + 8);
// advance atom_body past the 8 bytes of size we just parsed
atom_body += 8;
} else if (atom_size == 0) {
// calculate size of this atom from remainder of file
if (reader_->FileSize() > atom_offset_) {
atom_size = reader_->FileSize() - atom_offset_;
}
}
// atom sizes also include the size of the start of the atom, so sanity-check
// the size we just parsed against the number of bytes we needed to parse it
if (atom_size < atom_body) {
DLOG(WARNING) << base::StringPrintf("atom size: %"PRId64" less than min body size %d",
atom_size, atom_body);
return false;
}
// extract fourCC code as big-endian uint32
uint32 four_cc = LB::Platform::load_uint32_big_endian(atom + 4);
DLOG(INFO) << base::StringPrintf("four_cc: %c%c%c%c", atom[4], atom[5], atom[6], atom[7]);
#if SHELL_MP4_PARSER_DUMP_ATOMS
DumpAtomToDisk(four_cc, atom_size, atom_offset_);
#endif
// advance read pointer to atom body
atom_offset_ += atom_body;
// adjust size of body of atom from size of header
uint64 atom_data_size = atom_size - atom_body;
bool atom_parse_success = true;
// We use 95% certainty intervals for video metadata atom sizes. The map
// is written to handle larger atom sizes but having to recache metadata
// increases latencies on things like seeks.
int map_table_atom_cache_entries = 0;
// now take appropriate action based on atom type
switch (four_cc) {
// avc1 atoms are contained within stsd atoms and carry their own
// configuration baggage load, which we skip over and parse the atoms
// within, normally an avcC atom.
case kAtomType_avc1:
atom_offset_ += kSkipBytes_avc1;
break;
// avcC atoms contain the AVCConfigRecord, our video configuration info
case kAtomType_avcC:
atom_parse_success = DownloadAndParseAVCConfigRecord(atom_offset_,
atom_data_size);
if (atom_parse_success)
atom_offset_ += atom_data_size;
break;
// esds atoms contain actually usable audio configuration info for AAC.
case kAtomType_esds:
return ParseMP4_esds(atom_data_size);
// can tell us if mdia and mdhd atoms relate to audio or video metadata
case kAtomType_hdlr:
return ParseMP4_hdlr(atom_data_size, atom + atom_body);
// provides a duration and a timescale unique to a given track
case kAtomType_mdhd:
return ParseMP4_mdhd(atom_data_size, atom + atom_body);
// mp4a atoms contain audio configuration info, but we only want to know
// which version it is so we can skip to the esds, which we must be present
// when using AAC
case kAtomType_mp4a:
return ParseMP4_mp4a(atom_data_size, atom + atom_body);
// movie header atom contains track duration and time unit scale, we trust
// these data as the authoritative duration data for the mp4
case kAtomType_mvhd:
return ParseMP4_mvhd(atom_data_size, atom + atom_body);
// stsd atoms may contain avc1 atoms, which themselves may contain avcC
// atoms, which contain actually usable configuration information. skip to
// subatom.
case kAtomType_stsd:
atom_offset_ += kSkipBytes_stsd;
break;
// We're very much interested in the contents of the trak container atom,
// blow away state that we may have been keeping about any prior trak
// atoms we've parsed.
case kAtomType_trak:
current_trak_is_video_ = false;
current_trak_is_audio_ = false;
break;
// if one of the stbl subatoms add it to the appropriate audio or video map
// and then advance past it.
case kAtomType_co64:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_co64;
break;
case kAtomType_ctts:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_ctts;
break;
case kAtomType_stco:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_stco;
break;
case kAtomType_stts:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_stts;
break;
case kAtomType_stsc:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_stsc;
break;
case kAtomType_stss:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_stss;
break;
case kAtomType_stsz:
map_table_atom_cache_entries = kMapTableAtomCacheEntries_stsz;
break;
// these are container atoms, so we dont want to advance past the header
// as we are interested in their contents. Parsing them is trivial
// as all they are is a size header and a fourCC type tag, which we've
// already parsed and advanced past.
case kAtomType_mdia:
case kAtomType_minf:
case kAtomType_moov:
case kAtomType_stbl:
// no-op
break;
// known atom types that we wish to just skip past the body without warning
case kAtomType_dinf:
case kAtomType_dref:
case kAtomType_smhd:
case kAtomType_tkhd:
case kAtomType_vmhd:
atom_offset_ += atom_data_size;
break;
// parse functions are assumed to advance read_position_ themselves,
// as we are flattening a tree of atoms so that the atom_size we parsed
// this time, if it's a container, may not have been entirely consumed
// in this single call. However for unsupported atoms we just skip them
// entirely, meaning we will skip their contents too.
default:
atom_offset_ += atom_data_size;
DLOG(INFO) << base::StringPrintf(
"skipping unsupported MP4 atom: %c%c%c%c",
atom[4], atom[5], atom[6], atom[7]);
break;
}
if (map_table_atom_cache_entries > 0) {
if (current_trak_is_video_) {
atom_parse_success = video_map_->SetAtom(four_cc,
atom_offset_,
atom_data_size,
map_table_atom_cache_entries,
atom + atom_body);
} else if (current_trak_is_audio_) {
atom_parse_success = audio_map_->SetAtom(four_cc,
atom_offset_,
atom_data_size,
map_table_atom_cache_entries,
atom + atom_body);
}
atom_offset_ += atom_data_size;
}
if (!atom_parse_success) {
DLOG(ERROR) << base::StringPrintf(
"Unable to parse MP4 atom: %c%c%c%c",
atom[4], atom[5], atom[6], atom[7]);
}
return atom_parse_success;
}
#if SHELL_MP4_PARSER_DUMP_ATOMS
void ShellMP4Parser::DumpAtomToDisk(uint32 four_cc,
uint32 atom_size,
uint64 atom_offset) {
// download entire atom into buffer
scoped_refptr<ShellScopedArray> scoped_buffer =
ShellBufferFactory::Instance()->AllocateArray(atom_size,
filter_graph_log_);
uint8* buffer = scoped_buffer->Get();
int bytes_read = reader_->BlockingRead(atom_offset,
atom_size,
buffer);
DCHECK_EQ(bytes_read, atom_size);
// calculate file and table names
std::string av_prefix_file;
if (current_trak_is_video_) {
av_prefix_file = "/mp4_video_atom_";
} else if (current_trak_is_audio_) {
av_prefix_file = "/mp4_audio_atom_";
} else {
av_prefix_file = "/mp4_atom_";
}
std::string atom_name = base::StringPrintf("%c%c%c%c",
(char)(four_cc >> 24), (char)(four_cc >> 16),
(char)(four_cc >> 8), (char)four_cc);
// build path
std::string path = base::StringPrintf("%s%s%s_%lld.txt",
global_game_content_path->c_str(), av_prefix_file.c_str(),
atom_name.c_str(), atom_offset);
// get file for writing
FILE* atom_file = fopen(path.c_str(), "w");
DCHECK(atom_file);
// 13 bytes per line matches 80-column rule with indenting :)
for (int i = 0; i < atom_size; i += 13) {
std::string atom_chars;
// do whole lines at a time
if (atom_size - i > 13) {
atom_chars = base::StringPrintf(
" 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, "
"0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n",
buffer[i ], buffer[i + 1 ], buffer[i + 2 ], buffer[i + 3 ],
buffer[i + 4 ], buffer[i + 5 ], buffer[i + 6 ], buffer[i + 7 ],
buffer[i + 8 ], buffer[i + 9 ], buffer[i + 10], buffer[i + 11],
buffer[i + 12]);
} else {
atom_chars = " "; // start string with indentation
// do last line one char at a time
for (int j = i; j < atom_size - 1; j++) {
atom_chars += base::StringPrintf("0x%02x, ", buffer[j]);
}
// final char gets no comma and a newline
atom_chars += base::StringPrintf("0x%02x\n", buffer[atom_size - 1]);
}
// save line
fwrite(atom_chars.c_str(), 1, atom_chars.length(), atom_file);
}
// close file
fclose(atom_file);
}
#endif
bool ShellMP4Parser::ParseMP4_esds(uint64 atom_data_size) {
if (atom_data_size < kFullBoxHeaderAndFlagSize) {
DLOG(WARNING) << base::StringPrintf(
"esds box should at least be %d bytes but now it is %"PRId64" bytes",
kFullBoxHeaderAndFlagSize, atom_data_size);
return false;
}
uint64 esds_offset = atom_offset_ + kFullBoxHeaderAndFlagSize;
uint64 esds_size = atom_data_size - kFullBoxHeaderAndFlagSize;
// we'll need to download entire esds, allocate buffer for it
scoped_refptr<ShellScopedArray> esds_storage =
ShellBufferFactory::Instance()->AllocateArray(esds_size,
filter_graph_log_);
uint8* esds = NULL;
if (!esds_storage || !(esds = esds_storage->Get())) {
DLOG(WARNING) << base::StringPrintf(
"unable to allocate esds temp array of %"PRId64" bytes", esds_size);
return false;
}
// download esds
int bytes_read = reader_->BlockingRead(esds_offset, esds_size, esds);
if (bytes_read < esds_size) {
DLOG(WARNING) << "failed to download esds";
return false;
}
mp4::ESDescriptor es_descriptor;
std::vector<uint8> data(esds, esds + esds_size);
if (es_descriptor.Parse(data)) {
const std::vector<uint8>& dsi = es_descriptor.decoder_specific_info();
if (dsi.size() >= 2) {
ParseAudioSpecificConfig(dsi[0], dsi[1]);
atom_offset_ += atom_data_size;
return true;
}
DLOG(WARNING) << "esds audio specific config shorter than 2 bytes";
} else {
DLOG(WARNING) << "error in parse esds box";
}
return false;
}
bool ShellMP4Parser::ParseMP4_hdlr(uint64 atom_data_size, uint8* hdlr) {
// ensure we're downloading enough of the hdlr to parse
DCHECK_LE(kDesiredBytes_hdlr + 16, kAtomDownload);
// sanity-check for minimum size
if (atom_data_size < kDesiredBytes_hdlr) {
DLOG(WARNING) << base::StringPrintf("bad size %"PRId64" on hdlr",
atom_data_size);
return false;
}
// last 4 bytes of the 12 we need are an ascii code for the trak type, we
// want 'vide' for video or 'soun' for audio. ignore the rest.
uint32 hdlr_subtype = LB::Platform::load_uint32_big_endian(hdlr + 8);
// update state flags
current_trak_is_video_ = (hdlr_subtype == kVideoSubtype_hdlr_vide);
current_trak_is_audio_ = (hdlr_subtype == kAudioSubtype_hdlr_soun);
// save a time scale if pending
if (current_trak_time_scale_ > 0 && current_trak_is_video_) {
video_time_scale_hz_ = current_trak_time_scale_;
current_trak_time_scale_ = 0;
video_track_duration_ = current_trak_duration_;
one_video_tick_ = base::TimeDelta::FromMicroseconds(
1000000 / video_time_scale_hz_);
}
if (current_trak_time_scale_ > 0 && current_trak_is_audio_) {
audio_time_scale_hz_ = current_trak_time_scale_;
current_trak_time_scale_ = 0;
audio_track_duration_ = current_trak_duration_;
}
// skip rest of atom
atom_offset_ += atom_data_size;
return true;
}
bool ShellMP4Parser::ParseMP4_mdhd(uint64 atom_data_size, uint8* mdhd) {
DCHECK_LE(kDesiredBytes_mdhd + 16, kAtomDownload);
if (atom_data_size < kDesiredBytes_mdhd) {
DLOG(WARNING) << base::StringPrintf("bad size %"PRId64" on mdhd",
atom_data_size);
return false;
}
uint32 time_scale = LB::Platform::load_uint32_big_endian(mdhd + 12);
// double-check track duration, it may be different from the movie duration
uint32 track_duration_ticks =
LB::Platform::load_uint32_big_endian(mdhd + 16);
base::TimeDelta track_duration = TicksToTime(track_duration_ticks,
time_scale);
if (track_duration > duration_) {
DLOG(WARNING) << base::StringPrintf(
"mdhd has longer duration: %"PRId64" ms than old value: %"PRId64" ms.",
track_duration.InMilliseconds(), duration_.InMilliseconds());
duration_ = track_duration;
}
if (current_trak_is_video_) {
video_time_scale_hz_ = time_scale;
current_trak_time_scale_ = 0;
video_track_duration_ = track_duration;
one_video_tick_ = base::TimeDelta::FromMicroseconds(
1000000 / video_time_scale_hz_);
} else if (current_trak_is_audio_) {
audio_time_scale_hz_ = time_scale;
current_trak_time_scale_ = 0;
audio_track_duration_ = track_duration;
} else {
// it's possible we will encounter the mdhd before we encounter the hdlr,
// in that event we save the time scale value until we know.
current_trak_time_scale_ = time_scale;
current_trak_duration_ = track_duration;
}
atom_offset_ += atom_data_size;
return true;
}
bool ShellMP4Parser::ParseMP4_mp4a(uint64 atom_data_size, uint8* mp4a) {
DCHECK_LE(kDesiredBytes_mp4a + 16, kAtomDownload);
// we only need the first two bytes of the header, which details the version
// number of this atom, which tells us the size of the rest of the header,
// telling us how much we should skip to get to the extension contents.
if (atom_data_size < kDesiredBytes_mp4a) {
DLOG(WARNING) << base::StringPrintf("bad size %"PRId64" on mp4a",
atom_data_size);
return false;
}
uint16 mp4a_version = LB::Platform::load_uint16_big_endian(mp4a);
switch (mp4a_version) {
case 0:
atom_offset_ += kTotalSize_mp4a_v0;
return true;
case 1:
atom_offset_ += kTotalSize_mp4a_v1;
return true;
case 2:
atom_offset_ += kTotalSize_mp4a_v2;
return true;
default:
// unknown mp4a atom version, parse failure
DLOG(ERROR) << base::StringPrintf(
"parsed bad mp4a version %d", mp4a_version);
return false;
}
}
// partial layout of mvhd header is:
// offset | name | size in bytes
// -------+-------------------+---------------
// 0 | version | 1 (ignored)
// 1 | flags | 3 (ignored)
// 4 | creation time | 4 (ignored)
// 8 | modification time | 4 (ignored)
// 12 | time scale | 4
// 16 | duration: | 4
//
bool ShellMP4Parser::ParseMP4_mvhd(uint64 atom_data_size, uint8* mvhd) {
DCHECK_LE(kDesiredBytes_mvhd + 16, kAtomDownload);
// it should be at least long enough for us to extract the parts we want
if (atom_data_size < kDesiredBytes_mvhd) {
DLOG(WARNING) << base::StringPrintf("bad size %"PRId64" on mvhd",
atom_data_size);
return false;
}
uint32 time_scale_hz = LB::Platform::load_uint32_big_endian(mvhd + 12);
if (!time_scale_hz) {
DLOG(WARNING) << "got 0 time scale for mvhd";
return false;
}
// duration is in units of the time scale we just extracted
uint64 duration_ticks = LB::Platform::load_uint32_big_endian(mvhd + 16);
// calculate actual duration from that and the time scale
duration_ = TicksToTime(duration_ticks, time_scale_hz);
// advance read position
atom_offset_ += atom_data_size;
return true;
}
base::TimeDelta ShellMP4Parser::TicksToTime(uint64 ticks,
uint32 time_scale_hz) {
DCHECK(time_scale_hz);
return base::TimeDelta::FromMicroseconds((ticks * 1000000ULL) /
time_scale_hz);
}
uint64 ShellMP4Parser::TimeToTicks(base::TimeDelta time,
uint32 time_scale_hz) {
DCHECK(time_scale_hz);
return (time.InMicroseconds() * time_scale_hz) / 1000000ULL;
}
} // namespace media
| [
"[email protected]"
] | |
5e520b4ebc1aed5403ea5e96b1a595bc085f3c8e | 0611b1cc08b15d329057595365359947c20fcd59 | /algorithm/网络流/12.cpp | 368df89674d75fc913cdd2fc1469eee5d07513f1 | [] | no_license | Lan-ce-lot/overflow | c9a7167edaeeaa1f9f1e92624726b1d964289798 | ae76120e328a5a2991eb6ef7f1ae5e279374e15c | refs/heads/master | 2023-04-08T04:24:49.614146 | 2021-04-25T05:33:06 | 2021-04-25T05:33:06 | 279,082,035 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,148 | cpp | #include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn = 5e4 + 5;
const int INF = 0x3f3f3f3f;
int tot = 1, flag[2510][2510];
int n, m, s, t, u, v;
ll ans, w;
struct Edge {
int from, to;
ll cap, flow;
Edge(int u, int v, ll c, ll f) : from(u), to(v), cap(c), flow(f) {}
};
struct EdmondsKarp {
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
ll a[maxn]; // dis
int p[maxn];
void init(int n) {
for (int i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, int cap) {
edges.push_back(Edge(from, to, cap, 0));
edges.push_back(Edge(to, from, cap, 0));
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
ll Maxflow(int s, int t) {
ll flow = 0;
for (;;) {
memset(a, 0, sizeof a);
queue<int> Q;
Q.push(s);
a[s] = INF;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < G[x].size(); i++) {
Edge& e = edges[G[x][i]];
if (!a[e.to] && e.cap > e.flow) {
p[e.to] = G[x][i];
a[e.to] = min(a[x] * 1ll, e.cap - e.flow);
Q.push(e.to);
}
}
if (a[t]) break;
}
if (!a[t]) break;
for (int u = t; u != s; u = edges[p[u]].from) {
edges[p[u]].flow += a[t];
edges[p[u] ^ 1].flow -= a[t];
}
flow += a[t];
}
return flow;
}
};
signed main() {
// cout << 1 << endl;
scanf("%d%d%d%d", &n, &m, &s, &t);
EdmondsKarp E;
E.n = n;
E.m = m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
if (flag[u][v] == 0) {
E.AddEdge(u, v, w);
flag[u][v] = tot;
} else {
E.edges[flag[u][v] - 1].flow += w;
}
}
ans = E.Maxflow(s, t);
printf("%lld", ans);
return 0;
}
| [
"[email protected]"
] | |
fb59b6c6d870cfbd11adcbcb0c81aba254ba5633 | e9c4865fc9faf8f64b03aedd7a15fc4563e1148a | /Getline.h | ca736e7e70321ad6818b1e50aa08d8037f096f5d | [
"MIT"
] | permissive | nifty-site-manager/nsm | 937fa23d06997928ce4a642731206a1565f8252f | 9497b4f3088a5cfae770b24c220ac4a5cc1e2fc0 | refs/heads/master | 2023-07-09T04:00:35.802486 | 2023-07-08T18:17:44 | 2023-07-08T18:17:44 | 33,808,116 | 265 | 23 | MIT | 2022-09-23T07:21:14 | 2015-04-12T07:50:36 | C | UTF-8 | C++ | false | false | 1,105 | h | #ifndef GETLINE_H_
#define GETLINE_H_
#include <vector>
#include "ConsoleColor.h"
#include "Consts.h"
#include "FileSystem.h"
#include "Lolcat.h"
#include "StrFns.h"
void save_session(const std::string& path);
void write_prompt(const std::string& lang, const std::string& pwd, const std::string& promptCh);
void write_info(const std::string& info,
const std::string& pwd,
const std::string& promptCh,
const std::string& str,
size_t& sPos,
const size_t& usableLength,
const size_t& linePos,
const size_t& bLinePos);
#if defined _WIN32 || defined _WIN64
#include <conio.h>
#else //*nix
#endif
int nsm_getch();
int rnbwcout(const std::string& str);
int rnbwcout(const std::set<std::string>& strs, const std::string& lolcatCmd);
int getline(const std::string& lang,
const bool& addPwd,
const std::string& promptCh,
const int& lolcatActive,
std::string& str,
bool trackLines,
const std::vector<std::string>& tabCompletionStrs);
#endif //GETLINE_H_
| [
"[email protected]"
] | |
a594381b19e07bee9224de99304869a0cada6c0b | 3ee1cb7fb7440bb75fd38e57c9d83fbcfcea98e7 | /Lesson/Comprehensive Experiment/Hummer-bot/Hummer-bot.ino | 45304f28566653a2eb5da63908f3241f94b85d5b | [] | no_license | keywish/keywish-hummer-bot | aa06188373468bf12b06a7d7dee77b6e76bc2fa5 | 98e8e9dd5520d750e162e8be9f5fa2b054fdcbcd | refs/heads/master | 2021-06-04T03:27:49.534676 | 2020-05-07T03:31:43 | 2020-05-07T03:31:43 | 113,452,872 | 4 | 7 | null | 2021-10-05T03:02:01 | 2017-12-07T13:16:06 | C++ | UTF-8 | C++ | false | false | 11,297 | ino | #include "Hummerbot.h"
#include "ProtocolParser.h"
#include "KeyMap.h"
#include "debug.h"
#define INPUT1_PIN 6 // PWMB
#define INPUT2_PIN 10 // DIRB --- right
#define INPUT4_PIN 9 // PWMA
#define INPUT3_PIN 5 // DIRA --- left
#define IR_PIN 12
#define SERVO_PIN 13
#define ECHO_PIN 3
#define TRIG_PIN 2
#define PS2X_CLK 11
#define PS2X_CMD 7
#define PS2X_CS 8
#define PS2X_DAT 4
#define INFRARED_TRACING_PIN1 A0
#define INFRARED_TRACING_PIN2 A1
#define INFRARED_TRACING_PIN3 A2
#define INFRARED_AVOIDANCE_LEFT_PIN A3
#define INFRARED_AVOIDANCE_RIGHT_PIN A4
ProtocolParser *mProtocol = new ProtocolParser();
Hummerbot hbot(mProtocol, INPUT1_PIN, INPUT2_PIN, INPUT3_PIN, INPUT4_PIN);
byte Ps2xStatus, Ps2xType;
void setup()
{
Serial.begin(9600);
hbot.init();
hbot.SetControlMode(E_BLUETOOTH_CONTROL);
hbot.SetIrPin(HB_IR_PIN);
hbot.SetInfraredAvoidancePin(HB_INFRARED_AVOIDANCE_LEFT_PIN, HB_INFRARED_AVOIDANCE_RIGHT_PIN);
hbot.SetUltrasonicPin(HB_TRIGPIN, HB_ECHOPIN, HB_SERVOPIN);
hbot.SetInfraredTracingPin(HB_INFRARED_TRACING_PIN1, HB_INFRARED_TRACING_PIN2, HB_INFRARED_TRACING_PIN3);
hbot.SetPs2xPin(HB_PS2X_CLK, HB_PS2X_CMD, HB_PS2X_ATT, HB_PS2X_DAT);
hbot.SetSpeed(0);
Ps2xType = hbot.mPs2x->readType();
hbot.mUltrasonic->SetServoBaseDegree(70);
hbot.mUltrasonic->SetServoDegree(90);
}
//=========================== Ultrasonic_Infrared =====
void HandleUltrasonicInfraredAvoidance(void)
{
uint16_t RightValue, LeftValue;
uint16_t UlFrontDistance, UlLeftDistance, UlRightDistance;
RightValue = hbot.mInfraredAvoidance->GetInfraredAvoidanceRightValue();
LeftValue = hbot.mInfraredAvoidance->GetInfraredAvoidanceLeftValue();
UlFrontDistance = hbot.mUltrasonic->GetUltrasonicFrontDistance();
DEBUG_LOG(DEBUG_LEVEL_INFO, "UlFrontDistance =%d \n", UlFrontDistance);
if ((RightValue >= IA_THRESHOLD) && (LeftValue <= IA_THRESHOLD)) {
hbot.SetSpeed(80);
hbot.Drive(10 );
} else if ((RightValue < IA_THRESHOLD) && (LeftValue > IA_THRESHOLD)) {
hbot.SetSpeed(80);
hbot.Drive(170);
} else {
hbot.SetSpeed(50);
hbot.GoForward();
}
DEBUG_LOG(DEBUG_LEVEL_INFO, "UlFrontDistance = %d \n\r", UlFrontDistance);
if (UlFrontDistance < UL_LIMIT_MID) {
hbot.KeepStop();
if (UlFrontDistance <= UL_LIMIT_MIN || RightValue <= IA_THRESHOLD || LeftValue <= IA_THRESHOLD) {
hbot.SetSpeed(60);
hbot.GoBack();
delay(300);
hbot.KeepStop();
}
UlRightDistance = hbot.mUltrasonic->GetUltrasonicRightDistance();
UlLeftDistance = hbot.mUltrasonic->GetUltrasonicLeftDistance();
if (UlRightDistance >= UlLeftDistance) {
hbot.SetSpeed(100);
hbot.TurnRight();
delay(310);
}
if (UlLeftDistance > UlRightDistance) {
hbot.SetSpeed(100);
hbot.TurnLeft();
delay(310);
}
if (UlLeftDistance <= UL_LIMIT_MIN && UlRightDistance <= UL_LIMIT_MIN ) {
hbot.SetSpeed(100);
hbot.Drive(0);
delay(530);
hbot.KeepStop();
}
hbot.KeepStop();
}
}
void HandleUltrasonicAvoidance(void)
{
uint16_t UlFrontDistance, UlLeftDistance, UlRightDistance;
UlFrontDistance = hbot.mUltrasonic->GetUltrasonicFrontDistance();
DEBUG_LOG(DEBUG_LEVEL_INFO, "UlFrontDistance =%d \n", UlFrontDistance);
if ((UlFrontDistance < UL_LIMIT_MIN))
{
hbot.SetSpeed(100);
hbot.GoBack();
delay(250);
}
if (UlFrontDistance < UL_LIMIT_MID)
{
hbot.KeepStop();
delay(100);
UlRightDistance = hbot.mUltrasonic->GetUltrasonicRightDistance();
UlLeftDistance = hbot.mUltrasonic->GetUltrasonicLeftDistance();
if ((UlRightDistance > UL_LIMIT_MIN) && (UlRightDistance < UL_LIMIT_MAX))
{
hbot.SetSpeed(80);
hbot.TurnRight();
delay(310);
}
else if ((UlLeftDistance > UL_LIMIT_MIN) && (UlLeftDistance < UL_LIMIT_MAX))
{
hbot.SetSpeed(80);
hbot.TurnLeft();
delay(310);
}
else if ((UlRightDistance < UL_LIMIT_MIN) && (UlLeftDistance < UL_LIMIT_MIN) )
{
hbot.SetSpeed(80);
hbot.Drive(0);
delay(510);
}
} else {
hbot.SetSpeed(80);
hbot.GoForward();
}
}
//=============================Infrared tracking
void HandleInfraredTracing(void)
{
static byte old;
switch (hbot.mInfraredTracing->getValue()) {
case IT_ALL_BLACK:
hbot.KeepStop();
break;
case IT_ALL_WHITE:
if (old == IT_RIGHT1) {
while (hbot.mInfraredTracing->getValue() == IT_ALL_WHITE) {
hbot.SetSpeed(70);
hbot.Drive(174);
}
old = 0;
break;
} if (old == IT_LEFT1) {
while (hbot.mInfraredTracing->getValue() == IT_ALL_WHITE) {
hbot.SetSpeed(70);
hbot.Drive(6);
}
old = 0;
break;
} if (old == IT_RIGHT2) {
while (hbot.mInfraredTracing->getValue() == IT_ALL_WHITE) {
hbot.SetSpeed(70);
hbot.Drive(150);
}
old = 0;
break;
} if (old == IT_LEFT2) {
while (hbot.mInfraredTracing->getValue() == IT_ALL_WHITE) {
hbot.SetSpeed(70);
hbot.Drive(30);
}
old = 0;
break;
}
hbot.KeepStop();
break;
case IT_CENTER:
hbot.SetSpeed(45);
hbot.GoForward();
break;
case IT_RIGHT1:
hbot.SetSpeed(70);
hbot.Drive(174);
old = IT_RIGHT1;
break;
case IT_RIGHT2:
hbot.SetSpeed(70);
hbot.Drive(150);
old = IT_RIGHT2;
break;
case IT_LEFT1:
hbot.SetSpeed(70);
hbot.Drive(6);
old = IT_LEFT1;
break;
case IT_LEFT2:
hbot.SetSpeed(70);
hbot.Drive(30);
old = IT_LEFT2;
break;
}
}
//========================= bluetooth
void HandleBluetoothRemote(void)
{
if (mProtocol->ParserPackage())
{
switch (mProtocol->GetRobotControlFun())
{
case E_INFO:
break;
case E_ROBOT_CONTROL_DIRECTION:
hbot.Drive(mProtocol->GetRobotDegree());
break;
case E_ROBOT_CONTROL_SPEED:
hbot.SetSpeed(mProtocol->GetRobotSpeed());
break ;
case E_CONTROL_MODE:
hbot.SetControlMode(mProtocol->GetControlMode());
break;
case E_VERSION:
break;
}
}
}
void HandleInfaredRemote(byte irKeyCode)
{
switch ((E_IR_KEYCODE)hbot.mIrRecv->getIrKey(irKeyCode)) {
case IR_KEYCODE_STAR:
hbot.SpeedUp(10);
DEBUG_LOG(DEBUG_LEVEL_INFO, "hbot.Speed = %d \n", hbot.Speed);
break;
case IR_KEYCODE_POUND:
DEBUG_LOG(DEBUG_LEVEL_INFO, " start Degree = %d \n", hbot.Degree);
hbot.SpeedDown(10);
break;
case IR_KEYCODE_UP:
hbot.GoForward();
break;
case IR_KEYCODE_DOWN:
hbot.GoBack();
break;
case IR_KEYCODE_OK:
hbot.KeepStop();
break;
case IR_KEYCODE_LEFT:
hbot.TurnLeft();
break;
case IR_KEYCODE_RIGHT:
hbot.TurnRight();
break;
default:
break;
}
}
//====================================InfraredAvoidance
void HandleInfraredAvoidance()
{
uint16_t RightValue, LeftValue;
RightValue = hbot.mInfraredAvoidance->GetInfraredAvoidanceRightValue();
LeftValue = hbot.mInfraredAvoidance->GetInfraredAvoidanceLeftValue();
if ((RightValue > IA_THRESHOLD) && (LeftValue > IA_THRESHOLD))
{
hbot.SetSpeed(80);
hbot.GoForward();
}
else if ((RightValue > IA_THRESHOLD) && (LeftValue < IA_THRESHOLD))
{
hbot.SetSpeed(70);
hbot.TurnRight();
delay(200);
}
else if ((RightValue < IA_THRESHOLD) && (LeftValue > IA_THRESHOLD))
{
hbot.SetSpeed(70);
hbot.TurnLeft();
delay(200);
}
else if ((RightValue < IA_THRESHOLD) && (LeftValue < IA_THRESHOLD))
{
hbot.SetSpeed(80);
hbot.Drive(0);
delay(200);
}
}
void HandlePS2()
{
static int vibrate = 0;
byte PSS_X = 0, PSS_Y = 0;
hbot.mPs2x->read_gamepad(false, vibrate); // read controller and set large motor to spin at 'vibrate' speed
if (hbot.mPs2x->ButtonDataByte()) {
if (hbot.mPs2x->Button(PSB_PAD_UP)) { //will be TRUE as long as button is pressed
hbot.GoForward();
}
if (hbot.mPs2x->Button(PSB_PAD_RIGHT)) {
hbot.Drive(20);
}
if (hbot.mPs2x->Button(PSB_PAD_LEFT)) {
hbot.Drive(160);
}
if (hbot.mPs2x->Button(PSB_PAD_DOWN)) {
hbot.GoBack();
}
vibrate = hbot.mPs2x->Analog(PSAB_CROSS); //this will set the large motor vibrate speed based on how hard you press the blue (X) button
if (hbot.mPs2x->Button(PSB_CROSS)) { //will be TRUE if button was JUST pressed OR released
hbot.SpeedDown(5);
}
if (hbot.mPs2x->Button(PSB_TRIANGLE)) {
hbot.SpeedUp(5);
}
if (hbot.mPs2x->Button(PSB_SQUARE)) {
hbot.TurnLeft();
}
if (hbot.mPs2x->Button(PSB_CIRCLE)) {
hbot.TurnRight();
}
} else {
uint16_t RightValue = hbot.mPs2x->RightHart();
uint16_t LeftValue = hbot.mPs2x->LeftHart();
if ((RightValue > 360) && (LeftValue > 360))
{
hbot.KeepStop();
} else if (RightValue <= 360) {
if ((RightValue < 90) || (RightValue > 270 )) {
hbot.Drive(20);
} else if ((RightValue >= 90) && (RightValue < 270 )) {
hbot.Drive(160);
}
} else if (LeftValue <= 360) {
if ((LeftValue > 0) && (LeftValue < 180 )) {
hbot.GoForward();
} else if ((LeftValue >= 180) && (LeftValue < 360 )) {
hbot.GoBack();
}
}
}
delay(50);
}
void loop()
{
mProtocol->RecevData();
if (hbot.GetControlMode() != E_BLUETOOTH_CONTROL) {
if (mProtocol->ParserPackage()) {
if (mProtocol->GetRobotControlFun() == E_CONTROL_MODE) {
hbot.SetControlMode(mProtocol->GetControlMode());
}
}
}
switch (hbot.GetControlMode())
{
case E_BLUETOOTH_CONTROL:
HandleBluetoothRemote();
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_BLUETOOTH_CONTROL \n");
break;
case E_INFRARED_REMOTE_CONTROL:
byte irKeyCode;
if (irKeyCode = hbot.mIrRecv->getCode()) {
DEBUG_LOG(DEBUG_LEVEL_INFO, "irKeyCode = %lx \n", irKeyCode);
HandleInfaredRemote(irKeyCode);
delay(110);
}
else {
if (hbot.GetStatus() != E_STOP ) {
hbot.KeepStop();
}
}
break;
case E_INFRARED_TRACKING_MODE:
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_INFRARED_TRACKING \n");
HandleInfraredTracing();
hbot.SendTracingSignal();
break;
case E_INFRARED_AVOIDANCE:
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_INFRARED_AVOIDANCE \n");
HandleInfraredAvoidance();
break;
case E_ULTRASONIC_AVOIDANCE:
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_ULTRASONIC_AVOIDANCE \n");
HandleUltrasonicAvoidance();
break;
case E_ULTRASONIC_INFRARED_AVOIDANCE:
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_ULTRASONIC_INFRARED_AVOIDANCE \n");
HandleUltrasonicInfraredAvoidance();
hbot.SendInfraredData();
hbot.SendUltrasonicData();
break;
case E_PS2_REMOTE_CONTROL:
while (Ps2xStatus != 0) { //skip loop if no controller found
delay(500);
Ps2xStatus = hbot.ResetPs2xPin();
Ps2xType = hbot.mPs2x->readType();
DEBUG_LOG(DEBUG_LEVEL_INFO, "E_PS2_REMOTE_CONTROL \n");
}
if (Ps2xType != 2) {
HandlePS2();
}
break;
default:
break;
}
}
| [
"[email protected]"
] | |
668e04118fc5a7d7e78eea690c8678dca33ec924 | 4e5428c32f4f08fb9dad1b6612d5b59b0bef8385 | /PressFEditor/PressFEditor/Components/CameraController.cpp | 20f18a7e638b4fb0bd610392b0cb92df958593e7 | [] | no_license | adrianjmejias/Press-F | 94dd035c91e22261002d79002cf73d3ada51788d | abfde7c45d0b984100381d1d303810d314ef1dbc | refs/heads/master | 2022-12-17T04:23:50.842756 | 2020-03-28T23:05:20 | 2020-03-28T23:05:20 | 296,039,518 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 492 | cpp | #include "CameraController.h"
void CameraController::Update(const ImGuiIO& io)
{
//float scrollAmmount = io.MouseWheel;
//std::cout << "Rotation \t" << transform->GetRotation() << "|";
//std::cout << "Position \t" << transform->GetPosition();
//std::cout << std::endl;
}
void CameraController::OnEnable()
{
}
void CameraController::OnDisable()
{
}
void CameraController::Start()
{
}
json CameraController::Serialize()
{
return json();
}
void CameraController::ImGui()
{
}
| [
"[email protected]"
] | |
0219b27b7ced41bc4ef609e5ef4807f40ea4f9ac | 3039194199bedf2373989aba10a8fb9e81a696be | /Src/BlueLightSPS/Blue/ControlPanel.cpp | 73b5ea54aaba1ad645f5287c5e400691732680bd | [] | no_license | Patrick-Wang/BlueRay | c85f3f24cf8a5bae7b08e81098d367973ca68365 | 6d25157eb292c59210b3520937e8fed1597f4479 | refs/heads/master | 2021-01-19T01:56:57.008275 | 2017-06-05T01:55:21 | 2017-06-05T01:55:21 | 25,848,961 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,544 | cpp | #include "stdafx.h"
#include "ControlPanel.h"
#define TM_UI 50112
IMPLEMENT_DYNAMIC(CControlPanel, CBSObject)
CControlPanel::~CControlPanel()
{
}
BEGIN_MESSAGE_MAP(CControlPanel, CBSObject)
ON_WM_CREATE()
ON_WM_TIMER()
ON_WM_SHOWWINDOW()
END_MESSAGE_MAP()
int CControlPanel::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
//lpCreateStruct->dwExStyle |= WS_CLIPCHILDREN;
if (CBSObject::OnCreate(lpCreateStruct) == -1)
return -1;
OnInitChilds();
ShowWindow(SW_HIDE);
return 0;
}
BOOL CControlPanel::Create(CWnd* pParentWnd, UINT nID)
{
return CBSObject::Create(NULL, NULL,WS_CHILDWINDOW, CRect(0, 0, 0, 0), pParentWnd, nID, NULL);
}
void CControlPanel::OnTimer(UINT_PTR nIDEvent)
{
if (TM_UI == nIDEvent)
{
KillTimer(TM_UI);
OnUIPrepared();// SendMessage(UM_UI_PREPARED);
}
CBSObject::OnTimer(nIDEvent);
}
void CControlPanel::OnShowWindow(BOOL bShow, UINT nStatus)
{
CBSObject::OnShowWindow(bShow, nStatus);
if (bShow)
{
SetTimer(TM_UI, 0, NULL);
}
}
void CControlPanel::ShowChild(CWnd* pChild)
{
if (pChild != NULL)
{
pChild->ShowWindow(SW_SHOW);
CRect rt;
pChild->GetClientRect(rt);
pChild->ClientToScreen(rt);
GetParent()->ScreenToClient(rt);
GetParent()->InvalidateRect(rt);
}
}
void CControlPanel::HideChild(CWnd* pChild)
{
if (NULL != pChild)
{
pChild->ShowWindow(SW_HIDE);
CRect rt;
pChild->GetClientRect(rt);
pChild->ClientToScreen(rt);
GetParent()->ScreenToClient(rt);
rt.left -= 2;
rt.top -= 2;
rt.right += 2;
rt.bottom += 2;
GetParent()->InvalidateRect(rt);
}
}
| [
"[email protected]"
] | |
e2bd48520c6c26e1dbb95aaaf1aeb579809b8297 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/CMake/CMake-gumtree/Kitware_CMake_old_new_old_log_916.cpp | 08cec555e1b91069cd14028c1e3dd6c00604ea15 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 96 | cpp | archive_set_error(&a->archive, errno,
"%ls: Cannot stat",
tree_current_path(t)); | [
"[email protected]"
] | |
bab6c8941b384aef79ac51ff2e9b2261120ff264 | 72d9009d19e92b721d5cc0e8f8045e1145921130 | /CARBayesST/inst/testfiles/Zupdatesqbin/Zupdatesqbin_DeepState_TestHarness.cpp | 0fa0db455e47120541e006606988cdf54cb1d609 | [] | no_license | akhikolla/TestedPackages-NoIssues | be46c49c0836b3f0cf60e247087089868adf7a62 | eb8d498cc132def615c090941bc172e17fdce267 | refs/heads/master | 2023-03-01T09:10:17.227119 | 2021-01-25T19:44:44 | 2021-01-25T19:44:44 | 332,027,727 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,145 | cpp | // AUTOMATICALLY GENERATED BY RCPPDEEPSTATE PLEASE DO NOT EDIT BY HAND, INSTEAD EDIT
// Zupdatesqbin_DeepState_TestHarness_generation.cpp and Zupdatesqbin_DeepState_TestHarness_checks.cpp
#include <fstream>
#include <RInside.h>
#include <iostream>
#include <RcppDeepState.h>
#include <qs.h>
#include <DeepState.hpp>
NumericMatrix Zupdatesqbin(NumericMatrix Z, NumericMatrix Offset, NumericMatrix Y, const double delta, NumericVector lambda, const int nsites, const int ntime, const int G, NumericVector SS, NumericVector prioroffset, const double Gstar, NumericMatrix failures);
TEST(CARBayesST_deepstate_test,Zupdatesqbin_test){
RInside R;
std::cout << "input starts" << std::endl;
NumericMatrix Z = RcppDeepState_NumericMatrix();
qs::c_qsave(Z,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/Z.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "Z values: "<< Z << std::endl;
NumericMatrix Offset = RcppDeepState_NumericMatrix();
qs::c_qsave(Offset,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/Offset.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "Offset values: "<< Offset << std::endl;
NumericMatrix Y = RcppDeepState_NumericMatrix();
qs::c_qsave(Y,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/Y.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "Y values: "<< Y << std::endl;
NumericVector delta(1);
delta[0] = RcppDeepState_double();
qs::c_qsave(delta,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/delta.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "delta values: "<< delta << std::endl;
NumericVector lambda = RcppDeepState_NumericVector();
qs::c_qsave(lambda,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/lambda.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "lambda values: "<< lambda << std::endl;
IntegerVector nsites(1);
nsites[0] = RcppDeepState_int();
qs::c_qsave(nsites,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/nsites.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "nsites values: "<< nsites << std::endl;
IntegerVector ntime(1);
ntime[0] = RcppDeepState_int();
qs::c_qsave(ntime,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/ntime.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "ntime values: "<< ntime << std::endl;
IntegerVector G(1);
G[0] = RcppDeepState_int();
qs::c_qsave(G,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/G.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "G values: "<< G << std::endl;
NumericVector SS = RcppDeepState_NumericVector();
qs::c_qsave(SS,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/SS.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "SS values: "<< SS << std::endl;
NumericVector prioroffset = RcppDeepState_NumericVector();
qs::c_qsave(prioroffset,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/prioroffset.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "prioroffset values: "<< prioroffset << std::endl;
NumericVector Gstar(1);
Gstar[0] = RcppDeepState_double();
qs::c_qsave(Gstar,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/Gstar.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "Gstar values: "<< Gstar << std::endl;
NumericMatrix failures = RcppDeepState_NumericMatrix();
qs::c_qsave(failures,"/home/akhila/fuzzer_packages/fuzzedpackages/CARBayesST/inst/testfiles/Zupdatesqbin/inputs/failures.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "failures values: "<< failures << std::endl;
std::cout << "input ends" << std::endl;
try{
Zupdatesqbin(Z,Offset,Y,delta[0],lambda,nsites[0],ntime[0],G[0],SS,prioroffset,Gstar[0],failures);
}
catch(Rcpp::exception& e){
std::cout<<"Exception Handled"<<std::endl;
}
}
| [
"[email protected]"
] | |
b4b32d436cc22d538f6ef5d3f2b979a0bf2302a1 | d9bce2f96c9c3920e70a7d2c0215563991995eb5 | /thirdparty/imgui/imgui_extra_widgets.h | f1209437e349bfd3b9abac9f41a2ec4bbb29e65e | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
] | permissive | brucelevis/GTF | 05bfc8b6087593b0b78c32c27472b5bb9e46ec03 | 6746bed6bc742d513f244ac9949ff09b6aeaa0c6 | refs/heads/master | 2020-02-26T13:37:38.033899 | 2016-08-02T21:09:38 | 2016-08-02T21:09:38 | 67,216,859 | 1 | 0 | null | 2016-09-02T11:23:50 | 2016-09-02T11:23:49 | null | UTF-8 | C++ | false | false | 297 | h | //
// imgui_extra_widgets.h
// MeshPainter
//
// Created by David Gallardo on 20/02/16.
// Copyright (c) 2016 David Gallardo. All rights reserved.
//
#pragma once
#include "imgui.h"
namespace ImGui
{
bool ColorPicker4(float* col, bool show_alpha);
bool ColorPicker3(float* col);
}; | [
"[email protected]"
] | |
affe1af0928b3b08afaa3859f47d445fbb873391 | b0bde7a6b0d149d1d889b6ffeb7a763c4af1a9c7 | /src/GH_Model/GH_VVI.hpp | b72a146aed1fba7c327abd1a38647874dd70b6f6 | [] | no_license | cran/mixture | 6c8f2fa297ce5366626d6c601f072f9859c87342 | e95af1c429ec54d994567aa1288955a4aeb42344 | refs/heads/master | 2022-10-06T01:06:09.905099 | 2022-09-23T20:20:02 | 2022-09-23T20:20:02 | 17,697,556 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,119 | hpp |
#include "GH_Mixture_Model.h"
#pragma once
class GH_VVI: public GH_Mixture_Model
{
public:
using GH_Mixture_Model::GH_Mixture_Model;
void m_step_sigs(void)
{
// intialize Bk_s and denoms
std::vector<arma::mat> Bk_s;
std::vector<double> denoms;
Bk_s.assign(G,arma::mat(p,p,arma::fill::eye));
denoms.assign(G,0.0);
double lambda = 0;
// loop through and only compute the BK_s and and assign denominators
for(int g = 0; g < G; g++)
{
arma::mat D_g = arma::diagmat(Ws[g])*n_gs[g];
double power = (double)(1.0/p);
denoms[g] = pow(arma::det(D_g),power);
Bk_s[g] = D_g/denoms[g];
lambda += denoms[g];
}
lambda = (double)(lambda)/n;
// assign new Sig
for(int g = 0; g < G; g++)
{
arma::mat S = lambda*Bk_s[g];
sigs[g] = S;
inv_sigs[g] = arma::solve(S,EYE,arma::solve_opts::refine);
log_dets[g] = p*std::log(lambda);
}
}
};
| [
"[email protected]"
] | |
df01890431e317df66f3ac08b20fdbab1912a41c | 97431c426d9c48c1549a0dc17fbaae5b59a3cde3 | /Lista 5/zad3/edge.hpp | e20645ab79ea22864484fbb13d8e3b732720b7c0 | [] | no_license | janpawlowskiof/aisd | 93aac43825b64feb70dd01ea533c960774ff885f | bfd1114b266dab16e3a116e8985819016b69b438 | refs/heads/master | 2021-10-22T08:17:22.226123 | 2019-03-09T09:57:49 | 2019-03-09T09:57:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 335 | hpp | #pragma once
struct edge {
unsigned int u;
unsigned int v;
double weight;
edge(unsigned int u, unsigned int v, double weight) {
this->u = u;
this->v = v;
this->weight = weight;
}
};
struct {
bool operator() (edge e1, edge e2) {
return e1.weight < e2.weight;
}
} edge_comp; | [
"[email protected]"
] | |
fd35caf1d6c07c5ec8a56fb16c448a5725e2da23 | 8483830175b98ba2915d7bf90bed728bb6a4ed75 | /Examples/include/asposecpplib/system/globalization/compare_info.h | 5129e71d4aa646f1025f1ed3bcce8fdeb5049af2 | [
"MIT"
] | permissive | kashifiqb/Aspose.PDF-for-C | 83393e3173e2d74540f7ec7904eb91fb23b13550 | 13d49bba591c5704685820185741e64a462a5bdc | refs/heads/master | 2020-08-08T11:15:23.173738 | 2019-10-09T04:41:03 | 2019-10-09T04:41:03 | 213,819,800 | 0 | 0 | MIT | 2019-10-09T04:20:06 | 2019-10-09T04:20:06 | null | UTF-8 | C++ | false | false | 19,603 | h | /// @file system/globalization/compare_info.h
#pragma once
#include <system/globalization/compare_options.h>
#include <system/globalization/sort_key.h>
#include <system/globalization/sort_version.h>
#include <system/globalization/details/culture_data_ptr.h>
#include <system/reflection/assembly.h>
#include <system/details/lazy.h>
namespace System { namespace Globalization {
class CompareInfo;
/// CompareInfo pointer type.
typedef SharedPtr<CompareInfo> CompareInfoPtr;
/// Makes culture-sensitive string comparison.
/// Objects of this class should only be allocated using System::MakeObject() function.
/// Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults.
/// Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument.
class ASPOSECPP_SHARED_CLASS CompareInfo
: public virtual Object
//, public IDeserializationCallback
{
/// RTTI information.
RTTI_INFO(System::Globalization::CompareInfo, ::System::BaseTypesInfo<System::Object>)
public:
CompareInfo(const CompareInfo&) = delete;
CompareInfo& operator=(const CompareInfo&) = delete;
/// Gets name of the culture associated with comparer.
virtual ASPOSECPP_SHARED_API String get_Name() const;
/// Gets LCID of the culture associated with comparer.
ASPOSECPP_SHARED_API int get_LCID() const;
/// Gets information about sort version.
ASPOSECPP_SHARED_API SortVersionPtr get_Version() const;
/// Gets CompareInfo associated with the specified culture and using string comparison methods in the specified assembly.
/// @param culture Culture identifier (LCID).
/// @param assembly Assembly that contains string comparison methods.
/// @return CompareInfo object.
static ASPOSECPP_SHARED_API CompareInfoPtr GetCompareInfo(int culture, const SharedPtr<Reflection::Assembly>& assembly);
/// Gets CompareInfo associated with the specified culture and using string comparison methods in the specified assembly.
/// @param name Culture name.
/// @param assembly Assembly that contains string comparison methods.
/// @return CompareInfo object.
static ASPOSECPP_SHARED_API CompareInfoPtr GetCompareInfo(const String& name, const SharedPtr<Reflection::Assembly>& assembly);
/// Gets CompareInfo associated with the specified culture.
/// @param culture Culture identifier (LCID).
/// @return CompareInfo object.
static ASPOSECPP_SHARED_API CompareInfoPtr GetCompareInfo(int culture);
/// Gets CompareInfo associated with the specified culture.
/// @param name Culture name.
/// @return CompareInfo object.
static ASPOSECPP_SHARED_API CompareInfoPtr GetCompareInfo(const String& name);
/// Checks whether a specified character is sortable.
/// @param ch Unicode character.
/// @return True if @p ch is sortable; otherwise false.
static ASPOSECPP_SHARED_API bool IsSortable(char16_t ch);
/// Checks whether a specified string is sortable.
/// @param text A string.
/// @return True if @p text is not empty and all characters in @p text are sortable; otherwise false.
static ASPOSECPP_SHARED_API bool IsSortable(const String& text);
/// Compares strings. Not implemented.
/// @param string1 LHS string.
/// @param string2 RHS string.
/// @return Negative value if LHS string preceeds RHS one, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& string1, const String& string2) const;
/// Compares strings. Only Ordinal and OrdinalIgnoreCase modes are supported.
/// @param a LHS string.
/// @param b RHS string.
/// @param options String comparison type.
/// @return Negative value if LHS string preceeds RHS one, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& a, const String& b, CompareOptions options) const;
/// Compares a section of one string with a section of second string. Not implemented.
/// @param string1 First string.
/// @param offset1 Start index of characters in @p string1.
/// @param length1 Number of characters in @p string1 to compare.
/// @param string2 Second string.
/// @param offset2 Start index of characters in @p string2.
/// @param length2 Number of characters in @p string2 to compare.
/// @return Negative value if first string section preceeds second string section, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& string1, int offset1, int length1, const String& string2, int offset2, int length2) const;
/// Compares the end section of one string with the end section of second string using string comparison methods. Not implemented.
/// @param string1 First string.
/// @param offset1 Start index of characters in @p string1.
/// @param string2 Second string.
/// @param offset2 Start index of characters in @p string2.
/// @param options String comparison options.
/// @return Negative value if first string section preceeds second string section, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& string1, int offset1, const String& string2, int offset2, CompareOptions options) const;
/// Compares the end section of one string with the end section of second string. Not implemented.
/// @param string1 First string.
/// @param offset1 Start index of characters in @p string1.
/// @param string2 Second string.
/// @param offset2 Start index of characters in @p string2.
/// @return Negative value if first string section preceeds second string section, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& string1, int offset1, const String& string2, int offset2) const;
/// Compares a section of one string with a section of second string using string comparison methods. Not implemented.
/// @param string1 First string.
/// @param offset1 Start index of characters in @p string1.
/// @param length1 Number of characters in @p string1 to compare.
/// @param string2 Second string.
/// @param offset2 Start index of characters in @p string2.
/// @param length2 Number of characters in @p string2 to compare.
/// @param options String comparison options.
/// @return Negative value if first string section preceeds second string section, zero if they match, positive value otherwise.
virtual ASPOSECPP_SHARED_API int Compare(const String& string1, int offset1, int length1, const String& string2, int offset2, int length2, CompareOptions options) const;
/// Gets SortKey object for the specified string using specified compare options.
/// @param value Input string.
/// @param options Compare options.
/// @return SortKey object.
virtual ASPOSECPP_SHARED_API SortKeyPtr GetSortKey(const String& value, CompareOptions options) const;
/// Gets SortKey object for the specified string.
/// @param value Input string.
/// @return SortKey object.
virtual ASPOSECPP_SHARED_API SortKeyPtr GetSortKey(const String& value) const;
/// Looks for substring.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value, int start_index, int count) const;
/// Looks for substring. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value, int start_index, CompareOptions options) const;
/// Looks for substring. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value, int start_index, int count, CompareOptions options) const;
/// Looks for the specified character. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Character.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value, int start_index, int count, CompareOptions options) const;
/// Looks for substring.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value, int start_index) const;
/// Looks for the specified character.
/// @param source Source string.
/// @param value Character.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value) const;
/// Looks for substring.
/// @param source Source string.
/// @param value Lookup value.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value) const;
/// Looks for the specified character. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Character.
/// @param start_index Lookup start index in source string.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value, int start_index, CompareOptions options) const;
/// Looks for the specified character.
/// @param source Source string.
/// @param value Character.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value, int start_index, int count) const;
/// Looks for the specified character.
/// @param source Source string.
/// @param value Character.
/// @param start_index Lookup start index in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value, int start_index) const;
/// Looks for substring. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Lookup value.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, const String& value, CompareOptions options) const;
/// Looks for the specified character. Only Ordinal mode is supported.
/// @param source Source string.
/// @param value Character.
/// @param options Lookup options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int IndexOf(const String& source, char16_t value, CompareOptions options) const;
/// Checks if the specified string starts with the specified prefix using the specified compare options.
/// @param source Source string.
/// @param prefix Prefix string.
/// @param options Compare options.
/// @return True if string starts with prefix; otherwise false.
virtual ASPOSECPP_SHARED_API bool IsPrefix(const String& source, const String& prefix, CompareOptions options) const;
/// Checks if the specified string starts with the specified prefix.
/// @param source Source string.
/// @param prefix Prefix string.
/// @return True if string starts with prefix; otherwise false.
virtual ASPOSECPP_SHARED_API bool IsPrefix(const String& source, const String& prefix) const;
/// Checks if the specified string ends with the specified suffix using the specified compare options.
/// @param source Source string.
/// @param suffix Suffix string.
/// @param options Compare options.
/// @return True if string ends with suffix; otherwise false.
virtual ASPOSECPP_SHARED_API bool IsSuffix(const String& source, const String& suffix, CompareOptions options) const;
/// Checks if the specified string ends with the specified suffix.
/// @param source Source string.
/// @param suffix Suffix string.
/// @return True if string ends with suffix; otherwise false.
virtual ASPOSECPP_SHARED_API bool IsSuffix(const String& source, const String& suffix) const;
/// Searches last occurrence of the specified substring.
/// @param source Source string.
/// @param value Lookup value.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value) const;
/// Searches last occurrence of the specified substring using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value, int start_index, int count, CompareOptions options) const;
/// Searches last occurrence of the specified character using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value, int start_index, int count, CompareOptions options) const;
/// Searches last occurrence of the specified string.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value, int start_index, int count) const;
/// Searches last occurrence of the specified string using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value, int start_index, CompareOptions options) const;
/// Searches last occurrence of the specified character using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value, int start_index, CompareOptions options) const;
/// Searches last occurrence of the specified string.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value, int start_index) const;
/// Searches last occurrence of the specified character.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value, int start_index) const;
/// Searches last occurrence of the specified string using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, const String& value, CompareOptions options) const;
/// Searches last occurrence of the specified character using the specified compare options.
/// @param source Source string.
/// @param value Lookup value.
/// @param options Compare options.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value, CompareOptions options) const;
/// Searches last occurrence of the specified character.
/// @param source Source string.
/// @param value Lookup value.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value) const;
/// Searches last occurrence of the specified character.
/// @param source Source string.
/// @param value Lookup value.
/// @param start_index Lookup start index in source string.
/// @param count Number of characters in source string.
/// @return Index of lookup value in source string or -1 if not found.
virtual ASPOSECPP_SHARED_API int LastIndexOf(const String& source, char16_t value, int start_index, int count) const;
/// Gets string hash code based on specified comparison options.
/// @param value Input string.
/// @param options String comparsion options.
/// @return Hash code.
virtual ASPOSECPP_SHARED_API int GetHashCode(const String& value, CompareOptions options) const;
// Object methods
ASPOSECPP_SHARED_API bool Equals(SharedPtr<Object> other) override;
ASPOSECPP_SHARED_API int GetHashCode() const override;
ASPOSECPP_SHARED_API String ToString() ASPOSE_CONST override;
private:
/// Enabling using constructors.
FRIEND_FUNCTION_System_MakeObject;
/// Constructor.
/// @param culture_data Culture to use.
CompareInfo(const Details::CultureDataPtr& culture_data);
/// Culture data.
const Details::CultureDataPtr m_culture_data;
/// Sort version.
mutable System::Details::Lazy<SortVersionPtr> m_sort_version;
};
}} // namespace System::Globalization
| [
"[email protected]"
] | |
4fc9bacc2c4c62d1729349887c57cebd116f22d0 | f26ac91ea049d25c4b716455899aa79fff89a991 | /CODES/USACO/2012/Febrero/Gold/coupons.cpp | dcf941b8bc90d0c97f8e1655496bb565fbfe829f | [] | no_license | Saborit/CODING | 3490f8eae1b2ed9b39932eaad5422ce649e26b4d | 07c1e345f846f8f2d70d977f73838ee82187b329 | refs/heads/master | 2020-12-27T20:31:50.622995 | 2020-02-19T21:10:27 | 2020-02-19T21:10:27 | 238,040,809 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,405 | cpp | /* Code by wizard98
*
* greedy
**/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define MX 100005
#define INF (1<<30)
#define EPS 1e-9
#define MOD 1000000007
#define mid (x+xend)/2
#define izq nod*2
#define der nod*2+1
#define fr first
#define sc second
#define pb emplace_back
using namespace std;
using namespace __gnu_pbds;
typedef long long int64;
typedef unsigned long long unt64;
struct cow{
bool is_coupon;
int64 p, id;
bool operator < (const cow &c)const{
return p == c.p ? is_coupon > c.is_coupon : p > c.p;
}
};
int64 N, K, M, sol, a, b;
bool mk[MX];
priority_queue<cow> Q;
int main(void){
//~ freopen("a.in", "r", stdin);
//~ freopen("a.out", "w", stdout);
scanf("%lld%lld%lld", &N, &K, &M);
for(int i=1; i<=N; i++){
scanf("%lld%lld", &a, &b);
Q.push({false, a, i});
Q.push({true, b, i});
}
while( !Q.empty() && M>=0ll ){
if( Q.top().is_coupon ){
if( M - Q.top().p >= 0ll && K > 0ll && !mk[Q.top().id] ){
K--;
mk[Q.top().id] = true;
sol++;
M -= Q.top().p;
}
Q.pop();
}
else{
if( M - Q.top().p >= 0ll && !mk[Q.top().id] ){
mk[Q.top().id] = true;
sol++;
M -= Q.top().p;
}
Q.pop();
}
}
printf("%lld\n", sol);
return 0;
}
| [
"[email protected]"
] | |
a2cd03d739414f83a7331b3e1e9fed34bf35c849 | 054e3a175197696763e7f29cbb596a5c1e19742b | /CharacterController.h | 76cf7ae11b0ae8e40bcc68a32294a59f9e840a4d | [
"MIT"
] | permissive | euiko/raylib-flappybird | 4555c957e60023aaa1ecd19e5c17c38a2c7755c0 | d0c9f4a10f763974469bd2e6ad9c1b39fddf5766 | refs/heads/master | 2020-03-26T05:17:56.821388 | 2018-08-13T08:25:27 | 2018-08-13T08:25:27 | 144,549,342 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 897 | h | //
// Created by euiko on 8/13/18.
//
#ifndef LEARN_01_CHARACTERCONTROLLER_H
#define LEARN_01_CHARACTERCONTROLLER_H
#include <raylib.h>
#include <iostream>
const int CHAR_STATE_UP = 1;
const int CHAR_STATE_MID = 0;
const int CHAR_STATE_DOWN = -1;
typedef struct Character {
Vector2 location;
float angle;
float speed;
Texture2D textureMid;
Texture2D textureUp;
Texture2D textureDown;
Rectangle rectangle;
int state;
} Character;
class CharacterController {
private:
Character mCharacter;
float mGraviationSpeed;
float mElapsedTime;
void rotate(float angle);
Vector2 gravitationModifier();
public:
CharacterController(Character character, float graviationSpeed);
~CharacterController();
Vector2 moveUp();
Vector2 drawCharacter();
Vector2 inputHandler();
void onUpdate();
};
#endif //LEARN_01_CHARACTERCONTROLLER_H
| [
"[email protected]"
] | |
1310ccba7eab2fa2c73fedd2a53642b0c097370f | 28c000caf6617ba2074e0f2a8fc936ccb8c01fb3 | /hdu/hdu1097.cpp | 9090738410c39dc5debbee423879be6ba89fcb24 | [] | no_license | ATM006/acm_problem_code | f597fa31033fd663b14d74ad94cae3f7c1629b99 | ac40d230cd450bcce60df801eb3b8ce9409dfaac | refs/heads/master | 2020-08-31T21:34:00.707529 | 2014-01-23T05:30:42 | 2014-01-23T05:30:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 563 | cpp | #include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
int n, m, arr[10];
void solve() {
vector<int> ans;
memset(arr, -1, sizeof(arr));
int count = 0, fic = 1;
do {
fic *= m;
fic %= 10;
if (arr[fic] == -1) {
ans.push_back(fic);
arr[fic] = 1;
} else {
printf("%d\n", ans[(n - 1) % ans.size()]);
break;
}
} while (++count < n);
if (ans.size() == n) {
printf("%d\n", ans[n - 1]);
}
}
int main() {
while (scanf("%d%d", &m, &n) != EOF) {
m %= 10;
solve();
}
return 0;
}
| [
"[email protected]"
] | |
cbff10b520af267e1fae53b8c661d8f1bbce0803 | e217eaf05d0dab8dd339032b6c58636841aa8815 | /IfcRoad/src/OpenInfraPlatform/IfcRoad/IfcRoadEntitiesMap.h | 4f2a895caed289963c4be22c06c8c1a38a6b4dcd | [] | no_license | bigdoods/OpenInfraPlatform | f7785ebe4cb46e24d7f636e1b4110679d78a4303 | 0266e86a9f25f2ea9ec837d8d340d31a58a83c8e | refs/heads/master | 2021-01-21T03:41:20.124443 | 2016-01-26T23:20:21 | 2016-01-26T23:20:21 | 57,377,206 | 0 | 1 | null | 2016-04-29T10:38:19 | 2016-04-29T10:38:19 | null | UTF-8 | C++ | false | false | 72,333 | h | /*! \verbatim
* \copyright Copyright (c) 2015 Julian Amann. All rights reserved.
* \author Julian Amann <[email protected]> (https://www.cms.bgu.tum.de/en/team/amann)
* \brief This file is part of the OpenInfraPlatform.
* \endverbatim
*/
#pragma once
#include <map>
#include "OpenInfraPlatform/IfcRoad/IfcRoadEntityEnums.h"
namespace OpenInfraPlatform
{
namespace IfcRoad
{
static const std::pair<std::string, IfcRoadEntityEnum> initializers_IfcRoad_entity[] = {
std::pair<std::string, IfcRoadEntityEnum>("IFCACTIONREQUEST", IFCACTIONREQUEST),
std::pair<std::string, IfcRoadEntityEnum>("IFCACTOR", IFCACTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCACTORROLE", IFCACTORROLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCACTUATOR", IFCACTUATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCACTUATORTYPE", IFCACTUATORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCADDRESS", IFCADDRESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCADVANCEDBREP", IFCADVANCEDBREP),
std::pair<std::string, IfcRoadEntityEnum>("IFCADVANCEDBREPWITHVOIDS", IFCADVANCEDBREPWITHVOIDS),
std::pair<std::string, IfcRoadEntityEnum>("IFCADVANCEDFACE", IFCADVANCEDFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTERMINAL", IFCAIRTERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTERMINALBOX", IFCAIRTERMINALBOX),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTERMINALBOXTYPE", IFCAIRTERMINALBOXTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTERMINALTYPE", IFCAIRTERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTOAIRHEATRECOVERY", IFCAIRTOAIRHEATRECOVERY),
std::pair<std::string, IfcRoadEntityEnum>("IFCAIRTOAIRHEATRECOVERYTYPE", IFCAIRTOAIRHEATRECOVERYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCALARM", IFCALARM),
std::pair<std::string, IfcRoadEntityEnum>("IFCALARMTYPE", IFCALARMTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT", IFCALIGNMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DHORIZONTAL", IFCALIGNMENT2DHORIZONTAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DHORIZONTALSEGMENT", IFCALIGNMENT2DHORIZONTALSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DSEGMENT", IFCALIGNMENT2DSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DVERSEGCIRCULARARC", IFCALIGNMENT2DVERSEGCIRCULARARC),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DVERSEGLINE", IFCALIGNMENT2DVERSEGLINE),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DVERSEGPARABOLICARC", IFCALIGNMENT2DVERSEGPARABOLICARC),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DVERTICAL", IFCALIGNMENT2DVERTICAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCALIGNMENT2DVERTICALSEGMENT", IFCALIGNMENT2DVERTICALSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCANNOTATION", IFCANNOTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCANNOTATIONFILLAREA", IFCANNOTATIONFILLAREA),
std::pair<std::string, IfcRoadEntityEnum>("IFCAPPLICATION", IFCAPPLICATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCAPPLIEDVALUE", IFCAPPLIEDVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAPPROVAL", IFCAPPROVAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCAPPROVALRELATIONSHIP", IFCAPPROVALRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCARBITRARYCLOSEDPROFILEDEF", IFCARBITRARYCLOSEDPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCARBITRARYOPENPROFILEDEF", IFCARBITRARYOPENPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCARBITRARYPROFILEDEFWITHVOIDS", IFCARBITRARYPROFILEDEFWITHVOIDS),
std::pair<std::string, IfcRoadEntityEnum>("IFCASSET", IFCASSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCASYMMETRICISHAPEPROFILEDEF", IFCASYMMETRICISHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCAUDIOVISUALAPPLIANCE", IFCAUDIOVISUALAPPLIANCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAUDIOVISUALAPPLIANCETYPE", IFCAUDIOVISUALAPPLIANCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCAXIS1PLACEMENT", IFCAXIS1PLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCAXIS2PLACEMENT2D", IFCAXIS2PLACEMENT2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCAXIS2PLACEMENT3D", IFCAXIS2PLACEMENT3D),
std::pair<std::string, IfcRoadEntityEnum>("IFCBSPLINECURVE", IFCBSPLINECURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBSPLINECURVEWITHKNOTS", IFCBSPLINECURVEWITHKNOTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCBSPLINESURFACE", IFCBSPLINESURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBSPLINESURFACEWITHKNOTS", IFCBSPLINESURFACEWITHKNOTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCBEAM", IFCBEAM),
std::pair<std::string, IfcRoadEntityEnum>("IFCBEAMSTANDARDCASE", IFCBEAMSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBEAMTYPE", IFCBEAMTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBLOBTEXTURE", IFCBLOBTEXTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBLOCK", IFCBLOCK),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOILER", IFCBOILER),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOILERTYPE", IFCBOILERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOOLEANCLIPPINGRESULT", IFCBOOLEANCLIPPINGRESULT),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOOLEANRESULT", IFCBOOLEANRESULT),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYCONDITION", IFCBOUNDARYCONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYCURVE", IFCBOUNDARYCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYEDGECONDITION", IFCBOUNDARYEDGECONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYFACECONDITION", IFCBOUNDARYFACECONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYNODECONDITION", IFCBOUNDARYNODECONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDARYNODECONDITIONWARPING", IFCBOUNDARYNODECONDITIONWARPING),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDEDCURVE", IFCBOUNDEDCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDEDSURFACE", IFCBOUNDEDSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOUNDINGBOX", IFCBOUNDINGBOX),
std::pair<std::string, IfcRoadEntityEnum>("IFCBOXEDHALFSPACE", IFCBOXEDHALFSPACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDING", IFCBUILDING),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENT", IFCBUILDINGELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENTPART", IFCBUILDINGELEMENTPART),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENTPARTTYPE", IFCBUILDINGELEMENTPARTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENTPROXY", IFCBUILDINGELEMENTPROXY),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENTPROXYTYPE", IFCBUILDINGELEMENTPROXYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGELEMENTTYPE", IFCBUILDINGELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGSTOREY", IFCBUILDINGSTOREY),
std::pair<std::string, IfcRoadEntityEnum>("IFCBUILDINGSYSTEM", IFCBUILDINGSYSTEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCBURNER", IFCBURNER),
std::pair<std::string, IfcRoadEntityEnum>("IFCBURNERTYPE", IFCBURNERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCSHAPEPROFILEDEF", IFCCSHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLECARRIERFITTING", IFCCABLECARRIERFITTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLECARRIERFITTINGTYPE", IFCCABLECARRIERFITTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLECARRIERSEGMENT", IFCCABLECARRIERSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLECARRIERSEGMENTTYPE", IFCCABLECARRIERSEGMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLEFITTING", IFCCABLEFITTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLEFITTINGTYPE", IFCCABLEFITTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLESEGMENT", IFCCABLESEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCABLESEGMENTTYPE", IFCCABLESEGMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANPOINT", IFCCARTESIANPOINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANPOINTLIST", IFCCARTESIANPOINTLIST),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANPOINTLIST2D", IFCCARTESIANPOINTLIST2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANPOINTLIST3D", IFCCARTESIANPOINTLIST3D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANTRANSFORMATIONOPERATOR", IFCCARTESIANTRANSFORMATIONOPERATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANTRANSFORMATIONOPERATOR2D", IFCCARTESIANTRANSFORMATIONOPERATOR2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM", IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANTRANSFORMATIONOPERATOR3D", IFCCARTESIANTRANSFORMATIONOPERATOR3D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM", IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM),
std::pair<std::string, IfcRoadEntityEnum>("IFCCENTERLINEPROFILEDEF", IFCCENTERLINEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCCHILLER", IFCCHILLER),
std::pair<std::string, IfcRoadEntityEnum>("IFCCHILLERTYPE", IFCCHILLERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCHIMNEY", IFCCHIMNEY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCHIMNEYTYPE", IFCCHIMNEYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIRCLE", IFCCIRCLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIRCLEHOLLOWPROFILEDEF", IFCCIRCLEHOLLOWPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIRCLEPROFILEDEF", IFCCIRCLEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIRCULARARCSEGMENT2D", IFCCIRCULARARCSEGMENT2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIVILELEMENT", IFCCIVILELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCIVILELEMENTTYPE", IFCCIVILELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCLASSIFICATION", IFCCLASSIFICATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCCLASSIFICATIONREFERENCE", IFCCLASSIFICATIONREFERENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCLOSEDSHELL", IFCCLOSEDSHELL),
std::pair<std::string, IfcRoadEntityEnum>("IFCCLOTHOIDALARCSEGMENT2D", IFCCLOTHOIDALARCSEGMENT2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOIL", IFCCOIL),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOILTYPE", IFCCOILTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLOURRGB", IFCCOLOURRGB),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLOURRGBLIST", IFCCOLOURRGBLIST),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLOURSPECIFICATION", IFCCOLOURSPECIFICATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLUMN", IFCCOLUMN),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLUMNSTANDARDCASE", IFCCOLUMNSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOLUMNTYPE", IFCCOLUMNTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMMUNICATIONSAPPLIANCE", IFCCOMMUNICATIONSAPPLIANCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMMUNICATIONSAPPLIANCETYPE", IFCCOMMUNICATIONSAPPLIANCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPLEXPROPERTY", IFCCOMPLEXPROPERTY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPLEXPROPERTYTEMPLATE", IFCCOMPLEXPROPERTYTEMPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPOSITECURVE", IFCCOMPOSITECURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPOSITECURVEONSURFACE", IFCCOMPOSITECURVEONSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPOSITECURVESEGMENT", IFCCOMPOSITECURVESEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPOSITEPROFILEDEF", IFCCOMPOSITEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPRESSOR", IFCCOMPRESSOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOMPRESSORTYPE", IFCCOMPRESSORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONDENSER", IFCCONDENSER),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONDENSERTYPE", IFCCONDENSERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONIC", IFCCONIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTEDFACESET", IFCCONNECTEDFACESET),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONCURVEGEOMETRY", IFCCONNECTIONCURVEGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONGEOMETRY", IFCCONNECTIONGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONPOINTECCENTRICITY", IFCCONNECTIONPOINTECCENTRICITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONPOINTGEOMETRY", IFCCONNECTIONPOINTGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONSURFACEGEOMETRY", IFCCONNECTIONSURFACEGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONNECTIONVOLUMEGEOMETRY", IFCCONNECTIONVOLUMEGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRAINT", IFCCONSTRAINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONEQUIPMENTRESOURCE", IFCCONSTRUCTIONEQUIPMENTRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONEQUIPMENTRESOURCETYPE", IFCCONSTRUCTIONEQUIPMENTRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONMATERIALRESOURCE", IFCCONSTRUCTIONMATERIALRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONMATERIALRESOURCETYPE", IFCCONSTRUCTIONMATERIALRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONPRODUCTRESOURCE", IFCCONSTRUCTIONPRODUCTRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONPRODUCTRESOURCETYPE", IFCCONSTRUCTIONPRODUCTRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONRESOURCE", IFCCONSTRUCTIONRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONSTRUCTIONRESOURCETYPE", IFCCONSTRUCTIONRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONTEXT", IFCCONTEXT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONTEXTDEPENDENTUNIT", IFCCONTEXTDEPENDENTUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONTROL", IFCCONTROL),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONTROLLER", IFCCONTROLLER),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONTROLLERTYPE", IFCCONTROLLERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONVERSIONBASEDUNIT", IFCCONVERSIONBASEDUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCONVERSIONBASEDUNITWITHOFFSET", IFCCONVERSIONBASEDUNITWITHOFFSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOOLEDBEAM", IFCCOOLEDBEAM),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOOLEDBEAMTYPE", IFCCOOLEDBEAMTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOOLINGTOWER", IFCCOOLINGTOWER),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOOLINGTOWERTYPE", IFCCOOLINGTOWERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOORDINATEOPERATION", IFCCOORDINATEOPERATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOORDINATEREFERENCESYSTEM", IFCCOORDINATEREFERENCESYSTEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOSTITEM", IFCCOSTITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOSTSCHEDULE", IFCCOSTSCHEDULE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOSTVALUE", IFCCOSTVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOVERING", IFCCOVERING),
std::pair<std::string, IfcRoadEntityEnum>("IFCCOVERINGTYPE", IFCCOVERINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCREWRESOURCE", IFCCREWRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCREWRESOURCETYPE", IFCCREWRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSECTION", IFCCROSSSECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSECTIONDYNAMIC", IFCCROSSSECTIONDYNAMIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSECTIONGEOMETRY", IFCCROSSSECTIONGEOMETRY),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSECTIONSTATIC", IFCCROSSSECTIONSTATIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSLOPE", IFCCROSSSLOPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCROSSSLOPEPOINT", IFCCROSSSLOPEPOINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCSGPRIMITIVE3D", IFCCSGPRIMITIVE3D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCSGSOLID", IFCCSGSOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURRENCYRELATIONSHIP", IFCCURRENCYRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURTAINWALL", IFCCURTAINWALL),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURTAINWALLTYPE", IFCCURTAINWALLTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVE", IFCCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVEBOUNDEDPLANE", IFCCURVEBOUNDEDPLANE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVEBOUNDEDSURFACE", IFCCURVEBOUNDEDSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVESEGMENT2D", IFCCURVESEGMENT2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVESTYLE", IFCCURVESTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVESTYLEFONT", IFCCURVESTYLEFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVESTYLEFONTANDSCALING", IFCCURVESTYLEFONTANDSCALING),
std::pair<std::string, IfcRoadEntityEnum>("IFCCURVESTYLEFONTPATTERN", IFCCURVESTYLEFONTPATTERN),
std::pair<std::string, IfcRoadEntityEnum>("IFCCYLINDRICALSURFACE", IFCCYLINDRICALSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDAMPER", IFCDAMPER),
std::pair<std::string, IfcRoadEntityEnum>("IFCDAMPERTYPE", IFCDAMPERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDERIVEDPROFILEDEF", IFCDERIVEDPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCDERIVEDUNIT", IFCDERIVEDUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDERIVEDUNITELEMENT", IFCDERIVEDUNITELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDIMENSIONALEXPONENTS", IFCDIMENSIONALEXPONENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCDIRECTION", IFCDIRECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISCRETEACCESSORY", IFCDISCRETEACCESSORY),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISCRETEACCESSORYTYPE", IFCDISCRETEACCESSORYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONCHAMBERELEMENT", IFCDISTRIBUTIONCHAMBERELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONCHAMBERELEMENTTYPE", IFCDISTRIBUTIONCHAMBERELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONCIRCUIT", IFCDISTRIBUTIONCIRCUIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONCONTROLELEMENT", IFCDISTRIBUTIONCONTROLELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONCONTROLELEMENTTYPE", IFCDISTRIBUTIONCONTROLELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONELEMENT", IFCDISTRIBUTIONELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONELEMENTTYPE", IFCDISTRIBUTIONELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONFLOWELEMENT", IFCDISTRIBUTIONFLOWELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONFLOWELEMENTTYPE", IFCDISTRIBUTIONFLOWELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONPORT", IFCDISTRIBUTIONPORT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDISTRIBUTIONSYSTEM", IFCDISTRIBUTIONSYSTEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOCUMENTINFORMATION", IFCDOCUMENTINFORMATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOCUMENTINFORMATIONRELATIONSHIP", IFCDOCUMENTINFORMATIONRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOCUMENTREFERENCE", IFCDOCUMENTREFERENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOOR", IFCDOOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOORLININGPROPERTIES", IFCDOORLININGPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOORPANELPROPERTIES", IFCDOORPANELPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOORSTANDARDCASE", IFCDOORSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOORSTYLE", IFCDOORSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDOORTYPE", IFCDOORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDRAUGHTINGPREDEFINEDCOLOUR", IFCDRAUGHTINGPREDEFINEDCOLOUR),
std::pair<std::string, IfcRoadEntityEnum>("IFCDRAUGHTINGPREDEFINEDCURVEFONT", IFCDRAUGHTINGPREDEFINEDCURVEFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTFITTING", IFCDUCTFITTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTFITTINGTYPE", IFCDUCTFITTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTSEGMENT", IFCDUCTSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTSEGMENTTYPE", IFCDUCTSEGMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTSILENCER", IFCDUCTSILENCER),
std::pair<std::string, IfcRoadEntityEnum>("IFCDUCTSILENCERTYPE", IFCDUCTSILENCERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEDGE", IFCEDGE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEDGECURVE", IFCEDGECURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEDGELOOP", IFCEDGELOOP),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICAPPLIANCE", IFCELECTRICAPPLIANCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICAPPLIANCETYPE", IFCELECTRICAPPLIANCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICDISTRIBUTIONBOARD", IFCELECTRICDISTRIBUTIONBOARD),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICDISTRIBUTIONBOARDTYPE", IFCELECTRICDISTRIBUTIONBOARDTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICFLOWSTORAGEDEVICE", IFCELECTRICFLOWSTORAGEDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICFLOWSTORAGEDEVICETYPE", IFCELECTRICFLOWSTORAGEDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICGENERATOR", IFCELECTRICGENERATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICGENERATORTYPE", IFCELECTRICGENERATORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICMOTOR", IFCELECTRICMOTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICMOTORTYPE", IFCELECTRICMOTORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICTIMECONTROL", IFCELECTRICTIMECONTROL),
std::pair<std::string, IfcRoadEntityEnum>("IFCELECTRICTIMECONTROLTYPE", IFCELECTRICTIMECONTROLTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENT", IFCELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTASSEMBLY", IFCELEMENTASSEMBLY),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTASSEMBLYTYPE", IFCELEMENTASSEMBLYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTCOMPONENT", IFCELEMENTCOMPONENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTCOMPONENTTYPE", IFCELEMENTCOMPONENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTQUANTITY", IFCELEMENTQUANTITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTTYPE", IFCELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELEMENTARYSURFACE", IFCELEMENTARYSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELLIPSE", IFCELLIPSE),
std::pair<std::string, IfcRoadEntityEnum>("IFCELLIPSEPROFILEDEF", IFCELLIPSEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCENERGYCONVERSIONDEVICE", IFCENERGYCONVERSIONDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCENERGYCONVERSIONDEVICETYPE", IFCENERGYCONVERSIONDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCENGINE", IFCENGINE),
std::pair<std::string, IfcRoadEntityEnum>("IFCENGINETYPE", IFCENGINETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVAPORATIVECOOLER", IFCEVAPORATIVECOOLER),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVAPORATIVECOOLERTYPE", IFCEVAPORATIVECOOLERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVAPORATOR", IFCEVAPORATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVAPORATORTYPE", IFCEVAPORATORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVENT", IFCEVENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVENTTIME", IFCEVENTTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCEVENTTYPE", IFCEVENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTENDEDPROPERTIES", IFCEXTENDEDPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALINFORMATION", IFCEXTERNALINFORMATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALREFERENCE", IFCEXTERNALREFERENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALREFERENCERELATIONSHIP", IFCEXTERNALREFERENCERELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALSPATIALELEMENT", IFCEXTERNALSPATIALELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALSPATIALSTRUCTUREELEMENT", IFCEXTERNALSPATIALSTRUCTUREELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALLYDEFINEDHATCHSTYLE", IFCEXTERNALLYDEFINEDHATCHSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALLYDEFINEDSURFACESTYLE", IFCEXTERNALLYDEFINEDSURFACESTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTERNALLYDEFINEDTEXTFONT", IFCEXTERNALLYDEFINEDTEXTFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTRUDEDAREASOLID", IFCEXTRUDEDAREASOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCEXTRUDEDAREASOLIDTAPERED", IFCEXTRUDEDAREASOLIDTAPERED),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACE", IFCFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACEBASEDSURFACEMODEL", IFCFACEBASEDSURFACEMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACEBOUND", IFCFACEBOUND),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACEOUTERBOUND", IFCFACEOUTERBOUND),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACESURFACE", IFCFACESURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACETEDBREP", IFCFACETEDBREP),
std::pair<std::string, IfcRoadEntityEnum>("IFCFACETEDBREPWITHVOIDS", IFCFACETEDBREPWITHVOIDS),
std::pair<std::string, IfcRoadEntityEnum>("IFCFAILURECONNECTIONCONDITION", IFCFAILURECONNECTIONCONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCFAN", IFCFAN),
std::pair<std::string, IfcRoadEntityEnum>("IFCFANTYPE", IFCFANTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFASTENER", IFCFASTENER),
std::pair<std::string, IfcRoadEntityEnum>("IFCFASTENERTYPE", IFCFASTENERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFEATUREELEMENT", IFCFEATUREELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCFEATUREELEMENTADDITION", IFCFEATUREELEMENTADDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCFEATUREELEMENTSUBTRACTION", IFCFEATUREELEMENTSUBTRACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCFILLAREASTYLE", IFCFILLAREASTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFILLAREASTYLEHATCHING", IFCFILLAREASTYLEHATCHING),
std::pair<std::string, IfcRoadEntityEnum>("IFCFILLAREASTYLETILES", IFCFILLAREASTYLETILES),
std::pair<std::string, IfcRoadEntityEnum>("IFCFILTER", IFCFILTER),
std::pair<std::string, IfcRoadEntityEnum>("IFCFILTERTYPE", IFCFILTERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFIRESUPPRESSIONTERMINAL", IFCFIRESUPPRESSIONTERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCFIRESUPPRESSIONTERMINALTYPE", IFCFIRESUPPRESSIONTERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFIXEDREFERENCESWEPTAREASOLID", IFCFIXEDREFERENCESWEPTAREASOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWCONTROLLER", IFCFLOWCONTROLLER),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWCONTROLLERTYPE", IFCFLOWCONTROLLERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWFITTING", IFCFLOWFITTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWFITTINGTYPE", IFCFLOWFITTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWINSTRUMENT", IFCFLOWINSTRUMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWINSTRUMENTTYPE", IFCFLOWINSTRUMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWMETER", IFCFLOWMETER),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWMETERTYPE", IFCFLOWMETERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWMOVINGDEVICE", IFCFLOWMOVINGDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWMOVINGDEVICETYPE", IFCFLOWMOVINGDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWSEGMENT", IFCFLOWSEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWSEGMENTTYPE", IFCFLOWSEGMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWSTORAGEDEVICE", IFCFLOWSTORAGEDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWSTORAGEDEVICETYPE", IFCFLOWSTORAGEDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWTERMINAL", IFCFLOWTERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWTERMINALTYPE", IFCFLOWTERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWTREATMENTDEVICE", IFCFLOWTREATMENTDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFLOWTREATMENTDEVICETYPE", IFCFLOWTREATMENTDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFOOTING", IFCFOOTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCFOOTINGTYPE", IFCFOOTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFURNISHINGELEMENT", IFCFURNISHINGELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCFURNISHINGELEMENTTYPE", IFCFURNISHINGELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFURNITURE", IFCFURNITURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCFURNITURETYPE", IFCFURNITURETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOGRAPHICELEMENT", IFCGEOGRAPHICELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOGRAPHICELEMENTTYPE", IFCGEOGRAPHICELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOMETRICCURVESET", IFCGEOMETRICCURVESET),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOMETRICREPRESENTATIONCONTEXT", IFCGEOMETRICREPRESENTATIONCONTEXT),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOMETRICREPRESENTATIONITEM", IFCGEOMETRICREPRESENTATIONITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOMETRICREPRESENTATIONSUBCONTEXT", IFCGEOMETRICREPRESENTATIONSUBCONTEXT),
std::pair<std::string, IfcRoadEntityEnum>("IFCGEOMETRICSET", IFCGEOMETRICSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCGRID", IFCGRID),
std::pair<std::string, IfcRoadEntityEnum>("IFCGRIDAXIS", IFCGRIDAXIS),
std::pair<std::string, IfcRoadEntityEnum>("IFCGRIDPLACEMENT", IFCGRIDPLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCGROUP", IFCGROUP),
std::pair<std::string, IfcRoadEntityEnum>("IFCHALFSPACESOLID", IFCHALFSPACESOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCHEATEXCHANGER", IFCHEATEXCHANGER),
std::pair<std::string, IfcRoadEntityEnum>("IFCHEATEXCHANGERTYPE", IFCHEATEXCHANGERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCHUMIDIFIER", IFCHUMIDIFIER),
std::pair<std::string, IfcRoadEntityEnum>("IFCHUMIDIFIERTYPE", IFCHUMIDIFIERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCISHAPEPROFILEDEF", IFCISHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCIMAGETEXTURE", IFCIMAGETEXTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCINDEXEDCOLOURMAP", IFCINDEXEDCOLOURMAP),
std::pair<std::string, IfcRoadEntityEnum>("IFCINDEXEDPOLYCURVE", IFCINDEXEDPOLYCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCINDEXEDTEXTUREMAP", IFCINDEXEDTEXTUREMAP),
std::pair<std::string, IfcRoadEntityEnum>("IFCINDEXEDTRIANGLETEXTUREMAP", IFCINDEXEDTRIANGLETEXTUREMAP),
std::pair<std::string, IfcRoadEntityEnum>("IFCINTERCEPTOR", IFCINTERCEPTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCINTERCEPTORTYPE", IFCINTERCEPTORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCINVENTORY", IFCINVENTORY),
std::pair<std::string, IfcRoadEntityEnum>("IFCIRREGULARTIMESERIES", IFCIRREGULARTIMESERIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCIRREGULARTIMESERIESVALUE", IFCIRREGULARTIMESERIESVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCJUNCTIONBOX", IFCJUNCTIONBOX),
std::pair<std::string, IfcRoadEntityEnum>("IFCJUNCTIONBOXTYPE", IFCJUNCTIONBOXTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLSHAPEPROFILEDEF", IFCLSHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCLABORRESOURCE", IFCLABORRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLABORRESOURCETYPE", IFCLABORRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLAGTIME", IFCLAGTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCLAMP", IFCLAMP),
std::pair<std::string, IfcRoadEntityEnum>("IFCLAMPTYPE", IFCLAMPTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIBRARYINFORMATION", IFCLIBRARYINFORMATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIBRARYREFERENCE", IFCLIBRARYREFERENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTDISTRIBUTIONDATA", IFCLIGHTDISTRIBUTIONDATA),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTFIXTURE", IFCLIGHTFIXTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTFIXTURETYPE", IFCLIGHTFIXTURETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTINTENSITYDISTRIBUTION", IFCLIGHTINTENSITYDISTRIBUTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCE", IFCLIGHTSOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCEAMBIENT", IFCLIGHTSOURCEAMBIENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCEDIRECTIONAL", IFCLIGHTSOURCEDIRECTIONAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCEGONIOMETRIC", IFCLIGHTSOURCEGONIOMETRIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCEPOSITIONAL", IFCLIGHTSOURCEPOSITIONAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCLIGHTSOURCESPOT", IFCLIGHTSOURCESPOT),
std::pair<std::string, IfcRoadEntityEnum>("IFCLINE", IFCLINE),
std::pair<std::string, IfcRoadEntityEnum>("IFCLINESEGMENT2D", IFCLINESEGMENT2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCLOCALPLACEMENT", IFCLOCALPLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCLOOP", IFCLOOP),
std::pair<std::string, IfcRoadEntityEnum>("IFCMANIFOLDSOLIDBREP", IFCMANIFOLDSOLIDBREP),
std::pair<std::string, IfcRoadEntityEnum>("IFCMAPCONVERSION", IFCMAPCONVERSION),
std::pair<std::string, IfcRoadEntityEnum>("IFCMAPPEDITEM", IFCMAPPEDITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIAL", IFCMATERIAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALCLASSIFICATIONRELATIONSHIP", IFCMATERIALCLASSIFICATIONRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALCONSTITUENT", IFCMATERIALCONSTITUENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALCONSTITUENTSET", IFCMATERIALCONSTITUENTSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALDEFINITION", IFCMATERIALDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALDEFINITIONREPRESENTATION", IFCMATERIALDEFINITIONREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALLAYER", IFCMATERIALLAYER),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALLAYERSET", IFCMATERIALLAYERSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALLAYERSETUSAGE", IFCMATERIALLAYERSETUSAGE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALLAYERWITHOFFSETS", IFCMATERIALLAYERWITHOFFSETS),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALLIST", IFCMATERIALLIST),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROFILE", IFCMATERIALPROFILE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROFILESET", IFCMATERIALPROFILESET),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROFILESETUSAGE", IFCMATERIALPROFILESETUSAGE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROFILESETUSAGETAPERING", IFCMATERIALPROFILESETUSAGETAPERING),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROFILEWITHOFFSETS", IFCMATERIALPROFILEWITHOFFSETS),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALPROPERTIES", IFCMATERIALPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALRELATIONSHIP", IFCMATERIALRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCMATERIALUSAGEDEFINITION", IFCMATERIALUSAGEDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEASUREWITHUNIT", IFCMEASUREWITHUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCMECHANICALFASTENER", IFCMECHANICALFASTENER),
std::pair<std::string, IfcRoadEntityEnum>("IFCMECHANICALFASTENERTYPE", IFCMECHANICALFASTENERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEDICALDEVICE", IFCMEDICALDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEDICALDEVICETYPE", IFCMEDICALDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEMBER", IFCMEMBER),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEMBERSTANDARDCASE", IFCMEMBERSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMEMBERTYPE", IFCMEMBERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCMETRIC", IFCMETRIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCMIRROREDPROFILEDEF", IFCMIRROREDPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCMONETARYUNIT", IFCMONETARYUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCMOTORCONNECTION", IFCMOTORCONNECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCMOTORCONNECTIONTYPE", IFCMOTORCONNECTIONTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCNAMEDUNIT", IFCNAMEDUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCOBJECT", IFCOBJECT),
std::pair<std::string, IfcRoadEntityEnum>("IFCOBJECTDEFINITION", IFCOBJECTDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCOBJECTPLACEMENT", IFCOBJECTPLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCOBJECTIVE", IFCOBJECTIVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCOCCUPANT", IFCOCCUPANT),
std::pair<std::string, IfcRoadEntityEnum>("IFCOFFSETCURVE2D", IFCOFFSETCURVE2D),
std::pair<std::string, IfcRoadEntityEnum>("IFCOFFSETCURVE3D", IFCOFFSETCURVE3D),
std::pair<std::string, IfcRoadEntityEnum>("IFCOPENSHELL", IFCOPENSHELL),
std::pair<std::string, IfcRoadEntityEnum>("IFCOPENINGELEMENT", IFCOPENINGELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCOPENINGSTANDARDCASE", IFCOPENINGSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCORGANIZATION", IFCORGANIZATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCORGANIZATIONRELATIONSHIP", IFCORGANIZATIONRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCORIENTEDEDGE", IFCORIENTEDEDGE),
std::pair<std::string, IfcRoadEntityEnum>("IFCOUTERBOUNDARYCURVE", IFCOUTERBOUNDARYCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCOUTLET", IFCOUTLET),
std::pair<std::string, IfcRoadEntityEnum>("IFCOUTLETTYPE", IFCOUTLETTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCOWNERHISTORY", IFCOWNERHISTORY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPARAMETERIZEDPROFILEDEF", IFCPARAMETERIZEDPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCPATH", IFCPATH),
std::pair<std::string, IfcRoadEntityEnum>("IFCPCURVE", IFCPCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPERFORMANCEHISTORY", IFCPERFORMANCEHISTORY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPERMEABLECOVERINGPROPERTIES", IFCPERMEABLECOVERINGPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCPERMIT", IFCPERMIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPERSON", IFCPERSON),
std::pair<std::string, IfcRoadEntityEnum>("IFCPERSONANDORGANIZATION", IFCPERSONANDORGANIZATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPHYSICALCOMPLEXQUANTITY", IFCPHYSICALCOMPLEXQUANTITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPHYSICALQUANTITY", IFCPHYSICALQUANTITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPHYSICALSIMPLEQUANTITY", IFCPHYSICALSIMPLEQUANTITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPILE", IFCPILE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPILETYPE", IFCPILETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPIPEFITTING", IFCPIPEFITTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCPIPEFITTINGTYPE", IFCPIPEFITTINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPIPESEGMENT", IFCPIPESEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPIPESEGMENTTYPE", IFCPIPESEGMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPIXELTEXTURE", IFCPIXELTEXTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLACEMENT", IFCPLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLANARBOX", IFCPLANARBOX),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLANAREXTENT", IFCPLANAREXTENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLANE", IFCPLANE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLATE", IFCPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLATESTANDARDCASE", IFCPLATESTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPLATETYPE", IFCPLATETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOINT", IFCPOINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOINTONCURVE", IFCPOINTONCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOINTONSURFACE", IFCPOINTONSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOLYLOOP", IFCPOLYLOOP),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOLYGONALBOUNDEDHALFSPACE", IFCPOLYGONALBOUNDEDHALFSPACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOLYLINE", IFCPOLYLINE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPORT", IFCPORT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOSITIONINGELEMENT", IFCPOSITIONINGELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPOSTALADDRESS", IFCPOSTALADDRESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDCOLOUR", IFCPREDEFINEDCOLOUR),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDCURVEFONT", IFCPREDEFINEDCURVEFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDITEM", IFCPREDEFINEDITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDPROPERTIES", IFCPREDEFINEDPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDPROPERTYSET", IFCPREDEFINEDPROPERTYSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCPREDEFINEDTEXTFONT", IFCPREDEFINEDTEXTFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRESENTATIONITEM", IFCPRESENTATIONITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRESENTATIONLAYERASSIGNMENT", IFCPRESENTATIONLAYERASSIGNMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRESENTATIONLAYERWITHSTYLE", IFCPRESENTATIONLAYERWITHSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRESENTATIONSTYLE", IFCPRESENTATIONSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRESENTATIONSTYLEASSIGNMENT", IFCPRESENTATIONSTYLEASSIGNMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROCEDURE", IFCPROCEDURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROCEDURETYPE", IFCPROCEDURETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROCESS", IFCPROCESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRODUCT", IFCPRODUCT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRODUCTDEFINITIONSHAPE", IFCPRODUCTDEFINITIONSHAPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPRODUCTREPRESENTATION", IFCPRODUCTREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROFILEDEF", IFCPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROFILEPROPERTIES", IFCPROFILEPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROJECT", IFCPROJECT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROJECTLIBRARY", IFCPROJECTLIBRARY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROJECTORDER", IFCPROJECTORDER),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROJECTEDCRS", IFCPROJECTEDCRS),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROJECTIONELEMENT", IFCPROJECTIONELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTY", IFCPROPERTY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYABSTRACTION", IFCPROPERTYABSTRACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYBOUNDEDVALUE", IFCPROPERTYBOUNDEDVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYDEFINITION", IFCPROPERTYDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYDEPENDENCYRELATIONSHIP", IFCPROPERTYDEPENDENCYRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYENUMERATEDVALUE", IFCPROPERTYENUMERATEDVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYENUMERATION", IFCPROPERTYENUMERATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYLISTVALUE", IFCPROPERTYLISTVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYREFERENCEVALUE", IFCPROPERTYREFERENCEVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYSET", IFCPROPERTYSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYSETDEFINITION", IFCPROPERTYSETDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYSETTEMPLATE", IFCPROPERTYSETTEMPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYSINGLEVALUE", IFCPROPERTYSINGLEVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYTABLEVALUE", IFCPROPERTYTABLEVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYTEMPLATE", IFCPROPERTYTEMPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROPERTYTEMPLATEDEFINITION", IFCPROPERTYTEMPLATEDEFINITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROTECTIVEDEVICE", IFCPROTECTIVEDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROTECTIVEDEVICETRIPPINGUNIT", IFCPROTECTIVEDEVICETRIPPINGUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROTECTIVEDEVICETRIPPINGUNITTYPE", IFCPROTECTIVEDEVICETRIPPINGUNITTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROTECTIVEDEVICETYPE", IFCPROTECTIVEDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCPROXY", IFCPROXY),
std::pair<std::string, IfcRoadEntityEnum>("IFCPUMP", IFCPUMP),
std::pair<std::string, IfcRoadEntityEnum>("IFCPUMPTYPE", IFCPUMPTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYAREA", IFCQUANTITYAREA),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYCOUNT", IFCQUANTITYCOUNT),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYLENGTH", IFCQUANTITYLENGTH),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYSET", IFCQUANTITYSET),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYTIME", IFCQUANTITYTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYVOLUME", IFCQUANTITYVOLUME),
std::pair<std::string, IfcRoadEntityEnum>("IFCQUANTITYWEIGHT", IFCQUANTITYWEIGHT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAILING", IFCRAILING),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAILINGTYPE", IFCRAILINGTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAMP", IFCRAMP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAMPFLIGHT", IFCRAMPFLIGHT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAMPFLIGHTTYPE", IFCRAMPFLIGHTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRAMPTYPE", IFCRAMPTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRATIONALBSPLINECURVEWITHKNOTS", IFCRATIONALBSPLINECURVEWITHKNOTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRATIONALBSPLINESURFACEWITHKNOTS", IFCRATIONALBSPLINESURFACEWITHKNOTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRECTANGLEHOLLOWPROFILEDEF", IFCRECTANGLEHOLLOWPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCRECTANGLEPROFILEDEF", IFCRECTANGLEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCRECTANGULARPYRAMID", IFCRECTANGULARPYRAMID),
std::pair<std::string, IfcRoadEntityEnum>("IFCRECTANGULARTRIMMEDSURFACE", IFCRECTANGULARTRIMMEDSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRECURRENCEPATTERN", IFCRECURRENCEPATTERN),
std::pair<std::string, IfcRoadEntityEnum>("IFCREFERENCE", IFCREFERENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCREGULARTIMESERIES", IFCREGULARTIMESERIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCEMENTBARPROPERTIES", IFCREINFORCEMENTBARPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCEMENTDEFINITIONPROPERTIES", IFCREINFORCEMENTDEFINITIONPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGBAR", IFCREINFORCINGBAR),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGBARTYPE", IFCREINFORCINGBARTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGELEMENT", IFCREINFORCINGELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGELEMENTTYPE", IFCREINFORCINGELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGMESH", IFCREINFORCINGMESH),
std::pair<std::string, IfcRoadEntityEnum>("IFCREINFORCINGMESHTYPE", IFCREINFORCINGMESHTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELAGGREGATES", IFCRELAGGREGATES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNS", IFCRELASSIGNS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOACTOR", IFCRELASSIGNSTOACTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOCONTROL", IFCRELASSIGNSTOCONTROL),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOGROUP", IFCRELASSIGNSTOGROUP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOGROUPBYFACTOR", IFCRELASSIGNSTOGROUPBYFACTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOPROCESS", IFCRELASSIGNSTOPROCESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTOPRODUCT", IFCRELASSIGNSTOPRODUCT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSIGNSTORESOURCE", IFCRELASSIGNSTORESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATES", IFCRELASSOCIATES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESAPPROVAL", IFCRELASSOCIATESAPPROVAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESCLASSIFICATION", IFCRELASSOCIATESCLASSIFICATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESCONSTRAINT", IFCRELASSOCIATESCONSTRAINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESDOCUMENT", IFCRELASSOCIATESDOCUMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESLIBRARY", IFCRELASSOCIATESLIBRARY),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELASSOCIATESMATERIAL", IFCRELASSOCIATESMATERIAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTS", IFCRELCONNECTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSELEMENTS", IFCRELCONNECTSELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSPATHELEMENTS", IFCRELCONNECTSPATHELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSPORTTOELEMENT", IFCRELCONNECTSPORTTOELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSPORTS", IFCRELCONNECTSPORTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSSTRUCTURALACTIVITY", IFCRELCONNECTSSTRUCTURALACTIVITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSSTRUCTURALMEMBER", IFCRELCONNECTSSTRUCTURALMEMBER),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSWITHECCENTRICITY", IFCRELCONNECTSWITHECCENTRICITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONNECTSWITHREALIZINGELEMENTS", IFCRELCONNECTSWITHREALIZINGELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCONTAINEDINSPATIALSTRUCTURE", IFCRELCONTAINEDINSPATIALSTRUCTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCOVERSBLDGELEMENTS", IFCRELCOVERSBLDGELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELCOVERSSPACES", IFCRELCOVERSSPACES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDECLARES", IFCRELDECLARES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDECOMPOSES", IFCRELDECOMPOSES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDEFINES", IFCRELDEFINES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDEFINESBYOBJECT", IFCRELDEFINESBYOBJECT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDEFINESBYPROPERTIES", IFCRELDEFINESBYPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDEFINESBYTEMPLATE", IFCRELDEFINESBYTEMPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELDEFINESBYTYPE", IFCRELDEFINESBYTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELFILLSELEMENT", IFCRELFILLSELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELFLOWCONTROLELEMENTS", IFCRELFLOWCONTROLELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELINTERFERESELEMENTS", IFCRELINTERFERESELEMENTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELNESTS", IFCRELNESTS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELPROJECTSELEMENT", IFCRELPROJECTSELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELREFERENCEDINSPATIALSTRUCTURE", IFCRELREFERENCEDINSPATIALSTRUCTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELSEQUENCE", IFCRELSEQUENCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELSERVICESBUILDINGS", IFCRELSERVICESBUILDINGS),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELSPACEBOUNDARY", IFCRELSPACEBOUNDARY),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELSPACEBOUNDARY1STLEVEL", IFCRELSPACEBOUNDARY1STLEVEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELSPACEBOUNDARY2NDLEVEL", IFCRELSPACEBOUNDARY2NDLEVEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELVOIDSELEMENT", IFCRELVOIDSELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCRELATIONSHIP", IFCRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCREPARAMETRISEDCOMPOSITECURVESEGMENT", IFCREPARAMETRISEDCOMPOSITECURVESEGMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCREPRESENTATION", IFCREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCREPRESENTATIONCONTEXT", IFCREPRESENTATIONCONTEXT),
std::pair<std::string, IfcRoadEntityEnum>("IFCREPRESENTATIONITEM", IFCREPRESENTATIONITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCREPRESENTATIONMAP", IFCREPRESENTATIONMAP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRESOURCE", IFCRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRESOURCEAPPROVALRELATIONSHIP", IFCRESOURCEAPPROVALRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRESOURCECONSTRAINTRELATIONSHIP", IFCRESOURCECONSTRAINTRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRESOURCELEVELRELATIONSHIP", IFCRESOURCELEVELRELATIONSHIP),
std::pair<std::string, IfcRoadEntityEnum>("IFCRESOURCETIME", IFCRESOURCETIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCREVOLVEDAREASOLID", IFCREVOLVEDAREASOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCREVOLVEDAREASOLIDTAPERED", IFCREVOLVEDAREASOLIDTAPERED),
std::pair<std::string, IfcRoadEntityEnum>("IFCRIGHTCIRCULARCONE", IFCRIGHTCIRCULARCONE),
std::pair<std::string, IfcRoadEntityEnum>("IFCRIGHTCIRCULARCYLINDER", IFCRIGHTCIRCULARCYLINDER),
std::pair<std::string, IfcRoadEntityEnum>("IFCROAD", IFCROAD),
std::pair<std::string, IfcRoadEntityEnum>("IFCROADBODY", IFCROADBODY),
std::pair<std::string, IfcRoadEntityEnum>("IFCROOF", IFCROOF),
std::pair<std::string, IfcRoadEntityEnum>("IFCROOFTYPE", IFCROOFTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCROOT", IFCROOT),
std::pair<std::string, IfcRoadEntityEnum>("IFCROUNDEDRECTANGLEPROFILEDEF", IFCROUNDEDRECTANGLEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCSIUNIT", IFCSIUNIT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSANITARYTERMINAL", IFCSANITARYTERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSANITARYTERMINALTYPE", IFCSANITARYTERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSCHEDULINGTIME", IFCSCHEDULINGTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCSECTIONPROPERTIES", IFCSECTIONPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCSECTIONREINFORCEMENTPROPERTIES", IFCSECTIONREINFORCEMENTPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCSECTIONEDSPINE", IFCSECTIONEDSPINE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSENSOR", IFCSENSOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCSENSORTYPE", IFCSENSORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHADINGDEVICE", IFCSHADINGDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHADINGDEVICETYPE", IFCSHADINGDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHAPEASPECT", IFCSHAPEASPECT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHAPEMODEL", IFCSHAPEMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHAPEREPRESENTATION", IFCSHAPEREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSHELLBASEDSURFACEMODEL", IFCSHELLBASEDSURFACEMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSIMPLEPROPERTY", IFCSIMPLEPROPERTY),
std::pair<std::string, IfcRoadEntityEnum>("IFCSIMPLEPROPERTYTEMPLATE", IFCSIMPLEPROPERTYTEMPLATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSITE", IFCSITE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSLAB", IFCSLAB),
std::pair<std::string, IfcRoadEntityEnum>("IFCSLABELEMENTEDCASE", IFCSLABELEMENTEDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSLABSTANDARDCASE", IFCSLABSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSLABTYPE", IFCSLABTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSLIPPAGECONNECTIONCONDITION", IFCSLIPPAGECONNECTIONCONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSOLARDEVICE", IFCSOLARDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSOLARDEVICETYPE", IFCSOLARDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSOLIDMODEL", IFCSOLIDMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPACE", IFCSPACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPACEHEATER", IFCSPACEHEATER),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPACEHEATERTYPE", IFCSPACEHEATERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPACETYPE", IFCSPACETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALELEMENT", IFCSPATIALELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALELEMENTTYPE", IFCSPATIALELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALSTRUCTUREELEMENT", IFCSPATIALSTRUCTUREELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALSTRUCTUREELEMENTTYPE", IFCSPATIALSTRUCTUREELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALZONE", IFCSPATIALZONE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPATIALZONETYPE", IFCSPATIALZONETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSPHERE", IFCSPHERE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTACKTERMINAL", IFCSTACKTERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTACKTERMINALTYPE", IFCSTACKTERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTAIR", IFCSTAIR),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTAIRFLIGHT", IFCSTAIRFLIGHT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTAIRFLIGHTTYPE", IFCSTAIRFLIGHTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTAIRTYPE", IFCSTAIRTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALACTION", IFCSTRUCTURALACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALACTIVITY", IFCSTRUCTURALACTIVITY),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALANALYSISMODEL", IFCSTRUCTURALANALYSISMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCONNECTION", IFCSTRUCTURALCONNECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCONNECTIONCONDITION", IFCSTRUCTURALCONNECTIONCONDITION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCURVEACTION", IFCSTRUCTURALCURVEACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCURVECONNECTION", IFCSTRUCTURALCURVECONNECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCURVEMEMBER", IFCSTRUCTURALCURVEMEMBER),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCURVEMEMBERVARYING", IFCSTRUCTURALCURVEMEMBERVARYING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALCURVEREACTION", IFCSTRUCTURALCURVEREACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALITEM", IFCSTRUCTURALITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLINEARACTION", IFCSTRUCTURALLINEARACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOAD", IFCSTRUCTURALLOAD),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADCASE", IFCSTRUCTURALLOADCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADCONFIGURATION", IFCSTRUCTURALLOADCONFIGURATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADGROUP", IFCSTRUCTURALLOADGROUP),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADLINEARFORCE", IFCSTRUCTURALLOADLINEARFORCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADORRESULT", IFCSTRUCTURALLOADORRESULT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADPLANARFORCE", IFCSTRUCTURALLOADPLANARFORCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADSINGLEDISPLACEMENT", IFCSTRUCTURALLOADSINGLEDISPLACEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION", IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADSINGLEFORCE", IFCSTRUCTURALLOADSINGLEFORCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADSINGLEFORCEWARPING", IFCSTRUCTURALLOADSINGLEFORCEWARPING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADSTATIC", IFCSTRUCTURALLOADSTATIC),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALLOADTEMPERATURE", IFCSTRUCTURALLOADTEMPERATURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALMEMBER", IFCSTRUCTURALMEMBER),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALPLANARACTION", IFCSTRUCTURALPLANARACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALPOINTACTION", IFCSTRUCTURALPOINTACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALPOINTCONNECTION", IFCSTRUCTURALPOINTCONNECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALPOINTREACTION", IFCSTRUCTURALPOINTREACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALREACTION", IFCSTRUCTURALREACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALRESULTGROUP", IFCSTRUCTURALRESULTGROUP),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALSURFACEACTION", IFCSTRUCTURALSURFACEACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALSURFACECONNECTION", IFCSTRUCTURALSURFACECONNECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALSURFACEMEMBER", IFCSTRUCTURALSURFACEMEMBER),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALSURFACEMEMBERVARYING", IFCSTRUCTURALSURFACEMEMBERVARYING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTRUCTURALSURFACEREACTION", IFCSTRUCTURALSURFACEREACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTYLEMODEL", IFCSTYLEMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTYLEDITEM", IFCSTYLEDITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCSTYLEDREPRESENTATION", IFCSTYLEDREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSUBCONTRACTRESOURCE", IFCSUBCONTRACTRESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSUBCONTRACTRESOURCETYPE", IFCSUBCONTRACTRESOURCETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSUBEDGE", IFCSUBEDGE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACE", IFCSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACECURVESWEPTAREASOLID", IFCSURFACECURVESWEPTAREASOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACEFEATURE", IFCSURFACEFEATURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACEOFLINEAREXTRUSION", IFCSURFACEOFLINEAREXTRUSION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACEOFREVOLUTION", IFCSURFACEOFREVOLUTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACEREINFORCEMENTAREA", IFCSURFACEREINFORCEMENTAREA),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLE", IFCSURFACESTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLELIGHTING", IFCSURFACESTYLELIGHTING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLEREFRACTION", IFCSURFACESTYLEREFRACTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLERENDERING", IFCSURFACESTYLERENDERING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLESHADING", IFCSURFACESTYLESHADING),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACESTYLEWITHTEXTURES", IFCSURFACESTYLEWITHTEXTURES),
std::pair<std::string, IfcRoadEntityEnum>("IFCSURFACETEXTURE", IFCSURFACETEXTURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWEPTAREASOLID", IFCSWEPTAREASOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWEPTDISKSOLID", IFCSWEPTDISKSOLID),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWEPTDISKSOLIDPOLYGONAL", IFCSWEPTDISKSOLIDPOLYGONAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWEPTSURFACE", IFCSWEPTSURFACE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWITCHINGDEVICE", IFCSWITCHINGDEVICE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSWITCHINGDEVICETYPE", IFCSWITCHINGDEVICETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCSYSTEM", IFCSYSTEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCSYSTEMFURNITUREELEMENT", IFCSYSTEMFURNITUREELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCSYSTEMFURNITUREELEMENTTYPE", IFCSYSTEMFURNITUREELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTSHAPEPROFILEDEF", IFCTSHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCTABLE", IFCTABLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTABLECOLUMN", IFCTABLECOLUMN),
std::pair<std::string, IfcRoadEntityEnum>("IFCTABLEROW", IFCTABLEROW),
std::pair<std::string, IfcRoadEntityEnum>("IFCTANK", IFCTANK),
std::pair<std::string, IfcRoadEntityEnum>("IFCTANKTYPE", IFCTANKTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTASK", IFCTASK),
std::pair<std::string, IfcRoadEntityEnum>("IFCTASKTIME", IFCTASKTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCTASKTIMERECURRING", IFCTASKTIMERECURRING),
std::pair<std::string, IfcRoadEntityEnum>("IFCTASKTYPE", IFCTASKTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTELECOMADDRESS", IFCTELECOMADDRESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCTENDON", IFCTENDON),
std::pair<std::string, IfcRoadEntityEnum>("IFCTENDONANCHOR", IFCTENDONANCHOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCTENDONANCHORTYPE", IFCTENDONANCHORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTENDONTYPE", IFCTENDONTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTESSELLATEDFACESET", IFCTESSELLATEDFACESET),
std::pair<std::string, IfcRoadEntityEnum>("IFCTESSELLATEDITEM", IFCTESSELLATEDITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTLITERAL", IFCTEXTLITERAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTLITERALWITHEXTENT", IFCTEXTLITERALWITHEXTENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTSTYLE", IFCTEXTSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTSTYLEFONTMODEL", IFCTEXTSTYLEFONTMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTSTYLEFORDEFINEDFONT", IFCTEXTSTYLEFORDEFINEDFONT),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTSTYLETEXTMODEL", IFCTEXTSTYLETEXTMODEL),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTURECOORDINATE", IFCTEXTURECOORDINATE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTURECOORDINATEGENERATOR", IFCTEXTURECOORDINATEGENERATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTUREMAP", IFCTEXTUREMAP),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTUREVERTEX", IFCTEXTUREVERTEX),
std::pair<std::string, IfcRoadEntityEnum>("IFCTEXTUREVERTEXLIST", IFCTEXTUREVERTEXLIST),
std::pair<std::string, IfcRoadEntityEnum>("IFCTIMEPERIOD", IFCTIMEPERIOD),
std::pair<std::string, IfcRoadEntityEnum>("IFCTIMESERIES", IFCTIMESERIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCTIMESERIESVALUE", IFCTIMESERIESVALUE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTOPOLOGICALREPRESENTATIONITEM", IFCTOPOLOGICALREPRESENTATIONITEM),
std::pair<std::string, IfcRoadEntityEnum>("IFCTOPOLOGYREPRESENTATION", IFCTOPOLOGYREPRESENTATION),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRANSFORMER", IFCTRANSFORMER),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRANSFORMERTYPE", IFCTRANSFORMERTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRANSPORTELEMENT", IFCTRANSPORTELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRANSPORTELEMENTTYPE", IFCTRANSPORTELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRAPEZIUMPROFILEDEF", IFCTRAPEZIUMPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRIANGULATEDFACESET", IFCTRIANGULATEDFACESET),
std::pair<std::string, IfcRoadEntityEnum>("IFCTRIMMEDCURVE", IFCTRIMMEDCURVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTUBEBUNDLE", IFCTUBEBUNDLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTUBEBUNDLETYPE", IFCTUBEBUNDLETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCTYPEOBJECT", IFCTYPEOBJECT),
std::pair<std::string, IfcRoadEntityEnum>("IFCTYPEPROCESS", IFCTYPEPROCESS),
std::pair<std::string, IfcRoadEntityEnum>("IFCTYPEPRODUCT", IFCTYPEPRODUCT),
std::pair<std::string, IfcRoadEntityEnum>("IFCTYPERESOURCE", IFCTYPERESOURCE),
std::pair<std::string, IfcRoadEntityEnum>("IFCUSHAPEPROFILEDEF", IFCUSHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCUNITASSIGNMENT", IFCUNITASSIGNMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCUNITARYCONTROLELEMENT", IFCUNITARYCONTROLELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCUNITARYCONTROLELEMENTTYPE", IFCUNITARYCONTROLELEMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCUNITARYEQUIPMENT", IFCUNITARYEQUIPMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCUNITARYEQUIPMENTTYPE", IFCUNITARYEQUIPMENTTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCVALVE", IFCVALVE),
std::pair<std::string, IfcRoadEntityEnum>("IFCVALVETYPE", IFCVALVETYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCVECTOR", IFCVECTOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCVERTEX", IFCVERTEX),
std::pair<std::string, IfcRoadEntityEnum>("IFCVERTEXLOOP", IFCVERTEXLOOP),
std::pair<std::string, IfcRoadEntityEnum>("IFCVERTEXPOINT", IFCVERTEXPOINT),
std::pair<std::string, IfcRoadEntityEnum>("IFCVIBRATIONISOLATOR", IFCVIBRATIONISOLATOR),
std::pair<std::string, IfcRoadEntityEnum>("IFCVIBRATIONISOLATORTYPE", IFCVIBRATIONISOLATORTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCVIRTUALELEMENT", IFCVIRTUALELEMENT),
std::pair<std::string, IfcRoadEntityEnum>("IFCVIRTUALGRIDINTERSECTION", IFCVIRTUALGRIDINTERSECTION),
std::pair<std::string, IfcRoadEntityEnum>("IFCVOIDINGFEATURE", IFCVOIDINGFEATURE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWALL", IFCWALL),
std::pair<std::string, IfcRoadEntityEnum>("IFCWALLELEMENTEDCASE", IFCWALLELEMENTEDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWALLSTANDARDCASE", IFCWALLSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWALLTYPE", IFCWALLTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWASTETERMINAL", IFCWASTETERMINAL),
std::pair<std::string, IfcRoadEntityEnum>("IFCWASTETERMINALTYPE", IFCWASTETERMINALTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOW", IFCWINDOW),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOWLININGPROPERTIES", IFCWINDOWLININGPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOWPANELPROPERTIES", IFCWINDOWPANELPROPERTIES),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOWSTANDARDCASE", IFCWINDOWSTANDARDCASE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOWSTYLE", IFCWINDOWSTYLE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWINDOWTYPE", IFCWINDOWTYPE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWORKCALENDAR", IFCWORKCALENDAR),
std::pair<std::string, IfcRoadEntityEnum>("IFCWORKCONTROL", IFCWORKCONTROL),
std::pair<std::string, IfcRoadEntityEnum>("IFCWORKPLAN", IFCWORKPLAN),
std::pair<std::string, IfcRoadEntityEnum>("IFCWORKSCHEDULE", IFCWORKSCHEDULE),
std::pair<std::string, IfcRoadEntityEnum>("IFCWORKTIME", IFCWORKTIME),
std::pair<std::string, IfcRoadEntityEnum>("IFCZSHAPEPROFILEDEF", IFCZSHAPEPROFILEDEF),
std::pair<std::string, IfcRoadEntityEnum>("IFCZONE", IFCZONE)
};
} // end namespace IfcRoad
} // end namespace OpenInfraPlatform
| [
"[email protected]"
] | |
8d49ce2a1b887b3256a7459fc872e3b20ccaaf5d | d9850b6b3d57cdcf8e85d09909d0d319483d051e | /Spoj/QTREE.cpp | 5e76958bede3497608bdfcff2e502d2ef794681b | [] | no_license | devashishtyagi/Code | 4d50c6edeff72ee1d2e114cc1406880b7c469a0c | 15bf5c28eec89396268d08a13423b3120c14e6bb | refs/heads/master | 2021-01-13T01:54:18.782548 | 2013-10-21T04:28:22 | 2013-10-21T04:28:22 | 4,054,752 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,363 | cpp | /* CPP Tempelate
* @author Devashish Tyagi
*/
#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <fstream>
#include <stack>
#include <string>
#include <vector>
#include <list>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define sf(a) scanf("%d",&a)
#define ssf(a,b) scanf("%d %d",&a,&b)
#define pf(a) printf("%d\n",a)
#define foreach(container, it) for(typeof(container.begin()) it = container.begin(); it != container.end(); it++)
#define pi pair<int,int>
#define vi vector<int>
#define all(v) v.begin(),v.end()
#define pb push_back
#define mp make_pair
#define sz(a) (int)(a).size()
#define forn(i,a,b) for(int (i) = (a); (i) < (b); ++(i))
#define rforn(i,a,b) for(int (i) = (a)-1; (i) >= (b); --(i))
#define init0(a) memset((a),0,sizeof(a))
#define INF 1000000000
#define MOD 1000000009
#define PI 3.1415926535897932
#define MAXN 10001
using namespace std;
typedef long long LL;
vector< vector< pair<int, int> > > graph;;
vector< vector<int> > heavy_light;
int parent[MAXN], chain[MAXN], head[MAXN], inverse_index[MAXN], parent_cost[MAXN], depth[MAXN];
bool heavy[MAXN];
int from[MAXN], to[MAXN], cost[MAXN];
int num = 0;
class HeavyLight {
private:
vector<int> tree;
vector<int> store;
int N;
void build(int node, int i, int j) {
if (i > j)
return;
if (i == j) {
tree[node] = store[i];
}
else {
int mid = (i+j)>>1;
build(2*node, i, mid);
build(2*node+1, mid+1, j);
tree[node] = max(tree[2*node], tree[2*node+1]);
}
}
int calc(int node, int i, int j, int a, int b) {
if (i > j || a > b || a > j || b < i)
return -INF;
if (i == a && j == b) {
return tree[node];
}
int mid = (i+j)>>1;
int p1 = calc(2*node, i, mid, a, min(b, mid));
int p2 = calc(2*node+1, mid+1, j, max(a, mid+1), b);
return max(p1, p2);
}
void update(int node, int i, int j, int v, int p) {
if (i > j || v < i || v > j)
return;
if (i == v && j == v) {
tree[node] = p;
return;
}
int mid = (i+j)>>1;
update(2*node, i, mid, v, p);
update(2*node+1, mid+1, j, v, p);
tree[node] = max(tree[2*node], tree[2*node+1]);
}
public:
void init(int n, vector<int>& st) {
N = n;
for(int i = 0; i < st.size(); i++) {
store.push_back(parent_cost[st[i]]);
}
tree.resize(4*N+2);
build(1, 0, N-1);
}
int get(int l, int r) {
return calc(1, 0, N-1, l, r);
}
void change(int v, int p) {
update(1, 0, N-1, v, p);
}
};
int dfs(int v, int p) {
if (p != -1)
depth[v] = depth[p]+1;
vector<int> subtree_size(graph[v].size(), 0);
for(int i = 0; i < graph[v].size(); i++) {
int to = graph[v][i].first;
if (to == p)
continue;
parent[to] = v;
parent_cost[to] = cost[graph[v][i].second];
subtree_size[i] = dfs(to, v);
}
int total = accumulate(subtree_size.begin(), subtree_size.end(), 0);
total++;
for(int i = 0; i < graph[v].size(); i++) {
int to = graph[v][i].first;
if (to == p)
continue;
if (total/2 < subtree_size[i])
heavy[to] = true;
}
return total;
}
void chainer(int v, int p) {
if (p != -1) {
if (heavy[v]) {
chain[v] = chain[p];
head[v] = head[p];
inverse_index[v] = inverse_index[p]+1;
}
else {
chain[v] = num++;
head[v] = v;
inverse_index[v] = 0;
}
}
else {
chain[v] = num++;
head[v] = v;
inverse_index[v] = 0;
}
heavy_light[chain[v]].push_back(v);
for(int i = 0; i < graph[v].size(); i++) {
int to = graph[v][i].first;
if (to == p)
continue;
chainer(to, v);
}
}
int lca(int a, int b) {
while(chain[a] != chain[b]) {
if (depth[head[a]] < depth[head[b]])
b = parent[head[b]];
else
a = parent[head[a]];
}
if (depth[a] < depth[b])
return a;
return b;
}
int maxEdge(int final, int v, vector<HeavyLight>& hl) {
int ans = -INF;
while(chain[v] != chain[final]) {
ans = max(ans, hl[chain[v]].get(inverse_index[head[v]], inverse_index[v]));
v = parent[head[v]];
}
ans = max(ans, hl[chain[v]].get(inverse_index[final]+1, inverse_index[v]));
return ans;
}
int main()
{
int t;
scanf("%d", &t);
while(t--) {
int n;
scanf("%d", &n);
num = 0;
graph.clear();
graph.resize(n);
heavy_light.clear();
heavy_light.resize(n);
memset(heavy, false, sizeof heavy);
memset(depth, 0, sizeof depth);
for(int i = 0; i < n-1; i++) {
scanf("%d %d %d", &from[i], &to[i], &cost[i]);
from[i]--;
to[i]--;
graph[from[i]].push_back(make_pair(to[i], i));
graph[to[i]].push_back(make_pair(from[i], i));
}
parent[0] = -1;
parent_cost[0] = -INF;
dfs(0, -1);
chainer(0, -1);
vector<HeavyLight> hl(num);
for(int i = 0; i < num; i++)
hl[i].init(heavy_light[i].size(), heavy_light[i]);
while(true) {
char cmd[50];
scanf("%s", cmd);
if (cmd[0] == 'Q') {
int a, b;
scanf("%d %d", &a, &b);
a--; b--;
int final = lca(a, b);
int max_edge = maxEdge(final, a, hl);
max_edge = max(max_edge, maxEdge(final, b, hl));
printf("%d\n", max_edge);
}
else if (cmd[0] == 'C') {
int v, p;
scanf("%d %d", &v, &p);
v--;
if (to[v] == parent[from[v]]) {
hl[chain[from[v]]].change(inverse_index[from[v]], p);
}
else {
hl[chain[to[v]]].change(inverse_index[to[v]], p);
}
}
else
break;
}
}
return 0;
}
| [
"[email protected]"
] | |
413523962fb9e5de78c986be418ac2531be21c9f | 157fd7fe5e541c8ef7559b212078eb7a6dbf51c6 | /TRiAS/TRiASDB/Future work/TRiASQL/UpdateItemList.h | b4768278c8cd28888db61c8ea826d379a803c241 | [] | no_license | 15831944/TRiAS | d2bab6fd129a86fc2f06f2103d8bcd08237c49af | 840946b85dcefb34efc219446240e21f51d2c60d | refs/heads/master | 2020-09-05T05:56:39.624150 | 2012-11-11T02:24:49 | 2012-11-11T02:24:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,785 | h | /* Product: Small Parser
Copyright (C) 1999 Systementor AB, Stefan Holmberg
Email - [email protected]
Web: - http://www.systementor.se
///////////////////////////////////////////////////////////////////////////////
*/
/* * $History: UpdateItemList.h $
*
* ***************** Version 2 *****************
* User: Stefan Holmberg Date: 7/11/99 Time: 12:24p
* Updated in $/Products/SmallParser
*/
// UpdateItemList.h : Declaration of the cUpdateItemList
#ifndef __UPDATEITEMLIST_H_
#define __UPDATEITEMLIST_H_
#include "resource.h" // main symbols
#include "UpdateItem.h" // main symbols
/////////////////////////////////////////////////////////////////////////////
// cUpdateItemList
typedef CComEnumOnSTL<IEnumVARIANT, &IID_IEnumVARIANT, VARIANT, _Copy<VARIANT>, vector<CComVariant> > VecEnum;
typedef ICollectionOnSTLImpl<IUpdateItemList, vector<CComVariant>, VARIANT, _Copy<VARIANT>, VecEnum> IUpdateItemColl;
class ATL_NO_VTABLE cUpdateItemList :
public CComObjectRootEx<CComSingleThreadModel>,
public CComCoClass<cUpdateItemList, &CLSID_UpdateItemList>,
public ISupportErrorInfo,
public IDispatchImpl<IUpdateItemColl, &IID_IUpdateItemList, &LIBID_TRiASQL>
{
public:
cUpdateItemList();
~cUpdateItemList();
void AddItem( cUpdateItem *pIdent );
// DECLARE_REGISTRY_RESOURCEID(IDR_UPDATEITEMLIST)
DECLARE_NO_REGISTRY()
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(cUpdateItemList)
COM_INTERFACE_ENTRY(IUpdateItemList)
COM_INTERFACE_ENTRY(IDispatch)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
END_COM_MAP()
// ISupportsErrorInfo
STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid);
// IUpdateItemList
public:
};
#endif //__UPDATEITEMLIST_H_
| [
"Windows Live ID\\[email protected]"
] | Windows Live ID\[email protected] |
52c949873a7a882d527b674b56c82cd1e1f86b30 | 2d61e0ba094cafd3db3bebb0a37b5c2ef8630f03 | /src/denomination_functions.cpp | 4d4e1b864641bc758d5b59586c93d8adb1f2645a | [] | no_license | opencash-project/OpenCASH | 0b4fb886dc239007e69cdcf60351f1dbc846ba1c | 3192bd6296640e3c933e976c04d627d1d8746cb8 | refs/heads/master | 2022-12-04T13:05:48.296911 | 2020-08-23T23:55:59 | 2020-08-23T23:55:59 | 289,153,637 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,519 | cpp | // Copyright (c) 2017-2018 The OCASH Developers
// Copyright (c) 2018 The OCASHCOIN Developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "denomination_functions.h"
using namespace libzerocoin;
// -------------------------------------------------------------------------------------------------------
// Get exact amounts to mint for CTxOuts. Used to caculate rewards on a z0cash stake.
// -------------------------------------------------------------------------------------------------------
std::map<CoinDenomination, int> calculateOutputs(const CAmount nAmountToMint){
std::map<CoinDenomination, int> mapUsed;
CAmount nRemainingValue = nAmountToMint;
// Initialize
for (const auto& denom : zerocoinDenomList)
mapUsed.insert(std::pair<CoinDenomination, int>(denom, 0));
LogPrintf("%s: Total=%d Begining Calculate...\r\n", __func__, (nAmountToMint / COIN));
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
CAmount nValue = ZerocoinDenominationToAmount(coin);
do {
if (nRemainingValue >= nValue) {
mapUsed.at(coin)++;
nRemainingValue -= nValue;
LogPrintf("%s: Added=%d Remaining=%d\r\n", __func__, (nValue / COIN), (nRemainingValue / COIN));
}
} while (nRemainingValue >= nValue);
}
return mapUsed;
}
// -------------------------------------------------------------------------------------------------------
// Number of coins used for either change or a spend given a map of coins used
// -------------------------------------------------------------------------------------------------------
int getNumberOfCoinsUsed(
const std::map<CoinDenomination, CAmount>& mapChange)
{
int nChangeCount = 0;
for (const auto& denom : zerocoinDenomList) {
nChangeCount += mapChange.at(denom);
}
return nChangeCount;
}
// -------------------------------------------------------------------------------------------------------
// Find the max CoinDenomination amongst held coins
// -------------------------------------------------------------------------------------------------------
CoinDenomination getMaxDenomHeld(
const std::map<CoinDenomination, CAmount>& mapCoinsHeld)
{
CoinDenomination maxDenom = ZQ_ERROR;
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
if (mapCoinsHeld.at(coin)) {
maxDenom = coin;
break;
}
}
return maxDenom;
}
// -------------------------------------------------------------------------------------------------------
// Get Exact Amount with CoinsHeld
// -------------------------------------------------------------------------------------------------------
std::map<CoinDenomination, CAmount> getSpendCoins(const CAmount nValueTarget,
const std::map<CoinDenomination, CAmount> mapOfDenomsHeld)
{
std::map<CoinDenomination, CAmount> mapUsed;
CAmount nRemainingValue = nValueTarget;
// Initialize
for (const auto& denom : zerocoinDenomList)
mapUsed.insert(std::pair<CoinDenomination, CAmount>(denom, 0));
// Start with the Highest Denomination coin and grab coins as long as the remaining amount is greater than the
// current denomination value and we have the denom
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
CAmount nValue = ZerocoinDenominationToAmount(coin);
do {
if ((nRemainingValue >= nValue) && (mapUsed.at(coin) < mapOfDenomsHeld.at(coin))) {
mapUsed.at(coin)++;
nRemainingValue -= nValue;
}
} while ((nRemainingValue >= nValue) && (mapUsed.at(coin) < mapOfDenomsHeld.at(coin)));
}
return mapUsed;
}
// -------------------------------------------------------------------------------------------------------
// Get change (no limits)
// -------------------------------------------------------------------------------------------------------
std::map<CoinDenomination, CAmount> getChange(const CAmount nValueTarget)
{
std::map<CoinDenomination, CAmount> mapChange;
CAmount nRemainingValue = nValueTarget;
// Initialize
for (const auto& denom : zerocoinDenomList)
mapChange.insert(std::pair<CoinDenomination, CAmount>(denom, 0));
// Start with the Highest Denomination coin and grab coins as long as the remaining amount is greater than the
// current denomination value
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
CAmount nValue = ZerocoinDenominationToAmount(coin);
do {
if (nRemainingValue >= nValue) {
mapChange.at(coin)++;
nRemainingValue -= nValue;
}
} while (nRemainingValue >= nValue);
}
return mapChange;
}
// -------------------------------------------------------------------------------------------------------
// Attempt to use coins held to exactly reach nValueTarget, return mapOfDenomsUsed with the coin set used
// Return false if exact match is not possible
// -------------------------------------------------------------------------------------------------------
bool getIdealSpends(
const CAmount nValueTarget,
const std::list<CMintMeta>& listMints,
const std::map<CoinDenomination, CAmount> mapOfDenomsHeld,
std::map<CoinDenomination, CAmount>& mapOfDenomsUsed)
{
CAmount nRemainingValue = nValueTarget;
// Initialize
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.insert(std::pair<CoinDenomination, CAmount>(denom, 0));
// Start with the Highest Denomination coin and grab coins as long as the remaining amount is greater than the
// current denomination value
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
for (const CMintMeta& mint : listMints) {
if (mint.isUsed) continue;
if (nRemainingValue >= ZerocoinDenominationToAmount(coin) && coin == mint.denom) {
mapOfDenomsUsed.at(coin)++;
nRemainingValue -= ZerocoinDenominationToAmount(mint.denom);
}
if (nRemainingValue < ZerocoinDenominationToAmount(coin)) break;
}
}
return (nRemainingValue == 0);
}
// -------------------------------------------------------------------------------------------------------
// Return a list of Mint coins based on mapOfDenomsUsed and the overall value in nCoinsSpentValue
// -------------------------------------------------------------------------------------------------------
std::vector<CMintMeta> getSpends(
const std::list<CMintMeta>& listMints,
std::map<CoinDenomination, CAmount>& mapOfDenomsUsed,
CAmount& nCoinsSpentValue)
{
std::vector<CMintMeta> vSelectedMints;
nCoinsSpentValue = 0;
for (auto& coin : reverse_iterate(zerocoinDenomList)) {
do {
for (const CMintMeta& mint : listMints) {
if (mint.isUsed) continue;
if (coin == mint.denom && mapOfDenomsUsed.at(coin)) {
vSelectedMints.push_back(mint);
nCoinsSpentValue += ZerocoinDenominationToAmount(coin);
mapOfDenomsUsed.at(coin)--;
}
}
} while (mapOfDenomsUsed.at(coin));
}
return vSelectedMints;
}
// -------------------------------------------------------------------------------------------------------
// Just for printing/debuggin
// -------------------------------------------------------------------------------------------------------
void listSpends(const std::vector<CZerocoinMint>& vSelectedMints)
{
std::map<libzerocoin::CoinDenomination, int64_t> mapZerocoinSupply;
for (auto& denom : libzerocoin::zerocoinDenomList)
mapZerocoinSupply.insert(std::make_pair(denom, 0));
for (const CZerocoinMint& mint : vSelectedMints) {
libzerocoin::CoinDenomination denom = mint.GetDenomination();
mapZerocoinSupply.at(denom)++;
}
CAmount nTotal = 0;
for (auto& denom : libzerocoin::zerocoinDenomList) {
LogPrint("zero", "%s %d coins for denomination %d used\n", __func__, mapZerocoinSupply.at(denom), denom);
nTotal += libzerocoin::ZerocoinDenominationToAmount(denom);
}
LogPrint("zero", "Total value of coins %d\n", nTotal);
}
// -------------------------------------------------------------------------------------------------------
// Find the CoinDenomination with the most number for a given amount
// -------------------------------------------------------------------------------------------------------
CoinDenomination getDenomWithMostCoins(
const std::map<CoinDenomination, CAmount>& mapOfDenomsUsed)
{
CoinDenomination maxCoins = ZQ_ERROR;
CAmount nMaxNumber = 0;
for (const auto& denom : zerocoinDenomList) {
CAmount amount = mapOfDenomsUsed.at(denom);
if (amount > nMaxNumber) {
nMaxNumber = amount;
maxCoins = denom;
}
}
return maxCoins;
}
// -------------------------------------------------------------------------------------------------------
// Get the next denomination above the current one. Return ZQ_ERROR if already at the highest
// -------------------------------------------------------------------------------------------------------
CoinDenomination getNextHighestDenom(const CoinDenomination& this_denom)
{
CoinDenomination nextValue = ZQ_ERROR;
for (const auto& denom : zerocoinDenomList) {
if (ZerocoinDenominationToAmount(denom) > ZerocoinDenominationToAmount(this_denom)) {
nextValue = denom;
break;
}
}
return nextValue;
}
// -------------------------------------------------------------------------------------------------------
// Get the next denomination below the current one that is also amongst those held.
// Return ZQ_ERROR if none found
// -------------------------------------------------------------------------------------------------------
CoinDenomination getNextLowerDenomHeld(const CoinDenomination& this_denom,
const std::map<CoinDenomination, CAmount>& mapCoinsHeld)
{
CoinDenomination nextValue = ZQ_ERROR;
for (auto& denom : reverse_iterate(zerocoinDenomList)) {
if ((denom < this_denom) && (mapCoinsHeld.at(denom) != 0)) {
nextValue = denom;
break;
}
}
return nextValue;
}
int minimizeChange(
int nMaxNumberOfSpends,
int nChangeCount,
const CoinDenomination nextToMaxDenom,
const CAmount nValueTarget,
const std::map<CoinDenomination, CAmount>& mapOfDenomsHeld,
std::map<CoinDenomination, CAmount>& mapOfDenomsUsed)
{
// Now find out if possible without using 1 coin such that we have more spends but less change
// First get set of coins close to value but still less than value (since not exact)
CAmount nRemainingValue = nValueTarget;
CAmount AmountUsed = 0;
int nCoinCount = 0;
// Re-clear this
std::map<CoinDenomination, CAmount> savedMapOfDenomsUsed = mapOfDenomsUsed;
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.at(denom) = 0;
// Find the amount this is less than total but uses up higher denoms first,
// starting at the denom that is not greater than the overall total
for (const auto& denom : reverse_iterate(zerocoinDenomList)) {
if (denom <= nextToMaxDenom) {
CAmount nValue = ZerocoinDenominationToAmount(denom);
do {
if ((nRemainingValue > nValue) && (mapOfDenomsUsed.at(denom) < mapOfDenomsHeld.at(denom))) {
mapOfDenomsUsed.at(denom)++;
nRemainingValue -= nValue;
AmountUsed += nValue;
nCoinCount++;
}
} while ((nRemainingValue > nValue) && (mapOfDenomsUsed.at(denom) < mapOfDenomsHeld.at(denom)));
}
}
// Now work way back up from the bottom filling in with the denom that we have that is just
// bigger than the remaining amount
// Shouldn't need more than one coin here?
for (const auto& denom : zerocoinDenomList) {
CAmount nValue = ZerocoinDenominationToAmount(denom);
if ((nValue > nRemainingValue) && (mapOfDenomsUsed.at(denom) < mapOfDenomsHeld.at(denom))) {
mapOfDenomsUsed.at(denom)++;
nRemainingValue -= nValue;
AmountUsed += nValue;
nCoinCount++;
}
if (nRemainingValue < 0) break;
}
// This can still result in a case where you've used an extra spend than needed.
// e.g Spend of 26, while having 1*5 + 4*10
// First stage may be 2*10+5 (i.e < 26)
// Second stage can be 3*10+5 (no more fives, so add a 10)
// So 5 is no longer needed and will become change also
CAmount nAltChangeAmount = AmountUsed - nValueTarget;
std::map<CoinDenomination, CAmount> mapAltChange = getChange(nAltChangeAmount);
// Check if there is overlap between change and spend denominations
// And if so, remove those that overlap
for (const auto& denom : zerocoinDenomList) {
do {
if (mapAltChange.at(denom) && mapOfDenomsUsed.at(denom)) {
mapOfDenomsUsed.at(denom)--;
mapAltChange.at(denom)--;
nCoinCount--;
CAmount nValue = ZerocoinDenominationToAmount(denom);
AmountUsed -= nValue;
}
} while (mapAltChange.at(denom) && mapOfDenomsUsed.at(denom));
}
// Still possible to have wrong mix. So meet exact amount found above - with least number of coins
mapOfDenomsUsed = getSpendCoins(AmountUsed, mapOfDenomsHeld);
nCoinCount = getNumberOfCoinsUsed(mapOfDenomsUsed);
// Re-calculate change
nAltChangeAmount = AmountUsed - nValueTarget;
mapAltChange = getChange(nAltChangeAmount);
int AltChangeCount = getNumberOfCoinsUsed(mapAltChange);
// Alternative method yields less mints and is less than MaxNumberOfSpends if true
if ((AltChangeCount < nChangeCount) && (nCoinCount <= nMaxNumberOfSpends)) {
return AltChangeCount;
} else {
// if we don't meet above go back to what we started with
mapOfDenomsUsed = savedMapOfDenomsUsed;
return nChangeCount;
}
}
// -------------------------------------------------------------------------------------------------------
// Couldn't meet amount exactly, will need to generate change
// returning with a 0 means either too many spends or no change
// Latter should never happen since we should only get here if exact is not possible
// -------------------------------------------------------------------------------------------------------
int calculateChange(
int nMaxNumberOfSpends,
bool fMinimizeChange,
const CAmount nValueTarget,
const std::map<CoinDenomination, CAmount>& mapOfDenomsHeld,
std::map<CoinDenomination, CAmount>& mapOfDenomsUsed)
{
CoinDenomination minDenomOverTarget = ZQ_ERROR;
// Initialize
mapOfDenomsUsed.clear();
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.insert(std::pair<CoinDenomination, CAmount>(denom, 0));
for (const auto& denom : zerocoinDenomList) {
if (nValueTarget < ZerocoinDenominationToAmount(denom) && mapOfDenomsHeld.at(denom)) {
minDenomOverTarget = denom;
break;
}
}
// OK so if != ZQ_ERROR we have a solution using 1 coin
if (minDenomOverTarget != ZQ_ERROR) {
mapOfDenomsUsed.at(minDenomOverTarget) = 1;
// Now find out # of coins in change
CAmount nChangeAmount = ZerocoinDenominationToAmount(minDenomOverTarget) - nValueTarget;
std::map<CoinDenomination, CAmount> mapChange = getChange(nChangeAmount);
int nChangeCount = getNumberOfCoinsUsed(mapChange);
if (fMinimizeChange) {
CoinDenomination nextToMaxDenom = getNextLowerDenomHeld(minDenomOverTarget, mapOfDenomsHeld);
int newChangeCount = minimizeChange(nMaxNumberOfSpends, nChangeCount,
nextToMaxDenom, nValueTarget,
mapOfDenomsHeld, mapOfDenomsUsed);
// Alternative method yields less mints and is less than MaxNumberOfSpends if true
if (newChangeCount < nChangeCount) return newChangeCount;
// Reclear
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.at(denom) = 0;
// Then reset as before previous clearing
mapOfDenomsUsed.at(minDenomOverTarget) = 1;
}
return nChangeCount;
} else {
// Try to meet a different way
for (const auto& denom : zerocoinDenomList)
mapOfDenomsUsed.at(denom) = 0;
CAmount nRemainingValue = nValueTarget;
int nCoinCount = 0;
CAmount AmountUsed = 0;
for (const auto& denom : reverse_iterate(zerocoinDenomList)) {
CAmount nValue = ZerocoinDenominationToAmount(denom);
do {
if (mapOfDenomsHeld.at(denom) && nRemainingValue > 0) {
mapOfDenomsUsed.at(denom)++;
AmountUsed += nValue;
nRemainingValue -= nValue;
nCoinCount++;
}
} while ((nRemainingValue > 0) && (mapOfDenomsUsed.at(denom) < mapOfDenomsHeld.at(denom)));
if (nRemainingValue < 0) break;
}
CAmount nChangeAmount = AmountUsed - nValueTarget;
std::map<CoinDenomination, CAmount> mapChange = getChange(nChangeAmount);
int nMaxChangeCount = getNumberOfCoinsUsed(mapChange);
// Instead get max Denom held
CoinDenomination maxDenomHeld = getMaxDenomHeld(mapOfDenomsHeld);
// Assign for size (only)
std::map<CoinDenomination, CAmount> mapOfMinDenomsUsed = mapOfDenomsUsed;
int nChangeCount = minimizeChange(nMaxNumberOfSpends, nMaxChangeCount,
maxDenomHeld, nValueTarget,
mapOfDenomsHeld, mapOfMinDenomsUsed);
int nNumSpends = getNumberOfCoinsUsed(mapOfMinDenomsUsed);
if (!fMinimizeChange && (nCoinCount < nNumSpends)) {
return nMaxChangeCount;
}
mapOfDenomsUsed = mapOfMinDenomsUsed;
return nChangeCount;
}
}
// -------------------------------------------------------------------------------------------------------
// Given a Target Spend Amount, attempt to meet it with a set of coins where less than nMaxNumberOfSpends
// 'spends' are required
// -------------------------------------------------------------------------------------------------------
std::vector<CMintMeta> SelectMintsFromList(const CAmount nValueTarget, CAmount& nSelectedValue, int nMaxNumberOfSpends, bool fMinimizeChange,
int& nCoinsReturned, const std::list<CMintMeta>& listMints,
const std::map<CoinDenomination, CAmount> mapOfDenomsHeld, int& nNeededSpends)
{
std::vector<CMintMeta> vSelectedMints;
std::map<CoinDenomination, CAmount> mapOfDenomsUsed;
nNeededSpends = 0;
bool fCanMeetExactly = getIdealSpends(nValueTarget, listMints, mapOfDenomsHeld, mapOfDenomsUsed);
if (fCanMeetExactly) {
nCoinsReturned = 0;
nSelectedValue = nValueTarget;
vSelectedMints = getSpends(listMints, mapOfDenomsUsed, nSelectedValue);
// If true, we are good and done!
if (vSelectedMints.size() <= (size_t)nMaxNumberOfSpends) {
return vSelectedMints;
}
else {
nNeededSpends = vSelectedMints.size();
}
}
// Since either too many spends needed or can not spend the exact amount,
// calculate the change needed and the map of coins used
nCoinsReturned = calculateChange(nMaxNumberOfSpends, fMinimizeChange, nValueTarget, mapOfDenomsHeld, mapOfDenomsUsed);
if (nCoinsReturned == 0) {
LogPrint("zero", "%s: Problem getting change (TBD) or Too many spends %d\n", __func__, nValueTarget);
vSelectedMints.clear();
} else {
vSelectedMints = getSpends(listMints, mapOfDenomsUsed, nSelectedValue);
LogPrint("zero", "%s: %d coins in change for %d\n", __func__, nCoinsReturned, nValueTarget);
}
return vSelectedMints;
}
| [
"[email protected]"
] | |
968ae1bc2a433d8bef15f65f8bca929840d535be | fccc88fec4a64316380bf0d185bb8618e5c7c97d | /C/donhietdo/donhietdo.ino | addabf9420d4f82de8070a2cc39123459c07831d | [] | no_license | lequydon4199/IOT2020 | 4c3d535f5592dca400b81a3aaa51041776a2b4fd | 8def0fbc52aa839e1ac4278ae45c93547ae31b4c | refs/heads/master | 2023-01-31T17:13:56.363110 | 2020-12-19T05:03:18 | 2020-12-19T05:03:18 | 322,757,805 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,648 | ino | #include <Wire.h>
#include <Adafruit_MLX90614.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ArduinoJson.h>
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
const char* ssid = "bullshit";
const char* password = "tumotdenchin";
const char* server = "http://192.168.137.101:5000/logs";
void setup() {
Serial.begin(9600);
mlx.begin();
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(1000);
Serial.println("Connecting wifi ...");
}
Serial.print("Connected, IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
if (WiFi.status() == WL_CONNECTED) {
StaticJsonBuffer<300> JSONbuffer; //Declaring static JSON buffer
JsonObject& JSONencoder = JSONbuffer.createObject();
JSONencoder["temperature_object"] = mlx.readObjectTempC();
JSONencoder["temperature_ambient"] = mlx.readAmbientTempC();
char JSONmessageBuffer[300];
JSONencoder.prettyPrintTo(JSONmessageBuffer, sizeof(JSONmessageBuffer));
HTTPClient http; //Object of class HTTPClient
http.begin(server);
http.addHeader("Content-Type", "application/json"); //Specify content-type header
//Serial.println("POST TO SERVER ...");
Serial.print("Ambient = "); Serial.print(mlx.readAmbientTempC());
Serial.print("*C\tObject = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C");
int httpCode = http.POST(JSONmessageBuffer); //Send the request
String payload = http.getString();
//Serial.print("SERVER RESPOSNE CODE: ");Serial.println(httpCode);
} else {
Serial.println("Disconnect Wifi ...");
}
Serial.println();
delay(1000);
}
| [
"[email protected]"
] | |
32a1e777371b9b7aa406e82d1b2a86a58469943b | e490dfe5a0bdce25f455b5783b9d3ddb5f8f38d0 | /IOI Training Camp Tasks/2017/Home Tasks/Jumper.cpp | b6a7c71f6fc0bbbb20b3ed1b2a8495bb9df68e2c | [] | no_license | NirShalmon/Competitive-Programming-Code | 8984a52007419017477a508b1e353799b7719b45 | 0036ffacc40e4d732ac3cd06718044097246e1a5 | refs/heads/master | 2020-05-24T12:40:02.064363 | 2019-09-16T21:14:44 | 2019-09-16T21:14:44 | 187,273,117 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,512 | cpp | /*****************
Competative programming code written by Nir Shalmon
IMPORTANT NOTE: This code was written during a time limited competition or for use in competition.
THIS CODE IS NOT AN INDICATION OF MY USUAL CODE QUALITY!!
******************/
#include<bits/stdc++.h>
using namespace std;
int n,k;
pair<int, int> p[100000];
map<int, set<int>> x, y;
string st;
int main() {
ios::sync_with_stdio(false);
cin >> n>>k;
cin >> st;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
p[i] = { a + b, b - a };
if (i != 0) {
x[p[i].first].insert(p[i].second);
y[p[i].second].insert(p[i].first);
}
}
int cx = p[0].first,cy = p[0].second;
for (char c : st) {
if (c == 'A') {
auto f = y[cy].upper_bound(cx);
if (f != y[cy].end()) {
int nx = *f;
x[nx].erase(cy);
y[cy].erase(f);
cx = nx;
}
} else if (c == 'D') {
auto f = y[cy].upper_bound(cx);
if (f != y[cy].begin() && y[cy].size() > 0) {
--f;
int nx = *f;
x[nx].erase(cy);
y[cy].erase(f);
cx = nx;
}
}else if (c == 'C') {
auto f = x[cx].upper_bound(cy);
if (f != x[cx].end()) {
int ny = *f;
y[ny].erase(cx);
x[cx].erase(f);
cy = ny;
}
} else if (c == 'B') {
auto f = x[cx].upper_bound(cy);
if (f != x[cx].begin() && x[cx].size() > 0) {
--f;
int ny = *f;
y[ny].erase(cx);
x[cx].erase(f);
cy = ny;
}
}
}
cout << (cx - cy) / 2 << ' ' << (cx + cy) / 2;
} | [
"[email protected]"
] | |
0b4ec207fcba3805333506eaf4cc559446e09d01 | b6351ee2f787d3d6b4998de00011bf64040daef6 | /wemos programs/test_lolin32_analog/test_lolin32_analog.ino | 19844ec3fdfac949a7699cd6f7506ef42865448e | [] | no_license | jonasdeschoenmacker/Project_lijn-_en_muurvolger_2ELO1_team5 | 8e48c93cb0e05e8a147d676d71542f7093361fca | e68d7274b1ec64553265864dbbd561c1311d1d36 | refs/heads/master | 2020-04-07T13:23:11.785320 | 2018-03-07T10:01:00 | 2018-03-07T10:01:00 | 124,215,334 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 784 | ino |
int ledPin = 15;
int analogPin = 34;
int motorPin = 5;
// use first channel of 16 channels (started from zero)
//#define LEDC_CHANNEL_0 1
// use 13 bit precission for LEDC timer
//#define LEDC_TIMER_8_BIT 8
// use 5000 Hz as a LEDC base frequency
//#define LEDC_BASE_FREQ 12000
void setup()
{
ledcSetup(0, 5000, 8);
ledcAttachPin(motorPin, 0);
Serial.begin(115200);
}
void loop()
{
//Serial.println("Hello ESP32!");
//digitalWrite(ledPin, HIGH);
long input = analogRead(analogPin);
Serial.println(input);
//delay(500);
//digitalWrite(ledPin, LOW);
//delay(500);
int dutyCycle = map(input, 0, 4095, 0, 255);
//ledcWrite(motorPin, 200);
//ledcAnalogWrite(0, dutyCycle);
//analogWrite(motorPin, 100);
ledcWrite(0, dutyCycle);
delay(20);
}
| [
"[email protected]"
] | |
440f7191570d9d001660c293fb6281dc7d59bd62 | 70092c8cb3771664643082385a99498d5e4326a6 | /testCommon/Bin/Chunks_CPP_seed_-9039153669293870600/chunk_021_-09_metadata.cpp | ef759b0bc68bc31d21aacaeb7dd89fcd66eff462 | [
"MIT"
] | permissive | de-gel/MineCraftServer | bf2c9a19f367f346b23213ea640df7460347c894 | cc98e9fdd8a8b6c8fa0d83b9aabc6fbeb9bb1dd9 | refs/heads/master | 2021-05-02T13:56:08.043873 | 2018-02-09T04:14:55 | 2018-02-09T04:14:55 | 120,709,594 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 89,280 | cpp | section:0 y:0 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:0 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:1 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:2 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:3 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:4 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:5 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:6 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:7 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:8 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:9 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:10 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:11 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:12 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:13 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:14 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:0 y:15 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:0 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:1 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:2 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:3 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:4 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:5 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:6 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:7 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:8 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:9 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:10 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:11 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:12 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:13 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:14 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:1 y:15 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:0 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:1 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:2 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:3 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:4 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:5 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:6 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:7 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:8 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:9 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:10 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:11 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:12 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:13 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:14 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:2 y:15 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:0 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:1 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:2 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:3 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:4 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:5 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:6 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:7 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:8 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:9 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:10 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:11 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:12 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:13 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:14 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:3 y:15 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:12 x: 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0
section:4 y:0 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:0 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0
section:4 y:0 z:15 x: 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0
section:4 y:1 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:1 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:2 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:3 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:4 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:5 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:6 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:7 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:8 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:9 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:10 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:11 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:12 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:13 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:14 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:0 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:1 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:2 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:3 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:4 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:5 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:6 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:7 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:8 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:9 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:10 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:11 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:12 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:13 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:14 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
section:4 y:15 z:15 x: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
| [
"[email protected]"
] | |
fd6f7b38a62413e3d482d1964e327086ec154125 | f852083467f5137b63b7acf1fc56446fad7e2552 | /libpeconv/include/peconv/resource_parser.h | cd41cb3b13a2553104019d7608fb1c993664cdfd | [
"BSD-2-Clause"
] | permissive | Gaijin77/libpeconv | f35b5883ffe9be07623c56f4abf5959c98c09fb0 | 3fbd4a60466c05082ee044359226eecf5503e752 | refs/heads/master | 2022-04-23T12:58:49.441536 | 2020-04-13T17:24:33 | 2020-04-13T17:24:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 773 | h | /**
* @file
* @brief Parsing PE's resource directory.
*/
#pragma once
#include <Windows.h>
namespace peconv {
/**
A callback that will be executed by the function parse_resources when the Resource Entry was found.
*/
typedef bool(*t_on_res_entry_found) (
BYTE* modulePtr,
IMAGE_RESOURCE_DIRECTORY_ENTRY *root_dir,
IMAGE_RESOURCE_DATA_ENTRY *curr_entry
);
/**
A function walking through the Resource Tree of the given PE. On each Resource Entry found, the callback is executed.
\param modulePtr : pointer to the buffer with the PE in a Virtual format
\param on_entry : a callback function executed on each Resource Entry
*/
bool parse_resources(BYTE* modulePtr, t_on_res_entry_found on_entry);
};
| [
"[email protected]"
] | |
d3b3663df99701cb26b076de1de5253990d2ed6e | b3636e545eb3228327ce827e0e0f365dcabf6baf | /aten/src/ATen/native/UpSampleNearest2d.cpp | 295d974aa11b7abf38a03a9eb1a18aa03fcce095 | [
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"BSL-1.0",
"Apache-2.0",
"BSD-2-Clause"
] | permissive | mohamedmindee/pytorch | b358b35e467c50f4e5f112e44d3301ec3f7ef955 | 4ee631cdf0d7138d362c7091c8de73d5fa265d08 | refs/heads/master | 2023-02-18T04:35:43.286850 | 2021-01-14T12:25:30 | 2021-01-14T12:33:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,250 | cpp | #include <ATen/ATen.h>
#include <ATen/NativeFunctions.h>
#include <ATen/native/UpSample.h>
namespace at {
namespace meta {
static std::array<int64_t, 4> upsample_nearest2d_common_check(IntArrayRef input_size, IntArrayRef output_size) {
TORCH_CHECK(
output_size.size() == 2,
"It is expected output_size equals to 2, but got size ",
output_size.size());
TORCH_CHECK(
input_size.size() == 4,
"It is expected input_size equals to 4, but got size ",
input_size.size());
int64_t output_height = output_size[0];
int64_t output_width = output_size[1];
int64_t nbatch = input_size[0];
int64_t channels = input_size[1];
int64_t input_height = input_size[2];
int64_t input_width = input_size[3];
TORCH_CHECK(
input_height > 0 && input_width > 0 && output_height > 0 &&
output_width > 0,
"Input and output sizes should be greater than 0,"
" but got input (H: ",
input_height,
", W: ",
input_width,
") output (H: ",
output_height,
", W: ",
output_width,
")");
return {nbatch, channels, output_height, output_width};
}
TORCH_META_FUNC(upsample_nearest2d) (
const Tensor& input, IntArrayRef output_size, c10::optional<double> scales_h, c10::optional<double> scales_w
) {
auto full_output_size = upsample_nearest2d_common_check(input.sizes(), output_size);
// Allow for empty batch size but not other dimensions
TORCH_CHECK(
input.numel() != 0 || prod_intlist(input.sizes().begin() + 1, input.sizes().end()),
"Non-empty 4D data tensor expected but got a tensor with sizes ",
input.sizes());
set_output(full_output_size, input.options());
}
TORCH_META_FUNC(upsample_nearest2d_backward) (
const Tensor& grad_output,
IntArrayRef output_size,
IntArrayRef input_size,
c10::optional<double> scales_h,
c10::optional<double> scales_w
) {
auto full_output_size = upsample_nearest2d_common_check(input_size, output_size);
TORCH_CHECK(
grad_output.dim() == 4,
"Expected grad_output to be a tensor of dimension 4 but got: dimension ", grad_output.dim());
for (int i = 0; i < 4; ++i) {
TORCH_CHECK(
grad_output.size(i) == full_output_size[i],
"Expected grad_output to have the same shape as output;",
" output.size(", i, ") = ", full_output_size[i],
" but got grad_output.size(", i, ") = ", grad_output.size(i));
}
set_output(input_size, grad_output.options());
}
} // namespace meta
namespace native {
TORCH_IMPL_FUNC(upsample_nearest2d_out_cpu) (
const Tensor& input,
IntArrayRef output_size,
c10::optional<double> scales_h,
c10::optional<double> scales_w,
Tensor& output
) {
upsample_nearest2d_kernel(kCPU, output, input, scales_h, scales_w);
}
TORCH_IMPL_FUNC(upsample_nearest2d_backward_out_cpu) (
const Tensor& grad_output,
IntArrayRef output_size,
IntArrayRef input_size,
c10::optional<double> scales_h,
c10::optional<double> scales_w,
Tensor& grad_input) {
grad_input.zero_();
upsample_nearest2d_backward_kernel(kCPU, grad_input, grad_output, scales_h, scales_w);
}
using at::native::upsample::compute_output_size;
using at::native::upsample::get_scale_value;
Tensor upsample_nearest2d_cpu(
const Tensor& input,
c10::optional<IntArrayRef> output_size,
c10::optional<ArrayRef<double>> scale_factors) {
auto osize = compute_output_size(input.sizes(), output_size, scale_factors);
auto scale_h = get_scale_value(scale_factors, 0);
auto scale_w = get_scale_value(scale_factors, 1);
return at::upsample_nearest2d(input, osize, scale_h, scale_w);
}
Tensor upsample_nearest2d_backward_cpu(
const Tensor& grad_output,
c10::optional<IntArrayRef> output_size,
IntArrayRef input_size,
c10::optional<ArrayRef<double>> scale_factors) {
auto osize = compute_output_size(input_size, output_size, scale_factors);
auto scale_h = get_scale_value(scale_factors, 0);
auto scale_w = get_scale_value(scale_factors, 1);
return at::upsample_nearest2d_backward(grad_output, osize, input_size, scale_h, scale_w);
}
DEFINE_DISPATCH(upsample_nearest2d_kernel);
DEFINE_DISPATCH(upsample_nearest2d_backward_kernel);
} // namespace native
} // namespace at
| [
"[email protected]"
] | |
d02cd75cb31e6a66e88d4b72a8605df335aff364 | 976004c9f4426106d7ca59db25755d4d574b8025 | /algorithms/gaussian_processes/functions/cov/cov_mat3.h | 86559eb84d717cc11eba7cb7bea5d4ed874c702f | [] | no_license | peterzxli/cvpp | 18a90c23baaaa07a32b2aafdb25d6ae78a1768c0 | 3b73cfce99dc4b5908cd6cb7898ce5ef1e336dce | refs/heads/master | 2022-12-05T07:23:20.488638 | 2020-08-11T20:08:10 | 2020-08-11T20:08:10 | 286,062,971 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,217 | h | #ifndef COV_MAT3_H
#define COV_MAT3_H
#include "../cov_base.h"
namespace cvpp
{
class CovMat3 : public CovBase
{
protected:
public:
// Constructor
CovMat3( const unsigned& type = ISO ) : CovBase( type )
{
}
// Hyp Number
const unsigned n() const
{
return 1;
}
// Calculate Diagonal
Matd calcDiag( const Matd& X ,
const Vecd& hyps ) const
{
Matd k( X.r() );
k = exp( hyps[-1] );
return k;
}
// Calculate Dense
Matd calcDense( const Matd& X1 , const Matd& X2 ,
const Vecd& hyps ) const
{
Matd S = LSeqMat1( hyps , 0 , X1.c() );
Matd D = dist1( X1 * S , X2 * S ) * sqrt( 3.0 );
return exp( hyps[-1] ) * ( 1.0 + D ) % ( - D ).exp();
}
// Hyp Gradient Diagonal
Matd gradDiag( const Matd& X ,
const Vecd& hyps , const Matd& K , const unsigned& i ) const
{
switch( ls_type )
{
case ISO:
disp("NO COV HYPISO DIAGONAL GRADIENT");
case ARD:
disp("NO COV HYPARD DIAGONAL GRADIENT");
}
}
// Hyp Gradient Dense
Matd gradDense( const Matd& X1 , const Matd& X2 ,
const Vecd& hyps , const Matd& K , const unsigned& i ) const
{
switch( ls_type )
{
case ISO:
if( i == 0 )
{
Matd S = LSeqMat1( hyps , 0 , X1.c() );
Matd D = dist1( X1 * S , X2 * S ) * sqrt( 3.0 );
return exp( hyps[-1] ) * D.square() % ( - D ).exp();
}
if( i == 1 )
{
return K;
}
case ARD:
disp("NO COV HYPARD DENSE GRADIENT");
}
}
// Ind Gradient Diagonal
Matd gindDiag( const Matd& X ,
const Vecd& hyps , const Matd& K , const unsigned& i ) const
{
disp("NO COV IND DIAGONAL GRADIENT");
}
// Ind Gradient Dense
Matd gindDense( const Matd& X1 , const Matd& X2 ,
const Vecd& hyps , const Matd& K , const unsigned& i ) const
{
disp("NO COV IND DENSE GRADIENT");
}
};
}
#endif
| [
"[email protected]"
] | |
8bf6f70fbe9a047f26b13f73904b8dec04723311 | 9c73501c5a8413753ed5776299fe1f62a0a2659e | /src/Equations/Fluid/SPITransientTerm.cpp | b0fcded04d107697cb0bbb325f5e7867d4398834 | [
"MIT"
] | permissive | anymodel/DREAM-1 | 5d1ac63ffc48157f110ef672036d801442a2c917 | eba9fabddfa4ef439737807ef30978a52ab55afb | refs/heads/master | 2023-08-23T05:01:13.867792 | 2021-10-28T19:45:33 | 2021-10-28T19:45:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,623 | cpp | /**
* Implementation of the transient term for the SPI shard radii.
* We make special implementation for this transient term since the shard radii variable has many multiples
*/
#include <iostream>
#include "FVM/config.h"
#include "FVM/Matrix.hpp"
#include "DREAM/Equations/Fluid/SPITransientTerm.hpp"
#include "FVM/Grid/Grid.hpp"
using namespace DREAM;
/**
* Constructor.
*/
SPITransientTerm::SPITransientTerm(FVM::Grid *grid, const len_t unknownId, len_t nShard, real_t scaleFactor)
: FVM::EquationTerm(grid), unknownId(unknownId), nShard(nShard), scaleFactor(scaleFactor){}
/**
* Rebuild the transient term.
*
* dt: Length of next time step to take.
*/
void SPITransientTerm::Rebuild(const real_t, const real_t dt, FVM::UnknownQuantityHandler *uqty) {
this->dt = dt;
this->xn = uqty->GetUnknownDataPrevious(this->unknownId);
}
bool SPITransientTerm::SetJacobianBlock(const len_t, const len_t derivId, FVM::Matrix *jac, const real_t*){
if(derivId==this->unknownId){
for (len_t i = 0; i < nShard; i++){
jac->SetElement(i,i, scaleFactor/this->dt);
}
return true;
}
return false;
}
void SPITransientTerm::SetMatrixElements(FVM::Matrix*, real_t *rhs) {
this->SetVectorElements(rhs, nullptr);
}
/**
* Set the elements in the function vector 'F' (i.e.
* evaluate this term).
*
* vec: Vector containing value of 'F' on return.
* xnp1: Current solution.
*/
void SPITransientTerm::SetVectorElements(real_t *vec, const real_t *xnp1) {
for (len_t i = 0; i < nShard; i++)
vec[i] += scaleFactor*(xnp1[i] - xn[i]) / this->dt;
}
| [
"[email protected]"
] | |
4e0c1d50d7b9cb5409c9f7b2351b72b50bc866d0 | 61644b94b1a6d567c0b9fdf0f4b80e10ff187c5a | /sobel/src/main.cpp | a5d88c8bb8f4ef183f9ead29887c1dd4d03ae658 | [] | no_license | alex2835/stuff2 | 6b73a2075249197ea0098efdaad5f1af696f6fab | 8e79c2520287e7a0065c3b13177d3b57565712c7 | refs/heads/master | 2023-03-26T17:33:03.224601 | 2021-03-27T20:10:50 | 2021-03-27T20:10:50 | 238,885,548 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 341 | cpp |
#include "kernel/sobel.h"
#include "time/timer.h"
int main()
{
Image image("resources/baby_yoda_8K.jpg");
Bubble::Timer timer;
sobel_sigle_core(image);
printf("Single core: %fs\n", timer.Update().GetSeconds());
image = sobel(image);
printf("Multi core: %fs\n", timer.Update().GetSeconds());
image.save("baby_yoda");
return 0;
} | [
"[email protected]"
] | |
832a4e8205b9fc8864aedbe7c8670bc0c4c93f5d | 92636e2579e89b1a292358ab9d161b86beae0a21 | /src/ObjSceneObject.h | cca917c6b6394c6e8e95be1a539f764bf4aa7c57 | [
"BSD-3-Clause"
] | permissive | khutchins/Naive-Raytracer | 2185214cebc544d88cef24c5481528621f2f16d1 | fcdb37a611ffecd54ed1aa39ca7e2fd8e190c16d | refs/heads/master | 2021-01-01T05:51:23.180092 | 2016-12-05T23:20:43 | 2016-12-05T23:20:43 | 2,922,851 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,136 | h | #ifndef _SCENE_OBJECT_H_
#define _SCENE_OBJECT_H_
#include "Ray.h"
#include "Point.h"
#include "Vector.h"
#include "Color.h"
#include "Material.h"
#include <cstdlib>
#include <memory>
#include <vector>
enum EntityID {
ENTITY_SPHERE,
ENTITY_INFPLANE,
ENTITY_PLANE,
ENTITY_LIGHT,
ENTITY_DISK,
ENTITY_CYLINDER,
ENTITY_TUBE,
ENTITY_CUBOID,
ENTITY_TRIANGLE,
ENTITY_NONE
};
class SceneObject {
public:
Point origin;
bool isLight;
bool isVisible;
bool hasTexture; //Only can be true for planes currently
EntityID objectType;
Material material;
virtual SceneObject* intersect(Ray* r, Point &intersect) {return NULL;}
virtual Vector calculateNormalForPoint(Point p, Point raySource) {return Vector::VectorZero();}
virtual double getReflection() { return 0; }
virtual double getRefraction() { return 0; }
virtual Color getColor() { return Color::ColorBlack(); }
virtual Color calculateTextureFromMaterial(Point intercept, bool diagnosticEnabled) { return Color::ColorBlack(); }
virtual std::vector<std::unique_ptr<Ray>> raysForLighting(Point origin) { std::vector<std::unique_ptr<Ray>> rays; return rays; };
};
#endif
| [
"[email protected]"
] | |
185c7376502913fba85ce24604e82ba43f274621 | 5de7df0be411b4bad61f927cae845bdb8223308f | /src/libs/vtkh/rendering/LineRenderer.cpp | 9b115e668c3936095ef5348983f3a7e8e2a19064 | [
"BSD-3-Clause",
"Zlib"
] | permissive | Alpine-DAV/ascent | cb40429167a93c62f78fe650a0121258be279162 | e52b7bb8c9fd131f2fd49edf58037cc5ef77a166 | refs/heads/develop | 2023-09-06T07:57:11.558238 | 2023-08-25T16:05:31 | 2023-08-25T16:05:31 | 81,366,855 | 151 | 61 | NOASSERTION | 2023-09-13T19:31:09 | 2017-02-08T19:21:22 | C++ | UTF-8 | C++ | false | false | 1,108 | cpp | #include "LineRenderer.hpp"
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/MapperCylinder.h>
#include <memory>
namespace vtkh {
LineRenderer::LineRenderer()
: m_radius_set(false),
m_radius(0.5f)
{
typedef vtkm::rendering::MapperCylinder TracerType;
auto mapper = std::make_shared<TracerType>();
mapper->SetCompositeBackground(false);
this->m_mapper = mapper;
}
LineRenderer::~LineRenderer()
{
}
Renderer::vtkmCanvasPtr
LineRenderer::GetNewCanvas(int width, int height)
{
return std::make_shared<vtkm::rendering::CanvasRayTracer>(width, height);
}
std::string
LineRenderer::GetName() const
{
return "vtkh::LineRenderer";
}
void
LineRenderer::SetRadius(vtkm::Float32 radius)
{
m_radius = radius;
m_radius_set = true;
}
void
LineRenderer::PreExecute()
{
Renderer::PreExecute();
typedef vtkm::rendering::MapperCylinder MapperType;
std::shared_ptr<MapperType> mapper =
std::dynamic_pointer_cast<MapperType>(this->m_mapper);
// allow for the default mapper radius
if(m_radius_set)
{
mapper->SetRadius(m_radius);
}
}
} // namespace vtkh
| [
"[email protected]"
] | |
676a6f93b7d998b729133bb62dbbbf55be897fc3 | 002fd16f468b5185348d33432e943ad308b64534 | /Bluetooth Low Energy (LE) Generic Attribute (GATT) Profile Drivers/Solution/WpdService.cpp | ab3c63bdf696ad134b743ef6c28bcf86debfba25 | [] | no_license | lisq789/wdk80 | 62d2e134f13236fe1766e4664ee67664626aadcb | 67e3dc8fada017ff2f49fefb9ac670a955a27e36 | refs/heads/master | 2023-03-18T18:35:56.813973 | 2013-09-21T15:44:56 | 2013-09-21T15:44:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,293 | cpp | /*++
Copyright (c) Microsoft Corporation. All rights reserved.
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
PURPOSE.
Module Name:
WpdService.cpp
Abstract:
--*/
#include "stdafx.h"
#include "WpdService.tmh"
WpdService::WpdService() : m_pGattService(NULL)
{
}
WpdService::~WpdService()
{
}
HRESULT WpdService::Initialize(_In_ IWDFDevice* pDevice, _In_ BthLEDevice* pBthLEDevice)
{
if (pDevice == NULL)
{
return E_POINTER;
}
m_pGattService = pBthLEDevice->GetGattService();
m_ServiceMethods.Initialize(m_pGattService);
m_ServiceCapabilities.Initialize(m_pGattService);
return S_OK;
}
HRESULT WpdService::DispatchWpdMessage(
REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_Inout_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pszRequestFilename = NULL;
// Get the request filename to process the service message
hr = pParams->GetStringValue(PRIVATE_SAMPLE_DRIVER_REQUEST_FILENAME, &pszRequestFilename);
if (FAILED(hr))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to get the required requested filename");
}
if (hr == S_OK)
{
hr = CheckRequestFilename(pszRequestFilename);
CHECK_HR(hr, "Unknown request filename %ws received", pszRequestFilename);
}
if (hr == S_OK)
{
if (Command.fmtid == WPD_CATEGORY_SERVICE_CAPABILITIES)
{
hr = m_ServiceCapabilities.DispatchWpdMessage(Command, pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_START_INVOKE))
{
hr = m_ServiceMethods.OnStartInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_END_INVOKE))
{
hr = m_ServiceMethods.OnEndInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_CANCEL_INVOKE))
{
hr = m_ServiceMethods.OnCancelInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_COMMON_GET_SERVICE_OBJECT_ID))
{
hr = OnGetServiceObjectID(pszRequestFilename, pParams, pResults);
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "Unknown command %ws.%d received",CComBSTR(Command.fmtid), Command.pid);
}
}
CoTaskMemFree(pszRequestFilename);
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_SERVICE_COMMON_GET_SERVICE_OBJECT_ID
* command.
*
* The parameters sent to us are:
* None
*
* The driver should:
* - Return the objectID associated with the filename.
*
*/
HRESULT WpdService::OnGetServiceObjectID(
_In_ LPCWSTR pszRequestFilename,
_In_ IPortableDeviceValues* pParams,
_Inout_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if((pParams == NULL) ||
(pResults == NULL))
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// For simplicity, the request filename is the same as the service object ID
hr = pResults->SetStringValue(WPD_PROPERTY_SERVICE_OBJECT_ID, pszRequestFilename);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_COMMON_OBJECT_IDS");
return hr;
}
HRESULT WpdService::CheckRequestFilename(
_In_ LPCWSTR pszRequestFilename)
{
HRESULT hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
CAtlStringW strRequestFilename = pszRequestFilename;
// For simplicity, the request filename happens to be the same as the service object ID
if (strRequestFilename.CompareNoCase(m_pGattService->GetRequestFilename()) == 0)
{
hr = S_OK;
}
else
{
CHECK_HR(hr, "Unknown request filename %ws received", pszRequestFilename);
}
return hr;
}
| [
"[email protected]"
] | |
308f2f713494bca20529e6485f6bf95a9532a284 | f13ae317b6db8f4ce1e540f98cd35897f334fa5c | /cSymbol.cpp | 985f9c233f3cce27b359adae46b17c3e146ff9f0 | [] | no_license | chadgreene/CST320_ChadGreene | 3579da28e2d0fb1b4c5b28571045049d8a85268c | 1ceb4747592a103eae20c205a6e5d9deea002827 | refs/heads/master | 2021-01-01T18:23:32.660864 | 2015-03-14T18:16:22 | 2015-03-14T18:16:22 | 28,837,280 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,468 | cpp | /*******************************************************************************
* Author: Chad Greene
* Lab: Lab 7 Generate Code
* Date: 3/14/15
*
* Purpose: Build an abstract syntax tree by using Bison/Lex to parse a source
* file into appropriate nodes
*******************************************************************************/
#include "cSymbol.h"
int cSymbol::symbolCount = 0;
cSymbol::cSymbol(string symbol, bool type)
:m_symbol(symbol), m_sequence(++symbolCount), m_type(type), m_declared(false), m_typeRef(""), m_decl(nullptr), m_size(0)
{}
string cSymbol::toString()
{
return "sym: "+ m_symbol + " " + std::to_string(m_sequence);
}
bool cSymbol::IsType()
{
return m_type;
}
string cSymbol::GetSymbol()
{
return m_symbol;
}
void cSymbol::SetTypeFlag()
{
m_type = true;
}
void cSymbol::SetDeclared()
{
m_declared = true;
}
bool cSymbol::IsDeclared()
{
return m_declared;
}
void cSymbol::SetTypeRef(string typeRef, string baseType, cDeclNode* decl)
{
m_typeRef = typeRef;
m_baseType = baseType;
m_decl = decl;
}
string cSymbol::GetType()
{
return m_typeRef;
}
string cSymbol::GetBaseType()
{
return m_baseType;
}
cDeclNode* cSymbol::GetRef()
{
return m_decl;
}
void cSymbol::SetDecl(cDeclNode* decl)
{
m_decl = decl;
}
void cSymbol::ReduceSymbolCount()
{
symbolCount--;
}
void cSymbol::SetSize(int size)
{
m_size = size;
}
int cSymbol::GetSize()
{
return m_size;
}
| [
"[email protected]"
] | |
a1ab144804f1306b819f193e7124be68dbda58cb | 1a93a3b56dc2d54ffe3ee344716654888b0af777 | /env/Library/include/qt/QtQuickTemplates2/5.12.9/QtQuickTemplates2/private/qquicktabbar_p.h | 5367118cbc3555b8735e0656098842e40b478174 | [
"Python-2.0",
"LicenseRef-scancode-python-cwi",
"GPL-1.0-or-later",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause",
"0BSD",
"LicenseRef-scancode-free-unknown",
"GPL-3.0-only",
"GPL-2.0-only"
] | permissive | h4vlik/TF2_OD_BRE | ecdf6b49b0016407007a1a049f0fdb952d58cbac | 54643b6e8e9d76847329b1dbda69efa1c7ae3e72 | refs/heads/master | 2023-04-09T16:05:27.658169 | 2021-02-22T14:59:07 | 2021-02-22T14:59:07 | 327,001,911 | 0 | 0 | BSD-3-Clause | 2021-02-22T14:59:08 | 2021-01-05T13:08:03 | null | UTF-8 | C++ | false | false | 4,632 | h | /****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt Quick Templates 2 module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QQUICKTABBAR_P_H
#define QQUICKTABBAR_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtQuickTemplates2/private/qquickcontainer_p.h>
QT_BEGIN_NAMESPACE
class QQuickTabBarPrivate;
class QQuickTabBarAttached;
class QQuickTabBarAttachedPrivate;
class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTabBar : public QQuickContainer
{
Q_OBJECT
Q_PROPERTY(Position position READ position WRITE setPosition NOTIFY positionChanged FINAL)
// 2.2 (Qt 5.9)
Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth RESET resetContentWidth NOTIFY contentWidthChanged FINAL REVISION 2) // re-declare QQuickContainer::contentWidth (REV 5)
Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight RESET resetContentHeight NOTIFY contentHeightChanged FINAL REVISION 2) // re-declare QQuickContainer::contentHeight (REV 5)
public:
explicit QQuickTabBar(QQuickItem *parent = nullptr);
enum Position {
Header,
Footer
};
Q_ENUM(Position)
Position position() const;
void setPosition(Position position);
static QQuickTabBarAttached *qmlAttachedProperties(QObject *object);
Q_SIGNALS:
void positionChanged();
protected:
void updatePolish() override;
void componentComplete() override;
void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override;
bool isContent(QQuickItem *item) const override;
void itemAdded(int index, QQuickItem *item) override;
void itemMoved(int index, QQuickItem *item) override;
void itemRemoved(int index, QQuickItem *item) override;
QFont defaultFont() const override;
QPalette defaultPalette() const override;
#if QT_CONFIG(accessibility)
QAccessible::Role accessibleRole() const override;
#endif
private:
Q_DISABLE_COPY(QQuickTabBar)
Q_DECLARE_PRIVATE(QQuickTabBar)
};
class Q_QUICKTEMPLATES2_PRIVATE_EXPORT QQuickTabBarAttached : public QObject
{
Q_OBJECT
Q_PROPERTY(int index READ index NOTIFY indexChanged FINAL)
Q_PROPERTY(QQuickTabBar *tabBar READ tabBar NOTIFY tabBarChanged FINAL)
Q_PROPERTY(QQuickTabBar::Position position READ position NOTIFY positionChanged FINAL)
public:
explicit QQuickTabBarAttached(QObject *parent = nullptr);
int index() const;
QQuickTabBar *tabBar() const;
QQuickTabBar::Position position() const;
Q_SIGNALS:
void indexChanged();
void tabBarChanged();
void positionChanged();
private:
Q_DISABLE_COPY(QQuickTabBarAttached)
Q_DECLARE_PRIVATE(QQuickTabBarAttached)
};
QT_END_NAMESPACE
QML_DECLARE_TYPE(QQuickTabBar)
QML_DECLARE_TYPEINFO(QQuickTabBar, QML_HAS_ATTACHED_PROPERTIES)
#endif // QQUICKTABBAR_P_H
| [
"[email protected]"
] | |
5f24976516b476657e97274058e2bf8d7171a926 | 25b4afbcad749a833504269be17a9ad785370fef | /Pod/musicFramework/core/elements/Inversion.h | 72ccc7a8aaa701cdd68d5634e30a524628a6b4d5 | [
"MIT"
] | permissive | Bone111/MusicXMLParser | 87eee0a990a49a57a54a59e6ef2baa981c83a740 | 674f6b52634abb95008cc04ee02f4df0055851a6 | refs/heads/master | 2020-03-27T04:26:35.847365 | 2017-09-30T08:19:53 | 2017-09-30T08:19:53 | 145,939,832 | 3 | 2 | MIT | 2018-08-24T03:51:52 | 2018-08-24T03:51:51 | null | UTF-8 | C++ | false | false | 1,804 | h | // MusicXML Class Library
// Copyright (c) by Matthew James Briggs
// Distributed under the MIT License
#pragma once
#include "../../core/ForwardDeclare.h"
#include "../../core/ElementInterface.h"
#include "../../core/Integers.h"
#include "../../core/elements/InversionAttributes.h"
#include <iosfwd>
#include <memory>
#include <vector>
namespace mx
{
namespace core
{
MX_FORWARD_DECLARE_ATTRIBUTES( InversionAttributes )
MX_FORWARD_DECLARE_ELEMENT( Inversion )
inline InversionPtr makeInversion() { return std::make_shared<Inversion>(); }
inline InversionPtr makeInversion( const NonNegativeInteger& value ) { return std::make_shared<Inversion>( value ); }
inline InversionPtr makeInversion( NonNegativeInteger&& value ) { return std::make_shared<Inversion>( std::move( value ) ); }
class Inversion : public ElementInterface
{
public:
Inversion();
Inversion( const NonNegativeInteger& value );
virtual bool hasAttributes() const;
virtual bool hasContents() const;
virtual std::ostream& streamAttributes( std::ostream& os ) const;
virtual std::ostream& streamName( std::ostream& os ) const;
virtual std::ostream& streamContents( std::ostream& os, const int indentLevel, bool& isOneLineOnly ) const;
InversionAttributesPtr getAttributes() const;
void setAttributes( const InversionAttributesPtr& attributes );
NonNegativeInteger getValue() const;
void setValue( const NonNegativeInteger& value );
bool fromXElement( std::ostream& message, xml::XElement& xelement );
private:
NonNegativeInteger myValue;
InversionAttributesPtr myAttributes;
};
}
}
| [
"[email protected]"
] | |
b68cb93b195336d6f6df3c5370f99633031704ab | 30b7ffd17845db982883a91ce8d04551281658c4 | /Codeforces/Hello 2020/D.cpp | 2a1097a184a8d2b04d97614e58feffc9aac1c1e0 | [] | no_license | shas9/codehub | 95418765b602b52edb0d48a473ad7e7a798f76e5 | bda856bf6ca0f3a1d59980895cfab82f690c75a2 | refs/heads/master | 2023-06-21T01:09:34.275708 | 2021-07-26T14:54:03 | 2021-07-26T14:54:03 | 389,404,954 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,852 | cpp | #include <bits/stdc++.h>`
#define slld(longvalue) scanf("%lld", &longvalue)
#define plld(longvalue) printf("%lld\n", longvalue)
#define slf(longvalue) scanf("%lf", &longvalue)
#define plf(longvalue) printf("%lf\n", longvalue)
#define sc(letter) scanf("%c", &letter)
#define pc(letter) printf("%c", letter)
#define ss(name) scanf("%s", name)
#define ps(name) printf("%s", name)
#define pnew printf("\n")
#define ll long long
#define ull unsigned long long
#define pll pair < long long, long long >
#define pii pair < int, int >
#define printcase(indexing,ans) printf("Case %lld: %lld\n", indexing, ans)
#define pb(x) push_back(x)
#define bug printf("BUG\n")
#define mxlld LLONG_MAX
#define mnlld -LLONG_MAX
#define mxd 2e8
#define mnd -2e8
#define pi 3.14159265359
#define mod 1000000009
using namespace std;
bool check(ll n, ll pos)
{
return n & (1LL << pos);
}
ll Set(ll n, ll pos)
{
return n = n | (1LL << pos);
}
pll ven[3][100005];
ll ss[6][100005];
ll n;
map < ll, ll > mp[6];
ll chk(ll vv, ll pos)
{
ll start = ven[vv][pos].first;
ll finish = ven[vv][pos].second;
ll lo = 1;
ll hi = n;
if(mp[vv][start] > 1) return 1;
// cout << vv << " - " << pos << endl;
// cout << start << " & " << finish << endl;
while(lo <= hi)
{
ll mid = (lo + hi) / 2;
if(ss[vv][mid] <= start)
{
lo = mid + 1;
}
else if(ss[vv][mid] > finish)
{
hi = mid - 1;
}
else
{
// cout << ss[vv][mid] << " " << mid << endl;
return 1;
}
}
lo = 1;
hi = n;
if(mp[vv + 2][finish] > 1) return 1;
// cout << vv << " - " << pos << endl;
// cout << start << " & " << finish << endl;
while(lo <= hi)
{
ll mid = (lo + hi) / 2;
if(ss[vv + 2][mid] < start)
{
lo = mid + 1;
}
else if(ss[vv + 2][mid] >= finish)
{
hi = mid - 1;
}
else
{
// cout << ss[vv][mid] << " " << mid << endl;
return 1;
}
}
return 0;
}
int main()
{
ll i, j, k, l, m, o, r, q;
ll testcase;
ll input, flag, tag, ans;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
while(cin >> n)
{
// cout << n << endl;
mp[1].clear();
mp[2].clear();
mp[3].clear();
mp[4].clear();
for(i = 1; i <= n; i++)
{
slld(ven[1][i].first);
slld(ven[1][i].second);
slld(ven[2][i].first);
slld(ven[2][i].second);
ss[1][i] = ven[1][i].first;
ss[2][i] = ven[2][i].first;
ss[3][i] = ven[1][i].second;
ss[4][i] = ven[2][i].second;
mp[1][ss[1][i]]++;
mp[2][ss[2][i]]++;
mp[3][ss[3][i]]++;
mp[4][ss[4][i]]++;
}
sort(ss[1] + 1, ss[1] + 1 + n);
sort(ss[2] + 1, ss[2] + 1 + n);
sort(ss[3] + 1, ss[3] + 1 + n);
sort(ss[4] + 1, ss[4] + 1 + n);
// for(i = 1; i <= 2; i++)
// {
// for(j = 1; j <= n; j++)
// {
// cout << ss[i][j] << " ";
// }
//
// cout << endl;
// }
for(i = 1; i <= n; i++)
{
// cout << chk(1,i) << " " << chk(2,i) << endl;
if((chk(1,i) || chk(2,i)))
{
cout << "NO" << endl;
// cout << i << endl;
break;
}
}
if(i > n)
{
cout << "YES" << endl;
}
}
}
| [
"[email protected]"
] | |
ba1a8fc9bbed763e966f659a6ddb1042e6dda5d5 | 6fec2beaba97a18dd936e6d4a61042fa9817fc9c | /Odd_Even_Position_Nodes_are_Together.cpp | 15b3f200309477ed51728a89301f64f559c6caae | [] | no_license | Vashisht8953/CipherSchools_Assignments | 1376d13ebf87c8162a23c88009222f2f762f7fe1 | ddcff03396dba6b46c566d60abf39e6e4afb6af0 | refs/heads/main | 2023-03-08T06:36:19.899156 | 2021-02-23T12:05:08 | 2021-02-23T12:05:08 | 338,574,691 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,268 | cpp | #include<bits/stdc++.h>
using namespace std;
class Node
{
public:
int data;
Node* next;
};
Node* newNode(int key)
{
Node *temp = new Node;
temp->data = key;
temp->next = NULL;
return temp;
}
Node *rearrangeEvenOdd(Node *head)
{
if (head == NULL)
return NULL;
Node *odd = head;
Node *even = head->next;
Node *evenFirst = even;
while (1)
{
if (!odd || !even || !(even->next))
{
odd->next = evenFirst;
break;
}
odd->next = even->next;
odd = even->next;
if (odd->next == NULL)
{
even->next = NULL;
odd->next = evenFirst;
break;
}
even->next = odd->next;
even = odd->next;
}
return head;
}
void printlist(Node * node)
{
while (node != NULL)
{
cout << node->data << "->";
node = node->next;
}
cout << "NULL" << endl;
}
int main(void)
{
Node *head = newNode(1);
head->next = newNode(2);
head->next->next = newNode(3);
head->next->next->next = newNode(4);
head->next->next->next->next = newNode(5);
cout << "Given Linked List : ";
printlist(head);
head = rearrangeEvenOdd(head);
cout << "Modified Linked List : ";
printlist(head);
return 0;
}
| [
"[email protected]"
] | |
8c5813c55228edb5b8e839ada7505a2c54fdc456 | 35e450c01e0eb1f0317f7733752c26e8e1c234a6 | /064/main.cc | 0a3fb6d71cd74cec2f8778ad0088331c6b5034f8 | [] | no_license | michalliu/ibab_leetcode-solutions | 94970c3158bae8c0ada6d319f5f47ecf227135f3 | effeb128469605f70692b9545eb9ea156025b940 | refs/heads/master | 2020-04-15T12:29:23.828030 | 2016-10-31T12:30:50 | 2016-10-31T12:30:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,430 | cc | #include <vector>
using std::vector;
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
std::vector<vector<int>> distance(
grid.size(),
std::vector<int>(grid[0].size(), INT_MAX));
// Set initial cost
distance[0][0] = grid[0][0];
int M = distance.size();
int N = distance.front().size();
// Interpret the array as a graph with directed edges leading to the
// elements right and below of the current one.
// Walk through the elements, always setting the adjacent distances to
// the minimum of the current distance and the distance that can be
// achieved by coming from this vertex.
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
// Look to the right.
if (i < M - 1) {
if (distance[i + 1][j] > distance[i][j] + grid[i + 1][j]) {
distance[i + 1][j] = distance[i][j] + grid[i + 1][j];
}
}
// Look downwards.
if (j < N - 1) {
if (distance[i][j + 1] > distance[i][j] + grid[i][j + 1]) {
distance[i][j + 1] = distance[i][j] + grid[i][j + 1];
}
}
}
}
return distance[M - 1][N - 1];
}
};
int main() {
return 0;
}
| [
"[email protected]"
] | |
b8e7510516560b725c78ddd1f0b7f1325625135e | 57c5596078293981db900bf92a7027e69b451f9b | /main.cpp | 86b1815e379c73584628d3d88c3e225df96048b2 | [] | no_license | adeleon512/prog0_acd21 | f3332ed570d661e746e838d9410604a55b16598f | a4e16471b3ac502c686f93525779b9d4b96b9a1d | refs/heads/master | 2021-01-21T05:14:26.640130 | 2017-02-25T19:15:06 | 2017-02-25T19:15:06 | 83,155,456 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 691 | cpp | /*
* prog0_acd21.cpp
*
* Created on: Sep 4, 2013
* Author: Adam C.De Leon
* Net ID: acd21
* Program 0
* Menu for Adam C. De Leon's Java Extraordinaire
*/
#include <iostream>
using namespace std;
int main() {
cout << "Adam C. De Leon's Java Extraordinaire\n";
cout << "\n";
cout << "House Roast:\n";
cout << "8 oz.\t$1.25\n";
cout << "12 oz.\t$1.75\n";
cout << "24 oz.\t$2.75\n";
cout << "\n";
cout << "Latte or Cappuccino:\n";
cout << "8 oz.\t$2.15\n";
cout << "12 oz.\t$3.25\n";
cout << "24 oz.\t$4.25\n";
cout << "\n";
cout << "Fellow GIS majors are eligible for an 8% discount!\n";
return 0;
}
| [
"[email protected]"
] | |
6d265420b53364e293f2569187ec5f34ad67946a | 6c8929ca577273de6f284eec2a0665604a79bee0 | /MFCApplication8/mac.cpp | 87ab999c0d2cb2463a9f3d30f938b1d0429c0cd5 | [] | no_license | kimjihw/MFC-Ip-Scanner | 0927bdce821dedbf3383f79bea12a4af8624ff30 | 7419286e2842f64682da9e56348e4646f0c9a8bd | refs/heads/master | 2023-04-29T15:20:05.657573 | 2021-04-29T00:07:45 | 2021-04-29T00:07:45 | 362,639,690 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 677 | cpp | #include "mac.h"
#include "pch.h"
Mac::Mac(const std::string r) {
unsigned int a, b, c, d, e, f;
int res = sscanf_s(r.c_str(), "%02X:%02X:%02X:%02X:%02X:%02X", &a, &b, &c, &d, &e, &f);
if (res != SIZE) {
fprintf_s(stderr, "Mac::Mac sscanf return %d r=%s\n", res, r.c_str());
return;
}
mac_[0] = a;
mac_[1] = b;
mac_[2] = c;
mac_[3] = d;
mac_[4] = e;
mac_[5] = f;
}
Mac::operator std::string() const {
char buf[32]; // enough size
sprintf_s(buf, "%02x:%02X:%02X:%02X:%02X:%02X",
mac_[0],
mac_[1],
mac_[2],
mac_[3],
mac_[4],
mac_[5]);
return std::string(buf);
} | [
"[email protected]"
] | |
12ccc5557a71836c7d4931a3c7ebd8f1116776bb | 9dcc751eed6c10267328eafccfc009fd8f2f469f | /191007 인벤토리/stdafx.h | 0ae8f4d6a75ebbfc2502e44b3b8aedb6bb7c7ac6 | [] | no_license | siro0413/sgadev | 12797c96df45655c1367202b1a9cd5ec6b0fd13e | da587901570467e45b8b23da4acb1646a1f43e6b | refs/heads/master | 2020-07-04T17:11:48.069804 | 2020-01-09T10:50:06 | 2020-01-09T10:50:06 | 202,350,614 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 140 | h | #pragma once
#include <iostream>
#include <Windows.h>
#include <vector>
#include <string>
using namespace std;
#include "ItemDscs.h"
| [
"[email protected]"
] | |
b0c12e94ca57169df146c7a0d5114affee85e372 | 78918391a7809832dc486f68b90455c72e95cdda | /boost_lib/boost/xpressive/detail/utility/ignore_unused.hpp | 9d9492d2482a04669705a1f6118217a752f57437 | [
"MIT"
] | permissive | kyx0r/FA_Patcher | 50681e3e8bb04745bba44a71b5fd04e1004c3845 | 3f539686955249004b4483001a9e49e63c4856ff | refs/heads/master | 2022-03-28T10:03:28.419352 | 2020-01-02T09:16:30 | 2020-01-02T09:16:30 | 141,066,396 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 696 | hpp | ///////////////////////////////////////////////////////////////////////////////
// ignore_unused.hpp
//
// Copyright 2008 Eric Niebler. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_XPRESSIVE_DETAIL_UTILITY_IGNORE_UNUSED_HPP_EAN_10_04_2005
#define BOOST_XPRESSIVE_DETAIL_UTILITY_IGNORE_UNUSED_HPP_EAN_10_04_2005
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
#include "boost/proto/detail/ignore_unused.hpp"
namespace boost
{
namespace xpressive
{
namespace detail
{
using boost::proto::detail::ignore_unused;
}
}
}
#endif
| [
"[email protected]"
] | |
c4f856745ce6f63eb50c71344ae5fd58b3a57347 | f44210cbddfc38f62105aac4224533ad1324c02e | /and/ttp/2017/semana3/pathfinding.cpp | 628b4fad0eb097d971dfca21f4a16680ae335e21 | [
"MIT"
] | permissive | aLagoG/kygerand | 8067b95fde1a213e278406626f109f21818ad984 | 0991cf5d5c3d49f4602b6992d4e3bdec8e27898e | refs/heads/master | 2021-01-11T16:15:41.330307 | 2019-09-18T20:09:00 | 2019-09-18T20:09:00 | 80,049,161 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,028 | cpp | //1527
#include <stdio.h>
#include <vector>
#include <queue>
#include <bitset>
#include <utility>
#include <algorithm>
using namespace std;
typedef pair<int, int> pii;
int n,m;
vector<int> g[101];
bitset<101> v;
vector<int> f[101];
void bfs(){
int num=n-1;
pii t;
queue<pii> q;
q.push(pii(m,0));
f[0].push_back(m);
v[m] = 1;
while(num&&!q.empty()){
t = q.front();
q.pop();
for(auto i: g[t.first]){
if(v[i]){
continue;
}
q.push(pii(i,t.second+1));
v[i] = 1;
num--;
f[t.second+1].push_back(i);
// printf("%d %d --\n",i,t.second+1);
}
}
}
int main(){
int t;
scanf("%d %d",&n,&m);
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
scanf("%d",&t);
if(t){
g[i+1].push_back(j+1);
}
}
}
// for(int i=1;i<n;i++){
// for(auto j: g[i]){
// printf("%d ",j);
// }
// printf("\n");
// }
// printf("\n");
bfs();
for(int i=0;i<n;i++){
if(f[i].empty()){
break;
}
sort(f[i].begin(), f[i].end());
for(auto z: f[i]){
printf("%d ", z);
}
printf("\n");
}
} | [
"[email protected]"
] | |
194d4446fd396e6f70be47cdf2402b8c84f7659c | ed3ee305f0af6d2634ee36312f1962e5e3dbdb8e | /grppi_workflows/unit_tests/farm.cpp | 69ecdac0b9032f2ab7b9450a96a3a6f790c215a8 | [
"Apache-2.0"
] | permissive | javidoc00/dispel4py_GrPPI_workflows | 9f4a1108242955ceacc33a8335c826f1d6e1bdb7 | 9a6ad5297304e37de72519be039c3dd7976f257e | refs/heads/master | 2020-06-26T15:22:24.550608 | 2019-08-15T13:59:12 | 2019-08-15T13:59:12 | 199,672,094 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,731 | cpp | /*
* Copyright 2018 Universidad Carlos III de Madrid
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <atomic>
#include <utility>
#include <experimental/optional>
#include <gtest/gtest.h>
#include "grppi/farm.h"
#include "grppi/pipeline.h"
#include "grppi/dyn/dynamic_execution.h"
#include "grppi/common/optional.h"
#include "supported_executions.h"
using namespace std;
using namespace grppi;
template <typename T>
class farm_test : public ::testing::Test {
public:
T execution_{};
dynamic_execution dyn_execution_{execution_};
// Variables
std::atomic<int> output{};
// Vectors
vector<int> v{};
vector<int> v2{};
vector<int> v3{};
vector<int> w{};
// entry counter
size_t idx_in = 0;
size_t idx_out = 0;
// Invocation counter
std::atomic<int> invocations_in{0};
std::atomic<int> invocations_op{0};
std::atomic<int> invocations_sk{0};
void setup_empty() {}
template <typename E>
void run_empty(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<int>{
invocations_in++;
return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
return x;
}
),
[](int) {}
);
}
void check_empty() {
EXPECT_EQ(1, invocations_in); // Functor in was invoked once
EXPECT_EQ(0, invocations_op); // Functor op was not invoked
}
void setup_empty_sink() {}
template <typename E>
void run_empty_sink(const E & e) {
grppi::pipeline (e,
[this]() -> grppi::optional<int>{
invocations_in++;
return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
return x;
}),
[this](int) {
this->invocations_sk++;
}
);
}
void check_empty_sink() {
EXPECT_EQ(1, invocations_in);
EXPECT_EQ(0, invocations_op);
EXPECT_EQ(0, invocations_sk);
}
void setup_empty_ary() {}
template <typename E>
void run_empty_ary(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<tuple<int,int,int>> {
invocations_in++;
return {};
},
grppi::farm(4,
[this](tuple<int,int,int>) {
invocations_op++;
})
);
}
void check_empty_ary() {
EXPECT_EQ(1, invocations_in);
EXPECT_EQ(0, invocations_op);
}
void setup_empty_ary_sink() {}
template <typename E>
void run_empty_ary_sink(const E & e) {
grppi::pipeline (e,
[this]() -> grppi::optional<int>{
invocations_in++;
return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
return x;
}),
[this](int) {
this->invocations_sk++;
}
);
}
void check_empty_ary_sink() {
EXPECT_EQ(1, invocations_in);
EXPECT_EQ(0, invocations_op);
EXPECT_EQ(0, invocations_sk);
}
void setup_single() {
v = vector<int>{42};
w = vector<int>{99};
}
template <typename E>
void run_single(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<int> {
invocations_in++;
if (idx_in < v.size() ) {
idx_in++;
return v[idx_in-1];
} else
return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
w[idx_out] = x * 2;
idx_out++;
})
);
}
template <typename E>
void run_single_piecewise(const E & e) {
auto inner = grppi::farm(4,
[this](int x) {
invocations_op++;
w[idx_out] = x * 2;
idx_out++;
});
grppi::pipeline(e,
[this]() -> grppi::optional<int> {
invocations_in++;
if (idx_in < v.size() ) {
idx_in++;
return v[idx_in-1];
} else
return {};
},
inner
);
}
void check_single() {
EXPECT_EQ(2, invocations_in); // Functor in was invoked once
EXPECT_EQ(1, this->invocations_op); // one invocation of function op
EXPECT_EQ(84, this->w[0]);
}
void setup_single_sink() {
v = vector<int>{42};
w = vector<int>{99};
}
template <typename E>
void run_single_sink(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<int> {
invocations_in++;
if (idx_in < v.size() ) {
idx_in++;
return v[idx_in-1];
}
else return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
return x*2;
}
),
[this](int x) {
invocations_sk++;
w[idx_out] = x;
idx_out++;
}
);
}
void check_single_sink() {
EXPECT_EQ(2, invocations_in); // Functor in was invoked once
EXPECT_EQ(1, this->invocations_op); // one invocation of function op
EXPECT_EQ(1, this->invocations_sk); // one invocation of function sk
EXPECT_EQ(84, this->w[0]);
}
void setup_single_ary() {
v = vector<int>{11};
v2 = vector<int>{22};
v3 = vector<int>{33};
w = vector<int>{99};
}
template <typename E>
void run_single_ary(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<tuple<int,int,int>> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return make_tuple(v[idx_in-1],
v2[idx_in-1],
v3[idx_in-1]);
} else return {};
},
grppi::farm(4,
[this](tuple<int,int,int> x) {
invocations_op++;
w[idx_out] = get<0>(x) + get<1>(x) + get<2>(x);
idx_out++;
})
);
}
void check_single_ary() {
EXPECT_EQ(2, invocations_in); // Functor in was invoked twice
EXPECT_EQ(1, this->invocations_op); // one invocation of function op
EXPECT_EQ(66, this->w[0]);
}
void setup_single_ary_sink() {
v = vector<int>{11};
v2 = vector<int>{22};
v3 = vector<int>{33};
w = vector<int>{99};
}
template <typename E>
void run_single_ary_sink(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<tuple<int,int,int>> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return make_tuple(v[idx_in-1], v2[idx_in-1], v3[idx_in-1]);
}
else return {};
},
grppi::farm(4,
[this](tuple<int,int,int> x) {
invocations_op++;
return get<0>(x) + get<1>(x) + get<2>(x);;
}),
[this](int x) {
invocations_sk++;
w[idx_out] = x;
idx_out++;
});
}
void check_single_ary_sink() {
EXPECT_EQ(2, invocations_in); // Functor in was invoked twice
EXPECT_EQ(1, this->invocations_op); // one invocation of function op
EXPECT_EQ(1, this->invocations_sk); // one invocation of function sk
EXPECT_EQ(66, this->w[0]);
}
void setup_multiple() {
v = vector<int>{1,2,3,4,5};
output = 0;
}
template <typename E>
void run_multiple(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<int> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return v[idx_in-1];
} else return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
output += x * 2;
})
);
}
void check_multiple() {
EXPECT_EQ(6, this->invocations_in); // six invocations of function in
EXPECT_EQ(5, this->invocations_op); // five invocations of function op
EXPECT_EQ(30, this->output);
}
void setup_multiple_sink() {
v = vector<int>{1,2,3,4,5};
output = 0;
}
template <typename E>
void run_multiple_sink(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<int> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return v[idx_in-1];
} else return {};
},
grppi::farm(4,
[this](int x) {
invocations_op++;
return x * 2;
}),
[this](int x) {
invocations_sk++;
output +=x;
}
);
}
void check_multiple_sink() {
EXPECT_EQ(6, this->invocations_in); // six invocations of function in
EXPECT_EQ(5, this->invocations_op); // five invocations of function op
EXPECT_EQ(5, this->invocations_sk); // five invocations of function sk
EXPECT_EQ(30, this->output);
}
void setup_multiple_ary() {
v = vector<int>{1,2,3,4,5};
v2 = vector<int>{2,4,6,8,10};
v3 = vector<int>{10,10,10,10,10};
w = vector<int>{0,0,0,0,0};
output = 0;
}
template <typename E>
void run_multiple_ary(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<tuple<int,int,int>> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return make_tuple(v[idx_in-1],
v2[idx_in-1],
v3[idx_in-1]);
} else return {};
},
grppi::farm(4,
[this](tuple<int,int,int> x) {
invocations_op++;
output += get<0>(x) + get<1>(x) + get<2>(x);
})
);
}
void check_multiple_ary() {
EXPECT_EQ(6, this->invocations_in); // six invocations of function in
EXPECT_EQ(5, this->invocations_op); // five invocations of function op
EXPECT_EQ(95, this->output);
}
void setup_multiple_ary_sink() {
v = vector<int>{1,2,3,4,5};
v2 = vector<int>{2,4,6,8,10};
v3 = vector<int>{10,10,10,10,10};
output = 0;
}
template <typename E>
void run_multiple_ary_sink(const E & e) {
grppi::pipeline(e,
[this]() -> grppi::optional<tuple<int,int,int>> {
invocations_in++;
if (idx_in < v.size()) {
idx_in++;
return make_tuple(v[idx_in-1], v2[idx_in-1], v3[idx_in-1]);
}
else return {};
},
grppi::farm(4,
[this](tuple<int,int,int> x) {
invocations_op++;
return get<0>(x) + get<1>(x) + get<2>(x);
}),
[this](int x) {
invocations_sk++;
output += x;
});
}
void check_multiple_ary_sink() {
EXPECT_EQ(6, this->invocations_in); // six invocations of function in
EXPECT_EQ(5, this->invocations_op); // five invocations of function op
EXPECT_EQ(5, this->invocations_sk); // five invocations of function sk
EXPECT_EQ(95, this->output);
}
};
// Test for execution policies defined in supported_executions.h
TYPED_TEST_CASE(farm_test, executions);
TYPED_TEST(farm_test, static_empty)
{
this->setup_empty();
this->run_empty(this->execution_);
this->check_empty();
}
TYPED_TEST(farm_test, dyn_empty)
{
this->setup_empty();
this->run_empty(this->dyn_execution_);
this->check_empty();
}
TYPED_TEST(farm_test, static_empty_sink)
{
this->setup_empty_sink();
this->run_empty_sink(this->execution_);
this->check_empty_sink();
}
TYPED_TEST(farm_test, dyn_empty_sink)
{
this->setup_empty_sink();
this->run_empty_sink(this->dyn_execution_);
this->check_empty_sink();
}
TYPED_TEST(farm_test, static_empty_ary)
{
this->setup_empty();
this->run_empty_ary(this->execution_);
this->check_empty();
}
TYPED_TEST(farm_test, dyn_empty_ary)
{
this->setup_empty();
this->run_empty_ary(this->dyn_execution_);
this->check_empty();
}
TYPED_TEST(farm_test, static_empty_ary_sink)
{
this->setup_empty_ary_sink();
this->run_empty_ary_sink(this->execution_);
this->check_empty_ary_sink();
}
TYPED_TEST(farm_test, dyn_empty_ary_sink)
{
this->setup_empty_ary_sink();
this->run_empty_ary_sink(this->dyn_execution_);
this->check_empty_ary_sink();
}
TYPED_TEST(farm_test, static_single)
{
this->setup_single();
this->run_single(this->execution_);
this->check_single();
}
TYPED_TEST(farm_test, dyn_single)
{
this->setup_single();
this->run_single(this->dyn_execution_);
this->check_single();
}
TYPED_TEST(farm_test, static_single_piecewise)
{
this->setup_single();
this->run_single_piecewise(this->execution_);
this->check_single();
}
TYPED_TEST(farm_test, dyn_single_piecewise)
{
this->setup_single();
this->run_single_piecewise(this->dyn_execution_);
this->check_single();
}
TYPED_TEST(farm_test, static_single_sink)
{
this->setup_single_sink();
this->run_single_sink(this->execution_);
this->check_single_sink();
}
TYPED_TEST(farm_test, dyn_single_sink)
{
this->setup_single_sink();
this->run_single_sink(this->dyn_execution_);
this->check_single_sink();
}
TYPED_TEST(farm_test, static_single_ary)
{
this->setup_single_ary();
this->run_single_ary(this->dyn_execution_);
this->check_single_ary();
}
TYPED_TEST(farm_test, dyn_single_ary)
{
this->setup_single_ary();
this->run_single_ary(this->dyn_execution_);
this->check_single_ary();
}
TYPED_TEST(farm_test, static_single_ary_sink)
{
this->setup_single_ary_sink();
this->run_single_ary_sink(this->dyn_execution_);
this->check_single_ary_sink();
}
TYPED_TEST(farm_test, dyn_single_ary_sink)
{
this->setup_single_ary_sink();
this->run_single_ary_sink(this->dyn_execution_);
this->check_single_ary_sink();
}
TYPED_TEST(farm_test, static_multiple)
{
this->setup_multiple();
this->run_multiple(this->execution_);
this->check_multiple();
}
TYPED_TEST(farm_test, dyn_multiple)
{
this->setup_multiple();
this->run_multiple(this->dyn_execution_);
this->check_multiple();
}
TYPED_TEST(farm_test, static_multiple_sink)
{
this->setup_multiple();
this->run_multiple_sink(this->execution_);
this->check_multiple_sink();
}
TYPED_TEST(farm_test, dyn_multiple_sink)
{
this->setup_multiple();
this->run_multiple_sink(this->dyn_execution_);
this->check_multiple_sink();
}
TYPED_TEST(farm_test, static_multiple_ary)
{
this->setup_multiple_ary();
this->run_multiple_ary(this->execution_);
this->check_multiple_ary();
}
TYPED_TEST(farm_test, dyn_multiple_ary)
{
this->setup_multiple_ary();
this->run_multiple_ary(this->dyn_execution_);
this->check_multiple_ary();
}
TYPED_TEST(farm_test, static_multiple_ary_sink)
{
this->setup_multiple_ary();
this->run_multiple_ary_sink(this->execution_);
this->check_multiple_ary_sink();
}
TYPED_TEST(farm_test, dyn_multiple_ary_sink)
{
this->setup_multiple_ary_sink();
this->run_multiple_ary_sink(this->dyn_execution_);
this->check_multiple_ary_sink();
}
| [
"[email protected]"
] | |
e8c41873d20596cc930dccc463ff739ec177b3d6 | 73ee941896043f9b3e2ab40028d24ddd202f695f | /external/chromium_org/chrome/browser/storage_monitor/storage_monitor_linux_unittest.cc | 7a74069defa2d3504e9b40059e96e00a44ad57a5 | [
"BSD-3-Clause"
] | permissive | CyFI-Lab-Public/RetroScope | d441ea28b33aceeb9888c330a54b033cd7d48b05 | 276b5b03d63f49235db74f2c501057abb9e79d89 | refs/heads/master | 2022-04-08T23:11:44.482107 | 2016-09-22T20:15:43 | 2016-09-22T20:15:43 | 58,890,600 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 26,811 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// StorageMonitorLinux unit tests.
#include "chrome/browser/storage_monitor/storage_monitor_linux.h"
#include <mntent.h>
#include <stdio.h>
#include <string>
#include "base/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/browser/storage_monitor/mock_removable_storage_observer.h"
#include "chrome/browser/storage_monitor/removable_device_constants.h"
#include "chrome/browser/storage_monitor/storage_info.h"
#include "chrome/browser/storage_monitor/storage_monitor.h"
#include "chrome/browser/storage_monitor/test_media_transfer_protocol_manager_linux.h"
#include "chrome/browser/storage_monitor/test_storage_monitor.h"
#include "chrome/test/base/testing_browser_process.h"
#include "content/public/test/test_browser_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chrome {
namespace {
const char kValidFS[] = "vfat";
const char kInvalidFS[] = "invalidfs";
const char kInvalidPath[] = "invalid path does not exist";
const char kDeviceDCIM1[] = "d1";
const char kDeviceDCIM2[] = "d2";
const char kDeviceDCIM3[] = "d3";
const char kDeviceNoDCIM[] = "d4";
const char kDeviceFixed[] = "d5";
const char kInvalidDevice[] = "invalid_device";
const char kMountPointA[] = "mnt_a";
const char kMountPointB[] = "mnt_b";
const char kMountPointC[] = "mnt_c";
struct TestDeviceData {
const char* device_path;
const char* unique_id;
const char* device_name;
StorageInfo::Type type;
uint64 partition_size_in_bytes;
};
const TestDeviceData kTestDeviceData[] = {
{ kDeviceDCIM1, "UUID:FFF0-000F", "TEST_USB_MODEL_1",
StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, 88788 },
{ kDeviceDCIM2, "VendorModelSerial:ComName:Model2010:8989",
"TEST_USB_MODEL_2", StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
8773 },
{ kDeviceDCIM3, "VendorModelSerial:::WEM319X792", "TEST_USB_MODEL_3",
StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, 22837 },
{ kDeviceNoDCIM, "UUID:ABCD-1234", "TEST_USB_MODEL_4",
StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM, 512 },
{ kDeviceFixed, "UUID:743A-2349", "743A-2349",
StorageInfo::FIXED_MASS_STORAGE, 17282 },
};
scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
const base::FilePath& mount_point) {
bool device_found = false;
size_t i = 0;
for (; i < arraysize(kTestDeviceData); i++) {
if (device_path.value() == kTestDeviceData[i].device_path) {
device_found = true;
break;
}
}
scoped_ptr<StorageInfo> storage_info;
if (!device_found) {
NOTREACHED();
return storage_info.Pass();
}
StorageInfo::Type type = kTestDeviceData[i].type;
storage_info.reset(new StorageInfo(
StorageInfo::MakeDeviceId(type, kTestDeviceData[i].unique_id),
string16(),
mount_point.value(),
ASCIIToUTF16("volume label"),
ASCIIToUTF16("vendor name"),
ASCIIToUTF16("model name"),
kTestDeviceData[i].partition_size_in_bytes));
return storage_info.Pass();
}
uint64 GetDevicePartitionSize(const std::string& device) {
for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
if (device == kTestDeviceData[i].device_path)
return kTestDeviceData[i].partition_size_in_bytes;
}
return 0;
}
std::string GetDeviceId(const std::string& device) {
for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
if (device == kTestDeviceData[i].device_path) {
return StorageInfo::MakeDeviceId(kTestDeviceData[i].type,
kTestDeviceData[i].unique_id);
}
}
if (device == kInvalidDevice) {
return StorageInfo::MakeDeviceId(StorageInfo::FIXED_MASS_STORAGE,
kInvalidDevice);
}
return std::string();
}
class TestStorageMonitorLinux : public StorageMonitorLinux {
public:
TestStorageMonitorLinux(const base::FilePath& path,
base::MessageLoop* message_loop)
: StorageMonitorLinux(path),
message_loop_(message_loop) {
SetMediaTransferProtocolManagerForTest(
new TestMediaTransferProtocolManagerLinux());
SetGetDeviceInfoCallbackForTest(base::Bind(&GetDeviceInfo));
}
virtual ~TestStorageMonitorLinux() {}
private:
virtual void UpdateMtab(
const MtabWatcherLinux::MountPointDeviceMap& new_mtab) OVERRIDE {
StorageMonitorLinux::UpdateMtab(new_mtab);
message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
}
base::MessageLoop* message_loop_;
DISALLOW_COPY_AND_ASSIGN(TestStorageMonitorLinux);
};
class StorageMonitorLinuxTest : public testing::Test {
public:
struct MtabTestData {
MtabTestData(const std::string& mount_device,
const std::string& mount_point,
const std::string& mount_type)
: mount_device(mount_device),
mount_point(mount_point),
mount_type(mount_type) {
}
const std::string mount_device;
const std::string mount_point;
const std::string mount_type;
};
StorageMonitorLinuxTest()
: message_loop_(base::MessageLoop::TYPE_IO),
ui_thread_(content::BrowserThread::UI, &message_loop_),
file_thread_(content::BrowserThread::FILE, &message_loop_) {
}
virtual ~StorageMonitorLinuxTest() {}
protected:
virtual void SetUp() OVERRIDE {
// Create and set up a temp dir with files for the test.
ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
base::FilePath test_dir = scoped_temp_dir_.path().AppendASCII("test_etc");
ASSERT_TRUE(file_util::CreateDirectory(test_dir));
mtab_file_ = test_dir.AppendASCII("test_mtab");
MtabTestData initial_test_data[] = {
MtabTestData("dummydevice", "dummydir", kInvalidFS),
};
WriteToMtab(initial_test_data,
arraysize(initial_test_data),
true /* overwrite */);
test::TestStorageMonitor::RemoveSingleton();
monitor_ = new TestStorageMonitorLinux(mtab_file_, &message_loop_);
scoped_ptr<StorageMonitor> pass_monitor(monitor_);
TestingBrowserProcess* browser_process = TestingBrowserProcess::GetGlobal();
DCHECK(browser_process);
browser_process->SetStorageMonitor(pass_monitor.Pass());
mock_storage_observer_.reset(new MockRemovableStorageObserver);
monitor_->AddObserver(mock_storage_observer_.get());
monitor_->Init();
base::RunLoop().RunUntilIdle();
}
virtual void TearDown() OVERRIDE {
base::RunLoop().RunUntilIdle();
monitor_->RemoveObserver(mock_storage_observer_.get());
base::RunLoop().RunUntilIdle();
// Linux storage monitor must be destroyed on the UI thread, so do it here.
test::TestStorageMonitor::RemoveSingleton();
base::RunLoop().RunUntilIdle();
}
// Append mtab entries from the |data| array of size |data_size| to the mtab
// file, and run the message loop.
void AppendToMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
WriteToMtab(data, data_size, false /* do not overwrite */);
message_loop_.Run();
}
// Overwrite the mtab file with mtab entries from the |data| array of size
// |data_size|, and run the message loop.
void OverwriteMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
WriteToMtab(data, data_size, true /* overwrite */);
message_loop_.Run();
}
// Simplied version of OverwriteMtabAndRunLoop() that just deletes all the
// entries in the mtab file.
void WriteEmptyMtabAndRunLoop() {
OverwriteMtabAndRunLoop(NULL, // No data.
0); // No data length.
}
// Create a directory named |dir| relative to the test directory.
// It has a DCIM directory, so StorageMonitorLinux recognizes it as a media
// directory.
base::FilePath CreateMountPointWithDCIMDir(const std::string& dir) {
return CreateMountPoint(dir, true /* create DCIM dir */);
}
// Create a directory named |dir| relative to the test directory.
// It does not have a DCIM directory, so StorageMonitorLinux does not
// recognize it as a media directory.
base::FilePath CreateMountPointWithoutDCIMDir(const std::string& dir) {
return CreateMountPoint(dir, false /* do not create DCIM dir */);
}
void RemoveDCIMDirFromMountPoint(const std::string& dir) {
base::FilePath dcim =
scoped_temp_dir_.path().AppendASCII(dir).Append(kDCIMDirectoryName);
base::DeleteFile(dcim, false);
}
MockRemovableStorageObserver& observer() {
return *mock_storage_observer_;
}
StorageMonitor* notifier() {
return monitor_;
}
uint64 GetStorageSize(const base::FilePath& path) {
StorageInfo info;
if (!notifier()->GetStorageInfoForPath(path, &info))
return 0;
return info.total_size_in_bytes();
}
private:
// Create a directory named |dir| relative to the test directory.
// Set |with_dcim_dir| to true if the created directory will have a "DCIM"
// subdirectory.
// Returns the full path to the created directory on success, or an empty
// path on failure.
base::FilePath CreateMountPoint(const std::string& dir, bool with_dcim_dir) {
base::FilePath return_path(scoped_temp_dir_.path());
return_path = return_path.AppendASCII(dir);
base::FilePath path(return_path);
if (with_dcim_dir)
path = path.Append(kDCIMDirectoryName);
if (!file_util::CreateDirectory(path))
return base::FilePath();
return return_path;
}
// Write the test mtab data to |mtab_file_|.
// |data| is an array of mtab entries.
// |data_size| is the array size of |data|.
// |overwrite| specifies whether to overwrite |mtab_file_|.
void WriteToMtab(const MtabTestData* data,
size_t data_size,
bool overwrite) {
FILE* file = setmntent(mtab_file_.value().c_str(), overwrite ? "w" : "a");
ASSERT_TRUE(file);
// Due to the glibc *mntent() interface design, which is out of our
// control, the mtnent struct has several char* fields, even though
// addmntent() does not write to them in the calls below. To make the
// compiler happy while avoiding making additional copies of strings,
// we just const_cast() the strings' c_str()s.
// Assuming addmntent() does not write to the char* fields, this is safe.
// It is unlikely the platforms this test suite runs on will have an
// addmntent() implementation that does change the char* fields. If that
// was ever the case, the test suite will start crashing or failing.
mntent entry;
static const char kMountOpts[] = "rw";
entry.mnt_opts = const_cast<char*>(kMountOpts);
entry.mnt_freq = 0;
entry.mnt_passno = 0;
for (size_t i = 0; i < data_size; ++i) {
entry.mnt_fsname = const_cast<char*>(data[i].mount_device.c_str());
entry.mnt_dir = const_cast<char*>(data[i].mount_point.c_str());
entry.mnt_type = const_cast<char*>(data[i].mount_type.c_str());
ASSERT_EQ(0, addmntent(file, &entry));
}
ASSERT_EQ(1, endmntent(file));
}
// The message loop and file thread to run tests on.
base::MessageLoop message_loop_;
content::TestBrowserThread ui_thread_;
content::TestBrowserThread file_thread_;
scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
// Temporary directory for created test data.
base::ScopedTempDir scoped_temp_dir_;
// Path to the test mtab file.
base::FilePath mtab_file_;
TestStorageMonitorLinux* monitor_;
DISALLOW_COPY_AND_ASSIGN(StorageMonitorLinuxTest);
};
// Simple test case where we attach and detach a media device.
TEST_F(StorageMonitorLinuxTest, BasicAttachDetach) {
base::FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
ASSERT_FALSE(test_path.empty());
MtabTestData test_data[] = {
MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
MtabTestData(kDeviceFixed, kInvalidPath, kValidFS),
};
// Only |kDeviceDCIM2| should be attached, since |kDeviceFixed| has a bad
// path.
AppendToMtabAndRunLoop(test_data, arraysize(test_data));
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_attached().device_id());
EXPECT_EQ(string16(), observer().last_attached().name());
EXPECT_EQ(test_path.value(), observer().last_attached().location());
// |kDeviceDCIM2| should be detached here.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_detached().device_id());
}
// Only removable devices are recognized.
TEST_F(StorageMonitorLinuxTest, Removable) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
ASSERT_FALSE(test_path_a.empty());
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
};
// |kDeviceDCIM1| should be attached as expected.
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_attached().device_id());
EXPECT_EQ(string16(), observer().last_attached().name());
EXPECT_EQ(test_path_a.value(), observer().last_attached().location());
// This should do nothing, since |kDeviceFixed| is not removable.
base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
ASSERT_FALSE(test_path_b.empty());
MtabTestData test_data2[] = {
MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
// |kDeviceDCIM1| should be detached as expected.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_detached().device_id());
// |kDeviceNoDCIM| should be attached as expected.
MtabTestData test_data3[] = {
MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_attached().device_id());
EXPECT_EQ(string16(), observer().last_attached().name());
EXPECT_EQ(test_path_b.value(), observer().last_attached().location());
// |kDeviceNoDCIM| should be detached as expected.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(2, observer().detach_calls());
EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_detached().device_id());
}
// More complicated test case with multiple devices on multiple mount points.
TEST_F(StorageMonitorLinuxTest, SwapMountPoints) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
ASSERT_FALSE(test_path_a.empty());
ASSERT_FALSE(test_path_b.empty());
// Attach two devices.
// (*'d mounts are those StorageMonitor knows about.)
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM2 -> kMountPointB *
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
// Detach two devices from old mount points and attach the devices at new
// mount points.
// kDeviceDCIM1 -> kMountPointB *
// kDeviceDCIM2 -> kMountPointA *
MtabTestData test_data2[] = {
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
MtabTestData(kDeviceDCIM2, test_path_a.value(), kValidFS),
};
OverwriteMtabAndRunLoop(test_data2, arraysize(test_data2));
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(2, observer().detach_calls());
// Detach all devices.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(4, observer().detach_calls());
}
// More complicated test case with multiple devices on multiple mount points.
TEST_F(StorageMonitorLinuxTest, MultiDevicesMultiMountPoints) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
ASSERT_FALSE(test_path_a.empty());
ASSERT_FALSE(test_path_b.empty());
// Attach two devices.
// (*'d mounts are those StorageMonitor knows about.)
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM2 -> kMountPointB *
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
// Attach |kDeviceDCIM1| to |kMountPointB|.
// |kDeviceDCIM2| is inaccessible, so it is detached. |kDeviceDCIM1| has been
// attached at |kMountPointB|, but is still accessible from |kMountPointA|.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM2 -> kMountPointB
// kDeviceDCIM1 -> kMountPointB
MtabTestData test_data2[] = {
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
// Detach |kDeviceDCIM1| from |kMountPointA|, causing a detach and attach
// event.
// kDeviceDCIM2 -> kMountPointB
// kDeviceDCIM1 -> kMountPointB *
MtabTestData test_data3[] = {
MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
};
OverwriteMtabAndRunLoop(test_data3, arraysize(test_data3));
EXPECT_EQ(3, observer().attach_calls());
EXPECT_EQ(2, observer().detach_calls());
// Attach |kDeviceDCIM1| to |kMountPointA|.
// kDeviceDCIM2 -> kMountPointB
// kDeviceDCIM1 -> kMountPointB *
// kDeviceDCIM1 -> kMountPointA
MtabTestData test_data4[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data4, arraysize(test_data4));
EXPECT_EQ(3, observer().attach_calls());
EXPECT_EQ(2, observer().detach_calls());
// Detach |kDeviceDCIM1| from |kMountPointB|.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM2 -> kMountPointB *
OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(5, observer().attach_calls());
EXPECT_EQ(3, observer().detach_calls());
// Detach all devices.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(5, observer().attach_calls());
EXPECT_EQ(5, observer().detach_calls());
}
TEST_F(StorageMonitorLinuxTest, MultipleMountPointsWithNonDCIMDevices) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
ASSERT_FALSE(test_path_a.empty());
ASSERT_FALSE(test_path_b.empty());
// Attach to one first.
// (*'d mounts are those StorageMonitor knows about.)
// kDeviceDCIM1 -> kMountPointA *
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
// Attach |kDeviceDCIM1| to |kMountPointB|.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM1 -> kMountPointB
MtabTestData test_data2[] = {
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
EXPECT_EQ(1, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
// Attach |kDeviceFixed| (a non-removable device) to |kMountPointA|.
// kDeviceDCIM1 -> kMountPointA
// kDeviceDCIM1 -> kMountPointB *
// kDeviceFixed -> kMountPointA
MtabTestData test_data3[] = {
MtabTestData(kDeviceFixed, test_path_a.value(), kValidFS),
};
RemoveDCIMDirFromMountPoint(kMountPointA);
AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
// Detach |kDeviceFixed|.
// kDeviceDCIM1 -> kMountPointA
// kDeviceDCIM1 -> kMountPointB *
MtabTestData test_data4[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
};
CreateMountPointWithDCIMDir(kMountPointA);
OverwriteMtabAndRunLoop(test_data4, arraysize(test_data4));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
// Attach |kDeviceNoDCIM| (a non-DCIM device) to |kMountPointB|.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM1 -> kMountPointB
// kDeviceNoDCIM -> kMountPointB *
MtabTestData test_data5[] = {
MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
};
base::DeleteFile(test_path_b.Append(kDCIMDirectoryName), false);
AppendToMtabAndRunLoop(test_data5, arraysize(test_data5));
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(2, observer().detach_calls());
// Detach |kDeviceNoDCIM|.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceDCIM1 -> kMountPointB
MtabTestData test_data6[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
};
CreateMountPointWithDCIMDir(kMountPointB);
OverwriteMtabAndRunLoop(test_data6, arraysize(test_data6));
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(3, observer().detach_calls());
// Detach |kDeviceDCIM1| from |kMountPointB|.
// kDeviceDCIM1 -> kMountPointA *
OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(3, observer().detach_calls());
// Detach all devices.
WriteEmptyMtabAndRunLoop();
EXPECT_EQ(4, observer().attach_calls());
EXPECT_EQ(4, observer().detach_calls());
}
TEST_F(StorageMonitorLinuxTest, DeviceLookUp) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
base::FilePath test_path_c = CreateMountPointWithoutDCIMDir(kMountPointC);
ASSERT_FALSE(test_path_a.empty());
ASSERT_FALSE(test_path_b.empty());
ASSERT_FALSE(test_path_c.empty());
// Attach to one first.
// (starred mounts are those StorageMonitor knows about.)
// kDeviceDCIM1 -> kMountPointA *
// kDeviceNoDCIM -> kMountPointB *
// kDeviceFixed -> kMountPointC
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
StorageInfo device_info;
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_a, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
EXPECT_EQ(test_path_a.value(), device_info.location());
EXPECT_EQ(string16(), device_info.name());
EXPECT_EQ(88788ULL, device_info.total_size_in_bytes());
EXPECT_EQ(ASCIIToUTF16("volume label"), device_info.storage_label());
EXPECT_EQ(ASCIIToUTF16("vendor name"), device_info.vendor_name());
EXPECT_EQ(ASCIIToUTF16("model name"), device_info.model_name());
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), device_info.device_id());
EXPECT_EQ(test_path_b.value(), device_info.location());
EXPECT_EQ(string16(), device_info.name());
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
EXPECT_EQ(test_path_c.value(), device_info.location());
EXPECT_EQ(string16(), device_info.name());
// An invalid path.
EXPECT_FALSE(notifier()->GetStorageInfoForPath(base::FilePath(kInvalidPath),
&device_info));
// Test filling in of the mount point.
EXPECT_TRUE(
notifier()->GetStorageInfoForPath(test_path_a.Append("some/other/path"),
&device_info));
EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
EXPECT_EQ(test_path_a.value(), device_info.location());
EXPECT_EQ(string16(), device_info.name());
// One device attached at multiple points.
// kDeviceDCIM1 -> kMountPointA *
// kDeviceFixed -> kMountPointB
// kDeviceFixed -> kMountPointC
MtabTestData test_data2[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
};
AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_a, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(1, observer().detach_calls());
}
TEST_F(StorageMonitorLinuxTest, DevicePartitionSize) {
base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
ASSERT_FALSE(test_path_a.empty());
ASSERT_FALSE(test_path_b.empty());
MtabTestData test_data1[] = {
MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
MtabTestData(kDeviceFixed, kInvalidPath, kInvalidFS),
};
AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
EXPECT_EQ(2, observer().attach_calls());
EXPECT_EQ(0, observer().detach_calls());
EXPECT_EQ(GetDevicePartitionSize(kDeviceDCIM1),
GetStorageSize(test_path_a));
EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
GetStorageSize(test_path_b));
EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
GetStorageSize(base::FilePath(kInvalidPath)));
}
} // namespace
} // namespace chrome
| [
"[email protected]"
] | |
b51f8f6d977faa570489ca437943131e0d0bc802 | 576cf908e40f6fe87d3c361b566faeef0659c32c | /mm08.cpp | 121ded44d8c696580040d46178bcd6759c2f4b75 | [] | no_license | wanwankao/ds_ITSA | eaa0ab9ffb617b7b4361391109e26eabf874f1d9 | f2480b392465b92be0455215e9eeca432fdf4513 | refs/heads/master | 2020-12-12T10:11:41.743902 | 2020-01-15T15:09:59 | 2020-01-15T15:09:59 | 234,105,843 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 277 | cpp | #include<iostream>
#include<iomanip>
#include<math.h>
using namespace std;
//計算兩數和的平方值
int main() {
int num_1, num_2, result;
cin >> num_1 >> num_2;
result = pow((num_1 + num_2),2);
cout << result << endl;
return 0;
} | [
"[email protected]"
] | |
30071ddd303d573d5fd378d13d8376a91fd77e25 | 60a15a584b00895e47628c5a485bd1f14cfeebbe | /controls/PrintFieldAX/EnterValuesDlg.cpp | cbbfc63a0e00a9e0ad90e2bf928d843b7f953f21 | [] | no_license | fcccode/vt5 | ce4c1d8fe819715f2580586c8113cfedf2ab44ac | c88049949ebb999304f0fc7648f3d03f6501c65b | refs/heads/master | 2020-09-27T22:56:55.348501 | 2019-06-17T20:39:46 | 2019-06-17T20:39:46 | null | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 16,274 | cpp | // EnterValuesDlg.cpp : implementation file
//
#include "stdafx.h"
#include "PrintFieldAX.h"
#include "EnterValuesDlg.h"
#include "\vt5\awin\misc_utils.h"
#include "EditEx.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//#define DEFAULT_COMBO_SECTION "\\ValuesCombo\\Default\\"
#define DEFAULT_COMBO_SECTION "\\Default\\ValuesCombo\\"
CString CopyValueName(LPCTSTR lpstrSrc)
{
int nLen = _tcslen(lpstrSrc);
while (nLen > 0 && (lpstrSrc[nLen-1] == _T(' ') || lpstrSrc[nLen-1] == _T(':')))
nLen--;
CString s(lpstrSrc, nLen);
// _tcsncpy(lpstrDest, lpstrSrc, nLen);
// lpstrDest[nLen] = 0;
return s;
}
/////////////////////////////////////////////////////////////////////////////
// CEnterValuesDlg dialog
CEnterValuesDlg::CEnterValuesDlg(request_impl *p, CWnd* pParent /*=NULL*/)
: CDialog(CEnterValuesDlg::IDD, pParent)
{
m_pdata = p;
//{{AFX_DATA_INIT(CEnterValuesDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
m_nIdPrevActive = -1;
}
CEnterValuesDlg::~CEnterValuesDlg()
{
clear_editex_list( );
}
void CEnterValuesDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CEnterValuesDlg)
// NOTE: the ClassWizard will add DDX and DDV calls here
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CEnterValuesDlg, CDialog)
//{{AFX_MSG_MAP(CEnterValuesDlg)
ON_BN_CLICKED(IDHELP, OnHelp)
//}}AFX_MSG_MAP
ON_BN_CLICKED(IDC_COMBO_DEFAULT, OnBnClickedComboDefault)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CEnterValuesDlg message handlers
BOOL CEnterValuesDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// vanek
clear_editex_list( );
if( !m_strTitle.IsEmpty() )
SetWindowText( m_strTitle );
m_pdata->layout( this );
CRect rect;
GetWindowRect( &rect );
CRect rect_client;
GetClientRect( &rect_client );
int delta = rect.Width()-rect_client.Width();
int dx = max( rect.Width(), m_pdata->m_size.cx+delta )-rect.Width();
int dy = m_pdata->m_size.cy;
rect.bottom += dy;
rect.right += dx;
MoveWindow( &rect );
GetDlgItem( IDOK )->GetWindowRect( &rect );
ScreenToClient( rect );
rect.OffsetRect( dx, dy );
GetDlgItem( IDOK )->MoveWindow( &rect );
GetDlgItem( IDCANCEL )->GetWindowRect( &rect );
ScreenToClient( rect );
rect.OffsetRect( dx, dy );
GetDlgItem( IDCANCEL )->MoveWindow( &rect );
GetDlgItem( IDC_COMBO_DEFAULT )->GetWindowRect( &rect );
ScreenToClient( rect );
rect.OffsetRect( dx, dy );
GetDlgItem( IDC_COMBO_DEFAULT )->MoveWindow( &rect );
GetDlgItem( IDHELP )->GetWindowRect( &rect );
ScreenToClient( rect );
rect.OffsetRect( dx, dy );
GetDlgItem( IDHELP )->MoveWindow( &rect );
HFONT hfont = (HFONT)SendMessage( WM_GETFONT );
CClientDC dc( 0 );
dc.SelectObject( hfont );
for( group_data *pg = m_pdata->first_group; pg; pg = pg->next )
{
HWND hwnd_group = ::CreateWindow( "button", pg->caption, WS_CHILD|WS_VISIBLE|BS_GROUPBOX,
pg->rect.left, pg->rect.top, pg->rect.Width(), pg->rect.Height(),
GetSafeHwnd(), (HMENU)-1, AfxGetInstanceHandle(), 0 );
::SendMessage( hwnd_group, WM_SETFONT, (WPARAM)hfont, 0 );
for( control_data *p = pg->first_control; p; p = p->next )
{
bool bMultyLine =
(p->params.flags & PFF_TEXT_STYLE_MULTYLINE) == PFF_TEXT_STYLE_MULTYLINE &&
(p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_TEXT;
CSize size = dc.GetTextExtent( p->caption, p->caption.length() );
RECT rcc = { 0 };
dc.DrawText( (char *)p->caption, &rcc, DT_CALCRECT );
size.cx = rcc.right - rcc.left;
size.cy = rcc.bottom - rcc.top;
if( bMultyLine )
{
p->rect_static.bottom = p->rect_static.top+size.cy;
p->rect_edit.top = p->rect_static.bottom+4;
}
HWND hwnd_static = ::CreateWindow( "static", p->caption, WS_CHILD|WS_VISIBLE,
p->rect_static.left, p->rect_static.CenterPoint().y-size.cy/2, size.cx, size.cy,
GetSafeHwnd(), (HMENU)p->id_static, AfxGetInstanceHandle(), 0 );
::SendMessage( hwnd_static, WM_SETFONT, (WPARAM)hfont, 0 );
bool bCreateSlider = false;
CString str_def;
long ldef = 0;
// ::strencode( sz_e, p->caption, ":\n\r\\", sizeof( sz_e ) );
// ::strcpy( sz_e, p->caption );
CString sz_e = CopyValueName(p->caption);
if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_TEXT ||
(p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_DATE ) // [vanek] BT2000: 3671 - 10.03.2004
str_def = ::GetValueString( GetAppUnknown(), "\\Values", sz_e, "" );
else if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_NUMERIC )
{
if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_INTEGER )
{
ldef = ::GetValueInt( GetAppUnknown(), "\\Values", sz_e, p->params.ldef );
str_def.Format( "%ld", ldef );
bCreateSlider = true;
}
else if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_DOUBLE )
{
double fdef = ::GetValueDouble( GetAppUnknown(), "\\Values", sz_e, p->params.fdef );
if( p->data_format != -1 )
{
char format[MAX_PATH], _format[MAX_PATH];
sprintf( _format, "%d", p->data_format );
strcpy( format, "%." );
strcat( format, _format );
strcat( format, "lf" );
str_def.Format( format, fdef );
}
else
str_def = "";
}
}
/* if( p->params.flags & PFF_TEXT_STYLE_INITBYDATE )
{
str_def =COleDateTime::GetCurrentTime().Format();
}*/
DWORD dw_style = WS_CHILD|WS_VISIBLE|WS_TABSTOP|WS_BORDER;
HWND hwnd;
if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_DATE ||
(p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_TEXT &&
(p->params.flags & PFF_TEXT_STYLE_INITBYDATE) )
{
dw_style |= DTS_SHORTDATECENTURYFORMAT;
if ((p->params.flags & PFF_TEXT_STYLE_INITBYDATE) == 0)
dw_style |= DTS_SHOWNONE;
HWND hwnd = ::CreateWindowEx(0, DATETIMEPICK_CLASS, "DateTime", dw_style,
p->rect_edit.left, p->rect_edit.top, p->rect_edit.Width(), p->rect_edit.Height(),
GetSafeHwnd(), (HMENU)p->id, AfxGetInstanceHandle(), 0 );
if ( !str_def.IsEmpty() )
{
COleDateTime DTime;
DTime.ParseDateTime( str_def );
SYSTEMTIME stime;
DTime.GetAsSystemTime( stime );
DateTime_SetSystemtime( hwnd, GDT_VALID, &stime);
}
else
dw_style &= ~DTS_SHOWNONE;
}
else if( p->params.flags & PFF_TEXT_STYLE_COMBOBOX || p->params.flags & PFF_TEXT_STYLE_COMBOBOX2 )
{
if( p->params.flags & PFF_TEXT_STYLE_COMBOBOX )
dw_style |= CBS_AUTOHSCROLL|CBS_DROPDOWN;
else
dw_style |= CBS_AUTOHSCROLL|CBS_DROPDOWNLIST;
dw_style &= ~CBS_AUTOHSCROLL;
HWND hwnd =
::CreateWindowEx( WS_EX_CLIENTEDGE, "combobox", str_def, dw_style,
p->rect_edit.left, p->rect_edit.top, p->rect_edit.Width(), p->rect_edit.Height(),
GetSafeHwnd(), (HMENU)p->id, AfxGetInstanceHandle(), 0 );
::SendMessage( hwnd, WM_SETFONT, (WPARAM)hfont, 0 );
INamedDataPtr ptrNamedData( GetAppUnknown() );
ptrNamedData->SetupSection( _bstr_t( "\\ValuesCombo\\" )+(const char *)sz_e );
long count;
ptrNamedData->GetEntriesCount( &count );
int nCurSel = -1;
for( long i = 0; i < count; i++ )
{
BSTR bstr;
ptrNamedData->GetEntryName( i, &bstr );
_bstr_t bstr_entry = bstr;
::SysFreeString( bstr );
if (bstr_entry == _bstr_t(str_def))
nCurSel = i;
::SendMessage( hwnd, CB_ADDSTRING, 0, (LPARAM)(const char*)bstr_entry );
}
// [vanek] BT2000: 3539. Глюк combobox: когд?установлен стил?CBS_DROPDOWN, список пуст ?
// установлен?заведомо большая высота - не происходит снятия фокуса ?контрола (видимо на величину
// установленно?высоты), поэтом?увеличивае?высоту, только когд?добавили строки
if(count > 0)
::SetWindowPos( hwnd, 0, 0, 0, p->rect_edit.Width(), p->rect_edit.Height() + 100,
SWP_NOMOVE|SWP_NOZORDER );
if (p->params.flags & PFF_TEXT_STYLE_COMBOBOX2)
::SendMessage( hwnd, CB_SETCURSEL, (WPARAM)nCurSel, 0);
else
::SetWindowText( hwnd, str_def );
}
else
{
if( p->params.flags & PFF_TEXT_STYLE_MULTYLINE )
dw_style |= ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL;
else
dw_style |= ES_AUTOHSCROLL;
if( p->params.flags & PFF_STYLE_ALIGN_L )
dw_style |= ES_LEFT;
else if( p->params.flags & PFF_STYLE_ALIGN_C )
dw_style |= ES_CENTER;
else if( p->params.flags & PFF_STYLE_ALIGN_R )
dw_style |= ES_RIGHT;
// vanek
hwnd =
::CreateWindowEx( WS_EX_CLIENTEDGE, "edit", str_def, dw_style,
p->rect_edit.left, p->rect_edit.top, p->rect_edit.Width(), p->rect_edit.Height(),
GetSafeHwnd(), (HMENU)p->id, AfxGetInstanceHandle(), 0 );
if ( hwnd )
{
DWORD dwFlags = 0;
if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_NUMERIC )
{
dwFlags |= EDITEX_TYPE_NUMERIC;
if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_INTEGER )
dwFlags |= EDITEX_NUMERIC_TYPE_INTEGER;
else if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_DOUBLE )
dwFlags |= EDITEX_NUMERIC_TYPE_DOUBLE;
}
else if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_TEXT )
dwFlags |= EDITEX_TYPE_TEXT;
CEditEx *peditex = new CEditEx( dwFlags );
if( peditex->SubclassWindow( hwnd ) )
{
::SendMessage( hwnd, WM_SETFONT, (WPARAM)hfont, 0 );
m_EditExList.AddTail( peditex );
}
else
delete peditex; peditex = 0;
}
}
if( bCreateSlider )
{
long lmin = -10000;
long lmax = 10000;
if( p->params.flags & PFF_NUMERIC_STYLE_DEFAULT )
ldef = p->params.ldef;
if( p->params.flags & PFF_NUMERIC_STYLE_RANGES )
{
lmin = p->params.lmin;
lmax = p->params.lmax;
}
::CreateUpDownControl( WS_CHILD|WS_VISIBLE|UDS_SETBUDDYINT|UDS_ALIGNRIGHT|UDS_ARROWKEYS|UDS_NOTHOUSANDS,
0, 0, 0, 0, GetSafeHwnd(), p->id_spin, AfxGetInstanceHandle(),
hwnd, lmax, lmin, ldef );
}
}
}
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CEnterValuesDlg::OnOK()
{
char sz[4096];
CString sValCombo = "\\ValuesCombo\\";
for( group_data *pg = m_pdata->first_group; pg; pg = pg->next )
{
for( control_data *p = pg->first_control; p; p = p->next )
{
// ::strencode( sz_e, p->caption, ":\n\r\\", sizeof( sz_e ) );
// ::strcpy( sz_e, p->caption );
CString sz_e = CopyValueName(p->caption);
if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_DATE ||
p->params.flags & PFF_TEXT_STYLE_INITBYDATE )
{
HWND hwnd = ::GetDlgItem(m_hWnd, p->id);
SYSTEMTIME SysTime;
if (DateTime_GetSystemtime(hwnd,&SysTime) == GDT_VALID)
{
COleDateTime DateTime(SysTime);
CString sDate = DateTime.Format(VAR_DATEVALUEONLY);
SetValue( GetAppUnknown(), "\\Values", sz_e, sDate );
}
else
SetValue( GetAppUnknown(), "\\Values", sz_e, (const char*)0 );
}
else
{
GetDlgItemText( p->id, sz, sizeof( sz ) );
int ntext_len = strlen( sz );
if( p->params.flags & PFF_TEXT_STYLE_COMBOBOX || p->params.flags & PFF_TEXT_STYLE_COMBOBOX2 )
if( ntext_len )
::SetValue( GetAppUnknown(), sValCombo+(const char*)sz_e, sz, 0l );
if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_NUMERIC )
{
if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_INTEGER )
{
if( ntext_len )
{
long val;
if( sscanf( sz, "%d", &val ) != 1 )
{
AfxMessageBox( IDS_NOINTEGER );
return;
}
if( p->params.flags & PFF_NUMERIC_STYLE_RANGES )
{
if( val < p->params.lmin || val > p->params.lmax )
{
CString str;
str.Format( IDS_INT_NOTININTERVAL, val, p->params.lmin, p->params.lmax );
AfxMessageBox( str );
return;
}
}
SetValue( GetAppUnknown(), "\\Values", sz_e, val );
}
else
SetValue( GetAppUnknown(), "\\Values", sz_e, 0L );
}
else if( (p->params.flags & PFF_NUMERIC_TYPE_MASK) == PFF_NUMERIC_TYPE_DOUBLE )
{
if( ntext_len )
{
double val;
if( sscanf( sz, "%lf", &val ) != 1 )
{
AfxMessageBox( IDS_NODOUBLE );
return;
}
if( p->params.flags & PFF_NUMERIC_STYLE_RANGES )
{
if( val < p->params.fmin || val > p->params.fmax )
{
CString str;
str.Format( IDS_DOUBLE_NOTININTERVAL, val, p->params.fmin, p->params.fmax );
AfxMessageBox( str );
return;
}
}
SetValue( GetAppUnknown(), "\\Values", sz_e, val );
}
else
SetValue( GetAppUnknown(), "\\Values", sz_e, 0L );
}
}
else if( (p->params.flags & PFF_TYPE_MASKS) == PFF_TYPE_TEXT )
SetValue( GetAppUnknown(), "\\Values", sz_e, sz );
}
}
}
CDialog::OnOK();
}
void CEnterValuesDlg::OnHelp()
{
HelpDisplay( "UserValues" );
}
BOOL CEnterValuesDlg::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
if (nCode == CBN_SETFOCUS)
{
for( group_data *pg = m_pdata->first_group; pg; pg = pg->next )
{
for( control_data *p = pg->first_control; p; p = p->next )
{
if (p->id == nID)
{
// INamedDataPtr ptrNamedData( GetAppUnknown() );
// ptrNamedData->SetupSection( _bstr_t( DEFAULT_COMBO_SECTION )+p->caption);
// long count;
// ptrNamedData->GetEntriesCount(&count);
// ::EnableWindow(::GetDlgItem(m_hWnd, IDC_COMBO_DEFAULT), count>0);
::EnableWindow(::GetDlgItem(m_hWnd, IDC_COMBO_DEFAULT), TRUE);
m_nIdPrevActive = nID;
return CDialog::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}
}
}
}
else if (nCode == CBN_KILLFOCUS)
{
CWnd *pWnd = GetFocus();
if (pWnd == NULL || pWnd->GetDlgCtrlID() != IDC_COMBO_DEFAULT)
{
::EnableWindow(::GetDlgItem(m_hWnd, IDC_COMBO_DEFAULT), FALSE);
m_nIdPrevActive = -1;
}
}
return CDialog::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}
void CEnterValuesDlg::OnBnClickedComboDefault()
{
CComboBox ComboBox;
ComboBox.Attach(::GetDlgItem(m_hWnd,m_nIdPrevActive));
if (ComboBox.m_hWnd != NULL)
{
control_data *pFocus = NULL;
for( group_data *pg = m_pdata->first_group; pg; pg = pg->next )
{
for( control_data *p = pg->first_control; p; p = p->next )
{
if (p->id == m_nIdPrevActive)
{
pFocus = p;
break;
}
}
}
if (pFocus)
{
long count;
CArray<BSTR,BSTR&> saDefault;
INamedDataPtr ptrNamedData( GetAppUnknown() );
_bstr_t sCap = CopyValueName(pFocus->caption);
ptrNamedData->SetupSection(_bstr_t(DEFAULT_COMBO_SECTION)+sCap);
ptrNamedData->GetEntriesCount(&count);
BSTR bstr;
for(long i = 0; i < count; i++)
{
ptrNamedData->GetEntryName(i, &bstr);
saDefault.Add(bstr);
}
// Remove entries which are not contained in default section
ptrNamedData->SetupSection( _bstr_t( "\\ValuesCombo\\" )+sCap);
CArray<BSTR,BSTR&> sa;
ptrNamedData->GetEntriesCount(&count);
// Make array of entries to delete
for(long i = 0; i < count; i++)
{
ptrNamedData->GetEntryName(i, &bstr);
bool bFound = false;
for(long j = 0; j < saDefault.GetSize(); j++)
{
if (_bstr_t(bstr) == _bstr_t(saDefault[j]))
{
bFound = true;
break;
}
}
if (!bFound)
sa.Add(bstr);
else
::SysFreeString(bstr);
}
// Delete it
for(i = 0; i < sa.GetSize(); i++)
{
ptrNamedData->DeleteEntry(sa[i]);
::SysFreeString(sa[i]);
}
// Now remove values from combobox's list.
CString sText;
ComboBox.GetWindowText(sText);
ComboBox.ResetContent();
int nCurSel = 0;
for(i = 0; i < saDefault.GetSize(); i++)
{
CString s(saDefault[i]);
if (s == sText)
nCurSel = i;
ComboBox.AddString(s);
::SysFreeString(saDefault[i]);
}
ComboBox.SetCurSel(nCurSel);
}
}
ComboBox.SetFocus();
ComboBox.Detach();
// ::EnableWindow(::GetDlgItem(m_hWnd, IDC_COMBO_DEFAULT), FALSE);
}
| [
"[email protected]"
] | |
fca886e60bf5490bcbb9679c5459f2d55e2223d7 | ba8b5e939c248970e2a0fd1527ad52488319b39e | /ESP8266Basic/Commands.ino | eec17677989a2c9742ea88e3f00ce85bc0ab0afa | [
"BSD-3-Clause"
] | permissive | todocono/Basic | fd393c1cf2b61a12543208a7f051c7adf040f9a6 | 199e7d7319d86091772311f25e7ed8a3301e608c | refs/heads/master | 2021-01-15T14:28:38.588648 | 2016-03-31T11:33:18 | 2016-03-31T11:33:18 | 55,121,903 | 0 | 0 | null | 2016-03-31T05:08:50 | 2016-03-31T05:08:49 | null | UTF-8 | C++ | false | false | 26,058 | ino | parser_data pd;
int num_args;
PARSER_PREC args[PARSER_MAX_ARGUMENT_COUNT];
String *args_str[PARSER_MAX_ARGUMENT_COUNT];
void InitCommandParser()
{
//parser_data_init( &pd, NULL, variable_callback, function_callback, NULL );
pd.str = NULL;
pd.len = 0;
pd.pos = 0;
pd.error = NULL;
pd.variable_cb = variable_callback;
pd.function_cb = function_callback;
}
int ExtractArguments(String &inData)
{
int r;
inData.concat(')'); // add a parenthesys at the end
pd.pos = inData.indexOf(' ') + 1; // starts just after the command
pd.str = inData.c_str();
pd.len = inData.length() + 1; // important the +1 as this permit to touch the '\0'
pd.error = NULL; // reset the previous error
r = parser_read_argument_list( &pd, &num_args, args, args_str);
if (pd.error != NULL)
PrintAndWebOut(String(pd.error));
return r;
}
void DeAllocateArguments()
{
for (int i = 0; i < num_args; i++)
delete args_str[i];
}
void ExicuteTheCurrentLine()
{
int r;
String Param0;
String Param1;
String Param2;
String Param3;
String Param4;
String Param5;
inData.trim();
Param0 = getValue(inData, ' ', 0);
Param1 = getValue(inData, ' ', 1);
Param2 = getValue(inData, ' ', 2);
Param3 = getValue(inData, ' ', 3);
Param4 = getValue(inData, ' ', 4);
Param5 = getValue(inData, ' ', 5);
Param0.toLowerCase();
// Line_For_Eval = inData; /////////////////////////////////////////////////////////////////////////////////////////////////
// int valParam0 = Param0.toInt();
int valParam1 = Param1.toInt();
int valParam2 = Param2.toInt();
if (BasicDebuggingOn == 1)
{
Serial.println(F("Exicuting line Debug Statement"));
Serial.println(String(String(RunningProgramCurrentLine) + " " + inData));
Serial.println(Param0);
Serial.println(Param1);
Serial.println(Param2);
Serial.println(Param3);
Serial.println(Param4);
Serial.println(Param5);
}
Param0.trim();
if ( Param0 == "") return;
if (Param0.startsWith("[")) return;
if ( Param0 == F("if"))
{
// the goal here is to find if there is a "then" or an "else"
// so the best is to take the positions of each one
// we need to take care if these words are included into the commands or arguments
// so, for the moment, we should avoid to use these "words" inside the line
// we can just define that these words should be surrounded by spaces (" then " " else ")
//
int then_pos, else_pos;
then_pos = inData.indexOf(" then ");
else_pos = inData.indexOf(" else ");
if (then_pos < 0)
{
PrintAndWebOut(F("Syntax error in if command"));
return;
}
String Comparaison = inData.substring(2, then_pos);
Comparaison.trim();
//Serial.println(Comparaison);
if (evaluate(Comparaison) == "-1")
inData = inData.substring(then_pos + 6, else_pos);
else if (else_pos > 0)
inData = inData.substring(else_pos + 6);
else
return; // there is no else command
inData.trim();
//Serial.println(inData);
//Param0 = inData.substring(0, inData.indexOf(' ')); // recover the new command
Param0 = getValue(inData, ' ', 0);// recover the new command
Param1 = getValue(inData, ' ', 1);
Param2 = getValue(inData, ' ', 2);
Param3 = getValue(inData, ' ', 3);
Param4 = getValue(inData, ' ', 4);
Param5 = getValue(inData, ' ', 5);
Param0.toLowerCase();
}
if (Param0 == F("for"))
{
ForNextReturnLocations[0]++;
ForNextReturnLocations[ForNextReturnLocations[0]] = RunningProgramCurrentLine;
// looks for the 'to'
r = inData.lastIndexOf("to");
if (r == -1)
{
PrintAndWebOut(F("Syntax error in for"));
return;
}
Param1 = inData.substring(3, r); // extract the text i = 11 (eliminate the 'for' and the 'to ....')
// looks for the '='
r = Param1.indexOf('=');
Param2 = Param1.substring(0, r);
Param2.trim();
Param3 = Param1.substring(r + 1);
Param3.trim();
SetMeThatVar(Param2, evaluate(Param3));
return;
}
if (Param0 == F("next"))
{
//for x = 1 to 10
for (int i = ForNextReturnLocations[0]; i >= 1; i--)
{
delay(0);
String gotoTestFor = BasicProgram(ForNextReturnLocations[i]);
gotoTestFor.trim();
// looks for the '='
r = gotoTestFor.indexOf('=');
String VarTest = gotoTestFor.substring(3, r); //getValue(gotoTestFor, ' ', 1);
VarTest.trim();
//Serial.print("vartest "+ VarTest);
// looks for the 'to'
r = gotoTestFor.lastIndexOf("to");
String VarTestIfDone = gotoTestFor.substring(r + 2); //getValue(gotoTestFor, ' ', 5);
//VarTestIfDone.trim();
//Serial.print("VarTestIfDone " + VarTestIfDone);
if (ForNextReturnLocations[i] == 0) return;
if (VarTest == Param1)
{
float test1 = VarialbeLookup(VarTest).toFloat();
float test2 = evaluate(VarTestIfDone).toFloat(); //GetMeThatVar(VarTestIfDone).toFloat();
//Serial.println(test1);
//Serial.println(test2);
if ( test1 < test2 )
{
RunningProgramCurrentLine = ForNextReturnLocations[i];
SetMeThatVar(Param1, evaluate(Param1 + "+1"));
break;
}
else
{
ForNextReturnLocations[0]--;
return;
}
}
}
return;
}
if (Param0 == F("debugon"))
{
BasicDebuggingOn = 1;
return;
}
if (Param0 == F("debugoff"))
{
BasicDebuggingOn = 0;
return;
}
if (Param0 == F("run"))
{
ProgramName = GetMeThatVar(Param1);
GraphicsEliments[0][0] = 0;
RunningProgram = 1;
numberButtonInUse = 0;
RunningProgramCurrentLine = 0;
HTMLout = "";
TimerWaitTime = 0;
//RunBasicProgram();
return;
}
if (Param0 == F("reboot") | Param0 == F("restart"))
{
ESP.restart();
return;
}
if (Param0 == F("vars"))
{
//for debugging purpose to print out all of the basic variables
PrintAllMyVars();
return;
}
if (Param0 == F("memclear"))
{
for (byte i = 0; i < 50; i++)
{
AllMyVaribles[i][0] = "";
AllMyVaribles[i][1] = "";
}
return;
}
if (Param0 == F("list"))
{
for (int i = 0; i <= TotalNumberOfLines; i++)
{
if (BasicProgram(i).length() > 0)
{
delay(0);
//PrintAndWebOut(BasicProgram[i].length());
PrintAndWebOut(String(String(i) + " " + BasicProgram(i)));
}
}
return;
}
if (Param0 == F("dir"))
{
//SPIFFS.begin();
Dir dir = SPIFFS.openDir(String("/" ));
while (dir.next()) {
File f = dir.openFile("r");
PrintAndWebOut(String(dir.fileName() + " " + f.size()));
}
return;
}
if (Param0 == F("del"))
{
//SPIFFS.begin();
PrintAndWebOut(String("/" + Param1));
PrintAndWebOut(String(SPIFFS.remove(String("/" + Param1))));
return;
}
//Commnads to controll pins
if ( Param0 == F("pi"))
{
SetMeThatVar(Param2, String(UniversalPinIO("pi", GetMeThatVar(Param1), 0)));
return;
}
if ( Param0 == F("interrupt"))
{
UniversalPinIO(GetMeThatVar(Param2), GetMeThatVar(Param1), 0);
return;
}
if ( Param0 == F("po"))
{
valParam2 = VarialbeLookup(Param2).toInt();
UniversalPinIO("po", VarialbeLookup(Param1), valParam2);
return;
}
if ( Param0 == F("pwi"))
{
SetMeThatVar(Param2, String(UniversalPinIO("pwi", VarialbeLookup(Param1), 0)));
return;
}
if ( Param0 == F("pwo"))
{
valParam2 = VarialbeLookup(Param2).toInt();
UniversalPinIO("pwo", VarialbeLookup(Param1), valParam2);
return;
}
if ( Param0 == "temp" | Param0 == "ti")
{
valParam1 = GetMeThatVar(Param1).toInt();
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
sensors.requestTemperatures(); // Send the command to get temperatures
SetMeThatVar(Param2, String(sensors.getTempCByIndex(valParam1)));
return;
}
if ( Param0 == F("ai"))
{
SetMeThatVar(Param1, String(analogRead(A0)));
return;
}
if ( Param0 == F("servo"))
{
valParam2 = evaluate(Param2).toInt();
delay(0);
UniversalPinIO(F("servo"), evaluate(Param1), valParam2);
return;
}
//Feading and writing variables to flash memory
if ( Param0 == F("read"))
{
SetMeThatVar(Param2, LoadDataFromFile(GetMeThatVar(Param1)));
return;
}
if ( Param0 == F("write"))
{
SaveDataToFile(GetMeThatVar(Param1), VarialbeLookup(Param2));
return;
}
if ( Param0 == F("comando"))
{
r = ExtractArguments(inData);
if (num_args == 2)
{
if (isnan(args[0]))
Serial.println(*args_str[0]);
if (isnan(args[1]))
Serial.println(*args_str[1]);
}
DeAllocateArguments();
return;
}
if ( Param0 == F("delay"))
{
// this is an example of extraction using the ExtractArgument function just for one parameter
// the best way, with a single parameter, is to use directly the eval command
r = ExtractArguments(inData);
//valParam1 = GetMeThatVar(Param1).toInt();
delay(args[0]);
DeAllocateArguments(); // don't forget to call this function after each ExtractArguments
return;
}
if ( Param0 == F("timer"))
{
// this is another way to separate the arguments
// we can state that the label name is separated from the 1st argument by a ',';
// we can so find the ',' from the end of the string and take the argument space trimmed for the label name
// the 1st argument will be so the text between this ',' and the end of the command
Param1 = inData.substring(inData.indexOf(' ') + 1); // starts just after the command
r = Param1.lastIndexOf(',');
if (r == -1)
{
PrintAndWebOut(F("Syntax Error; Label or argument missing"));
return;
}
Param2 = Param1.substring(r + 1);
Param2.trim();
Param1 = Param1.substring(0, r);
TimerWaitTime = evaluate(Param1).toInt();
TimerBranch = Param2;
//TimerWaitTime = GetMeThatVar(Param1).toInt();
//TimerBranch = Param2;
return;
}
if ( Param0 == F("sleep"))
{
// this command needs to be checked!
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
ESP.deepSleep(evaluate(Param1).toInt() * 1000000, WAKE_RF_DEFAULT);
return;
}
if (Param0 == F("print"))
{
// this is an example of extraction using directly the evaluate function taking into account all the text after the command (so after the ' ' )
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
//PrintAndWebOut(GetMeThatVar(Param1));
PrintAndWebOut(evaluate(Param1));
return;
}
if (Param0 == F("serialprint"))
{
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
//Serial.print(GetMeThatVar(Param1));
Serial.print(evaluate(Param1));
return;
}
if (Param0 == F("serialprintln"))
{
//Serial.println(GetMeThatVar(Param1));
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
Serial.println(evaluate(Param1));
return;
}
if (Param0 == F("serial2begin"))
{
//Serial1.begin(GetMeThatVar(Param1).toInt());
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
Serial1.begin(evaluate(Param1).toInt());
return;
}
if (Param0 == F("serial2end"))
{
Serial1.end();
return;
}
if (Param0 == F("serial2print"))
{
Serial1.print(GetMeThatVar(Param1));
return;
}
if (Param0 == F("serial2println"))
{
Serial1.println(GetMeThatVar(Param1));
return;
}
if (Param0 == F("baudrate"))
{
//Serial.begin(GetMeThatVar(Param1).toInt());
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
Serial.begin(evaluate(Param1).toInt());
return;
}
//i2c led display
if (Param0 == "oledprint")
{
Param1 = GetMeThatVar(Param1);
int str_len = Param1.length() + 1;
char OLEDTString[str_len];
Param1.toCharArray(OLEDTString, str_len);
sendStrXY(OLEDTString, GetMeThatVar(Param3).toInt(), GetMeThatVar(Param2).toInt());
return;
}
if (Param0 == "oledcls")
{
clear_display();
return;
}
if (Param0 == "oledsend")
{
sendcommand(GetMeThatVar(Param1).toInt());
return;
}
//end i2c display code
//i2c 1602 lcd display
if (Param0 == "lcdprint")
{
Param1 = GetMeThatVar(Param1);
int str_len = Param1.length() + 1;
char LCDTString[str_len];
Param1.toCharArray(LCDTString, str_len);
lcd.setCursor(GetMeThatVar(Param2).toInt(), GetMeThatVar(Param3).toInt());
lcd.print(LCDTString);
return;
}
if (Param0 == "lcdcls")
{
lcd.clear();
return;
}
if (Param0 == "lcdbl")
{
if (GetMeThatVar(Param1).toInt() == 1)
{
lcd.backlight();
}
else
{
lcd.noBacklight();
}
return;
}
if (Param0 == "lcdsend")
{
//Param1 is the value to send
//Param2 is MODE: 0=COMMAND, 1=DATA, 2=FOUR_BITS
lcd.send(GetMeThatVar(Param1).toInt(), GetMeThatVar(Param2).toInt());
return;
}
//end i2c 1602 lcd display code
//Web Browser output commands
if (Param0 == F("wprint") | Param0 == F("html"))
{
Param1 = inData.substring(Param0.length() + 1); // starts just after the command
Param1 = evaluate(Param1);
HTMLout += Param1;
//Serial.print(HTMLout);
return;
}
if (Param0 == F("image"))
{
String tempInfo = GenerateIDtag(normalImage);
tempInfo.replace(F("name"), GetMeThatVar(Param1));
HTMLout += tempInfo;
//Serial.print(HTMLout);
return;
}
if (Param0 == F("javascript"))
{
String tempInfo = javascript;
tempInfo.replace(F("name"), GetMeThatVar(Param1));
HTMLout += tempInfo;
//Serial.print(HTMLout);
return;
}
if (Param0 == F("css"))
{
String tempInfo = CSSscript;
tempInfo.replace(F("name"), GetMeThatVar(Param1));
HTMLout += tempInfo;
//Serial.print(HTMLout);
return;
}
if (Param0 == F("textbox"))
{
String tempTextBox = GenerateIDtag(TextBox);
VarialbeLookup(Param1);
if (VariableLocated == 0)
{
SetMeThatVar(Param1, "");
GetMeThatVar(Param1);
}
tempTextBox.replace(F("variablevalue"), String(F("VARS|")) + String(LastVarNumberLookedUp));
tempTextBox.replace(F("variablenumber"), String(LastVarNumberLookedUp));
HTMLout = String(HTMLout + tempTextBox);
return;
}
if (Param0 == F("passwordbox"))
{
String tempTextBox = GenerateIDtag(passwordbox);
VarialbeLookup(Param1);
if (VariableLocated == 0)
{
SetMeThatVar(Param1, "");
GetMeThatVar(Param1);
}
tempTextBox.replace(F("variablevalue"), String(F("VARS|")) + String(LastVarNumberLookedUp));
tempTextBox.replace(F("variablenumber"), String(LastVarNumberLookedUp));
HTMLout = String(HTMLout + tempTextBox);
return;
}
if (Param0 == F("slider"))
{
String tempSlider = GenerateIDtag(Slider);
VarialbeLookup(Param1);
if (VariableLocated == 0)
{
SetMeThatVar(Param1, "");
GetMeThatVar(Param1);
}
tempSlider.replace(F("variablevalue"), String(F("VARS|")) + String(LastVarNumberLookedUp));
tempSlider.replace(F("variablenumber"), String(LastVarNumberLookedUp));
tempSlider.replace(F("minval"), GetMeThatVar(Param2));
tempSlider.replace(F("maxval"), GetMeThatVar(Param3));
HTMLout = String(HTMLout + tempSlider);
return;
}
if (Param0 == F("dropdown") | Param0 == F("listbox"))
{
String tempDropDownList = GenerateIDtag(DropDownList);
String tempDropDownListOpptions = DropDownListOpptions;
String TempItems;
String TempBla;
Param1 = GetMeThatVar(Param1);
for (int i = 0; i <= 20; i++)
{
tempDropDownListOpptions = DropDownListOpptions;
TempBla = getValue(String(Param1 + ","), ',', i);
TempBla.replace(",", "");
if (TempBla != "") {
tempDropDownListOpptions.replace(F("item"), TempBla);
TempItems = String( TempItems + tempDropDownListOpptions);
}
delay(0);
}
Param2 = GetMeThatVar(Param2);
if (VariableLocated == 0)
{
SetMeThatVar(Param2, "");
GetMeThatVar(Param2);
}
tempDropDownList.replace(F("variablenumber"), String(LastVarNumberLookedUp));
tempDropDownList.replace(F("options"), TempItems);
if (Param3.toInt() > 1 | Param0 == F("dropdown")) Param3 = "1";
tempDropDownList.replace(F("theSize"), String(Param3.toInt()));
HTMLout = String(HTMLout + tempDropDownList);
return;
}
if (Param0 == F("button"))
{
//Serial.println(Param1);
//Serial.println(Param2);
numberButtonInUse++;
String tempButton = GenerateIDtag(GOTObutton);
tempButton.replace(F("gotonotext"), GetMeThatVar(Param1));
//Serial.println(String(String(numberButtonInUse) + " = numberButtonInUse"));
tempButton.replace(F("gotonobranch"), String(F("goto")) + String(numberButtonInUse));
ButtonsInUse[numberButtonInUse] = Param2;
//Serial.println(ButtonsInUse[numberButtonInUse]);
HTMLout = String(HTMLout + tempButton);
return;
}
if (Param0 == F("imagebutton"))
{
numberButtonInUse++;
String tempButton = GenerateIDtag(GOTOimagebutton);
if (GetMeThatVar(Param1).startsWith(F("http://")) | GetMeThatVar(Param1).startsWith(F("HTTP://")) )tempButton.replace(F("/file?file="), "");
tempButton.replace(F("gotonotext"), GetMeThatVar(Param1));
tempButton.replace(F("gotonobranch"), String(F("goto")) + String(numberButtonInUse));
ButtonsInUse[numberButtonInUse] = Param2;
//Serial.println(ButtonsInUse[numberButtonInUse]);
HTMLout = String(HTMLout + tempButton);
return;
}
if (Param0 == F("onload"))
{
refreshBranch = Param1;
return;
}
if (Param0 == F("wait"))
{
//HTMLout = String(HTMLout + "<hr>" + GetMeThatVar(Param1));
WaitForTheInterpertersResponse = 1;
return;
}
//PrintAndWebOut("Just Passed the Wait Command");
if (Param0 == F("cls"))
{
numberButtonInUse = 0;
for (int i = 0; i <= 10; i++) {
ButtonsInUse[i] = "";
}
HTMLout = "";
return;
}
//All of my graphis engeine commands
if (Param0 == F("graphics"))
{
GraphicsEliments[0][1] = GetMeThatVar(Param1).toInt();
GraphicsEliments[0][2] = GetMeThatVar(Param2).toInt();
HTMLout += F("**graphics**");
return;
}
if (Param0 == F("gcls"))
{
GraphicsEliments[0][0] = 0;
return;
}
if (Param0 == F("line"))
{
int i;
GraphicsEliments[0][0] += 1;
i = GraphicsEliments[0][0];
GraphicsEliments[i][0] = 1;
GraphicsEliments[i][1] = GetMeThatVar(Param1).toInt();
GraphicsEliments[i][2] = GetMeThatVar(Param2).toInt();
GraphicsEliments[i][3] = GetMeThatVar(Param3).toInt();
GraphicsEliments[i][4] = GetMeThatVar(Param4).toInt();
GraphicsEliments[i][5] = GetMeThatVar(Param5).toInt();
return;
}
if (Param0 == F("circle"))
{
int i;
GraphicsEliments[0][0] += 1;
i = GraphicsEliments[0][0];
GraphicsEliments[i][0] = 2;
GraphicsEliments[i][1] = GetMeThatVar(Param1).toInt();
GraphicsEliments[i][2] = GetMeThatVar(Param2).toInt();
GraphicsEliments[i][3] = GetMeThatVar(Param3).toInt();
GraphicsEliments[i][5] = GetMeThatVar(Param4).toInt();
return;
}
if (Param0 == F("ellipse"))
{
int i;
GraphicsEliments[0][0] += 1;
i = GraphicsEliments[0][0];
GraphicsEliments[i][0] = 3;
GraphicsEliments[i][1] = GetMeThatVar(Param1).toInt();
GraphicsEliments[i][2] = GetMeThatVar(Param2).toInt();
GraphicsEliments[i][3] = GetMeThatVar(Param3).toInt();
GraphicsEliments[i][4] = GetMeThatVar(Param4).toInt();
GraphicsEliments[i][5] = GetMeThatVar(Param5).toInt();
return;
}
if (Param0 == F("rect"))
{
int i;
GraphicsEliments[0][0] += 1;
i = GraphicsEliments[0][0];
GraphicsEliments[i][0] = 4;
GraphicsEliments[i][1] = GetMeThatVar(Param1).toInt();
GraphicsEliments[i][2] = GetMeThatVar(Param2).toInt();
GraphicsEliments[i][3] = GetMeThatVar(Param3).toInt();
GraphicsEliments[i][4] = GetMeThatVar(Param4).toInt();
GraphicsEliments[i][5] = GetMeThatVar(Param5).toInt();
return;
}
if (Param0 == F("input"))
{
if (Param2 == "")
{
SetMeThatVar(Param1, getSerialInput());
}
else
{
Serial.print(GetMeThatVar(Param1));
SetMeThatVar(Param2, getSerialInput());
}
//PrintAndWebOut("");
return;
}
if (Param0 == F("serialflush"))
{
serialFlush();
return;
}
if (Param0 == F("serialtimeout"))
{
SerialTimeOut = GetMeThatVar(Param1).toInt();
return;
}
// if (Param0 == "ps2input")
// {
// SetMeThatVar(Param1, GetPS2input());
// }
//branching commands
if (Param0 == F("goto"))
{
for (int i = 1; i <= TotalNumberOfLines; i++) {
String gotoTest = BasicProgram(i);
// Serial.println(i);
gotoTest.trim();
if (fileOpenFail == 1) break;
if (gotoTest == Param1 | String(gotoTest + ":") == Param1 )
{
RunningProgramCurrentLine = i - 1;
return;
}
}
PrintAndWebOut(String(F("ERROR Branch not found:")) + Param1);
return;
}
if (Param0 == F("gosub"))
{
for (int i = 1; i <= TotalNumberOfLines; i++) {
String gotoTest = BasicProgram(i);
gotoTest.trim();
if (fileOpenFail == 1) break;
if (gotoTest == Param1 | String(gotoTest + ":") == Param1)
{
NumberOfReturns = NumberOfReturns + 1;
ReturnLocations[NumberOfReturns] = RunningProgramCurrentLine;
RunningProgramCurrentLine = i - 1;
i = TotalNumberOfLines + 1;
return;
}
}
PrintAndWebOut(String(F("ERROR Branch not found:")) + Param1);
return;
}
if (Param0 == F("return"))
{
RunningProgramCurrentLine = ReturnLocations[NumberOfReturns];
NumberOfReturns = NumberOfReturns - 1;
return;
}
if (Param0 == F("end"))
{
for (int i = 0; i <= 255; i++)
{
ForNextReturnLocations[i] = 0;
}
RunningProgram = 0;
WaitForTheInterpertersResponse = 1;
TimerWaitTime = 0;
PrintAndWebOut(F("Done..."));
return;
}
if (Param0 == F("load"))
{
for (int i = 0; i <= 255; i++)
{
ForNextReturnLocations[i] = 0;
}
GraphicsEliments[0][0] = 0;
PrintAndWebOut(String(F("Loading . . . . ")) + Param1);
ProgramName = Param1;
numberButtonInUse = 0;
RunningProgramCurrentLine = 0;
HTMLout = "";
TimerWaitTime = 0;
return;
}
//Wifi Commands
if (Param0 == F("connect"))
{
ConnectToTheWIFI(GetMeThatVar(Param1), GetMeThatVar(Param2), GetMeThatVar(Param3), GetMeThatVar(Param4), GetMeThatVar(Param5));
return;
}
if (Param0 == F("ap"))
{
CreateAP(GetMeThatVar(Param1), GetMeThatVar(Param2));
return;
}
if (Param0 == F("wifioff"))
{
//WiFi.disconnect();
WiFi.mode(WIFI_OFF);
return;
}
if (Param0 == F("setupemail"))
{
EmailServer = GetMeThatVar(Param1);
Emailport = GetMeThatVar(Param2).toInt();
EmailSMTPuser = GetMeThatVar(Param3);
EmailSMTPpassword = GetMeThatVar(Param4);
return;
}
if (Param0 == F("email") | Param0 == F("sendemail" ))
{
//To, From, Subject, MsgBody
sendEmail(GetMeThatVar(Param1), GetMeThatVar(Param2), GetMeThatVar(Param3), GetMeThatVar(Param4) );
return;
}
//Code to handle MSG Branch
if (Param0 == F("msgbranch"))
{
msgbranch = Param1;
return;
}
if (Param0 == F("msgreturn"))
{
MsgBranchRetrnData = VarialbeLookup(Param1);
return;
}
if (Param0 == F("msgget"))
{
Serial.println(Param1);
Serial.println(Param2);
Param1 = GetMeThatVar(Param1);
int str_len = Param1.length() + 1;
char MgetToTest[str_len];
Param1.toCharArray(MgetToTest, str_len);
SetMeThatVar(Param2, GetRidOfurlCharacters(server.arg( MgetToTest )));
return;
}
// let command down here for a reason
if ( Param1.startsWith(F("=")))
{
Param0 = "let";
}
if ( Param0.indexOf('=') > 1 )
{ Serial.println("Found the = sign");
inData.replace(F("="), F(" = "));
Param0 = "let";
}
if ( Param0 == F("let"))
{
//Serial.println("Evaluating . .. .");
//Serial.println(inData);
//SetMeThatVar(Param1, DoMathForMe(GetMeThatVar(Param3), Param4, GetMeThatVar(Param5)));
// we should use a more "scientific" way to recognize the line;
// tipically a let line is composed of :
// 1) an optional 'let' followed by space(s)
// 2) the variable name followed by space(s) or '='
// 3) the "=" sign
// 4) the math operation
// we assume that the line has already been 'trimmed' with leading and trailing spaces removed
// a new function is required to identify more clearly each element of the line!!!!
// this is just a test
// step 1
if (inData.substring(0, 3) == "let")
inData = inData.substring(4);
//step2
int equal_pos = inData.indexOf('=');
if (equal_pos == -1)
{
Serial.println(F("syntax error. Missing the '=' on the line!"));
return;
}
Param1 = inData.substring(0, equal_pos);
Param1.trim();
//Serial.println(Param1);
Param2 = inData.substring(equal_pos + 1);
Param2.trim();
//Serial.println(Param2);
Param3 = evaluate(Param2);
// Serial.print("risultato ");
// Serial.println(Param3);
SetMeThatVar(Param1, Param3);
return;
}
//Serial.println(RunningProgramCurrentLine);
//Param0 = getValue(inData, ' ', 0);
if ( inData != "") {
evaluate(inData);//will exicure any functions if no other commands were found.
return;
}
PrintAndWebOut(String(F("syntax error on line ")) + String(RunningProgramCurrentLine));
return;
}
| [
"[email protected]"
] | |
21c9fc5e809a62caa5bbe4e54318a3b7687cd332 | 791c27e89ac6c51709bc996ab4a66742573a489d | /BOJ/1063.cpp | 3bfa37dfcbeecb22cddfed213f16b1b5636034b9 | [] | no_license | JeongYeonUk/Problem | 6f031abed61c6229f3da86c20b188fc4481ed46d | 12ff42c72e0c91ab4a2927f17c874d791362530d | refs/heads/master | 2021-06-27T10:51:52.409707 | 2020-12-14T15:48:31 | 2020-12-14T15:48:31 | 188,515,199 | 0 | 1 | null | null | null | null | UHC | C++ | false | false | 1,708 | cpp | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
#include <algorithm>
#include <string>
#include <map>
using namespace std;
#define endl '\n'
#define INF 987654321
struct Point {
int y, x;
};
// 오, 왼, 위, 아래, 오아래, 왼아래, 오위, 왼위
const int dy[] = { 0,0,-1,1,1,1,-1,-1 };
const int dx[] = { 1,-1,0,0,1,-1,1,-1 };
int board[9][9];
int ord[128];
Point player[2];
int main()
{
ios_base::sync_with_stdio(false);
cout.tie(NULL); cin.tie(NULL);
int val = 0;
for (int i = 'A' - 'A'; i <= 'H' - 'A'; ++i) {
ord[i] = val++;
}
map<string, int> pre;
pre["R"] = 0; pre["L"] = 1; pre["B"] = 2; pre["T"] = 3;
pre["RT"] = 4; pre["LT"] = 5; pre["RB"] = 6; pre["LB"] = 7;
string king, stone;
int N;
cin >> king;
int king_y = king[1] - '0';
int king_x = ord[king[0] - 'A'];
player[0].y = king_y - 1; player[0].x = king_x;
cin >> stone;
int stone_y = stone[1] - '0';
int stone_x = ord[stone[0] - 'A'];
player[1].y = stone_y - 1; player[1].x = stone_x;
cin >> N;
string input;
for (int i = 0; i < N; ++i) {
cin >> input;
int dir = pre[input];
king_y = player[0].y; king_x = player[0].x;
stone_y = player[1].y; stone_x = player[1].x;
int nky = king_y + dy[dir], nkx = king_x + dx[dir];
int nsy = stone_y + dy[dir], nsx = stone_x + dx[dir];
if (nky < 0 || nkx < 0 || nky >= 8 || nkx >= 8) continue;
if (nky == stone_y && nkx == stone_x) {
if (nsy < 0 || nsx < 0 || nsy >= 8 || nsx >= 8) continue;
player[1].y = nsy; player[1].x = nsx;
}
player[0].y = nky; player[0].x = nkx;
}
cout << char(player[0].x + 'A') << player[0].y + 1 << endl;
cout << char(player[1].x + 'A') << player[1].y + 1 << endl;
return 0;
}
| [
"[email protected]"
] | |
8b298d9e5e37b38e3bb4fbc9027d256841aaa297 | 75407c7343521f74c51b0badf6ca22996e33b686 | /CPUT/CPUT/CPUTGuiControllerOGL.cpp | 504087442ede126d554efec6f0f66c7e5dd75add | [
"BSD-3-Clause"
] | permissive | xinfushe/InstancingAndroid | 76ce6f141ac870ec7b194771dd195ff465565fbf | fa178d64860a937a808e3f0d64aadb45f3e2414e | refs/heads/master | 2021-01-12T09:45:12.107603 | 2014-07-11T20:40:54 | 2014-07-11T20:40:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,295 | cpp | //--------------------------------------------------------------------------------------
// Copyright 2013 Intel Corporation
// All Rights Reserved
//
// Permission is granted to use, copy, distribute and prepare derivative works of this
// software for any purpose and without fee, provided, that the above copyright notice
// and this statement appear in all copies. Intel makes no representations about the
// suitability of this software for any purpose. THIS SOFTWARE IS PROVIDED "AS IS."
// INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, AND ALL LIABILITY,
// INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES, FOR THE USE OF THIS SOFTWARE,
// INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY RIGHTS, AND INCLUDING THE
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Intel does not
// assume any responsibility for any errors which may appear in this software nor any
// responsibility to update it.
//--------------------------------------------------------------------------------------
#include "CPUTGuiControllerOGL.h"
#include "CPUT_OGL.h" // for CPUTSetRasterizerState()
#include "CPUTTextureOGL.h"
#include "CPUTFont.h"
#include "CPUTAssetLibraryOGL.h"
#include "CPUTBufferOGL.h"
CPUTGuiControllerOGL* CPUTGuiControllerOGL::mguiController = NULL;
// chained constructor
//--------------------------------------------------------------------------------
CPUTGuiControllerOGL::CPUTGuiControllerOGL():
CPUTGuiController(),
mpTextMaterial(NULL),
mpControlMaterial(NULL),
mpConstantBufferVS(NULL),
mModelViewMatrices(),
mpUberBuffer(NULL),
mpMirrorBuffer(NULL),
mUberBufferIndex(0),
mUberBufferMax(CPUT_GUI_BUFFER_SIZE),
mpTextUberBuffer(NULL),
mpTextMirrorBuffer(NULL),
mTextUberBufferIndex(0),
mpFocusedControlMirrorBuffer(NULL),
mFocusedControlBufferIndex(0),
mpFocusedControlBuffer(NULL),
mpFocusedControlTextMirrorBuffer(NULL),
mFocusedControlTextBufferIndex(0),
mpFocusedControlTextBuffer(NULL)
{
mpMirrorBuffer = new CPUTGUIVertex[CPUT_GUI_BUFFER_SIZE];
mpTextMirrorBuffer = new CPUTGUIVertex[CPUT_GUI_BUFFER_STRING_SIZE];
mpFocusedControlMirrorBuffer = new CPUTGUIVertex[CPUT_GUI_BUFFER_SIZE];
mpFocusedControlTextMirrorBuffer = new CPUTGUIVertex[CPUT_GUI_BUFFER_STRING_SIZE];
}
// destructor
//--------------------------------------------------------------------------------
CPUTGuiControllerOGL::~CPUTGuiControllerOGL()
{
// delete all the controls under you
ReleaseResources();
DeleteAllControls();
SAFE_RELEASE(mpTextMaterial);
SAFE_RELEASE(mpControlMaterial);
// FPS counter
// delete arrays
SAFE_DELETE_ARRAY(mpTextMirrorBuffer);
SAFE_DELETE_ARRAY(mpMirrorBuffer);
SAFE_DELETE_ARRAY(mpFocusedControlMirrorBuffer);
SAFE_DELETE_ARRAY(mpFocusedControlTextMirrorBuffer);
}
// static getter
//--------------------------------------------------------------------------------
CPUTGuiControllerOGL* CPUTGuiControllerOGL::GetController()
{
if(NULL==mguiController)
{
mguiController = new CPUTGuiControllerOGL();
}
return mguiController;
}
// Delete the controller
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::DeleteController()
{
SAFE_DELETE(mguiController);
return CPUT_SUCCESS;
}
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::ReleaseResources()
{
//Release all allocated resources
SAFE_RELEASE(mpConstantBufferVS);
// release the texture atlas+buffers
SAFE_RELEASE(mpUberBuffer);
SAFE_RELEASE(mpTextUberBuffer);
SAFE_RELEASE(mpFocusedControlBuffer);
SAFE_RELEASE(mpFocusedControlTextBuffer);
// tell all controls to unregister all their static resources
CPUTText::UnRegisterStaticResources();
CPUTButton::UnRegisterStaticResources();
CPUTCheckbox::UnRegisterStaticResources();
CPUTSlider::UnRegisterStaticResources();
CPUTDropdown::UnRegisterStaticResources();
return CPUT_SUCCESS;
}
// Initialize the GUI controller and all it's static resources
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::Initialize(cString &ResourceDirectory)
{
SetResourceDirectory(ResourceDirectory);
return RegisterGUIResources();
}
// Control creation
// Create a button control and add it to the GUI layout controller
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::CreateButton(const cString ButtonText, CPUTControlID controlID, CPUTControlID panelID, CPUTButton **ppButton)
{
// create the control
CPUTButton *pButton = new CPUTButton(ButtonText, controlID, mpFont);
ASSERT(NULL != pButton, _L("Failed to create control.") );
// return control if requested
if(NULL!=ppButton)
{
*ppButton = pButton;
}
// add control to the gui manager
return this->AddControl(pButton, panelID);
}
// Create a slider control and add it to the GUI layout controller
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::CreateSlider(const cString SliderText, CPUTControlID controlID, CPUTControlID panelID, CPUTSlider **ppSlider)
{
// create the control
CPUTSlider *pSlider = new CPUTSlider(SliderText, controlID, mpFont);
ASSERT(NULL!=pSlider, _L("Failed creating slider") );
// return control if requested
if(NULL!=ppSlider)
{
*ppSlider = pSlider;
}
// add control to the gui manager
return this->AddControl(pSlider, panelID);
}
// Create a checkbox control and add it to the GUI layout controller
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::CreateCheckbox(const cString CheckboxText, CPUTControlID controlID, CPUTControlID panelID, CPUTCheckbox **ppCheckbox)
{
// create the control
CPUTCheckbox *pCheckbox = new CPUTCheckbox(CheckboxText, controlID, mpFont);
ASSERT(NULL!=pCheckbox, _L("Failed creating checkbox") );
// return control if requested
if(NULL!=ppCheckbox)
{
*ppCheckbox = pCheckbox;
}
// add control to the gui manager
return this->AddControl(pCheckbox, panelID);
}
// Create a dropdown control and add it to the GUI layout controller
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::CreateDropdown(const cString SelectionText, CPUTControlID controlID, CPUTControlID panelID, CPUTDropdown **ppDropdown)
{
// create the control
CPUTDropdown *pDropdown = new CPUTDropdown(SelectionText, controlID, mpFont);
ASSERT(NULL!=pDropdown, _L("Failed creating control") );
// return control if requested
if(NULL!=ppDropdown)
{
*ppDropdown = pDropdown;
}
// add control to the gui manager
CPUTResult result;
result = this->AddControl(pDropdown, panelID);
return result;
}
// Create a text item (static text)
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::CreateText(const cString Text, CPUTControlID controlID, CPUTControlID panelID, CPUTText **ppStatic)
{
DEBUG_PRINT(_L("Entered createText()"));
// create the control
CPUTText *pStatic=NULL;
DEBUG_PRINT(_L("Pre CPUTText()"));
pStatic = new CPUTText(Text, controlID, mpFont);
DEBUG_PRINT(_L("Post CPUTText()"));
ASSERT(NULL!=pStatic, _L("Failed creating static") );
if(NULL != ppStatic)
{
*ppStatic = pStatic;
}
DEBUG_PRINT(_L("About to return from CreateText()"));
// add control to the gui manager
return this->AddControl(pStatic, panelID);
}
// Deletes a control from the GUI manager
// Will delete all instances of the control no matter which panel(s) it is in and then
// deallocates the memory for the control
//--------------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::DeleteControl(CPUTControlID controlID)
{
// look thruogh all the panels and delete the item with this controlID
// for each panel
std::vector <CPUTControl*> pDeleteList;
for(UINT i=0; i<mControlPanelIDList.size(); i++)
{
// walk list of controls
for(UINT j=0; j<mControlPanelIDList[i]->mControlList.size(); j++)
{
if(controlID == mControlPanelIDList[i]->mControlList[j]->GetControlID())
{
// found an instance of the control we wish to delete
// see if it's in the list already
bool bFound = false;
for(UINT x=0; x<pDeleteList.size(); x++)
{
if( mControlPanelIDList[i]->mControlList[j] == pDeleteList[x] )
{
bFound = true;
break;
}
}
if(!bFound)
{
// store for deleting
pDeleteList.push_back( mControlPanelIDList[i]->mControlList[j] );
}
// remove the control from the container list
mControlPanelIDList[i]->mControlList.erase( mControlPanelIDList[i]->mControlList.begin() + j );
}
}
}
// delete the control(s) we found with this id
for(UINT i=0; i<pDeleteList.size(); i++)
{
SAFE_DELETE( pDeleteList[i] );
}
// force a resize event to recalculate new control locations now that some might have been deleted
this->Resize();
// don't worry about cleaning up std::vector list itself, it'll do so when it falls out of scope
return CPUT_SUCCESS;
}
// DrawFPS - Should the GUI draw the FPS counter in the upper-left?
//--------------------------------------------------------------------------------
void CPUTGuiControllerOGL::DrawFPS(bool drawfps)
{
//mbDrawFPS = drawfps;
}
// GetFPS - Returns the last frame's FPS value
//--------------------------------------------------------------------------------
float CPUTGuiControllerOGL::GetFPS()
{
return 0;//mLastFPS;
}
// Draw - must be positioned after all the controls are defined
//--------------------------------------------------------------------------------
void CPUTGuiControllerOGL::Draw()
{
HEAPCHECK;
static double timeSinceLastFPSUpdate = 0;
static int framesSinceLastFPSUpdate = 0;
static double avgFPS = 0;
static double minFrameTime = 999;
static double maxFrameTime = 0;
static CPUT_RECT windowRect = {0, 0, 0, 0};
if( 0 == GetNumberOfControlsInPanel())
{
return;
}
// check and see if any of the controls resized themselves
int ControlCount=GetNumberOfControlsInPanel();
bool ResizingNeeded = false;
for(int ii=0; ii<ControlCount; ii++)
{
CPUTControl *pControl = mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[ii];
if(true == pControl->ControlResizedItself())
{
ResizingNeeded = true;
pControl->ControlResizingHandled();
}
}
// if any of the controls resized, then re-do the autoarrangment
if(true == ResizingNeeded)
{
this->Resize();
}
// Now check to see if any controls' graphics are dirty
for(int ii=0; ii<ControlCount; ii++)
{
CPUTControl *pControl = mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[ii];
if(true == pControl->ControlGraphicsDirty())
{
mUberBufferDirty = true;
break;
}
}
// if any of the controls have announced they are dirty, then rebuild the mirror buffer and update the GFX buffer
if(mUberBufferDirty)
{
// if a resize was flagged, do it now.
if(mRecalculateLayout)
{
RecalculateLayout();
}
// 'clear' the buffer by resetting the pointer to the head
mUberBufferIndex = 0;
mTextUberBufferIndex = 0;
mFocusedControlBufferIndex = 0;
mFocusedControlTextBufferIndex = 0;
int ii=0;
while(ii<GetNumberOfControlsInPanel())
{
CPUTControl *pControl = mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[ii];
// don't draw the focus control - draw it last so it stays on 'top'
if(mpFocusControl != pControl)
{
switch(pControl->GetType())
{
case CPUT_BUTTON:
((CPUTButton*)pControl)->DrawIntoBuffer(mpMirrorBuffer, &mUberBufferIndex, mUberBufferMax, mpTextMirrorBuffer, &mTextUberBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_CHECKBOX:
((CPUTCheckbox*)pControl)->DrawIntoBuffer(mpMirrorBuffer, &mUberBufferIndex, mUberBufferMax, mpTextMirrorBuffer, &mTextUberBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_SLIDER:
((CPUTSlider*)pControl)->DrawIntoBuffer(mpMirrorBuffer, &mUberBufferIndex, mUberBufferMax, mpTextMirrorBuffer, &mTextUberBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_DROPDOWN:
((CPUTDropdown*)pControl)->DrawIntoBuffer(mpMirrorBuffer, &mUberBufferIndex, mUberBufferMax, mpTextMirrorBuffer, &mTextUberBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_STATIC:
((CPUTText*)pControl)->DrawIntoBuffer(mpTextMirrorBuffer, &mTextUberBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
}
}
ii++;
HEAPCHECK
}
// do the 'focused' control last so it stays on top (i.e. dropdowns)
if(mpFocusControl)
{
switch(mpFocusControl->GetType())
{
case CPUT_BUTTON:
((CPUTButton*)mpFocusControl)->DrawIntoBuffer(mpFocusedControlMirrorBuffer, &mFocusedControlBufferIndex, mUberBufferMax, mpFocusedControlTextMirrorBuffer, &mFocusedControlTextBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_CHECKBOX:
((CPUTCheckbox*)mpFocusControl)->DrawIntoBuffer(mpFocusedControlMirrorBuffer, &mFocusedControlBufferIndex, mUberBufferMax, mpFocusedControlTextMirrorBuffer, &mFocusedControlTextBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_SLIDER:
((CPUTSlider*)mpFocusControl)->DrawIntoBuffer(mpFocusedControlMirrorBuffer, &mFocusedControlBufferIndex, mUberBufferMax, mpFocusedControlTextMirrorBuffer, &mFocusedControlTextBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_DROPDOWN:
((CPUTDropdown*)mpFocusControl)->DrawIntoBuffer(mpFocusedControlMirrorBuffer, &mFocusedControlBufferIndex, mUberBufferMax, mpFocusedControlTextMirrorBuffer, &mFocusedControlTextBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
case CPUT_STATIC:
((CPUTText*)mpFocusControl)->DrawIntoBuffer(mpFocusedControlMirrorBuffer, &mFocusedControlTextBufferIndex, CPUT_GUI_BUFFER_STRING_SIZE);
break;
}
}
// update the uber-buffers with the control graphics
UpdateUberBuffers();
// Clear dirty flag on uberbuffer
mUberBufferDirty = false;
}
HEAPCHECK
if( mpConstantBufferVS )
{
// set up orthographic display
int windowWidth, windowHeight;
float znear = 0.1f;
float zfar = 100.0f;
float4x4 m;
pWindow->GetClientDimensions( &windowWidth, &windowHeight );
m = float4x4OrthographicOffCenterLH(0, (float)windowWidth, (float)windowHeight, 0, znear, zfar);
GUIConstantBufferVS ConstantBufferMatrices;
ConstantBufferMatrices.Projection = m;
m = float4x4Identity();
ConstantBufferMatrices.Model = m;
#ifndef CPUT_FOR_OGLES2
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, mpConstantBufferVS->GetBufferID()));
GL_CHECK(glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(GUIConstantBufferVS), &ConstantBufferMatrices));
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
#else
#warning "Need to do something with uniform buffers here"
#endif
}
CPUTRenderParameters params;
mpControlMaterial->GetMaterialEffects()[0]->SetRenderStates(params);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
// draw the control graphics
CPUTRenderParameters p;
mpUberBuffer->Draw(p, NULL);
mpTextMaterial->GetMaterialEffects()[0]->SetRenderStates(params);
// draw text things here
// draw the FPS counter
mpTextUberBuffer->Draw(p, NULL);
mpControlMaterial->GetMaterialEffects()[0]->SetRenderStates(params);
mpFocusedControlBuffer->Draw(p, NULL);
// draw focused control
mpTextMaterial->GetMaterialEffects()[0]->SetRenderStates(params);
mpFocusedControlTextBuffer->Draw(p, NULL);
glEnable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
HEAPCHECK;
}
//
//------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::UpdateUberBuffers()
{
// Update geometry to draw the control graphics
ASSERT(CPUT_GUI_VERTEX_BUFFER_SIZE > mUberBufferIndex, _L("CPUT GUI: Too many controls for default-sized uber-buffer. Increase CPUT_GUI_VERTEX_BUFFER_SIZE"));
//why +1?
mpUberBuffer->SetVertexSubData(0, sizeof(CPUTGUIVertex)*mUberBufferIndex+1, mpMirrorBuffer);
mpUberBuffer->SetNumVertices(mUberBufferIndex);
mpTextUberBuffer->SetVertexSubData(0, sizeof(CPUTGUIVertex)*mTextUberBufferIndex+1, mpTextMirrorBuffer);
mpTextUberBuffer->SetNumVertices(mTextUberBufferIndex);
mpFocusedControlBuffer->SetVertexSubData(0, sizeof(CPUTGUIVertex)*mFocusedControlBufferIndex+1, mpFocusedControlMirrorBuffer);
mpFocusedControlBuffer->SetNumVertices(mFocusedControlBufferIndex);
mpFocusedControlTextBuffer->SetVertexSubData(0, sizeof(CPUTGUIVertex)*mFocusedControlTextBufferIndex+1, mpFocusedControlTextMirrorBuffer);
mpFocusedControlTextBuffer->SetNumVertices(mFocusedControlTextBufferIndex);
return CPUT_SUCCESS;
}
// Load and register all the resources needed by the GUI system
//-----------------------------------------------------------------------------
CPUTResult CPUTGuiControllerOGL::RegisterGUIResources()
{
CPUTResult result = CPUT_SUCCESS;
cString name = _L("$cbGUIValues");
mpConstantBufferVS = new CPUTBufferOGL(name);
GLuint id = mpConstantBufferVS->GetBufferID();
#ifndef CPUT_FOR_OGLES2
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, mpConstantBufferVS->GetBufferID()));
GL_CHECK(glBufferData(GL_UNIFORM_BUFFER, sizeof(GUIConstantBufferVS), NULL, GL_DYNAMIC_DRAW)); // NULL to just init buffer size
GL_CHECK(glBindBuffer(GL_UNIFORM_BUFFER, 0));
DEBUG_PRINT(_L("bind gui constant buffers: %d\n"), id);
// GL_CHECK(glBindBufferBase(GL_UNIFORM_BUFFER, mpConstantBufferVS->GetBufferID(), mpConstantBufferVS->GetBufferID()));
DEBUG_PRINT(_L("completed bind gui constant buffers\n"));
#else
#warning "Need to do something with uniform buffers here"
#endif
CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer(_L(""), name, _L(""), mpConstantBufferVS);
CPUTAssetLibraryOGL *pAssetLibrary = NULL;
pAssetLibrary = (CPUTAssetLibraryOGL*)CPUTAssetLibraryOGL::GetAssetLibrary();
cString saveDir = pAssetLibrary->GetMediaDirectoryName();
pAssetLibrary->SetMediaDirectoryName(mResourceDirectory);
mpTextMaterial = pAssetLibrary->GetMaterial(_L("guimaterial_text"));
mpControlMaterial = pAssetLibrary->GetMaterial(_L("guimaterial_control"));
pAssetLibrary->SetMediaDirectoryName(saveDir);
CPUTBufferElementInfo pGUIVertex[3] = {
{ "POSITION", 0, 0, CPUT_F32, 3, 3*sizeof(float), 0 },
{ "TEXCOORD", 0, 1, CPUT_F32, 2, 2*sizeof(float), 3*sizeof(float)},
{ "COLOR", 0, 2, CPUT_F32, 4, 4*sizeof(float), 5*sizeof(float)},
};
unsigned int maxSize = std::max(CPUT_GUI_BUFFER_STRING_SIZE, CPUT_GUI_BUFFER_SIZE);
maxSize = std::max(maxSize, CPUT_GUI_VERTEX_BUFFER_SIZE);
maxSize *= sizeof( CPUTGUIVertex );
mpUberBuffer = new CPUTMeshOGL();
mpUberBuffer->CreateNativeResources(NULL, 0, 3, pGUIVertex, CPUT_GUI_VERTEX_BUFFER_SIZE, mpMirrorBuffer, NULL, 0, NULL);
mpTextUberBuffer = new CPUTMeshOGL();
mpTextUberBuffer->CreateNativeResources(NULL, 0, 3, pGUIVertex, CPUT_GUI_VERTEX_BUFFER_SIZE, NULL, NULL, 0, NULL);
mpFocusedControlBuffer = new CPUTMeshOGL();
mpFocusedControlBuffer->CreateNativeResources(NULL, 0, 3, pGUIVertex, CPUT_GUI_VERTEX_BUFFER_SIZE, mpFocusedControlMirrorBuffer, NULL, 0, NULL);
mpFocusedControlTextBuffer = new CPUTMeshOGL();
mpFocusedControlTextBuffer->CreateNativeResources(NULL, 0, 3, pGUIVertex, CPUT_GUI_VERTEX_BUFFER_SIZE, mpFocusedControlTextMirrorBuffer, NULL, 0, NULL);
// Walk all the controls/fonts and have them register all their required static resources
// Returning errors if you couldn't find your resources
result = CPUTText::RegisterStaticResources();
if(CPUTFAILED(result))
{
return result;
}
result = CPUTButton::RegisterStaticResources();
if(CPUTFAILED(result))
{
return result;
}
result = CPUTCheckbox::RegisterStaticResources();
if(CPUTFAILED(result))
{
return result;
}
result = CPUTSlider::RegisterStaticResources();
if(CPUTFAILED(result))
{
return result;
}
result = CPUTDropdown::RegisterStaticResources();
if(CPUTFAILED(result))
{
return result;
}
DEBUG_PRINT(_L("Exit RegisterGUIResources()\n"));
return CPUT_SUCCESS;
}
// Re-calculates all the positions of the controls based on their sizes
// to have a 'pretty' layout
//--------------------------------------------------------------------------------
void CPUTGuiControllerOGL::RecalculateLayout()
{
// if we have no valid panel, just return
if(CPUT_CONTROL_ID_INVALID == mActiveControlPanelSlotID)
{
return;
}
// if we don't want the auto-layout feature, just return
if(false == mbAutoLayout)
{
return;
}
// get window size
CPUT_RECT windowRect;
pWindow->GetClientDimensions(&windowRect.x, &windowRect.y, &windowRect.width, &windowRect.height);
// Build columns of controls right to left
int x,y;
x=0; y=0;
// walk list of controls, counting up their *heights*, until the
// column is full. While counting, keep track of the *widest*
int width, height;
const int GUI_WINDOW_PADDING = 5;
int numberOfControls = (int) mControlPanelIDList[mActiveControlPanelSlotID]->mControlList.size();
int indexStart=0;
int indexEnd=0;
int columnX = 0;
int columnNumber = 1;
while(indexEnd < numberOfControls)
{
int columnWidth=0;
y=0;
// figure out which controls belong in this column + column width
while( indexEnd < numberOfControls )
{
if(mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[indexEnd]->IsVisible() &&
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[indexEnd]->IsAutoArranged())
{
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[indexEnd]->GetDimensions(width, height);
if( y + height + GUI_WINDOW_PADDING < (windowRect.height-2*GUI_WINDOW_PADDING))
{
y = y + height + GUI_WINDOW_PADDING;
if(columnWidth < width)
{
columnWidth = width;
}
indexEnd++;
}
else
{
// if the window is now so small it won't fit a whole control, just
// draw one anyway and it'll just have to be clipped
if(indexEnd == indexStart)
{
columnWidth = width;
indexEnd++;
}
break;
}
}
else
{
indexEnd++;
}
}
// ok, now re-position each control with x at widest, and y at proper height
y=GUI_WINDOW_PADDING;
for(int i=indexStart; i<indexEnd; i++)
{
if(mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[i]->IsVisible() &&
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[i]->IsAutoArranged())
{
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[i]->GetDimensions(width, height);
x = windowRect.width - columnX - columnWidth - (columnNumber*GUI_WINDOW_PADDING);
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[i]->SetPosition(x,y);
mControlPanelIDList[mActiveControlPanelSlotID]->mControlList[i]->Resize(columnWidth, height);
y = y + height + GUI_WINDOW_PADDING;
}
}
indexStart = indexEnd;
columnX+=columnWidth;
columnNumber++;
}
mRecalculateLayout = false;
}
| [
"[email protected]"
] | |
09f4bc5d9983373fd9c1d6b7dd9f19075412614c | 29ae6a15cb4f6bd0e880caca18445f23368ee7a7 | /Codeforces__Problems/contest/500/a/63208410.cpp | 545630d5a6a3795fecb94d0d957d6c0b75911dd1 | [
"MIT"
] | permissive | mushfiq-906/cp__training | 3d5d59b2514a4adbb38e9d0c41a876030a114038 | 93fdc45cf20f71571b75eb8253052b70957087ad | refs/heads/master | 2023-05-02T18:50:50.742451 | 2021-05-23T09:37:12 | 2021-05-23T09:37:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 515 | cpp | #include <bits\stdc++.h>
using namespace std;
using ll = long long int;
using ull = unsigned long long;
int n, t;
const int N = 3e4 + 34;
vector<int> adj[N];
bool vis[N];
void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
for (int i : adj[u]) dfs(i);
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0), cout.tie(0);
cin >> n >> t;
for (int i = 1; i < n; i++) {
int x; cin >> x;
if (i + x <= n) adj[i].push_back(i + x);
}
dfs(1);
if (vis[t]) cout << "YES" << endl;
else cout << "NO" << endl;
} | [
"[email protected]"
] | |
1081825f12e3baf9ae20e3c8292bdd63668b5f4e | 0bf4e9718ac2e2845b2227d427862e957701071f | /tc/tco07/SortingInIterations.cpp | 286da75a69dde8740bf08dde9abf83ce0391577b | [] | no_license | unjambonakap/prog_contest | adfd6552d396f4845132f3ad416f98d8a5c9efb8 | e538cf6a1686539afb1d06181252e9b3376e8023 | refs/heads/master | 2022-10-18T07:33:46.591777 | 2022-09-30T14:44:47 | 2022-09-30T15:00:33 | 145,024,455 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,308 | cpp | // BEGIN CUT HERE
// END CUT HERE
#line 5 "SortingInIterations.cpp"
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <climits>
//#include <ext/hash_map>
using namespace std;
using namespace __gnu_cxx;
#define REP(i,n) for(int i = 0; i < int(n); ++i)
#define REPV(i, n) for (int i = (n) - 1; (int)i >= 0; --i)
#define FOR(i, a, b) for(int i = (int)(a); i <= (int)(b); ++i)
#define FORV(i, a, b) for(int i = (int)(a); i >= (int)(b); --i)
#define FE(i,t) for (typeof((t).begin())i=(t).begin();i!=(t).end();++i)
#define FEV(i,t) for (typeof((t).rbegin())i=(t).rbegin();i!=(t).rend();++i)
#define SZ(a) (int((a).size()))
#define two(x) (1 << (x))
#define twoll(x) (1LL << (x))
#define ALL(a) (a).begin(), (a).end()
#define CLR(a) (a).clear()
#define pb push_back
#define PF push_front
#define ST first
#define ND second
#define MP(x,y) make_pair(x, y)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef queue<int> qi;
template<class T> void checkmin(T &a, T b){if (b<a)a=b;}
template<class T> void checkmax(T &a, T b){if (b>a)a=b;}
template<class T> void out(T t[], int n){REP(i, n)cout<<t[i]<<" "; cout<<endl;}
template<class T> void out(vector<T> t, int n=-1){for (int i=0; i<(n==-1?t.size():n); ++i) cout<<t[i]<<" "; cout<<endl;}
inline int count_bit(int n){return (n == 0)?0:1+count_bit(n&(n-1));}
inline bool bit_set(int a, int b){return (a&two(b));}
inline int low_bit(int n){return (n^n-1)&n;}
inline int ctz(int n){return (n==0?-1:(n==1?0:ctz(n>>1)+1));}
int toInt(string s){int a; istringstream(s)>>a; return a;}
string toStr(int a){ostringstream os; os<<a; return os.str();}
const int maxn=4*1e5+10;
int tb[maxn];
struct node{
int st, nd, m;
int ma, cnt;
node *l, *r;
node(int st, int nd):st(st), nd(nd){
cnt=nd-st;
if (st==nd-1){l=r=0; ma=tb[st];}
else{
m=(st+nd)/2;
l=new node(st, m);
r=new node(m, nd);
ma=min(l->ma, r->ma);
}
}
~node(){
if (l!=0) delete l;
if (r!=0) delete r;
}
ll rnd(int mx){
if (ma>mx) return 0;
if (cnt==0)return 0;
if (l==0){
--cnt; ma=INT_MAX;
return tb[st];
}
int nm=min(mx, r->ma);
ll a=0;
if (l->ma<=nm) a+=l->rnd(nm);
nm=min(mx, l->ma);
if (r->ma<=nm) a+=r->rnd(nm);
ma=min(l->ma, r->ma);
cnt=l->cnt+r->cnt;
return a;
}
};
class SortingInIterations {
public:
long long sum(int a0, int X, int Y, int M, int n, int start, int finish) {
tb[0]=a0;
REP(i, n-1) tb[i+1]=(ll(tb[i])*X+Y)%M;
node r(0, n);
REP(i, start-1) r.rnd(INT_MAX);
ll res=0;
FOR(i, start, finish){
if (r.cnt==0)return -1;
res+=r.rnd(INT_MAX);
}
return res;
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); if ((Case == -1) || (Case == 4)) test_case_4(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const long long &Expected, const long long &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { int Arg0 = 2; int Arg1 = 1; int Arg2 = 400000; int Arg3 = 3; int Arg4 = 3; int Arg5 = 1; int Arg6 = 3; long long Arg7 = -1LL; verify_case(0, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
//void test_case_0() { int Arg0 = 4; int Arg1 = 2; int Arg2 = 0; int Arg3 = 7; int Arg4 = 10; int Arg5 = 1; int Arg6 = 1; long long Arg7 = 5LL; verify_case(0, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
void test_case_1() { int Arg0 = 1; int Arg1 = 0; int Arg2 = 0; int Arg3 = 5; int Arg4 = 5; int Arg5 = 1; int Arg6 = 2; long long Arg7 = 1LL; verify_case(1, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
void test_case_2() { int Arg0 = 7; int Arg1 = 6; int Arg2 = 9; int Arg3 = 10; int Arg4 = 10; int Arg5 = 2; int Arg6 = 3; long long Arg7 = 20LL; verify_case(2, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
void test_case_3() { int Arg0 = 0; int Arg1 = 1; int Arg2 = 1; int Arg3 = 100000; int Arg4 = 100000; int Arg5 = 1; int Arg6 = 1; long long Arg7 = 4999950000LL; verify_case(3, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
void test_case_4() { int Arg0 = 1; int Arg1 = 7; int Arg2 = 0; int Arg3 = 10; int Arg4 = 10; int Arg5 = 1; int Arg6 = 10; long long Arg7 = -1LL; verify_case(4, Arg7, sum(Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main(){
SortingInIterations ___test;
___test.run_test(-1);
}
// END CUT HERE
| [
"[email protected]"
] | |
1e2b64b1cd0ebe5fb8c8c442a36081235472c7e4 | 38d2221977cef0fe8a22284f3ba73fc64b451d37 | /競プロ/ABC/106/b.cpp | 6e1c5fcc4c335069f7ec2bb7b6f6ac9ed78ab770 | [] | no_license | masatoshi33/portfolio | 06f1fb3c01e1ac43ffeea3ec95c109ff77254550 | c268062fbe4f120a41b51f80cfd25f6412769af2 | refs/heads/master | 2023-03-16T03:36:43.307202 | 2021-02-25T18:23:51 | 2021-02-25T18:23:51 | 342,330,292 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 851 | cpp | #include <bits/stdc++.h>
#include <math.h>
#include <vector>
#include <queue>
#include <iomanip>
#include <string>
#include <algorithm>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i,n) for(int i=0;i<n;i++)
#define rep_1 (i,j,n) for(int i=j;i<n;i++)
typedef long long ll;
typedef long l;
const ll l_INF = 1010101010101010;
const int INF = 1010101010;
const int dx[4] = {-1,0,1,0};
const int dy[4] = {0,-1,0,1};
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
int main(){
int n; cin>>n;
int count=0,m_count=0;
for(int i=1;i<=n;i++){
count=0;
if(i%2==0) continue;
//if(i==sqrt(i)*sqrt(i)) continue;
for(int j=1;j<=i;j++){
if(i%j==0) count++;
}
if(count==8) m_count++;
}
cout<<m_count;
}
| [
"[email protected]"
] | |
f38365d0d49401c09ff2dde36237ea82b6767d5d | 8c7af9fedd99d385089aa13d9cfb6c932a64aac1 | /MFC1-2/MFC1-2/MFC1-2.h | ba8f8636bdff6c0a3f4ce9127a5b9128c7d5cc64 | [] | no_license | zhang1-meili/Test2 | 9355592fc11ec75ebfc863e2d92a791ee813031c | 676db7f31192bbaa74a3bd8bd60350dcf004e294 | refs/heads/master | 2021-05-23T20:00:20.265851 | 2020-05-26T07:47:48 | 2020-06-02T06:21:23 | 253,441,721 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 509 | h |
// MFC1-2.h : MFC1-2 应用程序的主头文件
//
#pragma once
#ifndef __AFXWIN_H__
#error "在包含此文件之前包含“stdafx.h”以生成 PCH 文件"
#endif
#include "resource.h" // 主符号
// CMFC12App:
// 有关此类的实现，请参阅 MFC1-2.cpp
//
class CMFC12App : public CWinAppEx
{
public:
CMFC12App();
// 重写
public:
virtual BOOL InitInstance();
virtual int ExitInstance();
// 实现
afx_msg void OnAppAbout();
DECLARE_MESSAGE_MAP()
};
extern CMFC12App theApp;
| [
"[email protected]"
] | |
a80fa268b3678667a0b490bc1b4f6413887e379c | 052bdfad3ac771db6a8968c069bb13ef37e8507e | /HW6/trie.cpp | 0210edde098dd084f2b73240d55e51285349b00d | [] | no_license | chasem51/Algorithms | 94700be066fe1f0fded0b42ab1084d1fb38ce0c0 | 2f50e0a9eeab426735f55c6a5d598e55a0b188ef | refs/heads/master | 2022-11-26T02:05:39.100460 | 2020-08-08T01:02:36 | 2020-08-08T01:02:36 | 255,060,252 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,144 | cpp | // LATE DAY
// Chase Maivald
// U18719879
#include <string>
#include "trie.h"
using namespace std;
void Trie::insert(string key, int val) {
TrieNode* temp = root;
for(int i = 0; i < key.length(); i++){
if(temp->children[key[i] - 'a'] == NULL){ // if the respective indice to a character DNE,
temp->children[key[i] - 'a'] = new TrieNode(); // init a new node for the trie map
tree_size++; // inc the tree size for every appended character
}
temp = temp->children[key[i] - 'a'] ; // place temp at the new indice
}
temp->val = val;
map_size++; // inc the map size for every new val
}
int Trie::search(string key) {
TrieNode *temp = root; // start at root
for (int i = 0; i < key.length(); i++){
if (temp->children[key[i] - 'a'] == NULL){ // if the respective indice's val in array of ptrs DNE
return 0;
}
temp = temp->children[key[i] - 'a']; // place temp at the string's respective indice
}
return temp->val; // return the value for the string character
}
// 1 if the string's char has no children
bool isLeaf(TrieNode* node){
for (int i = 0; i < 26; i++){
if ((node->children[i]) != NULL){
return 0;
}
else {
return 1;
}
}
}
int maxsize = 0;
int step = 0;
TrieNode* deletes(string key, TrieNode* node, int size, int depth){
step++;
if(!node) return NULL;
// if the leaf is the last char in a string
if(depth == size){
if (isLeaf(node)){
delete(node);
node = NULL;
maxsize++;
}
return node;
}
if(node->children[key[depth] - 'a'] && step == size){
node->children[key[depth] - 'a'] -> val = 0;
}
//checks for the following leaf, bc
int i = key[depth] - 'a';
node->children[i] = deletes(key, node->children[i], size, depth++);
return node;
}
void Trie::remove(string key){
step = 0;
this->root = deletes(key, this->root, key.length(), 0);
tree_size -= maxsize;
map_size = map_size - 1;
maxsize = 0;
}
| [
"[email protected]"
] | |
3f14ad110a1f8c9ed189d74d75faa61554e28ab7 | 0756dea0444ada160540685dd1d28fcd3ef4aac5 | /scripting/include/piston_node.h | c05db448e04433e2359a18f66e67ec0df0d206a7 | [
"MIT"
] | permissive | ange-yaghi/engine-sim | 439e38f717bf46dbe8b6825d181ed77f711f8f21 | 85f7c3b959a908ed5232ede4f1a4ac7eafe6b630 | refs/heads/master | 2023-02-18T03:26:25.469967 | 2023-01-22T17:44:02 | 2023-01-22T17:44:02 | 439,491,516 | 8,177 | 795 | MIT | 2023-01-13T00:07:50 | 2021-12-18T00:14:57 | C++ | UTF-8 | C++ | false | false | 1,649 | h | #ifndef ATG_ENGINE_SIM_PISTON_NODE_H
#define ATG_ENGINE_SIM_PISTON_NODE_H
#include "object_reference_node.h"
#include "rod_journal_node.h"
#include "piston_node.h"
#include "engine_sim.h"
#include <map>
#include <vector>
namespace es_script {
class PistonNode : public ObjectReferenceNode<PistonNode> {
public:
PistonNode() { /* void */ }
virtual ~PistonNode() { /* void */ }
void generate(
Piston *piston,
ConnectingRod *rod,
CylinderBank *cylinderBank,
int cylinderIndex) const
{
Piston::Parameters params = m_parameters;
params.Bank = cylinderBank;
params.CylinderIndex = cylinderIndex;
params.Rod = rod;
piston->initialize(params);
}
protected:
virtual void registerInputs() {
addInput("mass", &m_parameters.mass);
addInput("blowby", &m_parameters.BlowbyFlowCoefficient);
addInput("compression_height", &m_parameters.CompressionHeight);
addInput("wrist_pin_position", &m_parameters.WristPinPosition);
addInput("displacement", &m_parameters.Displacement);
ObjectReferenceNode<PistonNode>::registerInputs();
}
virtual void _evaluate() {
setOutput(this);
// Read inputs
readAllInputs();
m_parameters.Bank = nullptr;
m_parameters.Rod = nullptr;
m_parameters.CylinderIndex = 0;
}
Piston::Parameters m_parameters;
};
} /* namespace es_script */
#endif /* ATG_ENGINE_SIM_PISTON_NODE_H */
| [
"[email protected]"
] | |
d3ff8453568cb5f2bc7ed28b2a485798c48c5ea3 | 9102a16a4830a0e856b45db73aa8b11c2f5efc45 | /src/solver.h | ccb69c2e61293cb2952f4222abda764b7d003bcb | [] | no_license | dominichofer/ProjectBrutus | 9fcaf1ccd59aef74fdbf9d82cc83143a1a87ea1e | cb3a09b19c740b5636516ed628c31a22d9f5c8bf | refs/heads/master | 2023-07-21T18:44:50.745411 | 2015-05-07T16:23:11 | 2015-05-07T16:23:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,443 | h | #pragma once
#include <atomic>
#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <windows.h>
#include "datamanipulation.h"
#include "features.h"
#include "game.h"
#include "position.h"
#include "search.h"
#include "utility.h"
std::atomic<unsigned long long> NodeCounter;
std::atomic<std::size_t> PositionCounter;
std::atomic_flag Spinlock;
template <class DATASET>
class CPositionManager
{
private:
CPositionManager(const CPositionManager&); // not defined
CPositionManager& operator=(const CPositionManager&); // not defined
public:
std::atomic<std::size_t> m_index_counter;
std::vector<DATASET> m_Positions;
FILE* m_file;
fpos_t m_pos;
CPositionManager(const std::string& Filename, const std::size_t Size, const unsigned char depth, const unsigned char selectivity, const bool SkipSolved)
{
m_index_counter.store(0, std::memory_order_release);
fopen_s(&m_file, Filename.c_str(), "r+b");
if (SkipSolved)
LoopOverSolvedPositions(depth, selectivity);
LoadPositions(Size);
}
~CPositionManager() { fclose(m_file); }
void LoopOverSolvedPositions(const signed char depth, const unsigned char selectivity)
{
size_t LoopedPosition = 0;
const int N = 4 * 1024;
int ValidData;
DATASET* DataArray = new DATASET[N];
fgetpos(m_file, &m_pos);
while (ValidData = fread(DataArray, sizeof(DATASET), N, m_file))
{
for (int i = 0; i < ValidData; ++i)
{
if ((DataArray[i].depth < depth) || (DataArray[i].selectivity > selectivity)) // Needs to be solved
{
std::cout << "Looped over " << LoopedPosition << " already solved positions." << std::endl;
fsetpos(m_file, &m_pos);
fread(DataArray, sizeof(DATASET), i, m_file);
delete[] DataArray;
return;
}
++LoopedPosition;
}
fgetpos(m_file, &m_pos);
}
std::cout << "All positions were already solved!" << std::endl;
delete[] DataArray;
}
void LoadPositions(const std::size_t Size)
{
DATASET* DataArray = new DATASET[Size];
fgetpos(m_file, &m_pos);
std::size_t ValidData = fread(DataArray, sizeof(DATASET), Size, m_file);
m_Positions.insert(m_Positions.end(), DataArray, DataArray + ValidData);
delete[] DataArray;
}
void SavePositions()
{
const std::size_t size = m_Positions.size();
DATASET* DataArray = new DATASET[size];
for (std::size_t i = 0; i < size; ++i)
DataArray[i] = m_Positions[i];
fsetpos(m_file, &m_pos);
fwrite(DataArray, sizeof(DATASET), size, m_file);
delete[] DataArray;
}
DATASET * TryGetWork()
{
std::size_t Index = m_index_counter.fetch_add(1, std::memory_order_release);
if (Index < m_Positions.size())
return &(m_Positions[Index]);
else // Out of work
return NULL;
}
};
template <>
class CPositionManager<CDataset_Edax>
{
private:
CPositionManager(const CPositionManager&); // not defined
CPositionManager& operator=(const CPositionManager&); // not defined
public:
std::atomic<std::size_t> m_index_counter;
std::vector<CDataset_Edax> m_Positions;
FILE* m_file;
fpos_t m_pos;
CPositionManager(const std::string& Filename, const std::size_t Size, const unsigned char depth, const unsigned char selectivity, const bool SkipSolved)
{
m_index_counter.store(0, std::memory_order_release);
fopen_s(&m_file, Filename.c_str(), "r+b");
if (SkipSolved)
LoopOverSolvedPositions(depth, selectivity);
LoadPositions(Size);
}
~CPositionManager() { fclose(m_file); }
void LoopOverSolvedPositions(const signed char depth, const unsigned char selectivity) {}
void LoadPositions(const std::size_t Size)
{
CDataset_Edax* DataArray = new CDataset_Edax[Size];
fgetpos(m_file, &m_pos);
std::size_t ValidData = fread(DataArray, sizeof(CDataset_Edax), Size, m_file);
m_Positions.insert(m_Positions.end(), DataArray, DataArray + ValidData);
delete[] DataArray;
}
void SavePositions()
{
const std::size_t size = m_Positions.size();
CDataset_Edax* DataArray = new CDataset_Edax[size];
for (std::size_t i = 0; i < size; ++i)
DataArray[i] = m_Positions[i];
fsetpos(m_file, &m_pos);
fwrite(DataArray, sizeof(CDataset_Edax), size, m_file);
delete[] DataArray;
}
CDataset_Edax * TryGetWork()
{
std::size_t Index = m_index_counter.fetch_add(1, std::memory_order_release);
if (Index < m_Positions.size())
return &(m_Positions[Index]);
else // Out of work
return NULL;
}
};
template <class DATASET>
void Work(CPositionManager<DATASET>& PositionManager, const signed char depth, const unsigned char selectivity, CHashTable * HashTable, const bool verbose);
template <> void Work<CDataset_Position_Score>(CPositionManager<CDataset_Position_Score>& PositionManager, const signed char depth, const unsigned char selectivity, CHashTable * HashTable, const bool verbose)
{
unsigned long long NumSolved;
CDataset_Position_Score * data;
while (data = PositionManager.TryGetWork())
{
CSearch search(data->P, data->O, -64, 64, depth, selectivity, HashTable, 0);
search.Evaluate();
HashTable->AdvanceDate();
data->depth = depth;
data->selectivity = selectivity;
data->score = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if (verbose)
{
while (Spinlock.test_and_set());
search.print_result(9, NumSolved + 1, false);
Spinlock.clear();
}
else
{
if ((NumSolved & 0xF) == 0)
{
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
}
}
}
}
template <> void Work<CDataset_Position_Score_PV>(CPositionManager<CDataset_Position_Score_PV>& PositionManager, const signed char depth, const unsigned char selectivity, CHashTable * HashTable, const bool verbose)
{
unsigned long long NumSolved;
CDataset_Position_Score_PV * data;
while (data = PositionManager.TryGetWork())
{
{
unsigned long long P = data->P;
unsigned long long O = data->O;
for (int i = 0; i < 5; i++)
{
HashTable->Update(P, O, HashTableValueType(0, data->depth - i, data->selectivity, data->score, data->score, data->PV[i], 64));
if (data->PV[i] != 64)
PlayStone(P, O, data->PV[i]);
else
break;
}
if (data->PV[4] != 64)
HashTable->Update(P, O, HashTableValueType(0, data->depth - 5, data->selectivity, data->score, data->score, 64, 64));
}
CSearch search(data->P, data->O, -64, 64, depth, selectivity, HashTable, 5);
search.Evaluate(false);
HashTable->AdvanceDate();
data->depth = depth;
data->selectivity = selectivity;
data->score = search.score;
for (int i = 0; i < 5; ++i)
data->PV[i] = search.PV(i);
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if (verbose)
{
while (Spinlock.test_and_set());
search.print_result(9, NumSolved + 1, false);
Spinlock.clear();
}
else
{
if ((NumSolved & 0xF) == 0)
{
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
}
}
}
}
template <> void Work<CDataset_Position_FullScore>(CPositionManager<CDataset_Position_FullScore>& PositionManager, const signed char depth, const unsigned char selectivity, CHashTable * HashTable, const bool verbose)
{
unsigned long long NumSolved;
CDataset_Position_FullScore * data;
while (data = PositionManager.TryGetWork())
{
if (data->score[27] != DATASET_DEFAULT_score) // Game over.
{
data->depth = depth;
data->selectivity = selectivity;
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
continue;
}
if (data->score[36] != DATASET_DEFAULT_score) // Only best move score aviable.
{
//Search best move
CSearch search(data->P, data->O, data->score[36]-1, data->score[36]+1, depth, selectivity, HashTable, 2);
search.Evaluate();
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
if (search.PV(0) == DATASET_DEFAULT_PV) // No best move returned
{
if ((PossibleMoves(data->P, data->O) == 0) && PossibleMoves(data->O, data->P) == 0) // Game over
{
data->score[27] = data->score[36];
data->score[36] = DATASET_DEFAULT_score;
}
else
{
unsigned long long P = data->P;
unsigned long long O = data->O;
unsigned long long flipped;
unsigned char Move;
if (PossibleMoves(P, O) == 0)
std::swap(P, O);
unsigned long long BitBoardPossible = PossibleMoves(P, O);
while (BitBoardPossible)
{
Move = BitScanLSB(BitBoardPossible);
RemoveLSB(BitBoardPossible);
if (flipped = flip(P, O, Move))
{
CSearch search(O ^ flipped, P ^ (1ULL << Move) ^ flipped, -64, 64, depth-1, selectivity, HashTable, 1);
search.Evaluate();
data->score[Move] = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
}
}
}
}
else
{
data->score[search.PV(0)] = data->score[36];
data->score[36] = DATASET_DEFAULT_score;
unsigned long long P = data->P;
unsigned long long O = data->O;
unsigned long long flipped;
unsigned char Move;
if (PossibleMoves(P, O) == 0)
std::swap(P, O);
unsigned long long BitBoardPossible = PossibleMoves(P, O) ^ (1ULL << search.PV(0));
while (BitBoardPossible)
{
Move = BitScanLSB(BitBoardPossible);
RemoveLSB(BitBoardPossible);
if (flipped = flip(P, O, Move))
{
CSearch search(O ^ flipped, P ^ (1ULL << Move) ^ flipped, -64, 64, depth - 1, selectivity, HashTable, 1);
search.Evaluate();
data->score[Move] = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
}
}
}
HashTable->AdvanceDate();
data->depth = depth;
data->selectivity = selectivity;
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
continue;
}
unsigned long long P = data->P;
unsigned long long O = data->O;
unsigned long long flipped;
unsigned char Move;
if (PossibleMoves(P, O) == 0)
{
if (PossibleMoves(O, P) == 0) // Game over
{
CSearch search(P, O, -64, 64, depth, selectivity, HashTable, 0);
search.Evaluate();
HashTable->AdvanceDate();
data->depth = depth;
data->selectivity = selectivity;
data->score[27] = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
continue;
}
std::swap(P, O);
}
unsigned long long BitBoardPossible = PossibleMoves(P, O);
while (BitBoardPossible)
{
Move = BitScanLSB(BitBoardPossible);
RemoveLSB(BitBoardPossible);
if (flipped = flip(P, O, Move))
{
CSearch search(O ^ flipped, P ^ (1ULL << Move) ^ flipped, -64, 64, depth - 1, selectivity, HashTable, 1);
search.Evaluate();
data->score[Move] = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
}
}
HashTable->AdvanceDate();
data->depth = depth;
data->selectivity = selectivity;
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if ((NumSolved & 0xF) == 0)
{
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
}
}
}
template <> void Work<CDataset_Edax>(CPositionManager<CDataset_Edax>& PositionManager, const signed char depth, const unsigned char selectivity, CHashTable * HashTable, const bool verbose)
{
unsigned long long NumSolved;
CDataset_Edax * data;
while (data = PositionManager.TryGetWork())
{
unsigned long long P = data->P;
unsigned long long O = data->O;
unsigned long long flipped;
unsigned char Move;
if (PossibleMoves(P, O) == 0)
continue;
unsigned long long BitBoardPossible = PossibleMoves(P, O);
while (BitBoardPossible)
{
Move = BitScanLSB(BitBoardPossible);
RemoveLSB(BitBoardPossible);
if (flipped = flip(P, O, Move))
{
CSearch search(O ^ flipped, P ^ (1ULL << Move) ^ flipped, -64, 64, depth - 1, selectivity, HashTable, 1);
search.Evaluate();
data->score[Move] = search.score;
NodeCounter.fetch_add(search.NodeCounter, std::memory_order_relaxed);
}
}
HashTable->AdvanceDate();
NumSolved = PositionCounter.fetch_add(1, std::memory_order_relaxed);
if ((NumSolved & 0xF) == 0)
{
if (!Spinlock.test_and_set())
{
std::cout << "\r";
std::cerr << progressbar_percentage(50, static_cast<float>(NumSolved) / static_cast<float>(PositionManager.m_Positions.size()));
Spinlock.clear();
}
}
}
}
template <class DATASET> void printHeader();
template <> void printHeader<CDataset_Position_Score>()
{
printf(" # | | depth |score\n");
printf("---------+----------------------------------------------------------------+--------+-----\n");
}
template <> void printHeader<CDataset_Position_Score_PV>()
{
printf(" # | | depth |score| PV \n");
printf("---------+----------------------------------------------------------------+--------+-----+--------------------\n");
}
template <> void printHeader<CDataset_Position_FullScore>()
{
printf(" # | | depth |score\n");
printf("---------+----------------------------------------------------------------+--------+-----\n");
}
template <class DATASET>
void Solve(const std::string& Filename, const int n, const signed char depth, const unsigned char selectivity, const int nthreads, const bool verbose, const bool SkipSolved, const bool Save)
{
NodeCounter = 0;
std::cout << nthreads << " threads in total.\n";
std::chrono::high_resolution_clock::time_point startTime, endTime;
std::vector<std::thread> threads(nthreads - 1);
std::vector<CHashTable*> HashTables(nthreads);
CPositionManager<DATASET> PositionManager(Filename, n, depth, selectivity, SkipSolved);
for (auto& ht : HashTables)
ht = new CHashTable(20);
if (verbose)
CSearch(0, 0, -64, 64, 0, 5).print_header(9, false);
startTime = std::chrono::high_resolution_clock::now(); //Start Time
// Start workers
for (int i = 0; i < nthreads - 1; ++i)
threads[i] = std::thread(Work<DATASET>, std::ref(PositionManager), depth, selectivity, HashTables[i], verbose);
Work<DATASET>(PositionManager, depth, selectivity, HashTables[nthreads - 1], verbose);
// Join workers
for (auto& t : threads)
t.join();
endTime = std::chrono::high_resolution_clock::now(); //Stop Time
std::cerr << "\r";
std::cerr << progressbar_percentage(50, 1); std::cout << std::endl;
for (auto& ht : HashTables)
delete ht;
if (Save)
PositionManager.SavePositions();
std::chrono::milliseconds duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
std::cout << PositionCounter.load(std::memory_order_acquire) << " positions solved in: " << time_format(duration) << std::endl;
std::cout << PositionCounter.load(std::memory_order_acquire) * 1000.0 / duration.count() << " positions per second." << std::endl;
std::cout << ThousandsSeparator(NodeCounter) << " Nodes." << std::endl;
if (duration.count() == 0)
std::cout << "### nodes per second." << std::endl;
else
std::cout << ThousandsSeparator(NodeCounter * 1000 / duration.count()) << " nodes per second." << std::endl;
} | [
"[email protected]"
] | |
12d880697fa5ddb936b6b1d579df903cebf404bd | 33ec85bd54ff6c6eb746d77d1b967e320fd7b6b4 | /services/safwk/src/main.cpp | 2aade668a089407bd9276bf45ca5befc53de0237 | [
"Apache-2.0"
] | permissive | openharmony-gitee-mirror/distributedschedule_safwk | 57808d2b0f811808219b80b02f4edb6248dd665d | 1de684cf8b9bd56e1302f3f9e67068c18639ac05 | refs/heads/master | 2023-08-20T22:51:42.791354 | 2021-10-25T06:51:34 | 2021-10-25T06:51:34 | 400,051,659 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,177 | cpp | /*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <sys/prctl.h>
#include "ipc_skeleton.h"
#include "local_ability_manager.h"
#include "safwk_log.h"
#include "securec.h"
#include "string_ex.h"
using namespace OHOS;
using std::string;
namespace {
const string TAG = "SaMain";
using ProcessNameSetFunc = std::function<void(const string&)>;
constexpr auto DEFAULT_XML = "/system/usr/default.xml";
// The pid name can be up to 16 bytes long, including the terminating null byte.
// So need to set the max length of pid name to 15 bytes.
constexpr size_t MAX_LEN_PID_NAME = 15;
}
static void SetProcName(const string& filePath, const ProcessNameSetFunc& setProcessName)
{
std::vector<string> strVector;
SplitStr(filePath, "/", strVector);
auto vectorSize = strVector.size();
if (vectorSize > 0) {
auto& fileName = strVector[vectorSize - 1];
auto dotPos = fileName.find(".");
if (dotPos == string::npos) {
return;
}
if (dotPos > MAX_LEN_PID_NAME) {
dotPos = MAX_LEN_PID_NAME;
}
string profileName = fileName.substr(0, dotPos);
int32_t ret = prctl(PR_SET_NAME, profileName.c_str());
if (ret != 0) {
HILOGI(TAG, "call the system API prctl failed!");
}
setProcessName(profileName);
}
}
int main(int argc, char *argv[])
{
HILOGI(TAG, "safwk main entry");
auto setProcessName = [argc, argv](const string& name) -> void {
uintptr_t start = reinterpret_cast<uintptr_t>(argv[0]);
uintptr_t end = reinterpret_cast<uintptr_t>(strchr(argv[argc - 1], 0));
uintptr_t argvSize = end - start;
if (memset_s(argv[0], argvSize, 0, argvSize) != EOK) {
HILOGW(TAG, "failed to clear argv:%s", strerror(errno));
return;
}
if (strcpy_s(argv[0], argvSize, name.c_str()) != EOK) {
HILOGW(TAG, "failed to set process name:%s", strerror(errno));
return;
}
HILOGI(TAG, "Set process name to %s", argv[0]);
};
// Load system abilities related shared libraries from specific xml-format profile,
// when this process starts.
string profilePath(DEFAULT_XML);
if (argc > 1) {
string filePath(argv[1]);
if (filePath.empty() || filePath.find(".xml") == string::npos) {
HILOGE(TAG, "profile file path is invalid!");
return 0;
}
SetProcName(filePath, setProcessName);
profilePath = std::move(filePath);
}
LocalAbilityManager::GetInstance().DoStartSAProcess(profilePath);
return 0;
}
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.