answer
stringlengths 15
1.25M
|
|---|
package com.github.ffpojo.file.processor.record;
import com.github.ffpojo.exception.<API key>;
import com.github.ffpojo.file.processor.record.event.RecordEvent;
public class <API key> implements RecordProcessor {
public void processBody(RecordEvent event) throws <API key> {
// blank
}
public void processHeader(RecordEvent event) throws <API key> {
// blank
}
public void processTrailer(RecordEvent event) throws <API key> {
// blank
}
}
|
$(function () {
// Initialize chart
pieBasic('#d3-pie-basic', 120);
// Chart setup
function pieBasic(element, radius) {
// Basic setup
// Colors
var color = d3.scale.category20();
// Create chart
// Add SVG element
var container = d3.select(element).append("svg");
// Add SVG group
var svg = container
.attr("width", radius * 2)
.attr("height", radius * 2)
.append("g")
.attr("transform", "translate(" + radius + "," + radius + ")");
// Construct chart layout
// Arc
var arc = d3.svg.arc()
.outerRadius(radius)
.innerRadius(0);
// Pie
var pie = d3.layout.pie()
.sort(null)
.value(function(d) { return d.population; });
// Load data
d3.csv("assets/demo_data/d3/pies/pies_basic.csv", function(error, data) {
// Pull out values
data.forEach(function(d) {
d.population = +d.population;
});
// Append chart elements
// Bind data
var g = svg.selectAll(".d3-arc")
.data(pie(data))
.enter()
.append("g")
.attr("class", "d3-arc");
// Add arc path
g.append("path")
.attr("d", arc)
.style("stroke", "#fff")
.style("fill", function(d) { return color(d.data.age); });
// Add text labels
g.append("text")
.attr("transform", function(d) { return "translate(" + arc.centroid(d) + ")"; })
.attr("dy", ".35em")
.style("fill", "#fff")
.style("font-size", 12)
.style("text-anchor", "middle")
.text(function(d) { return d.data.age; });
});
}
});
|
#include <pal.h>
#include <math.h>
/**
*
* Calculates the inverse tangent (arc tangent) of b/a. Stability not guaranteed
* for 'a' values near 0. Results are in the range of -pi to pi.
*
* @param a Pointer to denominator input vector
*
* @param b Pointer to numerator input vector
*
* @param c Pointer to output vector
*
* @param n Size of 'a' and 'c' vector.
*
* @return None
*
* @todo Implement without using libm
*
*/
void PSYM(p_atan2)(const PTYPE *a, const PTYPE *b, PTYPE *c, int n)
{
int i;
for (i = 0; i < n; i++) {
*(c + i) = atan2f(*(b + i), *(a + i));
}
}
|
'use strict';
const models = require('./index');
/**
* @class
* Initializes a new instance of the <API key> class.
* @constructor
* The description of the start application upgrade
*
* @member {string} [name]
*
* @member {string} [<API key>]
*
* @member {array} [parameters]
*
* @member {string} [upgradeKind] Possible values include: 'Invalid', 'Rolling'
*
* @member {string} [rollingUpgradeMode] Possible values include: 'Invalid',
* 'UnmonitoredAuto', 'UnmonitoredManual', 'Monitored'
*
* @member {number} [<API key>]
*
* @member {boolean} [forceRestart]
*
* @member {object} [monitoringPolicy]
*
* @member {string} [monitoringPolicy.failureAction]
*
* @member {string} [monitoringPolicy.<API key>]
*
* @member {string} [monitoringPolicy.<API key>]
*
* @member {string} [monitoringPolicy.<API key>]
*
* @member {string} [monitoringPolicy.<API key>]
*
* @member {string} [monitoringPolicy.<API key>]
*
* @member {object} [<API key>]
*
* @member {boolean} [<API key>.<API key>]
*
* @member {number}
* [<API key>.<API key>]
*
* @member {object} [<API key>.<API key>]
* The policy of the default service type health
*
* @member {number}
* [<API key>.<API key>.<API key>]
*
* @member {number}
* [<API key>.<API key>.<API key>]
*
* @member {number}
* [<API key>.<API key>.<API key>]
*
*/
class <API key> {
constructor() {
}
/**
* Defines the metadata of <API key>
*
* @returns {object} metadata of <API key>
*
*/
mapper() {
return {
required: false,
serializedName: '<API key>',
type: {
name: 'Composite',
className: '<API key>',
modelProperties: {
name: {
required: false,
serializedName: 'Name',
type: {
name: 'String'
}
},
<API key>: {
required: false,
serializedName: '<API key>',
type: {
name: 'String'
}
},
parameters: {
required: false,
serializedName: 'Parameters',
type: {
name: 'Sequence',
element: {
required: false,
serializedName: '<API key>',
type: {
name: 'Composite',
className: '<API key>'
}
}
}
},
upgradeKind: {
required: false,
serializedName: 'UpgradeKind',
type: {
name: 'String'
}
},
rollingUpgradeMode: {
required: false,
serializedName: 'RollingUpgradeMode',
type: {
name: 'String'
}
},
<API key>: {
required: false,
serializedName: '<API key>',
type: {
name: 'Number'
}
},
forceRestart: {
required: false,
serializedName: 'ForceRestart',
type: {
name: 'Boolean'
}
},
monitoringPolicy: {
required: false,
serializedName: 'MonitoringPolicy',
type: {
name: 'Composite',
className: 'MonitoringPolicy'
}
},
<API key>: {
required: false,
serializedName: '<API key>',
type: {
name: 'Composite',
className: '<API key>'
}
}
}
}
};
}
}
module.exports = <API key>;
|
using System.Configuration;
using Microsoft.AspNet.WebHooks;
using Microsoft.AspNet.WebHooks.Diagnostics;
using Microsoft.Azure.WebJobs;
namespace CustomSender.WebJob
{
internal class Program
{
<summary>
Gets or sets the <see cref="IWebHookManager"/> instance to use.
</summary>
public static IWebHookManager Manager { get; set; }
public static void Main(string[] args)
{
// Set up default WebHook logger
ILogger logger = new TraceLogger();
// Set the WebHook Store we want to get WebHook subscriptions from. Azure store requires
// a valid Azure Storage connection string named <API key>.
IWebHookStore store = AzureWebHookStore.CreateStore(logger);
// Set the sender we want to actually send out the WebHooks. We could also
// enqueue messages for scale out.
IWebHookSender sender = new <API key>(logger);
// Set up WebHook manager which we use for creating notifications.
Manager = new WebHookManager(store, sender, logger);
// Initialize WebJob
var listener = <API key>.ConnectionStrings["WebHookListener"].ConnectionString;
<API key> config = new <API key>
{
<API key> = listener
};
JobHost host = new JobHost(config);
host.RunAndBlock();
}
}
}
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "DTD/xhtml1-transitional.dtd">
<html xml:lang="en" lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" />
<title>PMD 4.2.6 Reference Package test.net.sourceforge.pmd.rules.loggingjava</title>
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="style" />
</head>
<body>
<div class="overview">
<ul>
<li>
<a href="../../../../../../overview-summary.html">Overview</a>
</li>
<li class="selected">Package</li>
</ul>
</div>
<div class="framenoframe">
<ul>
<li>
<a href="../../../../../../index.html" target="_top">FRAMES</a>
</li>
<li>
<a href="package-summary.html" target="_top">NO FRAMES</a>
</li>
</ul>
</div>
<h2>Package test.net.sourceforge.pmd.rules.loggingjava</h2>
<table class="summary">
<thead>
<tr>
<th>Class Summary</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<a href="<API key>.html" target="classFrame"><API key></a>
</td>
</tr>
</tbody>
</table>
<div class="overview">
<ul>
<li>
<a href="../../../../../../overview-summary.html">Overview</a>
</li>
<li class="selected">Package</li>
</ul>
</div>
<div class="framenoframe">
<ul>
<li>
<a href="../../../../../../index.html" target="_top">FRAMES</a>
</li>
<li>
<a href="package-summary.html" target="_top">NO FRAMES</a>
</li>
</ul>
</div>
<hr />
Copyright © 2002-2011 InfoEther. All Rights Reserved.
</body>
</html>
|
import subprocess
def get_process_list():
processes = []
ps_output = subprocess.check_output(["ps", "-A", "-w", "-w", "-o", "pid", "-o", "command"])
ps_output = ps_output.decode('latin-1')
for line in ps_output.split("\n")[1:]:
line = line.strip()
if not line:
continue
pid = line[:line.find(" ")]
cmd = line[line.find(" ") + 1:]
processes.append({"pid": int(pid), "cmd": cmd})
return processes
def find_processes(name):
process_list = get_process_list()
found_processes = []
for process in process_list:
if process["cmd"].startswith(name):
found_processes.append(process)
return found_processes
|
package com.expanset.hk2.persistence;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import javax.inject.Inject;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.glassfish.hk2.api.PreDestroy;
import org.jvnet.hk2.annotations.Contract;
import org.jvnet.hk2.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.expanset.common.errors.ExceptionAdapter;
/**
* Service is intended for getting factories for persistence contexts creation.
* Each factory is named by a unique name which corresponds with a set of settings for this factory.
*/
@Service
@Contract
@ThreadSafe
public class <API key> implements PreDestroy {
@Inject
protected <API key> factoryCreator;
protected final Map<String, Map<String, String>> factoryProperties = new HashMap<>();
protected Map<String, String> commonProperties = new HashMap<>();
protected final Map<<API key>, <API key>> factories = new HashMap<>();
private final static Logger log = LoggerFactory.getLogger(<API key>.class);
/**
* Returns the persistence factory wrapper (cached or created).
* @param key Factory unique key (based on factory name and other data in key).
* @return Persistence factory wrapper.
*/
public synchronized <API key> getFactory(@Nonnull <API key> key) {
Validate.notNull(key, "key");
<API key> factory = factories.get(key);
if(factory == null) {
Map<String, String> properties = factoryProperties.get(key.getFactoryName());
if(properties == null) {
throw new <API key>(String.format(
"Factory properties with name %s not found. Properties must be registered before using",
StringUtils.isEmpty(key.getFactoryName()) ? "(default)" : key.getFactoryName()));
}
factory = factoryCreator.create(
key,
Collections.unmodifiableMap(properties),
Collections.unmodifiableMap(commonProperties));
factories.put(key, factory);
}
return factory;
}
/**
* Gets the property value.
* @param key Property key.
* @return Property value or null.
*/
public synchronized String getCommonProperty(@Nonnull String key) {
Validate.notNull(key, "key");
return commonProperties.get(key);
}
/**
* Sets the property value, that can be used by persistence engines.
* @param key Property key.
* @param value Property value.
*/
public synchronized void setCommonProperty(
@Nonnull String key,
@Nullable String value) {
Validate.notNull(key, "key");
commonProperties.put(key, value);
}
/**
* Returns persistence factory properties, found for the specified factory name.
* @param factoryName Factory name to search they properties.
* @return Factory properties or null if not found.
*/
public synchronized Map<String, String> <API key>(@Nonnull String factoryName) {
Validate.notNull(factoryName, "factoryName");
final Map<String, String> properties = factoryProperties.get(factoryName);
if(properties == null) {
return null;
}
return Collections.unmodifiableMap(properties);
}
/**
* Sets named persistence the factory properties.
* @param factoryName Name of the factory.
* @param properties New properties for the factory.
*/
public synchronized void <API key>(
@Nonnull String factoryName,
@Nonnull Map<String, String> properties) {
Validate.notNull(factoryName, "factoryName");
Validate.notNull(properties, "properties");
closeCachedFactory(factoryName);
factoryProperties.put(factoryName, new HashMap<>(properties));
}
/**
* Removes persistence factory by the factory name.
* @param factoryName Name of unnecessary factory.
*/
public synchronized void <API key>(@Nonnull String factoryName) {
Validate.notNull(factoryName, "factoryName");
closeCachedFactory(factoryName);
factoryProperties.remove(factoryName);
}
/**
* Resets settings of all persistence factories (configuration reloaded in example).
* @param newProperties Collection of the factory names and their properties.
* @param commonProperties Properties, that can be used by persistence engines.
*/
public synchronized void <API key>(
@Nullable Map<String, Map<String, String>> newProperties,
@Nullable Map<String, String> commonProperties) {
if(newProperties != null) {
factoryProperties.clear();
for(Entry<String, Map<String, String>> entry : newProperties.entrySet()) {
factoryProperties.put(entry.getKey(), new HashMap<>(entry.getValue()));
}
}
if(commonProperties != null) {
this.commonProperties.clear();
this.commonProperties.putAll(commonProperties);
}
for(<API key> factory : factories.values()) {
ExceptionAdapter.closeQuitely(factory, log);
}
factories.clear();
}
/**
* Removes factory from cache.
* @param factoryName Factory to remove from cache.
*/
public synchronized void evict(@Nonnull String factoryName) {
Validate.notNull(factoryName, "factoryName");
closeCachedFactory(factoryName);
}
/**
* Removes all cached factories.
*/
public synchronized void evictAll() {
for(<API key> factory : factories.values()) {
ExceptionAdapter.closeQuitely(factory, log);
}
factories.clear();
}
@Override
@javax.annotation.PreDestroy
public void preDestroy() {
evictAll();
}
private void closeCachedFactory(String factoryName) {
for (Iterator<Entry<<API key>, <API key>>> it =
factories.entrySet().iterator(); it.hasNext(); ) {
Entry<<API key>, <API key>> entry = it.next();
if(StringUtils.equals(entry.getKey().getFactoryName(), factoryName)) {
ExceptionAdapter.closeQuitely(entry.getValue(), log);
it.remove();
}
}
}
}
|
#include "xparameters.h"
#include "xcanps.h"
/*
* The configuration table for devices
*/
XCanPs_Config XCanPs_ConfigTable[] =
{
{
<API key>,
<API key>
}
};
|
package com.skysport.interfaces.model.develop.accessories.service.impl;
import com.skysport.core.annotation.SystemServiceLog;
import com.skysport.core.model.common.impl.CommonServiceImpl;
import com.skysport.core.utils.UuidGeneratorUtils;
import com.skysport.interfaces.bean.develop.AccessoriesInfo;
import com.skysport.interfaces.bean.develop.BomInfo;
import com.skysport.interfaces.bean.develop.MaterialSpInfo;
import com.skysport.interfaces.bean.develop.join.AccessoriesJoinInfo;
import com.skysport.interfaces.mapper.develop.<API key>;
import com.skysport.interfaces.mapper.develop.<API key>;
import com.skysport.interfaces.mapper.info.AccessoriesMapper;
import com.skysport.interfaces.model.develop.accessories.service.IAccessoriesService;
import com.skysport.interfaces.model.develop.pantone.helper.<API key>;
import com.skysport.interfaces.model.develop.pantone.service.<API key>;
import com.skysport.interfaces.model.develop.position.helper.<API key>;
import com.skysport.interfaces.model.develop.position.service.<API key>;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
@Service("accessoriesService")
public class <API key> extends CommonServiceImpl<AccessoriesInfo> implements IAccessoriesService, InitializingBean {
@Resource(name = "accessoriesMapper")
private AccessoriesMapper accessoriesMapper;
@Autowired
private <API key> <API key>;
@Autowired
private <API key> <API key>;
@Resource(name = "<API key>")
private <API key> <API key>;
@Resource(name = "<API key>")
private <API key> <API key>;
@Override
public void afterPropertiesSet() throws Exception {
commonMapper = accessoriesMapper;
}
/**
*
*
* @param bomInfo
*/
@Override
@SystemServiceLog(description = "")
public List<AccessoriesInfo> updateOrAddBatch(BomInfo bomInfo) {
List<AccessoriesJoinInfo> accessoriesItems = bomInfo.getAccessoriesItems();
List<AccessoriesInfo> accessoriesRtn = new ArrayList<>();
String bomId = StringUtils.isBlank(bomInfo.getNatrualkey()) ? bomInfo.getBomId() : bomInfo.getNatrualkey();
<API key>(accessoriesItems, bomId);
if (null != accessoriesItems) {
//idid
for (AccessoriesJoinInfo accessoriesJoinInfo : accessoriesItems) {
String accessoriesId = accessoriesJoinInfo.getAccessoriesInfo().getAccessoriesId();
MaterialSpInfo materialSpInfo = accessoriesJoinInfo.getMaterialSpInfo();
if (null != materialSpInfo.getUnitPrice() && null != materialSpInfo.getTotalAmount()) {
BigDecimal totalPrice = materialSpInfo.getUnitPrice().multiply(materialSpInfo.getTotalAmount());
materialSpInfo.setTotalPrice(totalPrice);
}
if (StringUtils.isNotBlank(accessoriesId)) {
setAccessoriesId(accessoriesJoinInfo, accessoriesId, bomId);
accessoriesMapper.updateInfo(accessoriesJoinInfo.getAccessoriesInfo());
<API key>.updateDosage(accessoriesJoinInfo.<API key>());
<API key>.updateSp(accessoriesJoinInfo.getMaterialSpInfo());
}
else {
// String kind_name = buildKindName(bomInfo, accessoriesJoinInfo);
// String seqNo = BuildSeqNoHelper.SINGLETONE.getFullSeqNo(kind_name, <API key>, WebConstants.<API key>);
// //++++NNN
// accessoriesId = kind_name + seqNo;
accessoriesId = UuidGeneratorUtils.getNextId();
setAccessoriesId(accessoriesJoinInfo, accessoriesId, bomId);
accessoriesMapper.add(accessoriesJoinInfo.getAccessoriesInfo());
<API key>.addDosage(accessoriesJoinInfo.<API key>());
<API key>.addSp(accessoriesJoinInfo.getMaterialSpInfo());
}
accessoriesRtn.add(accessoriesJoinInfo.getAccessoriesInfo());
if (null != accessoriesJoinInfo.getAccessoriesInfo().getPositionIds() && !accessoriesJoinInfo.getAccessoriesInfo().getPositionIds().isEmpty()) {
<API key>.addBatch(accessoriesJoinInfo.getAccessoriesInfo().getPositionIds(), accessoriesId);
}
if (null != accessoriesJoinInfo.getAccessoriesInfo().getPantoneIds() && !accessoriesJoinInfo.getAccessoriesInfo().getPantoneIds().isEmpty()) {
<API key>.addBatch(accessoriesJoinInfo.getAccessoriesInfo().getPantoneIds(), accessoriesId);
}
}
}
return accessoriesRtn;
}
@SystemServiceLog(description = "bomid")
@Override
public List<AccessoriesInfo> <API key>(String bomId) {
return accessoriesMapper.<API key>(bomId);
}
@SystemServiceLog(description = "bomid")
@Override
public List<AccessoriesInfo> <API key>(String bomId) {
return accessoriesMapper.<API key>(bomId);
}
@Override
public void <API key>(List<AccessoriesInfo> infos) {
if (null != infos && infos.size() > 0) {
accessoriesMapper.<API key>(infos);
}
}
@Override
public void <API key>(List<AccessoriesInfo> infos) {
if (null != infos && infos.size() > 0) {
accessoriesMapper.<API key>(infos);
}
}
// private String buildKindName(BomInfo bomInfo, AccessoriesJoinInfo accessoriesJoinInfo) {
// String kind_name = CharConstant.EMPTY;
// StringBuilder stringBuilder = new StringBuilder();
// String materialTypeId = StringUtils.isBlank(accessoriesJoinInfo.getAccessoriesInfo().getMaterialTypeId()) ? WebConstants.<API key> : accessoriesJoinInfo.getAccessoriesInfo().getMaterialTypeId();
// stringBuilder.append(materialTypeId);
// stringBuilder.append(accessoriesJoinInfo.getAccessoriesInfo().getSpId());
// stringBuilder.append(accessoriesJoinInfo.getAccessoriesInfo().getYearCode());
// stringBuilder.append(accessoriesJoinInfo.getAccessoriesInfo().getProductTypeId());
// return kind_name;
private void setAccessoriesId(AccessoriesJoinInfo accessoriesJoinInfo, String accessoriesId, String bomId) {
accessoriesJoinInfo.getAccessoriesInfo().setAccessoriesId(accessoriesId);
accessoriesJoinInfo.getAccessoriesInfo().setNatrualkey(accessoriesId);
accessoriesJoinInfo.getAccessoriesInfo().setBomId(bomId);
accessoriesJoinInfo.<API key>().setMaterialId(accessoriesId);
accessoriesJoinInfo.getMaterialSpInfo().setMaterialId(accessoriesId);
<API key>.SINGLETONE.setPositionFabricId(accessoriesJoinInfo.getAccessoriesInfo().getPositionIds(), accessoriesId);
<API key>.SINGLETONE.setPantoneFabricId(accessoriesJoinInfo.getAccessoriesInfo().getPantoneIds(), accessoriesId);
}
private void <API key>(List<AccessoriesJoinInfo> accessoriesItems, String bomId) {
List<String> allAccessoriesIds = accessoriesMapper.<API key>(bomId);
List<String> <API key> = <API key>(accessoriesItems);
allAccessoriesIds.removeAll(<API key>);
if (null != allAccessoriesIds && !allAccessoriesIds.isEmpty()) {
accessoriesMapper.<API key>(allAccessoriesIds);
}
}
private List<String> <API key>(List<AccessoriesJoinInfo> accessoriesItems) {
List<String> <API key> = new ArrayList<String>();
if (null != accessoriesItems) {
for (AccessoriesJoinInfo accessoriesJoinInfo : accessoriesItems) {
String accessoriesId = accessoriesJoinInfo.getAccessoriesInfo().getAccessoriesId();
if (StringUtils.isNotEmpty(accessoriesId)) {
<API key>.add(accessoriesId);
}
}
}
return <API key>;
}
}
|
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http:
<html xmlns="http:
<head>
<title>request.rb</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<link rel="stylesheet" href="../../../../../../../../../../../../../css/reset.css" type="text/css" media="screen" />
<link rel="stylesheet" href="../../../../../../../../../../../../../css/main.css" type="text/css" media="screen" />
<link rel="stylesheet" href="../../../../../../../../../../../../../css/github.css" type="text/css" media="screen" />
<script src="../../../../../../../../../../../../../js/jquery-1.3.2.min.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../../../../../../../../../../js/jquery-effect.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../../../../../../../../../../js/main.js" type="text/javascript" charset="utf-8"></script>
<script src="../../../../../../../../../../../../../js/highlight.pack.js" type="text/javascript" charset="utf-8"></script>
</head>
<body>
<div class="banner">
<span>Ruby on Rails 4.2.3</span><br />
<h1>
request.rb
</h1>
<ul class="files">
<li>
../../../../.rvm/gems/ruby-2.2.2@playme/gems/actionpack-4.2.3/lib/action_dispatch/http/request.rb
</li>
<li>Last modified: 2015-07-23 13:52:51 +0100</li>
</ul>
</div>
<div id="bodyContent">
<div id="content">
<!-- File only: requires -->
<div class="sectiontitle">Required Files</div>
<ul>
<li>stringio</li>
<li>active_support/inflector</li>
<li>action_dispatch/http/headers</li>
<li>action_controller/metal/exceptions</li>
<li>rack/request</li>
<li>action_dispatch/http/cache</li>
<li>action_dispatch/http/mime_negotiation</li>
<li>action_dispatch/http/parameters</li>
<li>action_dispatch/http/filter_parameters</li>
<li>action_dispatch/http/upload</li>
<li>action_dispatch/http/url</li>
<li>active_support/core_ext/array/conversions</li>
</ul>
<!-- Namespace -->
<div class="sectiontitle">Namespace</div>
<ul>
<li>
<span class="type">MODULE</span>
<a href="../../../../../../../../../../../../../classes/ActionController.html">ActionController</a>
</li>
<li>
<span class="type">MODULE</span>
<a href="../../../../../../../../../../../../../classes/ActionDispatch.html">ActionDispatch</a>
</li>
<li>
<span class="type">MODULE</span>
<a href="../../../../../../../../../../../../../classes/ActionDispatch/Http.html">ActionDispatch::Http</a>
</li>
<li>
<span class="type">CLASS</span>
<a href="../../../../../../../../../../../../../classes/ActionDispatch/Request.html">ActionDispatch::Request</a>
</li>
</ul>
<!-- Methods -->
</div>
</div>
</body>
</html>
|
import datetime
import time
from django.http import HttpResponse
from django.shortcuts import render_to_response, get_object_or_404
from django.utils.timezone import localtime, now
from graphite.util import json
from graphite.events import models
from graphite.render.attime import parseATTime
from django.core.urlresolvers import get_script_prefix
def to_timestamp(dt):
return time.mktime(dt.timetuple())
class EventEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime.datetime):
return to_timestamp(obj)
return json.JSONEncoder.default(self, obj)
def view_events(request):
if request.method == "GET":
context = { 'events' : fetch(request),
'slash' : get_script_prefix()
}
return render_to_response("events.html", context)
else:
return post_event(request)
def detail(request, event_id):
e = get_object_or_404(models.Event, pk=event_id)
context = { 'event' : e,
'slash' : get_script_prefix()
}
return render_to_response("event.html", context)
def post_event(request):
if request.method == 'POST':
event = json.loads(request.body)
assert isinstance(event, dict)
values = {}
values["what"] = event["what"]
values["tags"] = event.get("tags", None)
values["when"] = datetime.datetime.fromtimestamp(
event.get("when", time.time()))
if "data" in event:
values["data"] = event["data"]
e = models.Event(**values)
e.save()
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def get_data(request):
if 'jsonp' in request.REQUEST:
response = HttpResponse(
"%s(%s)" % (request.REQUEST.get('jsonp'),
json.dumps(fetch(request), cls=EventEncoder)),
mimetype='text/javascript')
else:
response = HttpResponse(
json.dumps(fetch(request), cls=EventEncoder),
mimetype="application/json")
return response
def fetch(request):
#XXX we need to move to USE_TZ=True to get rid of localtime() conversions
if request.GET.get("from", None) is not None:
time_from = localtime(parseATTime(request.GET["from"])).replace(tzinfo=None)
else:
time_from = datetime.datetime.fromtimestamp(0)
if request.GET.get("until", None) is not None:
time_until = localtime(parseATTime(request.GET["until"])).replace(tzinfo=None)
else:
time_until = now()
tags = request.GET.get("tags", None)
if tags is not None:
tags = request.GET.get("tags").split(" ")
return [x.as_dict() for x in
models.Event.find_events(time_from, time_until, tags=tags)]
|
'use strict';
/* eslint-env node, mocha */
const assert = require('yeoman-assert');
const fs = require('fs');
const helpers = require('yeoman-test');
const os = require('os');
const path = require('path');
// TODO(bwavell): add a bunch more tests
describe('generator-alfresco:jar-add-local-3-1-0', function () {
this.timeout(30000);
describe('an advanced project', function () {
const osTempDir = path.join(os.tmpdir(), 'temp-test');
// We need a test project setup before we begin
before(function () {
return helpers.run(path.join(__dirname, '../generators/app'))
.inDir(osTempDir)
.withOptions({ 'skip-install': true })
.withPrompts({
sdkVersion: '3.1.0',
projectStructure: 'advanced',
projectArtifactId: 'temp-test',
})
.toPromise();
});
it('starts with a basic project', function () {
assert.file([
path.join(osTempDir, 'pom.xml'),
path.join(osTempDir, 'run.sh'),
]);
});
it('project does not reference platform-jar or share-jar in top pom.xml', function () {
assert.noFileContent([
[path.join(osTempDir, 'pom.xml'), /<artifactId>platform-jar</],
[path.join(osTempDir, 'pom.xml'), /<artifactId>share-jar</],
]);
});
describe('installing a local platform jar using options', function () {
before(function () {
const jarSrc = path.join(__dirname, 'fixtures/platform-jar.jar');
const jarPath = path.join(osTempDir, 'customizations/modules/platform/platform-jar.jar');
fs.writeFileSync(jarPath, fs.readFileSync(jarSrc));
return helpers.run(path.join(__dirname, '../generators/jar-add-local'))
.cd(osTempDir)
.withOptions({
'force': true, // tests can't handle conflicts
'path': 'customizations/modules/platform/platform-jar.jar',
'group-id': 'org.alfresco',
'artifact-id': 'platform-jar',
'amp-version': '1.0.0-SNAPSHOT',
})
.toPromise();
});
it('references platform-jar in top pom.xml', function () {
assert.fileContent(path.join(osTempDir, 'pom.xml'), /<artifactId>platform-jar</);
});
});
describe('installing a local share jar using prompts', function () {
before(function () {
const ampSrc = path.join(__dirname, 'fixtures/share-jar.jar');
const ampPath = path.join(osTempDir, 'customizations/modules/share/share-jar.jar');
fs.writeFileSync(ampPath, fs.readFileSync(ampSrc));
return helpers.run(path.join(__dirname, '../generators/jar-add-local'))
.cd(osTempDir)
.withOptions({
'force': true, // tests can't handle conflicts
})
.withPrompts({
'path': 'customizations/modules/share/share-jar.jar',
})
.toPromise();
});
it('references share-jar in top pom.xml', function () {
assert.fileContent(path.join(osTempDir, 'pom.xml'), /<artifactId>share-jar</);
});
});
describe('installing an empty local platform jar using prompts', function () {
before(function () {
const ampSrc = path.join(__dirname, 'fixtures/empty-jar.jar');
const ampPath = path.join(osTempDir, 'customizations/modules/platform/empty-jar.jar');
fs.writeFileSync(ampPath, fs.readFileSync(ampSrc));
return helpers.run(path.join(__dirname, '../generators/jar-add-local'))
.cd(osTempDir)
.withOptions({
'force': true, // tests can't handle conflicts
})
.withPrompts({
'path': 'customizations/modules/platform/empty-jar.jar',
'groupId': 'com.empty',
'artifactId': 'empty-jar',
'ampVersion': '1.0.0-SNAPSHOT',
})
.toPromise();
});
it('references jar in top pom.xml', function () {
assert.fileContent(path.join(osTempDir, 'pom.xml'), /<artifactId>empty-jar</);
});
});
describe('attempting to install a local jar using invalid options when all jars are accounted for', function () {
// if you skip the previous test so that the share amp is not installed
// prior to this code running this will fail with nasty errors related
// to options not being provided. If however, the previous tests are run
// the then when we get here the prompts are not even displayed because
// we bail when we discover that there are no amps in ./amps or
// ./amps_share that aren't already referenced in the module registry.
before(function () {
const ampSrc = path.join(__dirname, 'fixtures/share-jar.jar');
const ampPath = path.join(osTempDir, 'customizations/modules/share/share-jar.jar');
fs.writeFileSync(ampPath, fs.readFileSync(ampSrc));
return helpers.run(path.join(__dirname, '../generators/jar-add-local'))
.cd(osTempDir)
.withOptions({
'force': true, // tests can't handle conflicts
})
.toPromise();
});
it('references jar in top pom.xml', function () {
assert.fileContent(path.join(osTempDir, 'pom.xml'), /<artifactId>share-jar</);
});
});
});
describe('a basic project', function () {
const osTempDir = path.join(os.tmpdir(), 'temp-test');
// We need a test project setup before we begin
before(function () {
return helpers.run(path.join(__dirname, '../generators/app'))
.inDir(osTempDir)
.withOptions({'skip-install': true})
.withPrompts({
sdkVersion: '3.1.0',
projectStructure: 'basic',
projectArtifactId: 'temp-test',
})
.toPromise();
});
it('has basic project assets', function () {
assert.file([
path.join(osTempDir, 'pom.xml'),
path.join(osTempDir, 'run.sh'),
]);
});
describe('installing a non-existent local platform jar using options', function () {
before(function () {
return helpers.run(path.join(__dirname, '../generators/amp-add-local'))
.cd(osTempDir)
.withOptions({
'force': true, // tests can't handle conflicts
'path': 'customizations/modules/platform/platform-jar.jar',
'group-id': 'org.alfresco',
'artifact-id': 'platform-jar',
'amp-version': '1.0.0-SNAPSHOT',
})
.toPromise();
});
it('does not reference platform-jar in top pom.xml because basic projects don\'t have a customizations folder', function () {
assert.noFileContent(path.join(osTempDir, 'pom.xml'), /<artifactId>platform-jar</);
});
});
});
});
// vim: autoindent expandtab tabstop=2 shiftwidth=2 softtabstop=2
|
#define <API key>
// include associated header file
#include "AnnotatorLib/Algo/CompressObjectTrack.h"
#include "AnnotatorLib/Algo/<API key>.h"
#include "AnnotatorLib/Commands/RemoveAnnotation.h"
#include "AnnotatorLib/Session.h"
#include <math.h>
namespace AnnotatorLib {
namespace Algo {
std::vector<shared_ptr<Annotation>> CompressObjectTrack::compressSession(
std::shared_ptr<Session> session, float max_diff) {
std::vector<shared_ptr<Annotation>> removed_elements;
for (auto it = session->getObjects().begin();
it != session->getObjects().end(); it++) {
if (it->second->hasAnnotations()) {
std::vector<shared_ptr<Annotation>> <API key> =
compress(session, it->second, max_diff);
if (!<API key>.empty())
removed_elements.insert(removed_elements.end(),
<API key>.begin(),
<API key>.end());
}
}
return removed_elements;
}
std::vector<shared_ptr<Annotation>> CompressObjectTrack::compress(
std::shared_ptr<Session> session, shared_ptr<Object> object,
float max_diff) {
std::vector<shared_ptr<Annotation>> removed_elements;
if (object->getAnnotations().size() < 3) return removed_elements;
shared_ptr<Annotation> curr =
object->getFirstAnnotation()->getNext(); // get second
while (curr && curr->hasNext()) {
shared_ptr<Annotation> a_new = <API key>::getInterpolation(
curr->getFrame(), curr->getPrevious(), curr->getNext());
shared_ptr<Annotation> prev = curr;
curr = curr->getNext();
// check if the interpolation is close enough to safely remove the
// annotation
float dist = std::sqrt(std::pow(a_new->getX() - prev->getX(), 2) +
std::pow(a_new->getY() - prev->getY(), 2));
float dist_size =
std::sqrt(std::pow(a_new->getWidth() - prev->getWidth(), 2) +
std::pow(a_new->getHeight() - prev->getHeight(), 2));
if (dist < max_diff && dist_size < max_diff) {
removed_elements.push_back(
session->removeAnnotation(prev->getId(), true));
}
a_new.reset();
}
return removed_elements;
}
} // of namespace Algo
} // of namespace AnnotatorLib
|
goog.provide('adapt.expr');
goog.require('adapt.base');
/**
* @typedef {{fontFamily:string, lineHeight:number, margin:number, hyphenate:boolean,
* columnWidth:number, horizontal:boolean, nightMode:boolean, spreadView:boolean,
* pageBorder:number}}
*/
adapt.expr.Preferences;
/**
* @return {adapt.expr.Preferences}
*/
adapt.expr.defaultPreferences = function() {
return {fontFamily:"serif", lineHeight:1.25, margin:8, hyphenate:true, columnWidth:25,
horizontal:false, nightMode:false, spreadView:false, pageBorder:1};
};
/**
* @param {adapt.expr.Preferences} pref
* @return {adapt.expr.Preferences}
*/
adapt.expr.clonePreferences = function(pref) {
return {fontFamily:pref.fontFamily, lineHeight:pref.lineHeight, margin:pref.margin,
hyphenate:pref.hyphenate, columnWidth:pref.columnWidth, horizontal:pref.horizontal,
nightMode:pref.nightMode, spreadView:pref.spreadView, pageBorder:pref.pageBorder};
};
/**
* @const
*/
adapt.expr.<API key> = adapt.expr.defaultPreferences();
/**
* Special marker value that indicates that the expression result is being
* calculated.
* @enum {!Object}
*/
adapt.expr.Special = {
PENDING: {}
};
/**
* @typedef {string|number|boolean|undefined}
*/
adapt.expr.Result;
/**
* @typedef {adapt.expr.Special|adapt.expr.Result}
*/
adapt.expr.PendingResult;
/**
* @param {number} viewW
* @param {number} viewH
* @param {number} objW
* @param {number} objH
* @return {string}
*/
adapt.expr.letterbox = function(viewW, viewH, objW, objH) {
var scale = Math.min((viewW - 0) / objW, (viewH - 0) / objH);
var x = (viewW - objW) / 2;
var y = (viewH - objH) / 2;
return "matrix(" + scale + ",0,0," + scale + "," + x + "," + y + ")";
};
/**
* @param {string} str
* @return {string} string that can be parsed as CSS string with value str
*/
adapt.expr.cssString = function(str) {
return '"' + adapt.base.escapeCSSStr(str + "") + '"';
};
/**
* @param {string} name
* @return {string} string that can be parsed as CSS name
*/
adapt.expr.cssIdent = function(name) {
return adapt.base.escapeCSSIdent(name + "");
};
/**
* @param {?string} objName
* @param {string} memberName
* @return {string}
*/
adapt.expr.makeQualifiedName = function(objName, memberName) {
if (objName) {
return adapt.base.escapeCSSIdent(objName) + "." +
adapt.base.escapeCSSIdent(memberName);
}
return adapt.base.escapeCSSIdent(memberName);
};
/**
* @type {number}
*/
adapt.expr.nextKeyIndex = 0;
/**
* Lexical scope of the expression.
* @param {adapt.expr.LexicalScope} parent
* @param {function(this:adapt.expr.Context,string,boolean):adapt.expr.Val=} resolver
* @constructor
*/
adapt.expr.LexicalScope = function(parent, resolver) {
this.parent = parent;
/** @type {string} */ this.scopeKey = "S" + (adapt.expr.nextKeyIndex++);
/** @type {Array.<adapt.expr.LexicalScope>} */ this.children = [];
/** @type {adapt.expr.Const} */ this.zero = new adapt.expr.Const(this, 0);
/** @type {adapt.expr.Const} */ this.one = new adapt.expr.Const(this, 1);
/** @type {adapt.expr.Const} */ this._true = new adapt.expr.Const(this, true);
/** @type {adapt.expr.Const} */ this._false = new adapt.expr.Const(this, false);
if (parent)
parent.children.push(this);
/** @type {Object.<string,adapt.expr.Val>} */ this.values = {};
/** @type {Object.<string,adapt.expr.Val>} */ this.funcs = {};
/** @type {Object.<string,function(this:adapt.expr.Context,...adapt.expr.Result):adapt.expr.Result>} */
this.builtIns = {};
/** @const */ this.resolver = resolver;
if (!parent) {
// root scope
var builtIns = this.builtIns;
builtIns["floor"] = Math.floor;
builtIns["ceil"] = Math.ceil;
builtIns["round"] = Math.round;
builtIns["sqrt"] = Math.sqrt;
builtIns["min"] = Math.min;
builtIns["max"] = Math.max;
builtIns["letterbox"] = adapt.expr.letterbox;
builtIns["css-string"] = adapt.expr.cssString;
builtIns["css-name"] = adapt.expr.cssIdent;
builtIns["typeof"] = function(x) { return typeof(x); };
this.defineBuiltInName("page-width", function() { return this.pageWidth(); });
this.defineBuiltInName("page-height", function() { return this.pageHeight(); });
this.defineBuiltInName("pref-font-family", function() { return this.pref.fontFamily; });
this.defineBuiltInName("pref-night-mode", function() { return this.pref.nightMode; });
this.defineBuiltInName("pref-hyphenate", function() { return this.pref.hyphenate; });
this.defineBuiltInName("pref-margin", function() { return this.pref.margin; });
this.defineBuiltInName("pref-line-height", function() { return this.pref.lineHeight; });
this.defineBuiltInName("pref-column-width", function() { return this.pref.columnWidth * this.fontSize; });
this.defineBuiltInName("pref-horizontal", function() {
return this.pref.horizontal;
});
this.defineBuiltInName("pref-spread-view", function() { return this.pref.spreadView; });
}
};
/**
* @param {string} name
* @param {function(this:adapt.expr.Context):adapt.expr.Result} fn
*/
adapt.expr.LexicalScope.prototype.defineBuiltInName = function(name, fn) {
this.values[name] = new adapt.expr.Native(this, fn, name);
};
/**
* @param {string} qualifiedName
* @param {adapt.expr.Val} val
* @return {void}
*/
adapt.expr.LexicalScope.prototype.defineName = function(qualifiedName, val) {
this.values[qualifiedName] = val;
};
/**
* @param {string} qualifiedName
* @param {adapt.expr.Val} val
* @return {void}
*/
adapt.expr.LexicalScope.prototype.defineFunc = function(qualifiedName, val) {
this.funcs[qualifiedName] = val;
};
/**
* @param {string} qualifiedName
* @param {function(this:adapt.expr.Context,...adapt.expr.Result):adapt.expr.Result} fn
* @return {void}
*/
adapt.expr.LexicalScope.prototype.defineBuiltIn = function(qualifiedName, fn) {
this.builtIns[qualifiedName] = fn;
};
/**
* @param {string} unit
* @returns {boolean}
*/
adapt.expr.<API key> = function(unit) {
switch (unit.toLowerCase()) {
case "px":
case "in":
case "pt":
case "pc":
case "cm":
case "mm":
case "q":
return true;
default:
return false;
}
};
/**
* @const
* @type {!Object.<string,number>}
*/
adapt.expr.defaultUnitSizes = {
"px": 1,
"in": 96,
"pt": 4/3,
"pc": 96/6,
"cm": 96/2.54,
"mm": 96/25.4,
"q": 96/2.54/40,
"em": 16,
"rem": 16,
"ex": 8,
"rex": 8
};
/**
* @typedef {Object.<string,adapt.expr.Result>}
*/
adapt.expr.ScopeContext;
/**
* Run-time instance of a scope and its children.
* @param {adapt.expr.LexicalScope} rootScope
* @param {number} viewportWidth
* @param {number} viewportHeight
* @param {number} fontSize
* @constructor
*/
adapt.expr.Context = function(rootScope, viewportWidth, viewportHeight, fontSize) {
/** @const */ this.rootScope = rootScope;
/** @protected @type {?number} */ this.actualPageWidth = null;
/** @const @type {function(this:adapt.expr.Context): number} */
this.pageWidth = function() {
if (this.actualPageWidth)
return this.actualPageWidth;
else
return this.pref.spreadView ? Math.floor(viewportWidth / 2) - this.pref.pageBorder : viewportWidth;
};
/** @protected @type {?number} */ this.actualPageHeight = null;
/** @const @type {function(this:adapt.expr.Context): number} */
this.pageHeight = function() {
if (this.actualPageHeight)
return this.actualPageHeight;
else
return viewportHeight;
};
/** @const */ this.fontSize = fontSize;
this.pref = adapt.expr.<API key>;
/** @type {Object.<string,adapt.expr.ScopeContext>} */ this.scopes = {};
};
/**
* @private
* @param {adapt.expr.LexicalScope} scope
* @return {!adapt.expr.ScopeContext}
*/
adapt.expr.Context.prototype.getScopeContext = function(scope) {
var s = this.scopes[scope.scopeKey];
if (!s) {
s = {};
this.scopes[scope.scopeKey] = s;
}
return s;
};
/**
* @param {adapt.expr.LexicalScope} scope
* @return {void}
*/
adapt.expr.Context.prototype.clearScope = function(scope) {
this.scopes[scope.scopeKey] = {};
for (var k = 0; k < scope.children.length; k++) {
this.clearScope(scope.children[k]);
}
};
/**
* @param {string} unit
* @return {number}
*/
adapt.expr.Context.prototype.queryUnitSize = function(unit) {
if (unit == "vw")
return this.pageWidth() / 100;
if (unit == "vh")
return this.pageHeight() / 100;
if (unit == "em" || unit == "rem")
return this.fontSize;
if (unit == "ex" || unit == "rex")
return adapt.expr.defaultUnitSizes["ex"] * this.fontSize / adapt.expr.defaultUnitSizes["em"];
return adapt.expr.defaultUnitSizes[unit];
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {string} qualifiedName
* @return {adapt.expr.Val}
*/
adapt.expr.Context.prototype.evalName = function(scope, qualifiedName) {
do {
var val = scope.values[qualifiedName];
if (val)
return val;
if (scope.resolver) {
val = scope.resolver.call(this, qualifiedName, false);
if (val)
return val;
}
scope = scope.parent;
} while (scope);
throw new Error("Name '" + qualifiedName + "' is undefined");
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {string} qualifiedName
* @param {Array.<adapt.expr.Val>} params
* @param {boolean} noBuiltInEval don't evaluate built-ins (for dependency calculations)
* @return {adapt.expr.Val}
*/
adapt.expr.Context.prototype.evalCall = function(scope, qualifiedName, params, noBuiltInEval) {
do {
var body = scope.funcs[qualifiedName];
if (body)
return body; // will be expanded by callee
if (scope.resolver) {
body = scope.resolver.call(this, qualifiedName, true);
if (body)
return body;
}
var fn = scope.builtIns[qualifiedName];
if (fn) {
if (noBuiltInEval)
return scope.zero;
var args = Array(params.length);
for (var i = 0; i < params.length; i++) {
args[i] = params[i].evaluate(this);
}
return new adapt.expr.Const(scope, fn.apply(this, args));
}
scope = scope.parent;
} while (scope);
throw new Error("Function '" + qualifiedName + "' is undefined");
};
/**
* @param {string} feature
* @param {adapt.expr.Val} value
* @return {boolean}
*/
adapt.expr.Context.prototype.evalMediaTest = function(feature, value) {
var prefix = "";
var r = feature.match(/^(min|max)-(.*)$/);
if (r) {
prefix = r[1];
feature = r[2];
}
var req = null;
var actual = null;
switch (feature) {
case "width":
case "height":
case "device-width":
case "device-height":
case "color":
if (value)
req = value.evaluate(this);
break;
}
switch (feature) {
case "width":
actual = this.pageWidth();
break;
case "height":
actual = this.pageHeight();
break;
case "device-width":
actual = window.screen.availWidth;
break;
case "device-height":
actual = window.screen.availHeight;
break;
case "color":
actual = window.screen.pixelDepth;
break;
}
if (actual != null && req != null) {
switch (prefix) {
case "min" :
return actual >= req;
case "max" :
return actual <= req;
default:
return actual == req;
}
}
return false;
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {string} key
* @return {adapt.expr.Result|undefined}
*/
adapt.expr.Context.prototype.queryVal = function(scope, key) {
var s = this.scopes[scope.scopeKey];
return s ? s[key] : undefined;
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {string} key
* @param {adapt.expr.Result} val
* @return {void}
*/
adapt.expr.Context.prototype.storeVal = function(scope, key, val) {
this.getScopeContext(scope)[key] = val;
};
/**
* @typedef {Object.<string,boolean|adapt.expr.Special>}
*/
adapt.expr.DependencyCache;
/**
* @param {adapt.expr.LexicalScope} scope
* @constructor
*/
adapt.expr.Val = function(scope) {
this.scope = scope;
this.key = "_" + adapt.expr.nextKeyIndex++;
};
/**
* @return {string}
* @override
*/
adapt.expr.Val.prototype.toString = function() {
var buf = new adapt.base.StringBuffer();
this.appendTo(buf, 0);
return buf.toString();
};
/**
* @param {adapt.base.StringBuffer} buf
* @param {number} priority
* @return {void}
*/
adapt.expr.Val.prototype.appendTo = function(buf, priority) {
throw new Error("F_ABSTRACT");
};
/**
* @protected
* @param {adapt.expr.Context} context
* @return {adapt.expr.Result}
*/
adapt.expr.Val.prototype.evaluateCore = function(context) {
throw new Error("F_ABSTRACT");
};
/**
* @param {adapt.expr.Context} context
* @param {Array.<adapt.expr.Val>} params
* @return {adapt.expr.Val}
*/
adapt.expr.Val.prototype.expand = function(context, params) {
return this;
};
/**
* @protected
* @param {adapt.expr.Val} other
* @param {adapt.expr.Context} context
* @param {adapt.expr.DependencyCache} dependencyCache
* @return {boolean}
*/
adapt.expr.Val.prototype.dependCore = function(other, context, dependencyCache) {
return other === this;
};
/**
* @protected
* @param {adapt.expr.Val} other
* @param {adapt.expr.Context} context
* @param {adapt.expr.DependencyCache} dependencyCache
* @return {boolean}
*/
adapt.expr.Val.prototype.dependOuter = function(other, context, dependencyCache) {
var cached = dependencyCache[this.key];
if (cached != null) {
if (cached === adapt.expr.Special.PENDING)
return false;
return /** @type {boolean} */ (cached);
} else {
dependencyCache[this.key] = adapt.expr.Special.PENDING;
var result = this.dependCore(other, context, dependencyCache);
dependencyCache[this.key] = result;
return result;
}
};
/**
* @param {adapt.expr.Val} other
* @param {adapt.expr.Context} context
* @return {boolean}
*/
adapt.expr.Val.prototype.depend = function(other, context) {
return this.dependOuter(other, context, {});
};
/**
* @param {adapt.expr.Context} context
* @return {adapt.expr.Result}
*/
adapt.expr.Val.prototype.evaluate = function(context) {
var result = context.queryVal(this.scope, this.key);
if (typeof result != "undefined")
return result;
result = this.evaluateCore(context);
context.storeVal(this.scope, this.key, result);
return result;
};
/**
* @return {boolean}
*/
adapt.expr.Val.prototype.isMediaName = function() {
return false;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} val
* @extends {adapt.expr.Val}
*/
adapt.expr.Prefix = function(scope, val) {
adapt.expr.Val.call(this, scope);
/** @type {adapt.expr.Val} */ this.val = val;
};
goog.inherits(adapt.expr.Prefix, adapt.expr.Val);
/**
* @protected
* @return {string}
*/
adapt.expr.Prefix.prototype.getOp = function() {
throw new Error("F_ABSTRACT");
};
/**
* @param {adapt.expr.Result} val
* @return {adapt.expr.Result}
*/
adapt.expr.Prefix.prototype.evalPrefix = function(val) {
throw new Error("F_ABSTRACT");
};
/**
* @override
*/
adapt.expr.Prefix.prototype.evaluateCore = function(context) {
var val = this.val.evaluate(context);
return this.evalPrefix(val);
};
/**
* @override
*/
adapt.expr.Prefix.prototype.dependCore = function(other, context, dependencyCache) {
return other === this || this.val.dependOuter(other, context, dependencyCache);
};
/**
* @override
*/
adapt.expr.Prefix.prototype.appendTo = function(buf, priority) {
if (10 < priority)
buf.append("(");
buf.append(this.getOp());
this.val.appendTo(buf, 10);
if (10 < priority)
buf.append(")");
};
/**
* @override
*/
adapt.expr.Prefix.prototype.expand = function(context, params) {
var val = this.val.expand(context, params);
if( val === this.val )
return this;
var r = new this.constructor(this.scope, val);
return r;
};
/**
* @constructor
* @extends {adapt.expr.Val}
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
*/
adapt.expr.Infix = function(scope, lhs, rhs) {
adapt.expr.Val.call(this, scope);
/** @type {adapt.expr.Val} */ this.lhs = lhs;
/** @type {adapt.expr.Val} */ this.rhs = rhs;
};
goog.inherits(adapt.expr.Infix, adapt.expr.Val);
/**
* @return {number}
*/
adapt.expr.Infix.prototype.getPriority = function() {
throw new Error("F_ABSTRACT");
};
/**
* @return {string}
*/
adapt.expr.Infix.prototype.getOp = function() {
throw new Error("F_ABSTRACT");
};
/**
* @param {adapt.expr.Result} lhs
* @param {adapt.expr.Result} rhs
* @return {adapt.expr.Result}
*/
adapt.expr.Infix.prototype.evalInfix = function(lhs, rhs) {
throw new Error("F_ABSTRACT");
};
/**
* @override
*/
adapt.expr.Infix.prototype.evaluateCore = function(context) {
var lhs = this.lhs.evaluate(context);
var rhs = this.rhs.evaluate(context);
return this.evalInfix(lhs, rhs);
};
/**
* @override
*/
adapt.expr.Infix.prototype.dependCore = function(other, context, dependencyCache) {
return other === this || this.lhs.dependOuter(other, context, dependencyCache) ||
this.rhs.dependOuter(other, context, dependencyCache);
};
/**
* @override
*/
adapt.expr.Infix.prototype.appendTo = function(buf, priority) {
var thisPriority = this.getPriority();
if (thisPriority <= priority)
buf.append("(");
this.lhs.appendTo(buf, thisPriority);
buf.append(this.getOp());
this.rhs.appendTo(buf, thisPriority);
if (thisPriority <= priority)
buf.append(")");
};
/**
* @override
*/
adapt.expr.Infix.prototype.expand = function(context, params) {
var lhs = this.lhs.expand(context, params);
var rhs = this.rhs.expand(context, params);
if( lhs === this.lhs && rhs === this.rhs )
return this;
var r = new this.constructor(this.scope, lhs, rhs);
return r;
};
/**
* @constructor
* @extends {adapt.expr.Infix}
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
*/
adapt.expr.Logical = function(scope, lhs, rhs) {
adapt.expr.Infix.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Logical, adapt.expr.Infix);
/**
* @override
*/
adapt.expr.Logical.prototype.getPriority = function() {
return 1;
};
/**
* @constructor
* @extends {adapt.expr.Infix}
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
*/
adapt.expr.Comparison = function(scope, lhs, rhs) {
adapt.expr.Infix.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Comparison, adapt.expr.Infix);
/**
* @override
*/
adapt.expr.Comparison.prototype.getPriority = function() {
return 2;
};
/**
* @constructor
* @extends {adapt.expr.Infix}
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
*/
adapt.expr.Additive = function(scope, lhs, rhs) {
adapt.expr.Infix.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Additive, adapt.expr.Infix);
/**
* @override
*/
adapt.expr.Additive.prototype.getPriority = function() {
return 3;
};
/**
* @constructor
* @extends {adapt.expr.Infix}
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
*/
adapt.expr.Multiplicative = function(scope, lhs, rhs) {
adapt.expr.Infix.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Multiplicative, adapt.expr.Infix);
/**
* @override
*/
adapt.expr.Multiplicative.prototype.getPriority = function() {
return 4;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} val
* @extends {adapt.expr.Prefix}
*/
adapt.expr.Not = function(scope, val) {
adapt.expr.Prefix.call(this, scope, val);
};
goog.inherits(adapt.expr.Not, adapt.expr.Prefix);
/**
* @override
*/
adapt.expr.Not.prototype.getOp = function() {
return "!";
};
/**
* @override
*/
adapt.expr.Not.prototype.evalPrefix = function(val) {
return !val;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} val
* @extends {adapt.expr.Prefix}
*/
adapt.expr.Negate = function(scope, val) {
adapt.expr.Prefix.call(this, scope, val);
};
goog.inherits(adapt.expr.Negate, adapt.expr.Prefix);
/**
* @override
*/
adapt.expr.Negate.prototype.getOp = function() {
return "-";
};
/**
* @override
*/
adapt.expr.Negate.prototype.evalPrefix = function(val) {
return -val;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Logical}
*/
adapt.expr.And = function(scope, lhs, rhs) {
adapt.expr.Logical.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.And, adapt.expr.Logical);
/**
* @override
*/
adapt.expr.And.prototype.getOp = function() {
return "&&";
};
/**
* @override
*/
adapt.expr.And.prototype.evaluateCore = function(context) {
return this.lhs.evaluate(context) && this.rhs.evaluate(context);
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.And}
*/
adapt.expr.AndMedia = function(scope, lhs, rhs) {
adapt.expr.And.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.AndMedia, adapt.expr.And);
/**
* @override
*/
adapt.expr.AndMedia.prototype.getOp = function() {
return " and ";
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Logical}
*/
adapt.expr.Or = function(scope, lhs, rhs) {
adapt.expr.Logical.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Or, adapt.expr.Logical);
/**
* @override
*/
adapt.expr.Or.prototype.getOp = function() {
return "||";
};
/**
* @override
*/
adapt.expr.Or.prototype.evaluateCore = function(context) {
return this.lhs.evaluate(context) || this.rhs.evaluate(context);
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Or}
*/
adapt.expr.OrMedia = function(scope, lhs, rhs) {
adapt.expr.Or.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.OrMedia, adapt.expr.Or);
/**
* @override
*/
adapt.expr.OrMedia.prototype.getOp = function() {
return ", ";
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Lt = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Lt, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Lt.prototype.getOp = function() {
return "<";
};
/**
* @override
*/
adapt.expr.Lt.prototype.evalInfix = function(lhs, rhs) {
return lhs < rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Le = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Le, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Le.prototype.getOp = function() {
return "<=";
};
/**
* @override
*/
adapt.expr.Le.prototype.evalInfix = function(lhs, rhs) {
return lhs <= rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Gt = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Gt, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Gt.prototype.getOp = function() {
return ">";
};
/**
* @override
*/
adapt.expr.Gt.prototype.evalInfix = function(lhs, rhs) {
return lhs > rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Ge = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Ge, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Ge.prototype.getOp = function() {
return ">=";
};
/**
* @override
*/
adapt.expr.Ge.prototype.evalInfix = function(lhs, rhs) {
return lhs >= rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Eq = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Eq, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Eq.prototype.getOp = function() {
return "==";
};
/**
* @override
*/
adapt.expr.Eq.prototype.evalInfix = function(lhs, rhs) {
return lhs == rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Comparison}
*/
adapt.expr.Ne = function(scope, lhs, rhs) {
adapt.expr.Comparison.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Ne, adapt.expr.Comparison);
/**
* @override
*/
adapt.expr.Ne.prototype.getOp = function() {
return "!=";
};
/**
* @override
*/
adapt.expr.Ne.prototype.evalInfix = function(lhs, rhs) {
return lhs != rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Additive}
*/
adapt.expr.Add = function(scope, lhs, rhs) {
adapt.expr.Additive.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Add, adapt.expr.Additive);
/**
* @override
*/
adapt.expr.Add.prototype.getOp = function() {
return "+";
};
/**
* @override
*/
adapt.expr.Add.prototype.evalInfix = function(lhs, rhs) {
return lhs + rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Additive}
*/
adapt.expr.Subtract = function(scope, lhs, rhs) {
adapt.expr.Additive.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Subtract, adapt.expr.Additive);
/**
* @override
*/
adapt.expr.Subtract.prototype.getOp = function() {
return " - ";
};
/**
* @override
*/
adapt.expr.Subtract.prototype.evalInfix = function(lhs, rhs) {
return lhs - rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Multiplicative}
*/
adapt.expr.Multiply = function(scope, lhs, rhs) {
adapt.expr.Multiplicative.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Multiply, adapt.expr.Multiplicative);
/**
* @override
*/
adapt.expr.Multiply.prototype.getOp = function() {
return "*";
};
/**
* @override
*/
adapt.expr.Multiply.prototype.evalInfix = function(lhs, rhs) {
return lhs * rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Multiplicative}
*/
adapt.expr.Divide = function(scope, lhs, rhs) {
adapt.expr.Multiplicative.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Divide, adapt.expr.Multiplicative);
/**
* @override
*/
adapt.expr.Divide.prototype.getOp = function() {
return "/";
};
/**
* @override
*/
adapt.expr.Divide.prototype.evalInfix = function(lhs, rhs) {
return lhs / rhs;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} lhs
* @param {adapt.expr.Val} rhs
* @extends {adapt.expr.Multiplicative}
*/
adapt.expr.Modulo = function(scope, lhs, rhs) {
adapt.expr.Multiplicative.call(this, scope, lhs, rhs);
};
goog.inherits(adapt.expr.Modulo, adapt.expr.Multiplicative);
/**
* @override
*/
adapt.expr.Modulo.prototype.getOp = function() {
return "%";
};
/**
* @override
*/
adapt.expr.Modulo.prototype.evalInfix = function(lhs, rhs) {
return lhs % rhs;
};
/**
* Numerical value with a unit.
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {number} num
* @param {string} unit
* @extends {adapt.expr.Val}
*/
adapt.expr.Numeric = function(scope, num, unit) {
adapt.expr.Val.call(this, scope);
/** @type {number} */ this.num = num;
/** @type {string} */ this.unit = unit;
};
goog.inherits(adapt.expr.Numeric, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Numeric.prototype.appendTo = function(buf, priority) {
buf.append(this.num.toString());
buf.append(adapt.base.escapeCSSIdent(this.unit));
};
/**
* @override
*/
adapt.expr.Numeric.prototype.evaluateCore = function(context) {
return this.num * context.queryUnitSize(this.unit);
};
/**
* Named value.
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {string} qualifiedName CSS-escaped name sequence separated by dots.
* @extends {adapt.expr.Val}
*/
adapt.expr.Named = function(scope, qualifiedName) {
adapt.expr.Val.call(this, scope);
this.qualifiedName = qualifiedName;
};
goog.inherits(adapt.expr.Named, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Named.prototype.appendTo = function(buf, priority) {
buf.append(this.qualifiedName);
};
/**
* @override
*/
adapt.expr.Named.prototype.evaluateCore = function(context) {
return context.evalName(this.scope, this.qualifiedName).evaluate(context);
};
/**
* @override
*/
adapt.expr.Named.prototype.dependCore = function(other, context, dependencyCache) {
return other === this ||
context.evalName(this.scope, this.qualifiedName).dependOuter(other, context, dependencyCache);
};
/**
* Named value.
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {boolean} not
* @param {string} name
* @extends {adapt.expr.Val}
*/
adapt.expr.MediaName = function(scope, not, name) {
adapt.expr.Val.call(this, scope);
/** @type {boolean} */ this.not = not;
/** @type {string} */ this.name = name;
};
goog.inherits(adapt.expr.MediaName, adapt.expr.Val);
/**
* @override
*/
adapt.expr.MediaName.prototype.appendTo = function(buf, priority) {
if (this.not)
buf.append('not ');
buf.append(adapt.base.escapeCSSIdent(this.name));
};
/**
* @override
*/
adapt.expr.MediaName.prototype.evaluateCore = function(context) {
return true;
};
/**
* @override
*/
adapt.expr.MediaName.prototype.isMediaName = function() {
return true;
};
/**
* A value that is calculated by calling a JavaScript function. Note that the
* result is cached and this function will be called only once between any
* clears for its scope in the context.
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {function(this:adapt.expr.Context):adapt.expr.Result} fn function to call.
* @param {string} str a way to represent this value in toString() call.
* @extends {adapt.expr.Val}
*/
adapt.expr.Native = function(scope, fn, str) {
adapt.expr.Val.call(this, scope);
/**
* @type {function(this:adapt.expr.Context):adapt.expr.Result}
*/
this.fn = fn;
/** @type {string} */ this.str = str;
};
goog.inherits(adapt.expr.Native, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Native.prototype.appendTo = function(buf, priority) {
buf.append(this.str);
};
/**
* @override
*/
adapt.expr.Native.prototype.evaluateCore = function(context) {
return this.fn.call(context);
};
/**
* @param {adapt.base.StringBuffer} buf
* @param {Array.<adapt.expr.Val>} arr
* @return {void}
*/
adapt.expr.appendValArray = function(buf, arr) {
buf.append("(");
for (var i = 0 ; i < arr.length ; i++) {
if (i)
buf.append(",");
arr[i].appendTo(buf, 0);
}
buf.append(")");
};
/**
* @param {adapt.expr.Context} context
* @param {Array.<adapt.expr.Val>} arr
* @param {Array.<adapt.expr.Val>} params
* @return {Array.<adapt.expr.Val>}
*/
adapt.expr.expandValArray = function(context, arr, params) {
/** @type {Array.<adapt.expr.Val>} */ var expanded = arr;
for (var i = 0; i < arr.length; i++) {
var p = arr[i].expand(context, params);
if (arr !== expanded) {
expanded[i] = p;
} else if (p !== arr[i]) {
expanded = Array(arr.length);
for (var j = 0; j < i; j++) {
expanded[j] = arr[j];
}
expanded[i] = p;
}
}
return expanded;
};
/**
* @param {adapt.expr.Context} context
* @param {Array.<adapt.expr.Val>} arr
* @return {Array.<adapt.expr.Result>}
*/
adapt.expr.evalValArray = function(context, arr) {
/** @type {Array.<adapt.expr.Result>} */ var result = Array(arr.length);
for (var i = 0; i < arr.length; i++) {
result[i] = arr[i].evaluate(context);
}
return result;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {string} qualifiedName
* @param {Array.<adapt.expr.Val>} params
* @extends {adapt.expr.Val}
*/
adapt.expr.Call = function(scope, qualifiedName, params) {
adapt.expr.Val.call(this, scope);
/** @type {string} */ this.qualifiedName = qualifiedName;
/** @type {Array.<adapt.expr.Val>} */ this.params = params;
};
goog.inherits(adapt.expr.Call, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Call.prototype.appendTo = function(buf, priority) {
buf.append(this.qualifiedName);
adapt.expr.appendValArray(buf, this.params);
};
/**
* @override
*/
adapt.expr.Call.prototype.evaluateCore = function(context) {
var body = context.evalCall(this.scope, this.qualifiedName, this.params, false);
return body.expand(context, this.params).evaluate(context);
};
/**
* @override
*/
adapt.expr.Call.prototype.dependCore = function(other, context, dependencyCache) {
if (other === this)
return true;
for (var i = 0; i < this.params.length; i++) {
if (this.params[i].dependOuter(other, context, dependencyCache))
return true;
}
var body = context.evalCall(this.scope, this.qualifiedName, this.params, true);
// No expansion here!
return body.dependOuter(other, context, dependencyCache);
};
/**
* @override
*/
adapt.expr.Call.prototype.expand = function(context, params) {
var expandedParams = adapt.expr.expandValArray(context, this.params, params);
if (expandedParams === this.params)
return this;
return new adapt.expr.Call(this.scope, this.qualifiedName, expandedParams);
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} cond
* @param {adapt.expr.Val} ifTrue
* @param {adapt.expr.Val} ifFalse
* @extends {adapt.expr.Val}
*/
adapt.expr.Cond = function(scope, cond, ifTrue, ifFalse) {
adapt.expr.Val.call(this, scope);
/** @type {adapt.expr.Val} */ this.cond = cond;
/** @type {adapt.expr.Val} */ this.ifTrue = ifTrue;
/** @type {adapt.expr.Val} */ this.ifFalse = ifFalse;
};
goog.inherits(adapt.expr.Cond, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Cond.prototype.appendTo = function(buf, priority) {
if( priority > 0 )
buf.append("(");
this.cond.appendTo(buf, 0);
buf.append("?");
this.ifTrue.appendTo(buf, 0);
buf.append(":");
this.ifFalse.appendTo(buf, 0);
if( priority > 0 )
buf.append(")");
};
/**
* @override
*/
adapt.expr.Cond.prototype.evaluateCore = function(context) {
if (this.cond.evaluate(context))
return this.ifTrue.evaluate(context);
else
return this.ifFalse.evaluate(context);
};
/**
* @override
*/
adapt.expr.Cond.prototype.dependCore = function(other, context, dependencyCache) {
return other === this || this.cond.dependOuter(other, context, dependencyCache) ||
this.ifTrue.dependOuter(other, context, dependencyCache) || this.ifFalse.dependOuter(other, context, dependencyCache);
};
/**
* @override
*/
adapt.expr.Cond.prototype.expand = function(context, params) {
var cond = this.cond.expand(context, params);
var ifTrue = this.ifTrue.expand(context, params);
var ifFalse = this.ifFalse.expand(context, params);
if (cond === this.cond && ifTrue === this.ifTrue && ifFalse === this.ifFalse)
return this;
var r = new adapt.expr.Cond(this.scope, cond, ifTrue, ifFalse);
return r;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Result} val
* @extends {adapt.expr.Val}
*/
adapt.expr.Const = function(scope, val) {
adapt.expr.Val.call(this, scope);
this.val = val;
};
goog.inherits(adapt.expr.Const, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Const.prototype.appendTo = function(buf, priority) {
switch (typeof this.val) {
case "number":
case "boolean":
buf.append(this.val.toString());
break;
case "string":
buf.append('"');
buf.append(adapt.base.escapeCSSStr(this.val));
buf.append('"');
break;
default:
throw new Error("F_UNEXPECTED_STATE");
}
};
/**
* @override
*/
adapt.expr.Const.prototype.evaluateCore = function(context) {
return this.val;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.MediaName} name
* @param {adapt.expr.Val} value
* @extends {adapt.expr.Val}
*/
adapt.expr.MediaTest = function(scope, name, value) {
adapt.expr.Val.call(this, scope);
this.name = name;
this.value = value;
};
goog.inherits(adapt.expr.MediaTest, adapt.expr.Val);
/**
* @override
*/
adapt.expr.MediaTest.prototype.appendTo = function(buf, priority) {
buf.append('(');
buf.append(adapt.base.escapeCSSStr(this.name.name));
buf.append(':');
this.value.appendTo(buf, 0);
buf.append(')');
};
/**
* @override
*/
adapt.expr.MediaTest.prototype.evaluateCore = function(context) {
return context.evalMediaTest(this.name.name, this.value);
};
/**
* @override
*/
adapt.expr.MediaTest.prototype.dependCore = function(other, context, dependencyCache) {
return other === this || this.value.dependOuter(other, context, dependencyCache);
};
/**
* @override
*/
adapt.expr.MediaTest.prototype.expand = function(context, params) {
var value = this.value.expand(context, params);
if (value === this.value)
return this;
var r = new adapt.expr.MediaTest(this.scope, this.name, value);
return r;
};
/**
* @constructor
* @param {adapt.expr.LexicalScope} scope
* @param {number} index
* @extends {adapt.expr.Val}
*/
adapt.expr.Param = function(scope, index) {
adapt.expr.Val.call(this, scope);
this.index = index;
};
goog.inherits(adapt.expr.Param, adapt.expr.Val);
/**
* @override
*/
adapt.expr.Param.prototype.appendTo = function(buf, priority) {
buf.append("$");
buf.append(this.index.toString());
};
/**
* @override
*/
adapt.expr.Param.prototype.expand = function(context, params) {
var v = params[this.index];
if (!v)
throw new Error("Parameter missing: " + this.index);
return /** @type {adapt.expr.Val} */ (v);
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} v1
* @param {adapt.expr.Val} v2
* @return {adapt.expr.Val}
*/
adapt.expr.and = function(scope, v1, v2) {
if (v1 === scope._false || v1 === scope.zero ||
v2 == scope._false || v2 == scope.zero)
return scope._false;
if (v1 === scope._true || v1 === scope.one)
return v2;
if (v2 === scope._true || v2 === scope.one)
return v1;
return new adapt.expr.And(scope, v1, v2);
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} v1
* @param {adapt.expr.Val} v2
* @return {adapt.expr.Val}
*/
adapt.expr.add = function(scope, v1, v2) {
if (v1 === scope.zero)
return v2;
if (v2 === scope.zero)
return v1;
return new adapt.expr.Add(scope, v1, v2);
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} v1
* @param {adapt.expr.Val} v2
* @return {adapt.expr.Val}
*/
adapt.expr.sub = function(scope, v1, v2) {
if (v1 === scope.zero)
return new adapt.expr.Negate(scope, v2);
if (v2 === scope.zero)
return v1;
return new adapt.expr.Subtract(scope, v1, v2);
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} v1
* @param {adapt.expr.Val} v2
* @return {adapt.expr.Val}
*/
adapt.expr.mul = function(scope, v1, v2) {
if (v1 === scope.zero || v2 === scope.zero)
return scope.zero;
if (v1 === scope.one)
return v2;
if (v2 === scope.one)
return v1;
return new adapt.expr.Multiply(scope, v1, v2);
};
/**
* @param {adapt.expr.LexicalScope} scope
* @param {adapt.expr.Val} v1
* @param {adapt.expr.Val} v2
* @return {adapt.expr.Val}
*/
adapt.expr.div = function(scope, v1, v2) {
if (v1 === scope.zero)
return scope.zero;
if (v2 === scope.one)
return v1;
return new adapt.expr.Divide(scope, v1, v2);
};
|
body {
margin: 0;
padding: 0;
font-family: 'BenchNine', sans-serif;
}
li {
list-style: none;
}
a:hover,
a:visited,
a {
text-decoration: none;
}
h1,
h2 {
text-transform: uppercase;
font-weight: bold;
}
/*header area*/
.top-header {
background: #fff !important;
position: fixed;
width: 100%;
z-index: 99999;
}
.header-backup {
width: 20px;
height: 119px;
background: transparent;
margin: auto;
}
.top-header img.logo {
margin-bottom: 25px;
margin-top: -15px;
transition: all .5s ease 0s;
-webkit-transition: all .5s ease 0s;
-moz-transition: all .5s ease 0s;
-o-transition: all .5s ease 0s;
-ms-transition: all .5s ease 0s;
}
.navbar-default {
background-color: transparent;
border-color: transparent;
margin-bottom: 0;
margin-top: 8px;
transition: all .5s ease 0s;
-webkit-transition: all .5s ease 0s;
-moz-transition: all .5s ease 0s;
-o-transition: all .5s ease 0s;
-ms-transition: all .5s ease 0s;
}
.nav-bar {
margin-top: 29px;
}
.navbar-toggle span {
color: #fff;
}
ul.nav {
margin: 0;
padding: 0;
}
.navbar-default .navbar-nav>li>a {
font-size: 24px;
color: #737373;
text-transform: uppercase;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
padding: 14px 15px;
font-weight: bold;
}
.navbar-default .navbar-nav>li>a:hover {
color: #42b3e5;
}
.navbar-default .navbar-toggle .icon-bar {
background-color: #000;
}
li a.active {
color: #42b3e5 !important;
}
.navbar-default .navbar-toggle {
border-color: #fff;
margin-top: 4px;
}
/*slider area*/
.slider-row {
margin: 0;
padding: 0;
}
.slider-wrapper {
margin: 0;
padding: 0 !important;
background: #000 !important;
}
.carousel-caption h1 {
font-size: 157px;
color: #fff;
text-transform: uppercase;
margin-bottom: 0;
}
.carousel-caption p {
font-size: 40px;
color: #fff;
text-transform: uppercase;
font-weight: bold;
margin-top: 0;
}
.carousel-caption button {
width: 240px;
height: 60px;
background: #3a9ecb;
color: #fff;
font-size: 30px;
text-transform: uppercase;
border: 0;
transition: all .5s ease 0s;
-webkit-transition: all .5s ease 0s;
-moz-transition: all .5s ease 0s;
-o-transition: all .5s ease 0s;
-ms-transition: all .5s ease 0s;
}
.carousel-caption button:hover {
background: #2a2a2a;
}
.carousel-control {
width: 5%;
}
.carousel-inner {
background: -<API key>(left, #000, blue);
/* For Safari 5.1 to 6.0 */
background: -o-linear-gradient(left, #000, blue);
/* For Opera 11.1 to 12.0 */
background: -moz-linear-gradient(left, #000, blue);
/* For Firefox 3.6 to 15 */
background: linear-gradient(to left, #000, blue);
/* Standard syntax */
}
.item {
position: relative;
}
.carousel-caption {
position: absolute;
text-align: left;
left: 12%;
line-height: 1;
top: 50%;
margin-top: -100px;
}
.carousel-control .<API key>,
.carousel-control .icon-prev {
font-size: 18px;
padding: 5px;
background: #fff;
border-radius: 50%;
color: transparent;
margin-left: 0;
margin-top: 50px;
}
.carousel-control .<API key>,
.carousel-control .icon-next {
font-size: 18px;
padding: 5px;
background: #fff;
border-radius: 50%;
color: transparent;
margin-right: 0;
margin-top: 50px;
}
/*about area*/
.about h2 {
font-size: 90px;
color: #42b3e5;
margin-top: 50px;
}
.about h4 {
font-size: 24px;
color: #737373;
margin-bottom: 45px;
}
.about-img img {
width: 100%;
}
.single-about-detail {
position: relative;
}
.pentagon-text h1 {
font-size: 60px;
color: #383838;
margin-top: 0;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
position: absolute;
left: 15%;
width: 50px;
top: -6%;
}
.pentagon-text {
width: 70px;
height: 52px;
background: #fff;
position: relative;
top: -30px;
left: 43%;
}
.pentagon-text:before {
content: "";
position: absolute;
top: -15px;
left: 0;
width: 0;
height: 0;
border-left: 34px solid transparent;
border-right: 35px solid transparent;
border-bottom: 15px solid #fff;
}
.pentagon-text:after {
content: "";
position: absolute;
bottom: -15px;
left: 0;
width: 0;
height: 0px;
border-left: 36px solid transparent;
border-right: 34px solid transparent;
border-top: 15px solid #fff;
}
.about-details {
background: #2a2a2a;
border-top: 2px solid #fff;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
}
.about-details h3 {
font-size: 36px;
color: #fff;
margin-top: 0;
}
.about-details p {
font-size: 13px;
color: #fff;
font-family: 'Open Sans', sans-serif;
padding: 0 25px;
padding-bottom: 30px;
}
.single-about-detail:hover .about-details {
background: #3a9dca;
}
.single-about-detail:hover .pentagon-text h1 {
color: #3a9dca;
}
/*service area*/
.service {
background: url(../img/pattern.jpg);
background-repeat: repeat-y;
margin-top: 40px;
}
.service h2 {
font-size: 90px;
color: #fff;
margin-top: 70px;
margin-bottom: 0;
}
.service h4 {
font-size: 24px;
color: #fff;
margin-top: 0;
margin-bottom: 70px;
display: block;
}
.single-service-img {
width: 205px;
height: 125px;
background: #fff;
position: relative;
left: 50%;
margin-left: -100px;
}
.single-service-img:before {
content: "";
position: absolute;
top: -42px;
left: 0;
width: 0;
height: 0;
border-left: 102px solid transparent;
border-right: 104px solid transparent;
border-bottom: 42px solid #fff;
}
.single-service-img:after {
content: "";
position: absolute;
bottom: -42px;
left: 0;
width: 0;
height: 0;
border-left: 102px solid transparent;
border-right: 102px solid transparent;
border-top: 42px solid #fff;
z-index: 10;
}
.service-img {
width: 200px;
height: 123px;
background: #3a9ecb;
position: relative;
top: 1px;
left: 2px;
}
.service-img:before {
content: "";
position: absolute;
top: -40px;
left: 0;
width: 0;
height: 0;
border-left: 100px solid transparent;
border-right: 100px solid transparent;
border-bottom: 40px solid #3a9ecb;
}
.service-img:after {
content: "";
position: absolute;
bottom: -39px;
left: 0;
width: 0;
height: 0;
border-left: 100px solid transparent;
border-right: 100px solid transparent;
border-top: 40px solid #3a9ecb;
z-index: 999;
}
.single-service h3 {
margin-top: 60px;
color: #fff;
padding-bottom: 90px;
}
.service-img img.heart {
left: 20%;
top: 18%;
}
.service-img img.brain {
left: 26%;
top: 11%;
}
.service-img img.knee {
left: 38%;
}
.service-img img.bone {
left: 25%;
top: 14%;
}
.service-img img {
position: absolute;
}
/*team section*/
.team {
padding-bottom: 60px;
}
.team h2 {
font-size: 90px;
color: #42b3e5;
margin-top: 50px;
margin-bottom: 0;
}
.team h4 {
font-size: 24px;
color: #737373;
margin-top: 0;
margin-bottom: 45px;
}
.single-member {
margin: 0;
padding: 0;
}
.person img {
width: 100%;
}
.person-detail {
padding: 10px;
background: #3a9cc8;
position: relative;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
}
.arrow-top {
position: absolute;
width: 20px;
height: 20px;
background: #3ba0cc;
transform: rotate(45deg);
-webkit-transform: rotate(45deg);
-moz-transform: rotate(45deg);
-o-transform: rotate(45deg);
-ms-transform: rotate(45deg);
bottom: -10px;
left: 46%;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
}
.arrow-bottom {
position: absolute;
width: 20px;
height: 20px;
background: #3ba0cc;
transform: rotate(45deg);
-webkit-transform: rotate(45deg);
-moz-transform: rotate(45deg);
-o-transform: rotate(45deg);
-ms-transform: rotate(45deg);
top: -9px;
left: 46%;
transition: all .7s ease 0s;
-webkit-transition: all .7s ease 0s;
-moz-transition: all .7s ease 0s;
-o-transition: all .7s ease 0s;
-ms-transition: all .7s ease 0s;
}
.person-detail h3 {
font-size: 30px;
color: #fff;
}
.person-detail p {
font-size: 13px;
color: #fff;
font-family: 'Open Sans', sans-serif;
}
.single-member:hover .person-detail {
background: #2a2a2a;
}
.single-member:hover .arrow-top {
background: #2a2a2a;
}
.single-member:hover .arrow-bottom {
background: #2a2a2a;
}
/*contact section*/
.contact-caption {
background: #3a9dca;
}
.contact-heading h2 {
color: #fff;
font-size: 90px;
}
.contact-info {
padding-left: 40px;
}
.contact-info h3 {
padding-left: 0;
font-size: 30px;
color: #fff;
text-transform: uppercase;
font-weight: bold;
border-bottom: 1px solid #13849c;
padding-bottom: 12px;
margin-bottom: 0;
}
.contact-form h3 {
padding-left: 0;
font-size: 30px;
color: #fff;
text-transform: uppercase;
font-weight: bold;
border-bottom: 1px solid #13849c;
padding-bottom: 12px;
margin-bottom: 0;
}
.contact-info ul {
margin: 0;
padding: 0;
}
.contact-info ul li {
font-family: 'Open Sans', sans-serif;
font-size: 14px;
color: #fff;
}
.contact-info i.fa {
font-size: 16px;
padding-right: 12px;
width: 25px;
height: 38px;
}
.contact-info ul li span {
font-weight: bold;
}
.contact-form input {
width: 100%;
height: 40px;
background: #fff;
font-size: 13px;
color: #084a5c;
font-family: 'Open Sans', sans-serif;
padding: 12px;
border: 0;
margin-bottom: 12px;
}
.contact-form textarea {
font-family: 'Open Sans', sans-serif;
padding: 12px;
width: 100%;
height: 140px;
border: 0;
margin-bottom: 12px;
}
.info-detail {
border-top: 1px solid #53cde5;
padding-top: 15px;
}
.form {
border-top: 1px solid #53cde5;
padding-top: 15px;
text-align: right;
}
.contact-form input.submit-btn {
width: 180px;
height: 50px;
float: right;
font-size: 24px;
color: #fff;
background: url(../img/btn-bg.jpg);
background-repeat: no-repeat;
padding: 0;
font-family: 'BenchNine', sans-serif;
font-weight: bold;
}
.contact-form {
padding-right: 40px;
}
/*gmap*/
#map {
height: 830px;
}
.map {
position: relative;
overflow: hidden;
}
.contact {
position: absolute;
width: 100%;
height: 830px;
margin-top: 0px;
left: 0;
margin-top: -830px;
background: rgba(0, 0, 0, 0.51);
}
.contact-caption {
margin-top: 120px;
}
/*footer*/
.footer-para {
margin: 0;
padding: 0;
}
.footer p {
font-size: 12px;
color: #000;
font-family: 'Open Sans', sans-serif;
font-weight: 300;
margin: 0;
padding: 25px 0;
}
.footer a i.fa {
font-size: 24px;
color: #b1b1b1;
padding: 22px 10px;
}
.footer a i.fa:hover {
color: #42b3e5;
}
.carousel-inner {
position: relative;
}
.carousel-fade .carousel-inner .item {
opacity: 0;
transition-property: opacity;
}
.carousel-fade .carousel-inner .active {
opacity: 1;
}
.carousel-fade .carousel-inner .active.left,
.carousel-fade .carousel-inner .active.right {
left: 0;
opacity: 0;
z-index: 1;
}
.carousel-fade .carousel-inner .next.left,
.carousel-fade .carousel-inner .prev.right {
opacity: 1;
}
.carousel-fade .carousel-control {
z-index: 2;
opacity: 1;
background-image: linear-gradient(to right, rgba(0, 0, 0, .0001) 0, rgba(0, 0, 0, 0) 100%);
}
@media all and (transform-3d),
(-webkit-transform-3d) {
.carousel-fade .carousel-inner > .item.next,
.carousel-fade .carousel-inner > .item.active.right {
opacity: 0;
-webkit-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
.carousel-fade .carousel-inner > .item.prev,
.carousel-fade .carousel-inner > .item.active.left {
opacity: 0;
-webkit-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
.carousel-fade .carousel-inner > .item.next.left,
.carousel-fade .carousel-inner > .item.prev.right,
.carousel-fade .carousel-inner > .item.active {
opacity: 1;
-webkit-transform: translate3d(0, 0, 0);
transform: translate3d(0, 0, 0);
}
}
/* just for demo purpose */
html,
body,
.carousel,
.carousel-inner,
.carousel-inner .item {
height: 100%;
}
@media (min-width: 992px) and (max-width: 1199px) {
.navbar-default .navbar-nav>li>a {
font-size: 20px;
padding: 14px 12px;
}
.carousel-caption h1 {
font-size: 120px;
}
.carousel-caption p {
font-size: 32px;
}
.carousel-caption button {
width: 215px;
height: 55px;
font-size: 26px;
}
h2 {
font-size: 75px !important;
}
h4 {
font-size: 22px !important;
}
.person-detail h3 {
font-size: 26px;
}
.person-detail p {
font-size: 12px;
}
}
@media (min-width: 768px) and (max-width: 991px) {
.navbar-default .navbar-nav>li>a {
font-size: 16px;
padding: 10px 8px;
}
.carousel-caption h1 {
font-size: 90px;
}
.carousel-caption p {
font-size: 30px;
}
.carousel-caption button {
width: 180px;
height: 50px;
background: #3a9ecb;
color: #fff;
font-size: 22px;
}
h2 {
font-size: 70px !important;
}
h4 {
font-size: 18px !important;
}
#map {
height: 1050px;
}
.contact {
margin-top: -1050px;
height: 1050px;
}
.contact-caption {
margin-top: 110px;
}
}
@media (min-width: 480px) and (max-width: 767px) {
.header-logo img {
margin-top: 20px;
}
.navbar-default .navbar-nav>li>a {
font-size: 20px;
}
.carousel-caption {
margin-top: -110px;
}
.carousel-caption h1 {
font-size: 75px;
}
.carousel-caption p {
font-size: 25px;
}
.carousel-caption button {
width: 160px;
height: 40px;
font-size: 20px;
}
#map {
height: 1120px;
}
.contact {
height: 1120px;
margin-top: -1120px;
}
h2 {
font-size: 70px !important;
}
h4 {
font-size: 21px !important;
}
.contact-info ul {
margin-left: 4px;
}
.contact-info i.fa {
width: 25px;
}
.contact-caption {
margin-top: 140px;
}
}
/* XS Portrait */
@media (max-width: 479px) {
.top-header img.logo {
margin: 20px 10px;
}
.header-logo {
margin-top: 20px !important;
}
.navbar-default .navbar-toggle {
border-color: #fff;
margin-top: -7px;
right: 10%;
}
.navbar-default .navbar-nav>li>a {
font-size: 16px;
text-align: left;
}
.header-backup {
height: 80px;
}
.carousel-caption {
margin-top: -60px;
}
.carousel-caption h1 {
font-size: 20px;
}
.carousel-caption p {
font-size: 12px;
}
.carousel-caption button {
width: 90px;
height: 23px;
font-size: 16px;
}
.carousel-control .<API key>,
.carousel-control .icon-next {
margin-top: 30px;
}
.carousel-control .<API key>,
.carousel-control .icon-prev {
margin-top: 30px;
}
.about h2 {
font-size: 50px;
color: #42b3e5;
margin-top: 30px;
}
.service h2 {
font-size: 50px;
margin-top: 40px;
}
.team h2 {
font-size: 50px;
margin-top: 40px;
}
h4 {
font-size: 18px !important;
}
.contact-caption {
margin-top: 38%;
}
#map {
height: 950px;
}
.contact {
height: 950px;
margin-top: -950px;
}
.contact-heading h2 {
font-size: 50px;
text-align: left;
margin-left: 15px;
}
.contact-info h3 {
margin-left: 8px;
font-size: 25px;
padding-bottom: 8px;
}
.info-detail {
margin-left: 8px;
}
.contact-info ul li {
font-size: 10px;
}
.contact-info i.fa {
font-size: 13px;
width: 20px;
height: 18px;
}
.contact-info,
.contact-form {
padding: 10px;
}
.contact-form h3 {
font-size: 25px;
padding-bottom: 8px;
margin-bottom: 0;
margin-right: 0px;
}
.footer a i.fa {
font-size: 18px;
padding: 25px 7px;
}
.footer p {
font-size: 10px;
}
}
|
package marubinotto.piggydb.ui.page.partial;
import marubinotto.piggydb.ui.page.LoginPage;
import marubinotto.piggydb.ui.page.common.AbstractMainUiHtml;
import marubinotto.util.message.CodedException;
public abstract class AbstractPartial extends AbstractMainUiHtml {
public String error;
public boolean hasErrors() {
return this.error != null;
}
@Override
public void setRedirect(String location) {
if (location.startsWith(getContext().getPagePath(LoginPage.class))) {
this.error = getMessage("session-expired");
}
addModel("hasErrors", hasErrors()); // for onRender won't be called
}
@Override
public String getRedirect() {
// Disable redirect
return null;
}
@Override
public void onRender() {
try {
super.onRender();
}
catch (CodedException e) {
this.error = getMessage(e);
}
catch (Exception e) {
this.error = e.toString();
getLogger().error("Unexpected exception", e);
}
addModel("hasErrors", hasErrors());
<API key>();
}
}
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<div ng-include="headerInclude"></div>
<div ng-controller="Apiman.<API key>" class="container page" data-field="page" ng-cloak="" ng-show="pageState == 'loaded'">
<div ng-include="'plugins/api-manager/html/plan/plan_bc.include'"></div>
<!-- Entity Summary Row -->
<div ng-include="'plugins/api-manager/html/plan/plan_entity.include'"></div>
<!-- Navigation + Content Row -->
<div class="row">
<!-- Left hand nav -->
<div ng-include="'plugins/api-manager/html/plan/plan_tabs.include'"></div>
<!-- /Left hand nav -->
<!-- Content -->
<div class="col-md-10 <API key> <API key>" >
<div class="col-md-9">
<!-- Title and help text -->
<div class="title" apiman-i18n-key="plan-policies">Plan Policies</div>
<div class="description" apiman-i18n-key="plan-policies-help">Here is a list of all Policies defined for this Plan. These Policies will be applied to all API invocations made by Client Apps using this Plan in a Contract (in addition to whatever Policies are defined individually by the Client App and/or API).</div>
<hr />
<!-- The list of policies -->
<div apiman-permission="planEdit" apiman-status="Created,Ready" class="apiman-filters <API key>">
<a apiman-i18n-key="add-policy" href="{{ pluginName }}/orgs/{{ org.id }}/plans/{{ plan.id }}/{{ version.version }}/new-policy" class="btn btn-primary pull-right">Add Policy</a>
</div>
<div class="clearfix"></div>
<div class="apiman-policies" data-field="policies">
<div class="apiman-no-content container-fluid" ng-hide="policies.length > 0">
<div class="row">
<div class="col-md-9">
<p class="<API key>" apiman-i18n-key="<API key>">It looks like there aren't any policies defined! That may be exactly what you want (of course) but if not, you may try defining one using the Add Policy button above...</p>
</div>
<div apiman-permission="planEdit" apiman-status="Created,Ready" class="col-md-3">
<div class="<API key>"></div>
</div>
</div>
</div>
<div class="clearfix"></div>
<apiman-policy-list ng-model="policies" remove-function="removePolicy" reorder-function="reorderPolicies" type="plans" org-id="{{ org.id }}" page-id="{{ plan.id }}" version="{{ version.version }}"></policy-list>
</div>
</div>
</div>
<!-- /Content -->
</div>
</div> <!-- /container -->
</body>
</html>
|
#!/bin/bash
# Update the DNS server with a record for this host
set -eu
set -x
set -o pipefail
DNS_UPDATE_KEY="%DNS_UPDATE_KEY%"
if [ -z "$DNS_UPDATE_KEY" ]; then
echo "Skipping the DNS update because the key is empty."
exit
fi
if yum info python-dns; then
retry yum -y install python-dns
else
retry yum -y install python2-dns
fi
NAME="%DNS_ENTRY%"
# If we didn't get an explicit name, use this server's hostname
if [ -n "$NAME" -a "${NAME:0:1}" = "%" -a "${NAME: -1}" = "%" ]; then
NAME="$(hostname)"
fi
# NOTE: the dot after the hostname is necessary
/usr/local/bin/update_dns -z "%ZONE%" -s "%DNS_SERVER%" -k "$DNS_UPDATE_KEY" "$NAME." "%IP_ADDRESS%"
|
function plot_histogram(){
var dataset = [];
var myData = JSON.parse(JSON_DATA_GLOBAL);
// Load dataset
for (var key in myData) {
if (myData.hasOwnProperty(key)) {
if(myData[key].calories != null){
dataset.push(parseInt(myData[key].calories));
}
}
}
// A formatter for counts.
var formatCount = d3.format(",.0f");
var margin = {top: 10, right: 30, bottom: 30, left: 30},
width = CHART_WIDTH - margin.left - margin.right,
height = CHART_HEIGHT - margin.top - margin.bottom;
var max = d3.max(dataset, function(d){
return d;
});
var x = d3.scale.linear()
.domain([0, max])
.range([0,width]);
// Generate a histogram using twenty uniformly-spaced bins.
var data = d3.layout.histogram()
.bins(x.ticks(HISTOGRAM_BINS))
(dataset);
var y = d3.scale.linear()
.domain([0, d3.max(data, function(d) { return d.y; })])
.range([height, 0]);
var xAxis = d3.svg.axis()
.scale(x)
.orient("bottom");
var svg = d3.select("#chart").append("svg")
.attr("width", width + margin.left + margin.right)
.attr("height", height + margin.top + margin.bottom)
.append("g")
.attr("transform", "translate(" + margin.left + "," + margin.top + ")");
var bar = svg.selectAll(".bar")
.data(data)
.enter().append("g")
.attr("class", "bar")
.attr("transform", function(d) { return "translate(" + x(d.x) + "," + y(d.y) + ")"; });
bar.append("rect")
.attr("x", 1)
.attr("width", x(data[0].dx) - 1)
.attr("height", function(d) { return height - y(d.y); })
.style("fill", HISTOGRAM_FILL);
bar.append("text")
.attr("dy", ".75em")
.attr("y", 6)
.attr("x", x(data[0].dx) / 2)
.attr("text-anchor", "middle")
.text(function(d) { return formatCount(d.y); });
svg.append("g")
.attr("class", "x axis")
.attr("transform", "translate(0," + height + ")")
.call(xAxis);
}
|
package gov.va.escreening.form;
import java.io.Serializable;
public class VistaTestFormBean implements Serializable {
private static final long serialVersionUID = 1L;
private String lastFourSsn;
private String firstName;
private String middleName;
private String lastName;
private String searchString;
private String ien;
private String selectedRpcId;
private String clinicalReminderIen;
private String dialogElementIen;
public String getLastFourSsn() {
return lastFourSsn;
}
public void setLastFourSsn(String lastFourSsn) {
this.lastFourSsn = lastFourSsn;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getMiddleName() {
return middleName;
}
public void setMiddleName(String middleName) {
this.middleName = middleName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getSearchString() {
return searchString;
}
public void setSearchString(String searchString) {
this.searchString = searchString;
}
public String getIen() {
return ien;
}
public void setIen(String ien) {
this.ien = ien;
}
public String getSelectedRpcId() {
return selectedRpcId;
}
public void setSelectedRpcId(String selectedRpcId) {
this.selectedRpcId = selectedRpcId;
}
public String <API key>() {
return clinicalReminderIen;
}
public void <API key>(String clinicalReminderIen) {
this.clinicalReminderIen = clinicalReminderIen;
}
public String getDialogElementIen() {
return dialogElementIen;
}
public void setDialogElementIen(String dialogElementIen) {
this.dialogElementIen = dialogElementIen;
}
public VistaTestFormBean() {
}
}
|
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.3 in JDK 1.6
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2011.10.20 at 11:04:04 AM BST
package org.openehr.schemas.v1;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "C_DV_ORDINAL", propOrder = {
"assumedValue",
"list"
})
public class CDVORDINAL
extends CDOMAINTYPE
{
@XmlElement(name = "assumed_value")
protected DVORDINAL assumedValue;
protected List<DVORDINAL> list;
/**
* Gets the value of the assumedValue property.
*
* @return
* possible object is
* {@link DVORDINAL }
*
*/
public DVORDINAL getAssumedValue() {
return assumedValue;
}
/**
* Sets the value of the assumedValue property.
*
* @param value
* allowed object is
* {@link DVORDINAL }
*
*/
public void setAssumedValue(DVORDINAL value) {
this.assumedValue = value;
}
/**
* Gets the value of the list property.
*
* <p>
* This accessor method returns a reference to the live list,
* not a snapshot. Therefore any modification you make to the
* returned list will be present inside the JAXB object.
* This is why there is not a <CODE>set</CODE> method for the list property.
*
* <p>
* For example, to add a new item, do as follows:
* <pre>
* getList().add(newItem);
* </pre>
*
*
* <p>
* Objects of the following type(s) are allowed in the list
* {@link DVORDINAL }
*
*
*/
public List<DVORDINAL> getList() {
if (list == null) {
list = new ArrayList<DVORDINAL>();
}
return this.list;
}
}
|
package org.hamster.weixinmp.dao.entity.item;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hamster.weixinmp.config.WxConfig;
import org.hamster.weixinmp.dao.entity.base.<API key>;
/**
* @author honey.zhao@aliyun.com
* @version Dec 29, 2013
*
*/
@Entity
@Table(name = WxConfig.TABLE_PREFIX + "item_video")
public class WxItemVideoEntity extends <API key> {
@Column(name = "media_id", length = WxConfig.COL_LEN_INDICATOR, nullable = true)
private String mediaId;
@Column(name = "title", length = WxConfig.COL_LEN_TITLE, nullable = true)
private String title;
@Column(name = "description", length = WxConfig.COL_LEN_CONTENT, nullable = true)
private String description;
@ManyToOne
@JoinColumn(name = "thumb_id", nullable = true)
WxItemThumbEntity thumb;
public String getMediaId() {
return mediaId;
}
public void setMediaId(String mediaId) {
this.mediaId = mediaId;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public WxItemThumbEntity getThumb() {
return thumb;
}
public void setThumb(WxItemThumbEntity thumb) {
this.thumb = thumb;
}
public WxItemVideoEntity() {
super();
// TODO Auto-generated constructor stub
}
public WxItemVideoEntity(String mediaId, String title, String description,
WxItemThumbEntity thumb) {
super();
this.mediaId = mediaId;
this.title = title;
this.description = description;
this.thumb = thumb;
}
@Override
public String toString() {
return "WxItemVideoEntity [mediaId=" + mediaId + ", title=" + title
+ ", description=" + description + ", thumb=" + thumb + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result
+ ((description == null) ? 0 : description.hashCode());
result = prime * result + ((mediaId == null) ? 0 : mediaId.hashCode());
result = prime * result + ((thumb == null) ? 0 : thumb.hashCode());
result = prime * result + ((title == null) ? 0 : title.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
WxItemVideoEntity other = (WxItemVideoEntity) obj;
if (description == null) {
if (other.description != null)
return false;
} else if (!description.equals(other.description))
return false;
if (mediaId == null) {
if (other.mediaId != null)
return false;
} else if (!mediaId.equals(other.mediaId))
return false;
if (thumb == null) {
if (other.thumb != null)
return false;
} else if (!thumb.equals(other.thumb))
return false;
if (title == null) {
if (other.title != null)
return false;
} else if (!title.equals(other.title))
return false;
return true;
}
}
|
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.25.0
// protoc v3.14.0
// source: envoy/config/route/v3/route_components.proto
package <API key>
import (
_ "github.com/cncf/xds/go/udpa/annotations"
_ "github.com/envoyproxy/go-control-plane/envoy/annotations"
v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
v31 "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3"
v34 "github.com/envoyproxy/go-control-plane/envoy/type/metadata/v3"
v33 "github.com/envoyproxy/go-control-plane/envoy/type/tracing/v3"
v32 "github.com/envoyproxy/go-control-plane/envoy/type/v3"
_ "github.com/envoyproxy/protoc-gen-validate/validate"
proto "github.com/golang/protobuf/proto"
any "github.com/golang/protobuf/ptypes/any"
duration "github.com/golang/protobuf/ptypes/duration"
_struct "github.com/golang/protobuf/ptypes/struct"
wrappers "github.com/golang/protobuf/ptypes/wrappers"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.<API key>
type <API key> int32
const (
// No TLS requirement for the virtual host.
VirtualHost_NONE <API key> = 0
// External requests must use TLS. If a request is external and it is not
// using TLS, a 301 redirect will be sent telling the client to use HTTPS.
<API key> <API key> = 1
// All requests must use TLS. If a request is not using TLS, a 301 redirect
// will be sent telling the client to use HTTPS.
VirtualHost_ALL <API key> = 2
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "NONE",
1: "EXTERNAL_ONLY",
2: "ALL",
}
<API key> = map[string]int32{
"NONE": 0,
"EXTERNAL_ONLY": 1,
"ALL": 2,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[0].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[0]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{0, 0}
}
type <API key> int32
const (
// HTTP status code - 503 Service Unavailable.
<API key> <API key> = 0
// HTTP status code - 404 Not Found.
<API key> <API key> = 1
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "SERVICE_UNAVAILABLE",
1: "NOT_FOUND",
}
<API key> = map[string]int32{
"SERVICE_UNAVAILABLE": 0,
"NOT_FOUND": 1,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[1].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[1]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{6, 0}
}
// Configures :ref:`internal redirect <<API key>>` behavior.
// [
// Deprecated: Do not use.
type <API key> int32
const (
<API key> <API key> = 0
<API key> <API key> = 1
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "<API key>",
1: "<API key>",
}
<API key> = map[string]int32{
"<API key>": 0,
"<API key>": 1,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[2].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[2]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{6, 1}
}
type <API key> int32
const (
RetryPolicy_SECONDS <API key> = 0
<API key> <API key> = 1
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "SECONDS",
1: "UNIX_TIMESTAMP",
}
<API key> = map[string]int32{
"SECONDS": 0,
"UNIX_TIMESTAMP": 1,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[3].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[3]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{7, 0}
}
type <API key> int32
const (
// Moved Permanently HTTP Status Code - 301.
<API key> <API key> = 0
// Found HTTP Status Code - 302.
<API key> <API key> = 1
// See Other HTTP Status Code - 303.
<API key> <API key> = 2
// Temporary Redirect HTTP Status Code - 307.
<API key> <API key> = 3
// Permanent Redirect HTTP Status Code - 308.
<API key> <API key> = 4
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "MOVED_PERMANENTLY",
1: "FOUND",
2: "SEE_OTHER",
3: "TEMPORARY_REDIRECT",
4: "PERMANENT_REDIRECT",
}
<API key> = map[string]int32{
"MOVED_PERMANENTLY": 0,
"FOUND": 1,
"SEE_OTHER": 2,
"TEMPORARY_REDIRECT": 3,
"PERMANENT_REDIRECT": 4,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[4].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[4]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{9, 0}
}
type <API key> int32
const (
// Query :ref:`dynamic metadata <<API key>>`
<API key> <API key> = 0
// Query :ref:`route entry metadata <<API key>.route.v3.Route.metadata>`
<API key> <API key> = 1
)
// Enum value maps for <API key>.
var (
<API key> = map[int32]string{
0: "DYNAMIC",
1: "ROUTE_ENTRY",
}
<API key> = map[string]int32{
"DYNAMIC": 0,
"ROUTE_ENTRY": 1,
}
)
func (x <API key>) Enum() *<API key> {
p := new(<API key>)
*p = x
return p
}
func (x <API key>) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (<API key>) Descriptor() protoreflect.EnumDescriptor {
return <API key>[5].Descriptor()
}
func (<API key>) Type() protoreflect.EnumType {
return &<API key>[5]
}
func (x <API key>) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use <API key>.Descriptor instead.
func (<API key>) EnumDescriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 7, 0}
}
// The top level element in the routing configuration is a virtual host. Each virtual host has
// a logical name as well as a set of domains that get routed to it based on the incoming request's
// host header. This allows a single listener to service multiple top level domain path trees. Once
// a virtual host is selected based on the domain, the routes are processed in order to see which
// upstream cluster to route to or whether to perform a redirect.
// [#next-free-field: 21]
type VirtualHost struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The logical name of the virtual host. This is used when emitting certain
// statistics but is not relevant for routing.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// A list of domains (host/authority header) that will be matched to this
// virtual host. Wildcard hosts are supported in the suffix or prefix form.
// Domain search order:
// 2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
// 3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
// 4. Special wildcard ``*`` matching any domain.
// .. note::
// The wildcard will not match the empty string.
// e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not ``-bar.foo.com``.
// The longest wildcards match first.
// Only a single virtual host in the entire route configuration can match on ``*``. A domain
// must be unique across all virtual hosts or the config will fail to load.
// Domains cannot contain control characters. This is validated by the well_known_regex HTTP_HEADER_VALUE.
Domains []string `protobuf:"bytes,2,rep,name=domains,proto3" json:"domains,omitempty"`
// The list of routes that will be matched, in order, for incoming requests.
// The first route that matches will be used.
Routes []*Route `protobuf:"bytes,3,rep,name=routes,proto3" json:"routes,omitempty"`
// Specifies the type of TLS enforcement the virtual host expects. If this option is not
// specified, there is no TLS requirement for the virtual host.
RequireTls <API key> `protobuf:"varint,4,opt,name=require_tls,json=requireTls,proto3,enum=envoy.config.route.v3.<API key>" json:"require_tls,omitempty"`
// A list of virtual clusters defined for this virtual host. Virtual clusters
// are used for additional statistics gathering.
VirtualClusters []*VirtualCluster `protobuf:"bytes,5,rep,name=virtual_clusters,json=virtualClusters,proto3" json:"virtual_clusters,omitempty"`
// Specifies a set of rate limit configurations that will be applied to the
// virtual host.
RateLimits []*RateLimit `protobuf:"bytes,6,rep,name=rate_limits,json=rateLimits,proto3" json:"rate_limits,omitempty"`
// Specifies a list of HTTP headers that should be added to each request
// handled by this virtual host. Headers specified at this level are applied
// after headers from enclosed :ref:`<API key>.route.v3.Route` and before headers from the
// enclosing :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including
// details on header value syntax, see the documentation on :ref:`custom request headers
// <<API key>>`.
RequestHeadersToAdd []*v3.HeaderValueOption `protobuf:"bytes,7,rep,name=<API key>,json=requestHeadersToAdd,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be removed from each request
// handled by this virtual host.
<API key> []string `protobuf:"bytes,13,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be added to each response
// handled by this virtual host. Headers specified at this level are applied
// after headers from enclosed :ref:`<API key>.route.v3.Route` and before headers from the
// enclosing :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including
// details on header value syntax, see the documentation on :ref:`custom request headers
// <<API key>>`.
<API key> []*v3.HeaderValueOption `protobuf:"bytes,10,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be removed from each response
// handled by this virtual host.
<API key> []string `protobuf:"bytes,11,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates that the virtual host has a CORS policy.
Cors *CorsPolicy `protobuf:"bytes,8,opt,name=cors,proto3" json:"cors,omitempty"`
// The per_filter_config field can be used to provide virtual host-specific
// configurations for filters. The key should match the filter name, such as
// *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
// specific; see the :ref:`HTTP filter documentation <config_http_filters>`
// for if and how it is utilized.
// [#comment: An entry's value may be wrapped in a
// :ref:`FilterConfig<<API key>.route.v3.FilterConfig>`
// message to specify additional options.]
<API key> map[string]*any.Any `protobuf:"bytes,15,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Decides whether the :ref:`<API key>
// <<API key>>` header should be included
// in the upstream request. Setting this option will cause it to override any existing header
// value, so in the case of two Envoys on the request path with this option enabled, the upstream
// will see the attempt count as perceived by the second Envoy. Defaults to false.
// This header is unaffected by the
// :ref:`<API key>
// <<API key>.filters.http.router.v3.Router.<API key>>` flag.
// [
<API key> bool `protobuf:"varint,14,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Decides whether the :ref:`<API key>
// <<API key>>` header should be included
// in the downstream response. Setting this option will cause the router to override any existing header
// value, so in the case of two Envoys on the request path with this option enabled, the downstream
// will see the attempt count as perceived by the Envoy closest upstream from itself. Defaults to false.
// This header is unaffected by the
// :ref:`<API key>
// <<API key>.filters.http.router.v3.Router.<API key>>` flag.
<API key> bool `protobuf:"varint,19,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates the retry policy for all routes in this virtual host. Note that setting a
// route level entry will take precedence over this config and it'll be treated
// independently (e.g.: values are not inherited).
RetryPolicy *RetryPolicy `protobuf:"bytes,16,opt,name=retry_policy,json=retryPolicy,proto3" json:"retry_policy,omitempty"`
// [#<API key>:]
// Specifies the configuration for retry policy extension. Note that setting a route level entry
// will take precedence over this config and it'll be treated independently (e.g.: values are not
// inherited). :ref:`Retry policy <<API key>.route.v3.VirtualHost.retry_policy>` should not be
// set if this field is used.
<API key> *any.Any `protobuf:"bytes,20,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates the hedge policy for all routes in this virtual host. Note that setting a
// route level entry will take precedence over this config and it'll be treated
// independently (e.g.: values are not inherited).
HedgePolicy *HedgePolicy `protobuf:"bytes,17,opt,name=hedge_policy,json=hedgePolicy,proto3" json:"hedge_policy,omitempty"`
// The maximum bytes which will be buffered for retries and shadowing.
// If set and a route-specific limit is not set, the bytes actually buffered will be the minimum
// value of this and the listener <API key>.
<API key> *wrappers.UInt32Value `protobuf:"bytes,18,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> map[string]*_struct.Struct `protobuf:"bytes,12,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *VirtualHost) Reset() {
*x = VirtualHost{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *VirtualHost) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VirtualHost) ProtoMessage() {}
func (x *VirtualHost) ProtoReflect() protoreflect.Message {
mi := &<API key>[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use VirtualHost.ProtoReflect.Descriptor instead.
func (*VirtualHost) Descriptor() ([]byte, []int) {
return <API key>(), []int{0}
}
func (x *VirtualHost) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *VirtualHost) GetDomains() []string {
if x != nil {
return x.Domains
}
return nil
}
func (x *VirtualHost) GetRoutes() []*Route {
if x != nil {
return x.Routes
}
return nil
}
func (x *VirtualHost) GetRequireTls() <API key> {
if x != nil {
return x.RequireTls
}
return VirtualHost_NONE
}
func (x *VirtualHost) GetVirtualClusters() []*VirtualCluster {
if x != nil {
return x.VirtualClusters
}
return nil
}
func (x *VirtualHost) GetRateLimits() []*RateLimit {
if x != nil {
return x.RateLimits
}
return nil
}
func (x *VirtualHost) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.RequestHeadersToAdd
}
return nil
}
func (x *VirtualHost) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *VirtualHost) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.<API key>
}
return nil
}
func (x *VirtualHost) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *VirtualHost) GetCors() *CorsPolicy {
if x != nil {
return x.Cors
}
return nil
}
func (x *VirtualHost) <API key>() map[string]*any.Any {
if x != nil {
return x.<API key>
}
return nil
}
func (x *VirtualHost) <API key>() bool {
if x != nil {
return x.<API key>
}
return false
}
func (x *VirtualHost) <API key>() bool {
if x != nil {
return x.<API key>
}
return false
}
func (x *VirtualHost) GetRetryPolicy() *RetryPolicy {
if x != nil {
return x.RetryPolicy
}
return nil
}
func (x *VirtualHost) <API key>() *any.Any {
if x != nil {
return x.<API key>
}
return nil
}
func (x *VirtualHost) GetHedgePolicy() *HedgePolicy {
if x != nil {
return x.HedgePolicy
}
return nil
}
func (x *VirtualHost) <API key>() *wrappers.UInt32Value {
if x != nil {
return x.<API key>
}
return nil
}
// Deprecated: Do not use.
func (x *VirtualHost) <API key>() map[string]*_struct.Struct {
if x != nil {
return x.<API key>
}
return nil
}
// A filter-defined action type.
type FilterAction struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Action *any.Any `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
}
func (x *FilterAction) Reset() {
*x = FilterAction{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FilterAction) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FilterAction) ProtoMessage() {}
func (x *FilterAction) ProtoReflect() protoreflect.Message {
mi := &<API key>[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FilterAction.ProtoReflect.Descriptor instead.
func (*FilterAction) Descriptor() ([]byte, []int) {
return <API key>(), []int{1}
}
func (x *FilterAction) GetAction() *any.Any {
if x != nil {
return x.Action
}
return nil
}
// A route is both a specification of how to match a request as well as an indication of what to do
// next (e.g., redirect, forward, rewrite, etc.).
// .. attention::
// Envoy supports routing on HTTP method via :ref:`header matching
// <<API key>.route.v3.HeaderMatcher>`.
// [#next-free-field: 19]
type Route struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name for the route.
Name string `protobuf:"bytes,14,opt,name=name,proto3" json:"name,omitempty"`
// Route matching parameters.
Match *RouteMatch `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
// Types that are assignable to Action:
// *Route_Route
// *Route_Redirect
// *<API key>
// *Route_FilterAction
// *<API key>
Action isRoute_Action `protobuf_oneof:"action"`
// The Metadata field can be used to provide additional information
// about the route. It can be used for configuration, stats, and logging.
// The metadata should go under the filter namespace that will need it.
// For instance, if the metadata is intended for the Router filter,
// the filter name should be specified as *envoy.filters.http.router*.
Metadata *v3.Metadata `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
// Decorator for the matched route.
Decorator *Decorator `protobuf:"bytes,5,opt,name=decorator,proto3" json:"decorator,omitempty"`
// The <API key> field can be used to provide route-specific
// configurations for filters. The key should match the filter name, such as
// *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
// specific; see the :ref:`HTTP filter documentation <config_http_filters>` for
// if and how it is utilized.
// [#comment: An entry's value may be wrapped in a
// :ref:`FilterConfig<<API key>.route.v3.FilterConfig>`
// message to specify additional options.]
<API key> map[string]*any.Any `protobuf:"bytes,13,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Specifies a set of headers that will be added to requests matching this
// route. Headers specified at this level are applied before headers from the
// enclosing :ref:`<API key>.route.v3.VirtualHost` and
// :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including details on
// header value syntax, see the documentation on :ref:`custom request headers
// <<API key>>`.
RequestHeadersToAdd []*v3.HeaderValueOption `protobuf:"bytes,9,rep,name=<API key>,json=requestHeadersToAdd,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be removed from each request
// matching this route.
<API key> []string `protobuf:"bytes,12,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a set of headers that will be added to responses to requests
// matching this route. Headers specified at this level are applied before
// headers from the enclosing :ref:`<API key>.route.v3.VirtualHost` and
// :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including
// details on header value syntax, see the documentation on
// :ref:`custom request headers <<API key>>`.
<API key> []*v3.HeaderValueOption `protobuf:"bytes,10,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be removed from each response
// to requests matching this route.
<API key> []string `protobuf:"bytes,11,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Presence of the object defines whether the connection manager's tracing configuration
// is overridden by this route specific instance.
Tracing *Tracing `protobuf:"bytes,15,opt,name=tracing,proto3" json:"tracing,omitempty"`
// The maximum bytes which will be buffered for retries and shadowing.
// If set, the bytes actually buffered will be the minimum value of this and the
// listener <API key>.
<API key> *wrappers.UInt32Value `protobuf:"bytes,16,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> map[string]*_struct.Struct `protobuf:"bytes,8,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *Route) Reset() {
*x = Route{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Route) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Route) ProtoMessage() {}
func (x *Route) ProtoReflect() protoreflect.Message {
mi := &<API key>[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Route.ProtoReflect.Descriptor instead.
func (*Route) Descriptor() ([]byte, []int) {
return <API key>(), []int{2}
}
func (x *Route) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Route) GetMatch() *RouteMatch {
if x != nil {
return x.Match
}
return nil
}
func (m *Route) GetAction() isRoute_Action {
if m != nil {
return m.Action
}
return nil
}
func (x *Route) GetRoute() *RouteAction {
if x, ok := x.GetAction().(*Route_Route); ok {
return x.Route
}
return nil
}
func (x *Route) GetRedirect() *RedirectAction {
if x, ok := x.GetAction().(*Route_Redirect); ok {
return x.Redirect
}
return nil
}
func (x *Route) GetDirectResponse() *<API key> {
if x, ok := x.GetAction().(*<API key>); ok {
return x.DirectResponse
}
return nil
}
func (x *Route) GetFilterAction() *FilterAction {
if x, ok := x.GetAction().(*Route_FilterAction); ok {
return x.FilterAction
}
return nil
}
func (x *Route) <API key>() *NonForwardingAction {
if x, ok := x.GetAction().(*<API key>); ok {
return x.NonForwardingAction
}
return nil
}
func (x *Route) GetMetadata() *v3.Metadata {
if x != nil {
return x.Metadata
}
return nil
}
func (x *Route) GetDecorator() *Decorator {
if x != nil {
return x.Decorator
}
return nil
}
func (x *Route) <API key>() map[string]*any.Any {
if x != nil {
return x.<API key>
}
return nil
}
func (x *Route) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.RequestHeadersToAdd
}
return nil
}
func (x *Route) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *Route) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.<API key>
}
return nil
}
func (x *Route) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *Route) GetTracing() *Tracing {
if x != nil {
return x.Tracing
}
return nil
}
func (x *Route) <API key>() *wrappers.UInt32Value {
if x != nil {
return x.<API key>
}
return nil
}
// Deprecated: Do not use.
func (x *Route) <API key>() map[string]*_struct.Struct {
if x != nil {
return x.<API key>
}
return nil
}
type isRoute_Action interface {
isRoute_Action()
}
type Route_Route struct {
// Route request to some upstream cluster.
Route *RouteAction `protobuf:"bytes,2,opt,name=route,proto3,oneof"`
}
type Route_Redirect struct {
// Return a redirect.
Redirect *RedirectAction `protobuf:"bytes,3,opt,name=redirect,proto3,oneof"`
}
type <API key> struct {
// Return an arbitrary HTTP response directly, without proxying.
DirectResponse *<API key> `protobuf:"bytes,7,opt,name=direct_response,json=directResponse,proto3,oneof"`
}
type Route_FilterAction struct {
// [#<API key>:]
// A filter-defined action (e.g., it could dynamically generate the RouteAction).
// [#comment: TODO(samflattery): Remove cleanup in route_fuzz_test.cc when
// implemented]
FilterAction *FilterAction `protobuf:"bytes,17,opt,name=filter_action,json=filterAction,proto3,oneof"`
}
type <API key> struct {
// [#<API key>:]
// An action used when the route will generate a response directly,
// without forwarding to an upstream host. This will be used in non-proxy
// xDS clients like the gRPC server. It could also be used in the future
// in Envoy for a filter that directly generates responses for requests.
NonForwardingAction *NonForwardingAction `protobuf:"bytes,18,opt,name=<API key>,json=nonForwardingAction,proto3,oneof"`
}
func (*Route_Route) isRoute_Action() {}
func (*Route_Redirect) isRoute_Action() {}
func (*<API key>) isRoute_Action() {}
func (*Route_FilterAction) isRoute_Action() {}
func (*<API key>) isRoute_Action() {}
// Compared to the :ref:`cluster <<API key>.route.v3.RouteAction.cluster>` field that specifies a
// single upstream cluster as the target of a request, the :ref:`weighted_clusters
// <<API key>.route.v3.RouteAction.weighted_clusters>` option allows for specification of
// multiple upstream clusters along with weights that indicate the percentage of
// traffic to be forwarded to each cluster. The router selects an upstream cluster based on the
// weights.
type WeightedCluster struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies one or more upstream clusters associated with the route.
Clusters []*<API key> `protobuf:"bytes,1,rep,name=clusters,proto3" json:"clusters,omitempty"`
// Specifies the total weight across all clusters. The sum of all cluster weights must equal this
// value, which must be greater than 0. Defaults to 100.
TotalWeight *wrappers.UInt32Value `protobuf:"bytes,3,opt,name=total_weight,json=totalWeight,proto3" json:"total_weight,omitempty"`
// Specifies the runtime key prefix that should be used to construct the
// runtime keys associated with each cluster. When the *runtime_key_prefix* is
// specified, the router will look for weights associated with each upstream
// cluster under the key *runtime_key_prefix* + "." + *cluster[i].name* where
// *cluster[i]* denotes an entry in the clusters array field. If the runtime
// key for the cluster does not exist, the value specified in the
// configuration file will be used as the default weight. See the :ref:`runtime documentation
// <operations_runtime>` for how key names map to the underlying implementation.
RuntimeKeyPrefix string `protobuf:"bytes,2,opt,name=runtime_key_prefix,json=runtimeKeyPrefix,proto3" json:"runtime_key_prefix,omitempty"`
}
func (x *WeightedCluster) Reset() {
*x = WeightedCluster{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *WeightedCluster) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WeightedCluster) ProtoMessage() {}
func (x *WeightedCluster) ProtoReflect() protoreflect.Message {
mi := &<API key>[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use WeightedCluster.ProtoReflect.Descriptor instead.
func (*WeightedCluster) Descriptor() ([]byte, []int) {
return <API key>(), []int{3}
}
func (x *WeightedCluster) GetClusters() []*<API key> {
if x != nil {
return x.Clusters
}
return nil
}
func (x *WeightedCluster) GetTotalWeight() *wrappers.UInt32Value {
if x != nil {
return x.TotalWeight
}
return nil
}
func (x *WeightedCluster) GetRuntimeKeyPrefix() string {
if x != nil {
return x.RuntimeKeyPrefix
}
return ""
}
// [#next-free-field: 13]
type RouteMatch struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to PathSpecifier:
// *RouteMatch_Prefix
// *RouteMatch_Path
// *<API key>
// *<API key>
// *<API key>
PathSpecifier <API key> `protobuf_oneof:"path_specifier"`
// Indicates that prefix/path matching should be case sensitive. The default
// is true.
CaseSensitive *wrappers.BoolValue `protobuf:"bytes,4,opt,name=case_sensitive,json=caseSensitive,proto3" json:"case_sensitive,omitempty"`
// Indicates that the route should additionally match on a runtime key. Every time the route
// is considered for a match, it must also fall under the percentage of matches indicated by
// this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
// number is <= the value of the numerator N, or if the key is not present, the default
// value, the router continues to evaluate the remaining match criteria. A runtime_fraction
// route configuration can be used to roll out route changes in a gradual manner without full
// code/config deploys. Refer to the :ref:`traffic shifting
// <<API key>>` docs for additional documentation.
// .. note::
// Parsing this field is implemented such that the runtime key's data may be represented
// as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
// integer with the assumption that the value is an integral percentage out of 100. For
// instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
// whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.
RuntimeFraction *v3.<API key> `protobuf:"bytes,9,opt,name=runtime_fraction,json=runtimeFraction,proto3" json:"runtime_fraction,omitempty"`
// Specifies a set of headers that the route should match on. The router will
// config. A match will happen if all the headers in the route are present in
// the request with the same values (or based on presence if the value field
// is not in the config).
Headers []*HeaderMatcher `protobuf:"bytes,6,rep,name=headers,proto3" json:"headers,omitempty"`
// Specifies a set of URL query parameters on which the route should
// match. The router will check the query string from the *path* header
// against all the specified query parameters. If the number of specified
// query parameters is nonzero, they all must match the *path* header's
// query string for a match to occur.
QueryParameters []*<API key> `protobuf:"bytes,7,rep,name=query_parameters,json=queryParameters,proto3" json:"query_parameters,omitempty"`
// If specified, only gRPC requests will be matched. The router will check
// that the content-type header has a application/grpc or one of the various
// application/grpc+ values.
Grpc *<API key> `protobuf:"bytes,8,opt,name=grpc,proto3" json:"grpc,omitempty"`
// If specified, the client tls context will be matched against the defined
// match options.
// [
TlsContext *<API key> `protobuf:"bytes,11,opt,name=tls_context,json=tlsContext,proto3" json:"tls_context,omitempty"`
}
func (x *RouteMatch) Reset() {
*x = RouteMatch{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RouteMatch) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RouteMatch) ProtoMessage() {}
func (x *RouteMatch) ProtoReflect() protoreflect.Message {
mi := &<API key>[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RouteMatch.ProtoReflect.Descriptor instead.
func (*RouteMatch) Descriptor() ([]byte, []int) {
return <API key>(), []int{4}
}
func (m *RouteMatch) GetPathSpecifier() <API key> {
if m != nil {
return m.PathSpecifier
}
return nil
}
func (x *RouteMatch) GetPrefix() string {
if x, ok := x.GetPathSpecifier().(*RouteMatch_Prefix); ok {
return x.Prefix
}
return ""
}
func (x *RouteMatch) GetPath() string {
if x, ok := x.GetPathSpecifier().(*RouteMatch_Path); ok {
return x.Path
}
return ""
}
func (x *RouteMatch) GetSafeRegex() *v31.RegexMatcher {
if x, ok := x.GetPathSpecifier().(*<API key>); ok {
return x.SafeRegex
}
return nil
}
func (x *RouteMatch) GetConnectMatcher() *<API key> {
if x, ok := x.GetPathSpecifier().(*<API key>); ok {
return x.ConnectMatcher
}
return nil
}
// Deprecated: Do not use.
func (x *RouteMatch) <API key>() string {
if x, ok := x.GetPathSpecifier().(*<API key>); ok {
return x.<API key>
}
return ""
}
func (x *RouteMatch) GetCaseSensitive() *wrappers.BoolValue {
if x != nil {
return x.CaseSensitive
}
return nil
}
func (x *RouteMatch) GetRuntimeFraction() *v3.<API key> {
if x != nil {
return x.RuntimeFraction
}
return nil
}
func (x *RouteMatch) GetHeaders() []*HeaderMatcher {
if x != nil {
return x.Headers
}
return nil
}
func (x *RouteMatch) GetQueryParameters() []*<API key> {
if x != nil {
return x.QueryParameters
}
return nil
}
func (x *RouteMatch) GetGrpc() *<API key> {
if x != nil {
return x.Grpc
}
return nil
}
func (x *RouteMatch) GetTlsContext() *<API key> {
if x != nil {
return x.TlsContext
}
return nil
}
type <API key> interface {
<API key>()
}
type RouteMatch_Prefix struct {
// If specified, the route is a prefix rule meaning that the prefix must
// match the beginning of the *:path* header.
Prefix string `protobuf:"bytes,1,opt,name=prefix,proto3,oneof"`
}
type RouteMatch_Path struct {
// If specified, the route is an exact path rule meaning that the path must
// exactly match the *:path* header once the query string is removed.
Path string `protobuf:"bytes,2,opt,name=path,proto3,oneof"`
}
type <API key> struct {
// If specified, the route is a regular expression rule meaning that the
// regex must match the *:path* header once the query string is removed. The entire path
// (without the query string) must match the regex. The rule will not match if only a
// subsequence of the *:path* header matches the regex.
// [
// that we utilize StringMatcher, and additionally have consistent options around whether we
// strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
// to deprecate the existing options. We should even consider whether we want to do away with
// path_specifier entirely and just rely on a set of header matchers which can already match
// on :path, etc. The issue with that is it is unclear how to generically deal with query string
// stripping. This needs more thought.]
SafeRegex *v31.RegexMatcher `protobuf:"bytes,10,opt,name=safe_regex,json=safeRegex,proto3,oneof"`
}
type <API key> struct {
// If this is used as the matcher, the matcher will only match CONNECT requests.
// Note that this will not match HTTP/2 upgrade-style CONNECT requests
// (WebSocket and the like) as they are normalized in Envoy as HTTP/1.1 style
// upgrades.
// This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2,
// where Extended CONNECT requests may have a path, the path matchers will work if
// there is a path present.
// Note that CONNECT support is currently considered alpha in Envoy.
// [#comment: TODO(htuch): Replace the above comment with an alpha tag.]
ConnectMatcher *<API key> `protobuf:"bytes,12,opt,name=connect_matcher,json=connectMatcher,proto3,oneof"`
}
type <API key> struct {
// Deprecated: Do not use.
<API key> string `protobuf:"bytes,3,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*RouteMatch_Prefix) <API key>() {}
func (*RouteMatch_Path) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// [#next-free-field: 12]
type CorsPolicy struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies string patterns that match allowed origins. An origin is allowed if any of the
// string matchers match.
<API key> []*v31.StringMatcher `protobuf:"bytes,11,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies the content for the *<API key>* header.
AllowMethods string `protobuf:"bytes,2,opt,name=allow_methods,json=allowMethods,proto3" json:"allow_methods,omitempty"`
// Specifies the content for the *<API key>* header.
AllowHeaders string `protobuf:"bytes,3,opt,name=allow_headers,json=allowHeaders,proto3" json:"allow_headers,omitempty"`
// Specifies the content for the *<API key>* header.
ExposeHeaders string `protobuf:"bytes,4,opt,name=expose_headers,json=exposeHeaders,proto3" json:"expose_headers,omitempty"`
// Specifies the content for the *<API key>* header.
MaxAge string `protobuf:"bytes,5,opt,name=max_age,json=maxAge,proto3" json:"max_age,omitempty"`
// Specifies whether the resource allows credentials.
AllowCredentials *wrappers.BoolValue `protobuf:"bytes,6,opt,name=allow_credentials,json=allowCredentials,proto3" json:"allow_credentials,omitempty"`
// Types that are assignable to EnabledSpecifier:
// *<API key>
// *<API key>
EnabledSpecifier <API key> `protobuf_oneof:"enabled_specifier"`
// Specifies the % of requests for which the CORS policies will be evaluated and tracked, but not
// enforced.
// This field is intended to be used when ``filter_enabled`` and ``enabled`` are off. One of those
// fields have to explicitly disable the filter in order for this setting to take effect.
// If :ref:`runtime_key <<API key>.core.v3.<API key>.runtime_key>` is specified,
// Envoy will lookup the runtime key to get the percentage of requests for which it will evaluate
// and track the request's *Origin* to determine if it's valid but will not enforce any policies.
ShadowEnabled *v3.<API key> `protobuf:"bytes,10,opt,name=shadow_enabled,json=shadowEnabled,proto3" json:"shadow_enabled,omitempty"`
// Deprecated: Do not use.
<API key> []string `protobuf:"bytes,1,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> []string `protobuf:"bytes,8,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *CorsPolicy) Reset() {
*x = CorsPolicy{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CorsPolicy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CorsPolicy) ProtoMessage() {}
func (x *CorsPolicy) ProtoReflect() protoreflect.Message {
mi := &<API key>[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CorsPolicy.ProtoReflect.Descriptor instead.
func (*CorsPolicy) Descriptor() ([]byte, []int) {
return <API key>(), []int{5}
}
func (x *CorsPolicy) <API key>() []*v31.StringMatcher {
if x != nil {
return x.<API key>
}
return nil
}
func (x *CorsPolicy) GetAllowMethods() string {
if x != nil {
return x.AllowMethods
}
return ""
}
func (x *CorsPolicy) GetAllowHeaders() string {
if x != nil {
return x.AllowHeaders
}
return ""
}
func (x *CorsPolicy) GetExposeHeaders() string {
if x != nil {
return x.ExposeHeaders
}
return ""
}
func (x *CorsPolicy) GetMaxAge() string {
if x != nil {
return x.MaxAge
}
return ""
}
func (x *CorsPolicy) GetAllowCredentials() *wrappers.BoolValue {
if x != nil {
return x.AllowCredentials
}
return nil
}
func (m *CorsPolicy) GetEnabledSpecifier() <API key> {
if m != nil {
return m.EnabledSpecifier
}
return nil
}
func (x *CorsPolicy) GetFilterEnabled() *v3.<API key> {
if x, ok := x.GetEnabledSpecifier().(*<API key>); ok {
return x.FilterEnabled
}
return nil
}
// Deprecated: Do not use.
func (x *CorsPolicy) <API key>() *wrappers.BoolValue {
if x, ok := x.GetEnabledSpecifier().(*<API key>); ok {
return x.<API key>
}
return nil
}
func (x *CorsPolicy) GetShadowEnabled() *v3.<API key> {
if x != nil {
return x.ShadowEnabled
}
return nil
}
// Deprecated: Do not use.
func (x *CorsPolicy) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
// Deprecated: Do not use.
func (x *CorsPolicy) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Specifies the % of requests for which the CORS filter is enabled.
// If neither ``enabled``, ``filter_enabled``, nor ``shadow_enabled`` are specified, the CORS
// filter will be enabled for 100% of the requests.
// If :ref:`runtime_key <<API key>.core.v3.<API key>.runtime_key>` is
// specified, Envoy will lookup the runtime key to get the percentage of requests to filter.
FilterEnabled *v3.<API key> `protobuf:"bytes,9,opt,name=filter_enabled,json=filterEnabled,proto3,oneof"`
}
type <API key> struct {
// Deprecated: Do not use.
<API key> *wrappers.BoolValue `protobuf:"bytes,7,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// [#next-free-field: 37]
type RouteAction struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to ClusterSpecifier:
// *RouteAction_Cluster
// *<API key>
// *<API key>
ClusterSpecifier <API key> `protobuf_oneof:"cluster_specifier"`
// The HTTP status code to use when configured cluster is not found.
// The default response code is 503 Service Unavailable.
<API key> <API key> `protobuf:"varint,20,opt,name=<API key>,json=<API key>,proto3,enum=envoy.config.route.v3.<API key>" json:"<API key>,omitempty"`
// Optional endpoint metadata match criteria used by the subset load balancer. Only endpoints
// in the upstream cluster with metadata matching what's set in this field will be considered
// for load balancing. If using :ref:`weighted_clusters
// <<API key>.route.v3.RouteAction.weighted_clusters>`, metadata will be merged, with values
// provided there taking precedence. The filter name should be specified as *envoy.lb*.
MetadataMatch *v3.Metadata `protobuf:"bytes,4,opt,name=metadata_match,json=metadataMatch,proto3" json:"metadata_match,omitempty"`
// Indicates that during forwarding, the matched prefix (or path) should be
// swapped with this value. This option allows application URLs to be rooted
// at a different path from those exposed at the reverse proxy layer. The router filter will
// place the original path before rewrite into the :ref:`<API key>
// <<API key>>` header.
// Only one of *prefix_rewrite* or
// :ref:`regex_rewrite <<API key>.route.v3.RouteAction.regex_rewrite>`
// may be specified.
// .. attention::
// Pay careful attention to the use of trailing slashes in the
// :ref:`route's match <<API key>.route.v3.Route.match>` prefix value.
// Stripping a prefix from a path requires multiple Routes to handle all cases. For example,
// rewriting */prefix* to */* and */prefix/etc* to */etc* cannot be done in a single
// :ref:`Route <<API key>.route.v3.Route>`, as shown by the below config entries:
// .. code-block:: yaml
// - match:
// prefix: "/prefix/"
// route:
// prefix_rewrite: "/"
// - match:
// prefix: "/prefix"
// route:
// prefix_rewrite: "/"
// Having above entries in the config, requests to */prefix* will be stripped to */*, while
// requests to */prefix/etc* will be stripped to */etc*.
PrefixRewrite string `protobuf:"bytes,5,opt,name=prefix_rewrite,json=prefixRewrite,proto3" json:"prefix_rewrite,omitempty"`
// Indicates that during forwarding, portions of the path that match the
// pattern should be rewritten, even allowing the substitution of capture
// groups from the pattern into the new path as specified by the rewrite
// substitution string. This is useful to allow application paths to be
// rewritten in a way that is aware of segments with variable content like
// identifiers. The router filter will place the original path as it was
// before the rewrite into the :ref:`<API key>
// <<API key>>` header.
// Only one of :ref:`prefix_rewrite <<API key>.route.v3.RouteAction.prefix_rewrite>`
// or *regex_rewrite* may be specified.
// * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
// string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
// into ``/v1/api/instance/foo``.
// * The pattern ``one`` paired with a substitution string of ``two`` would
// transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
// * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
// ``\1two\2`` would replace only the first occurrence of ``one``,
// transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
// * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
// would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
// ``/aaa/yyy/bbb``.
RegexRewrite *v31.<API key> `protobuf:"bytes,32,opt,name=regex_rewrite,json=regexRewrite,proto3" json:"regex_rewrite,omitempty"`
// Types that are assignable to <API key>:
// *<API key>
// *<API key>
// *<API key>
// *<API key>
<API key> <API key> `protobuf_oneof:"<API key>"`
// Specifies the upstream timeout for the route. If not specified, the default is 15s. This
// spans between the point at which the entire downstream request (i.e. end-of-stream) has been
// processed and when the upstream response has been completely processed. A value of 0 will
// disable the route's timeout.
// .. note::
// This timeout includes all retries. See also
// :ref:`<API key>`,
// :ref:`<API key>`, and the
// :ref:`retry overview <<API key>>`.
Timeout *duration.Duration `protobuf:"bytes,8,opt,name=timeout,proto3" json:"timeout,omitempty"`
// Specifies the idle timeout for the route. If not specified, there is no per-route idle timeout,
// although the connection manager wide :ref:`stream_idle_timeout
// <<API key>.filters.network.<API key>.v3.<API key>.stream_idle_timeout>`
// will still apply. A value of 0 will completely disable the route's idle timeout, even if a
// connection manager stream idle timeout is configured.
// The idle timeout is distinct to :ref:`timeout
// <<API key>.route.v3.RouteAction.timeout>`, which provides an upper bound
// on the upstream response time; :ref:`idle_timeout
// <<API key>.route.v3.RouteAction.idle_timeout>` instead bounds the amount
// of time the request's stream may be idle.
// After header decoding, the idle timeout will apply on downstream and
// upstream request events. Each time an encode/decode event for headers or
// data is processed for the stream, the timer will be reset. If the timeout
// fires, the stream is terminated with a 408 Request Timeout error code if no
// upstream response header has been received, otherwise a stream reset
// occurs.
// If the :ref:`overload action <<API key>>` "envoy.overload_actions.reduce_timeouts"
// is configured, this timeout is scaled according to the value for
// :ref:`<API key> <<API key>.overload.v3.<API key>.TimerType.<API key>>`.
IdleTimeout *duration.Duration `protobuf:"bytes,24,opt,name=idle_timeout,json=idleTimeout,proto3" json:"idle_timeout,omitempty"`
// Indicates that the route has a retry policy. Note that if this is set,
// it'll take precedence over the virtual host level retry policy entirely
// (e.g.: policies are not merged, most internal one becomes the enforced policy).
RetryPolicy *RetryPolicy `protobuf:"bytes,9,opt,name=retry_policy,json=retryPolicy,proto3" json:"retry_policy,omitempty"`
// [#<API key>:]
// Specifies the configuration for retry policy extension. Note that if this is set, it'll take
// precedence over the virtual host level retry policy entirely (e.g.: policies are not merged,
// most internal one becomes the enforced policy). :ref:`Retry policy <<API key>.route.v3.VirtualHost.retry_policy>`
// should not be set if this field is used.
<API key> *any.Any `protobuf:"bytes,33,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates that the route has request mirroring policies.
<API key> []*<API key> `protobuf:"bytes,30,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Optionally specifies the :ref:`routing priority <<API key>>`.
Priority v3.RoutingPriority `protobuf:"varint,11,opt,name=priority,proto3,enum=envoy.config.core.v3.RoutingPriority" json:"priority,omitempty"`
// Specifies a set of rate limit configurations that could be applied to the
// route.
RateLimits []*RateLimit `protobuf:"bytes,13,rep,name=rate_limits,json=rateLimits,proto3" json:"rate_limits,omitempty"`
// Specifies if the rate limit filter should include the virtual host rate
// limits. By default, if the route configured rate limits, the virtual host
// :ref:`rate_limits <<API key>.route.v3.VirtualHost.rate_limits>` are not applied to the
// request.
// This field is deprecated. Please use :ref:`vh_rate_limits <<API key>.filters.http.ratelimit.v3.RateLimitPerRoute.vh_rate_limits>`
// Deprecated: Do not use.
IncludeVhRateLimits *wrappers.BoolValue `protobuf:"bytes,14,opt,name=<API key>,json=includeVhRateLimits,proto3" json:"<API key>,omitempty"`
// Specifies a list of hash policies to use for ring hash load balancing. Each
// hash policy is evaluated individually and the combined result is used to
// route the request. The method of combination is deterministic such that
// identical lists of hash policies will produce the same hash. Since a hash
// policy examines specific parts of a request, it can fail to produce a hash
// (i.e. if the hashed header is not present). If (and only if) all configured
// hash policies fail to generate a hash, no hash will be produced for
// the route. In this case, the behavior is the same as if no hash policies
// were specified (i.e. the ring hash load balancer will choose a random
// backend). If a hash policy has the "terminal" attribute set to true, and
// there is already a hash generated, the hash is returned immediately,
// ignoring the rest of the hash policy list.
HashPolicy []*<API key> `protobuf:"bytes,15,rep,name=hash_policy,json=hashPolicy,proto3" json:"hash_policy,omitempty"`
// Indicates that the route has a CORS policy.
Cors *CorsPolicy `protobuf:"bytes,17,opt,name=cors,proto3" json:"cors,omitempty"`
// Deprecated by :ref:`<API key> <<API key>.route.v3.RouteAction.MaxStreamDuration.<API key>>`
// If present, and the request is a gRPC request, use the
// or its default value (infinity) instead of
// :ref:`timeout <<API key>.route.v3.RouteAction.timeout>`, but limit the applied timeout
// to the maximum value specified here. If configured as 0, the maximum allowed timeout for
// gRPC requests is infinity. If not configured at all, the `grpc-timeout` header is not used
// and gRPC requests time out like any other requests using
// :ref:`timeout <<API key>.route.v3.RouteAction.timeout>` or its default.
// This can be used to prevent unexpected upstream request timeouts due to potentially long
// time gaps between gRPC request and response in gRPC streaming mode.
// .. note::
// If a timeout is specified using :ref:`<API key>`, it takes
// both are present. See also
// :ref:`<API key>`,
// :ref:`<API key>`, and the
// :ref:`retry overview <<API key>>`.
// Deprecated: Do not use.
MaxGrpcTimeout *duration.Duration `protobuf:"bytes,23,opt,name=max_grpc_timeout,json=maxGrpcTimeout,proto3" json:"max_grpc_timeout,omitempty"`
// Deprecated by :ref:`<API key> <<API key>.route.v3.RouteAction.MaxStreamDuration.<API key>>`.
// If present, Envoy will adjust the timeout provided by the `grpc-timeout` header by subtracting
// the provided duration from the header. This is useful in allowing Envoy to set its global
// timeout to be less than that of the deadline imposed by the calling client, which makes it more
// likely that Envoy will handle the timeout instead of having the call canceled by the client.
// The offset will only be applied if the provided grpc_timeout is greater than the offset. This
// ensures that the offset will only ever decrease the timeout and never set it to 0 (meaning
// infinity).
// Deprecated: Do not use.
GrpcTimeoutOffset *duration.Duration `protobuf:"bytes,28,opt,name=grpc_timeout_offset,json=grpcTimeoutOffset,proto3" json:"grpc_timeout_offset,omitempty"`
UpgradeConfigs []*<API key> `protobuf:"bytes,25,rep,name=upgrade_configs,json=upgradeConfigs,proto3" json:"upgrade_configs,omitempty"`
// If present, Envoy will try to follow an upstream redirect response instead of proxying the
// response back to the downstream. An upstream redirect response is defined
// by :ref:`<API key>
// <<API key>.route.v3.<API key>.<API key>>`.
<API key> *<API key> `protobuf:"bytes,34,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> <API key> `protobuf:"varint,26,opt,name=<API key>,json=<API key>,proto3,enum=envoy.config.route.v3.<API key>" json:"<API key>,omitempty"`
// An internal redirect is handled, iff the number of previous internal redirects that a
// downstream request has encountered is lower than this value, and
// :ref:`<API key> <<API key>.route.v3.RouteAction.<API key>>`
// is set to :ref:`<API key>
// <<API key>.route.v3.RouteAction.<API key>.<API key>>`
// In the case where a downstream request is bounced among multiple routes by internal redirect,
// the first route that hits this threshold, or has
// :ref:`<API key> <<API key>.route.v3.RouteAction.<API key>>`
// set to
// :ref:`<API key>
// <<API key>.route.v3.RouteAction.<API key>.<API key>>`
// will pass the redirect back to downstream.
// If not specified, at most one redirect will be followed.
// Deprecated: Do not use.
<API key> *wrappers.UInt32Value `protobuf:"bytes,31,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates that the route has a hedge policy. Note that if this is set,
// it'll take precedence over the virtual host level hedge policy entirely
// (e.g.: policies are not merged, most internal one becomes the enforced policy).
HedgePolicy *HedgePolicy `protobuf:"bytes,27,opt,name=hedge_policy,json=hedgePolicy,proto3" json:"hedge_policy,omitempty"`
// Specifies the maximum stream duration for this route.
MaxStreamDuration *<API key> `protobuf:"bytes,36,opt,name=max_stream_duration,json=maxStreamDuration,proto3" json:"max_stream_duration,omitempty"`
// Deprecated: Do not use.
<API key> *<API key> `protobuf:"bytes,10,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *RouteAction) Reset() {
*x = RouteAction{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RouteAction) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RouteAction) ProtoMessage() {}
func (x *RouteAction) ProtoReflect() protoreflect.Message {
mi := &<API key>[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RouteAction.ProtoReflect.Descriptor instead.
func (*RouteAction) Descriptor() ([]byte, []int) {
return <API key>(), []int{6}
}
func (m *RouteAction) GetClusterSpecifier() <API key> {
if m != nil {
return m.ClusterSpecifier
}
return nil
}
func (x *RouteAction) GetCluster() string {
if x, ok := x.GetClusterSpecifier().(*RouteAction_Cluster); ok {
return x.Cluster
}
return ""
}
func (x *RouteAction) GetClusterHeader() string {
if x, ok := x.GetClusterSpecifier().(*<API key>); ok {
return x.ClusterHeader
}
return ""
}
func (x *RouteAction) GetWeightedClusters() *WeightedCluster {
if x, ok := x.GetClusterSpecifier().(*<API key>); ok {
return x.WeightedClusters
}
return nil
}
func (x *RouteAction) <API key>() <API key> {
if x != nil {
return x.<API key>
}
return <API key>
}
func (x *RouteAction) GetMetadataMatch() *v3.Metadata {
if x != nil {
return x.MetadataMatch
}
return nil
}
func (x *RouteAction) GetPrefixRewrite() string {
if x != nil {
return x.PrefixRewrite
}
return ""
}
func (x *RouteAction) GetRegexRewrite() *v31.<API key> {
if x != nil {
return x.RegexRewrite
}
return nil
}
func (m *RouteAction) <API key>() <API key> {
if m != nil {
return m.<API key>
}
return nil
}
func (x *RouteAction) <API key>() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.HostRewriteLiteral
}
return ""
}
func (x *RouteAction) GetAutoHostRewrite() *wrappers.BoolValue {
if x, ok := x.<API key>().(*<API key>); ok {
return x.AutoHostRewrite
}
return nil
}
func (x *RouteAction) <API key>() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.HostRewriteHeader
}
return ""
}
func (x *RouteAction) <API key>() *v31.<API key> {
if x, ok := x.<API key>().(*<API key>); ok {
return x.<API key>
}
return nil
}
func (x *RouteAction) GetTimeout() *duration.Duration {
if x != nil {
return x.Timeout
}
return nil
}
func (x *RouteAction) GetIdleTimeout() *duration.Duration {
if x != nil {
return x.IdleTimeout
}
return nil
}
func (x *RouteAction) GetRetryPolicy() *RetryPolicy {
if x != nil {
return x.RetryPolicy
}
return nil
}
func (x *RouteAction) <API key>() *any.Any {
if x != nil {
return x.<API key>
}
return nil
}
func (x *RouteAction) <API key>() []*<API key> {
if x != nil {
return x.<API key>
}
return nil
}
func (x *RouteAction) GetPriority() v3.RoutingPriority {
if x != nil {
return x.Priority
}
return v3.<API key>
}
func (x *RouteAction) GetRateLimits() []*RateLimit {
if x != nil {
return x.RateLimits
}
return nil
}
// Deprecated: Do not use.
func (x *RouteAction) <API key>() *wrappers.BoolValue {
if x != nil {
return x.IncludeVhRateLimits
}
return nil
}
func (x *RouteAction) GetHashPolicy() []*<API key> {
if x != nil {
return x.HashPolicy
}
return nil
}
func (x *RouteAction) GetCors() *CorsPolicy {
if x != nil {
return x.Cors
}
return nil
}
// Deprecated: Do not use.
func (x *RouteAction) GetMaxGrpcTimeout() *duration.Duration {
if x != nil {
return x.MaxGrpcTimeout
}
return nil
}
// Deprecated: Do not use.
func (x *RouteAction) <API key>() *duration.Duration {
if x != nil {
return x.GrpcTimeoutOffset
}
return nil
}
func (x *RouteAction) GetUpgradeConfigs() []*<API key> {
if x != nil {
return x.UpgradeConfigs
}
return nil
}
func (x *RouteAction) <API key>() *<API key> {
if x != nil {
return x.<API key>
}
return nil
}
// Deprecated: Do not use.
func (x *RouteAction) <API key>() <API key> {
if x != nil {
return x.<API key>
}
return <API key>
}
// Deprecated: Do not use.
func (x *RouteAction) <API key>() *wrappers.UInt32Value {
if x != nil {
return x.<API key>
}
return nil
}
func (x *RouteAction) GetHedgePolicy() *HedgePolicy {
if x != nil {
return x.HedgePolicy
}
return nil
}
func (x *RouteAction) <API key>() *<API key> {
if x != nil {
return x.MaxStreamDuration
}
return nil
}
// Deprecated: Do not use.
func (x *RouteAction) <API key>() *<API key> {
if x != nil {
return x.<API key>
}
return nil
}
type <API key> interface {
<API key>()
}
type RouteAction_Cluster struct {
// Indicates the upstream cluster to which the request should be routed
Cluster string `protobuf:"bytes,1,opt,name=cluster,proto3,oneof"`
}
type <API key> struct {
// Envoy will determine the cluster to route to by reading the value of the
// HTTP header named by cluster_header from the request headers. If the
// header is not found or the referenced cluster does not exist, Envoy will
// return a 404 response.
// .. attention::
// Internally, Envoy always uses the HTTP/2 *:authority* header to represent the HTTP/1
// *Host* header. Thus, if attempting to match on *Host*, match on *:authority* instead.
// .. note::
// If the header appears multiple times only the first value is used.
ClusterHeader string `protobuf:"bytes,2,opt,name=cluster_header,json=clusterHeader,proto3,oneof"`
}
type <API key> struct {
// Multiple upstream clusters can be specified for a given route. The
// request is routed to one of the upstream clusters based on weights
// assigned to each cluster. See
// :ref:`traffic splitting <<API key>>`
// for additional documentation.
WeightedClusters *WeightedCluster `protobuf:"bytes,3,opt,name=weighted_clusters,json=weightedClusters,proto3,oneof"`
}
func (*RouteAction_Cluster) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Indicates that during forwarding, the host header will be swapped with
// this value.
HostRewriteLiteral string `protobuf:"bytes,6,opt,name=<API key>,json=hostRewriteLiteral,proto3,oneof"`
}
type <API key> struct {
// Indicates that during forwarding, the host header will be swapped with
// the hostname of the upstream host chosen by the cluster manager. This
// option is applicable only when the destination cluster for a route is of
// type *strict_dns* or *logical_dns*. Setting this to true with other cluster
// types has no effect.
AutoHostRewrite *wrappers.BoolValue `protobuf:"bytes,7,opt,name=auto_host_rewrite,json=autoHostRewrite,proto3,oneof"`
}
type <API key> struct {
// Indicates that during forwarding, the host header will be swapped with the content of given
// downstream or :ref:`custom <<API key>>` header.
// If header value is empty, host header is left intact.
// .. attention::
// Pay attention to the potential security implications of using this option. Provided header
// must come from trusted source.
// .. note::
// If the header appears multiple times only the first value is used.
HostRewriteHeader string `protobuf:"bytes,29,opt,name=host_rewrite_header,json=hostRewriteHeader,proto3,oneof"`
}
type <API key> struct {
// Indicates that during forwarding, the host header will be swapped with
// the result of the regex substitution executed on path value with query and fragment removed.
// This is useful for transitioning variable content between path segment and subdomain.
// For example with the following config:
// .. code-block:: yaml
// <API key>:
// pattern:
// google_re2: {}
// regex: "^/(.+)/.+$"
// substitution: \1
// Would rewrite the host header to `envoyproxy.io` given the path `/envoyproxy.io/some/path`.
<API key> *v31.<API key> `protobuf:"bytes,35,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// HTTP retry :ref:`architecture overview <<API key>>`.
// [#next-free-field: 12]
type RetryPolicy struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the conditions under which retry takes place. These are the same
// conditions documented for :ref:`<API key>` and
// :ref:`<API key>`.
RetryOn string `protobuf:"bytes,1,opt,name=retry_on,json=retryOn,proto3" json:"retry_on,omitempty"`
// Specifies the allowed number of retries. This parameter is optional and
// defaults to 1. These are the same conditions documented for
// :ref:`<API key>`.
NumRetries *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=num_retries,json=numRetries,proto3" json:"num_retries,omitempty"`
// Specifies a non-zero upstream timeout per retry attempt. This parameter is optional. The
// same conditions documented for
// :ref:`<API key>` apply.
// .. note::
// If left unspecified, Envoy will use the global
// :ref:`route timeout <<API key>.route.v3.RouteAction.timeout>` for the request.
// Consequently, when using a :ref:`5xx <<API key>>` based
// retry policy, a request that times out will not be retried as the total timeout budget
// would have been exhausted.
PerTryTimeout *duration.Duration `protobuf:"bytes,3,opt,name=per_try_timeout,json=perTryTimeout,proto3" json:"per_try_timeout,omitempty"`
// Specifies an implementation of a RetryPriority which is used to determine the
// distribution of load across priorities used for retries. Refer to
// :ref:`retry plugin configuration <<API key>>` for more details.
RetryPriority *<API key> `protobuf:"bytes,4,opt,name=retry_priority,json=retryPriority,proto3" json:"retry_priority,omitempty"`
// Specifies a collection of RetryHostPredicates that will be consulted when selecting a host
// for retries. If any of the predicates reject the host, host selection will be reattempted.
// Refer to :ref:`retry plugin configuration <<API key>>` for more
// details.
RetryHostPredicate []*<API key> `protobuf:"bytes,5,rep,name=<API key>,json=retryHostPredicate,proto3" json:"<API key>,omitempty"`
// The maximum number of times host selection will be reattempted before giving up, at which
// point the host that was last selected will be routed to. If unspecified, this will default to
// retrying once.
<API key> int64 `protobuf:"varint,6,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// HTTP status codes that should trigger a retry in addition to those specified by retry_on.
<API key> []uint32 `protobuf:"varint,7,rep,packed,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies parameters that control exponential retry back off. This parameter is optional, in which case the
// default base interval is 25 milliseconds or, if set, the current value of the
// `upstream.<API key>` runtime parameter. The default maximum interval is 10 times
// the base interval. The documentation for :ref:`<API key>`
// describes Envoy's back-off algorithm.
RetryBackOff *<API key> `protobuf:"bytes,8,opt,name=retry_back_off,json=retryBackOff,proto3" json:"retry_back_off,omitempty"`
// Specifies parameters that control a retry back-off strategy that is used
// when the request is rate limited by the upstream server. The server may
// return a response header like ``Retry-After`` or ``X-RateLimit-Reset`` to
// provide feedback to the client on how long to wait before retrying. If
// configured, this back-off strategy will be used instead of the
// default exponential back off strategy (configured using `retry_back_off`)
// whenever a response includes the matching headers.
<API key> *<API key> `protobuf:"bytes,11,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// HTTP response headers that trigger a retry if present in the response. A retry will be
// triggered if any of the header matches match the upstream response headers.
// The field is only consulted if 'retriable-headers' retry policy is active.
RetriableHeaders []*HeaderMatcher `protobuf:"bytes,9,rep,name=retriable_headers,json=retriableHeaders,proto3" json:"retriable_headers,omitempty"`
// HTTP headers which must be present in the request for retries to be attempted.
<API key> []*HeaderMatcher `protobuf:"bytes,10,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *RetryPolicy) Reset() {
*x = RetryPolicy{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RetryPolicy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RetryPolicy) ProtoMessage() {}
func (x *RetryPolicy) ProtoReflect() protoreflect.Message {
mi := &<API key>[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RetryPolicy.ProtoReflect.Descriptor instead.
func (*RetryPolicy) Descriptor() ([]byte, []int) {
return <API key>(), []int{7}
}
func (x *RetryPolicy) GetRetryOn() string {
if x != nil {
return x.RetryOn
}
return ""
}
func (x *RetryPolicy) GetNumRetries() *wrappers.UInt32Value {
if x != nil {
return x.NumRetries
}
return nil
}
func (x *RetryPolicy) GetPerTryTimeout() *duration.Duration {
if x != nil {
return x.PerTryTimeout
}
return nil
}
func (x *RetryPolicy) GetRetryPriority() *<API key> {
if x != nil {
return x.RetryPriority
}
return nil
}
func (x *RetryPolicy) <API key>() []*<API key> {
if x != nil {
return x.RetryHostPredicate
}
return nil
}
func (x *RetryPolicy) <API key>() int64 {
if x != nil {
return x.<API key>
}
return 0
}
func (x *RetryPolicy) <API key>() []uint32 {
if x != nil {
return x.<API key>
}
return nil
}
func (x *RetryPolicy) GetRetryBackOff() *<API key> {
if x != nil {
return x.RetryBackOff
}
return nil
}
func (x *RetryPolicy) <API key>() *<API key> {
if x != nil {
return x.<API key>
}
return nil
}
func (x *RetryPolicy) GetRetriableHeaders() []*HeaderMatcher {
if x != nil {
return x.RetriableHeaders
}
return nil
}
func (x *RetryPolicy) <API key>() []*HeaderMatcher {
if x != nil {
return x.<API key>
}
return nil
}
// HTTP request hedging :ref:`architecture overview <<API key>>`.
type HedgePolicy struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the number of initial requests that should be sent upstream.
// Must be at least 1.
// Defaults to 1.
// [#<API key>:]
InitialRequests *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=initial_requests,json=initialRequests,proto3" json:"initial_requests,omitempty"`
// Specifies a probability that an additional upstream request should be sent
// on top of what is specified by initial_requests.
// Defaults to 0.
// [#<API key>:]
<API key> *v32.FractionalPercent `protobuf:"bytes,2,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Indicates that a hedged request should be sent when the per-try timeout is hit.
// This means that a retry will be issued without resetting the original request, leaving multiple upstream requests in flight.
// The first request to complete successfully will be the one returned to the caller.
// * At any time, a successful response (i.e. not triggering any of the retry-on conditions) would be returned to the client.
// * Before per-try timeout, an error response (per retry-on conditions) would be retried immediately or returned ot the client
// if there are no more retries left.
// * After per-try timeout, an error response would be discarded, as a retry in the form of a hedged request is already in progress.
// Note: For this to have effect, you must have a :ref:`RetryPolicy <<API key>.route.v3.RetryPolicy>` that retries at least
// one error code and specifies a maximum number of retries.
// Defaults to false.
<API key> bool `protobuf:"varint,3,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *HedgePolicy) Reset() {
*x = HedgePolicy{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HedgePolicy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HedgePolicy) ProtoMessage() {}
func (x *HedgePolicy) ProtoReflect() protoreflect.Message {
mi := &<API key>[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HedgePolicy.ProtoReflect.Descriptor instead.
func (*HedgePolicy) Descriptor() ([]byte, []int) {
return <API key>(), []int{8}
}
func (x *HedgePolicy) GetInitialRequests() *wrappers.UInt32Value {
if x != nil {
return x.InitialRequests
}
return nil
}
func (x *HedgePolicy) <API key>() *v32.FractionalPercent {
if x != nil {
return x.<API key>
}
return nil
}
func (x *HedgePolicy) <API key>() bool {
if x != nil {
return x.<API key>
}
return false
}
// [#next-free-field: 10]
type RedirectAction struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// When the scheme redirection take place, the following rules apply:
// 1. If the source URI scheme is `http` and the port is explicitly
// set to `:80`, the port will be removed after the redirection
// 2. If the source URI scheme is `https` and the port is explicitly
// set to `:443`, the port will be removed after the redirection
// Types that are assignable to <API key>:
// *<API key>
// *<API key>
<API key> <API key> `protobuf_oneof:"<API key>"`
// The host portion of the URL will be swapped with this value.
HostRedirect string `protobuf:"bytes,1,opt,name=host_redirect,json=hostRedirect,proto3" json:"host_redirect,omitempty"`
// The port value of the URL will be swapped with this value.
PortRedirect uint32 `protobuf:"varint,8,opt,name=port_redirect,json=portRedirect,proto3" json:"port_redirect,omitempty"`
// Types that are assignable to <API key>:
// *<API key>
// *<API key>
// *<API key>
<API key> <API key> `protobuf_oneof:"<API key>"`
// The HTTP status code to use in the redirect response. The default response
// code is MOVED_PERMANENTLY (301).
ResponseCode <API key> `protobuf:"varint,3,opt,name=response_code,json=responseCode,proto3,enum=envoy.config.route.v3.<API key>" json:"response_code,omitempty"`
// Indicates that during redirection, the query portion of the URL will
// be removed. Default value is false.
StripQuery bool `protobuf:"varint,6,opt,name=strip_query,json=stripQuery,proto3" json:"strip_query,omitempty"`
}
func (x *RedirectAction) Reset() {
*x = RedirectAction{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RedirectAction) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RedirectAction) ProtoMessage() {}
func (x *RedirectAction) ProtoReflect() protoreflect.Message {
mi := &<API key>[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RedirectAction.ProtoReflect.Descriptor instead.
func (*RedirectAction) Descriptor() ([]byte, []int) {
return <API key>(), []int{9}
}
func (m *RedirectAction) <API key>() <API key> {
if m != nil {
return m.<API key>
}
return nil
}
func (x *RedirectAction) GetHttpsRedirect() bool {
if x, ok := x.<API key>().(*<API key>); ok {
return x.HttpsRedirect
}
return false
}
func (x *RedirectAction) GetSchemeRedirect() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.SchemeRedirect
}
return ""
}
func (x *RedirectAction) GetHostRedirect() string {
if x != nil {
return x.HostRedirect
}
return ""
}
func (x *RedirectAction) GetPortRedirect() uint32 {
if x != nil {
return x.PortRedirect
}
return 0
}
func (m *RedirectAction) <API key>() <API key> {
if m != nil {
return m.<API key>
}
return nil
}
func (x *RedirectAction) GetPathRedirect() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.PathRedirect
}
return ""
}
func (x *RedirectAction) GetPrefixRewrite() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.PrefixRewrite
}
return ""
}
func (x *RedirectAction) GetRegexRewrite() *v31.<API key> {
if x, ok := x.<API key>().(*<API key>); ok {
return x.RegexRewrite
}
return nil
}
func (x *RedirectAction) GetResponseCode() <API key> {
if x != nil {
return x.ResponseCode
}
return <API key>
}
func (x *RedirectAction) GetStripQuery() bool {
if x != nil {
return x.StripQuery
}
return false
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// The scheme portion of the URL will be swapped with "https".
HttpsRedirect bool `protobuf:"varint,4,opt,name=https_redirect,json=httpsRedirect,proto3,oneof"`
}
type <API key> struct {
// The scheme portion of the URL will be swapped with this value.
SchemeRedirect string `protobuf:"bytes,7,opt,name=scheme_redirect,json=schemeRedirect,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
type <API key> interface {
<API key>()
}
type <API key> struct {
// The path portion of the URL will be swapped with this value.
// Please note that query string in path_redirect will override the
// request's query string and will not be stripped.
// For example, let's say we have the following routes:
// - match: { path: "/old-path-1" }
// redirect: { path_redirect: "/new-path-1" }
// - match: { path: "/old-path-2" }
// redirect: { path_redirect: "/new-path-2", strip-query: "true" }
// - match: { path: "/old-path-3" }
// redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
// 1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
// 2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
// 3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
PathRedirect string `protobuf:"bytes,2,opt,name=path_redirect,json=pathRedirect,proto3,oneof"`
}
type <API key> struct {
// Indicates that during redirection, the matched prefix (or path)
// should be swapped with this value. This option allows redirect URLs be dynamically created
// based on the request.
// .. attention::
// Pay attention to the use of trailing slashes as mentioned in
// :ref:`RouteAction's prefix_rewrite <<API key>.route.v3.RouteAction.prefix_rewrite>`.
PrefixRewrite string `protobuf:"bytes,5,opt,name=prefix_rewrite,json=prefixRewrite,proto3,oneof"`
}
type <API key> struct {
// Indicates that during redirect, portions of the path that match the
// pattern should be rewritten, even allowing the substitution of capture
// groups from the pattern into the new path as specified by the rewrite
// substitution string. This is useful to allow application paths to be
// rewritten in a way that is aware of segments with variable content like
// identifiers.
// * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
// string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
// into ``/v1/api/instance/foo``.
// * The pattern ``one`` paired with a substitution string of ``two`` would
// transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
// * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
// ``\1two\2`` would replace only the first occurrence of ``one``,
// transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
// * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
// would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
// ``/aaa/yyy/bbb``.
RegexRewrite *v31.<API key> `protobuf:"bytes,9,opt,name=regex_rewrite,json=regexRewrite,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the HTTP response status to be returned.
Status uint32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
// Specifies the content of the response body. If this setting is omitted,
// no body is included in the generated response.
// .. note::
// Headers can be specified using *<API key>* in the enclosing
// :ref:`<API key>.route.v3.Route`, :ref:`<API key>.route.v3.RouteConfiguration` or
// :ref:`<API key>.route.v3.VirtualHost`.
Body *v3.DataSource `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{10}
}
func (x *<API key>) GetStatus() uint32 {
if x != nil {
return x.Status
}
return 0
}
func (x *<API key>) GetBody() *v3.DataSource {
if x != nil {
return x.Body
}
return nil
}
// [#<API key>:]
type NonForwardingAction struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *NonForwardingAction) Reset() {
*x = NonForwardingAction{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *NonForwardingAction) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*NonForwardingAction) ProtoMessage() {}
func (x *NonForwardingAction) ProtoReflect() protoreflect.Message {
mi := &<API key>[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use NonForwardingAction.ProtoReflect.Descriptor instead.
func (*NonForwardingAction) Descriptor() ([]byte, []int) {
return <API key>(), []int{11}
}
type Decorator struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The operation name associated with the request matched to this route. If tracing is
// enabled, this information will be used as the span name reported for this request.
// .. note::
// For ingress (inbound) requests, or egress (outbound) responses, this value may be overridden
// by the :ref:`<API key>
// <<API key>>` header.
Operation string `protobuf:"bytes,1,opt,name=operation,proto3" json:"operation,omitempty"`
// Whether the decorated details should be propagated to the other party. The default is true.
Propagate *wrappers.BoolValue `protobuf:"bytes,2,opt,name=propagate,proto3" json:"propagate,omitempty"`
}
func (x *Decorator) Reset() {
*x = Decorator{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Decorator) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Decorator) ProtoMessage() {}
func (x *Decorator) ProtoReflect() protoreflect.Message {
mi := &<API key>[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Decorator.ProtoReflect.Descriptor instead.
func (*Decorator) Descriptor() ([]byte, []int) {
return <API key>(), []int{12}
}
func (x *Decorator) GetOperation() string {
if x != nil {
return x.Operation
}
return ""
}
func (x *Decorator) GetPropagate() *wrappers.BoolValue {
if x != nil {
return x.Propagate
}
return nil
}
type Tracing struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Target percentage of requests managed by this HTTP connection manager that will be force
// traced if the :ref:`x-client-trace-id <<API key>>`
// header is set. This field is a direct analog for the runtime variable
// 'tracing.client_sampling' in the :ref:`HTTP Connection Manager
// <<API key>>`.
// Default: 100%
ClientSampling *v32.FractionalPercent `protobuf:"bytes,1,opt,name=client_sampling,json=clientSampling,proto3" json:"client_sampling,omitempty"`
// Target percentage of requests managed by this HTTP connection manager that will be randomly
// selected for trace generation, if not requested by the client or not forced. This field is
// a direct analog for the runtime variable 'tracing.random_sampling' in the
// :ref:`HTTP Connection Manager <<API key>>`.
// Default: 100%
RandomSampling *v32.FractionalPercent `protobuf:"bytes,2,opt,name=random_sampling,json=randomSampling,proto3" json:"random_sampling,omitempty"`
// Target percentage of requests managed by this HTTP connection manager that will be traced
// after all other sampling checks have been applied (client-directed, force tracing, random
// sampling). This field functions as an upper limit on the total configured sampling rate. For
// instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
// of client requests with the appropriate headers to be force traced. This field is a direct
// analog for the runtime variable 'tracing.global_enabled' in the
// :ref:`HTTP Connection Manager <<API key>>`.
// Default: 100%
OverallSampling *v32.FractionalPercent `protobuf:"bytes,3,opt,name=overall_sampling,json=overallSampling,proto3" json:"overall_sampling,omitempty"`
// A list of custom tags with unique tag name to create tags for the active span.
// It will take effect after merging with the :ref:`corresponding configuration
// <<API key>.filters.network.<API key>.v3.<API key>.Tracing.custom_tags>`
// configured in the HTTP connection manager. If two tags with the same name are configured
// each in the HTTP connection manager and the route level, the one configured here takes
// priority.
CustomTags []*v33.CustomTag `protobuf:"bytes,4,rep,name=custom_tags,json=customTags,proto3" json:"custom_tags,omitempty"`
}
func (x *Tracing) Reset() {
*x = Tracing{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Tracing) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Tracing) ProtoMessage() {}
func (x *Tracing) ProtoReflect() protoreflect.Message {
mi := &<API key>[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Tracing.ProtoReflect.Descriptor instead.
func (*Tracing) Descriptor() ([]byte, []int) {
return <API key>(), []int{13}
}
func (x *Tracing) GetClientSampling() *v32.FractionalPercent {
if x != nil {
return x.ClientSampling
}
return nil
}
func (x *Tracing) GetRandomSampling() *v32.FractionalPercent {
if x != nil {
return x.RandomSampling
}
return nil
}
func (x *Tracing) GetOverallSampling() *v32.FractionalPercent {
if x != nil {
return x.OverallSampling
}
return nil
}
func (x *Tracing) GetCustomTags() []*v33.CustomTag {
if x != nil {
return x.CustomTags
}
return nil
}
// A virtual cluster is a way of specifying a regex matching rule against
// certain important endpoints such that statistics are generated explicitly for
// the matched requests. The reason this is useful is that when doing
// prefix/path matching Envoy does not always know what the application
// emit per endpoint statistics. However, often systems have highly critical
// statistics are perfect in the sense that they are emitted on the downstream
// side such that they include network level failures.
// Documentation for :ref:`virtual cluster statistics <<API key>>`.
// .. note::
// Virtual clusters are a useful tool, but we do not recommend setting up a virtual cluster for
// every application endpoint. This is both not easily maintainable and as well the matching and
// statistics output are not free.
type VirtualCluster struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies a list of header matchers to use for matching requests. Each specified header must
// match. The pseudo-headers `:path` and `:method` can be used to match the request path and
// method, respectively.
Headers []*HeaderMatcher `protobuf:"bytes,4,rep,name=headers,proto3" json:"headers,omitempty"`
// Specifies the name of the virtual cluster. The virtual cluster name as well
// as the virtual host name are used when emitting statistics. The statistics are emitted by the
// router filter and are documented :ref:`here <<API key>>`.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// Deprecated: Do not use.
<API key> string `protobuf:"bytes,1,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> v3.RequestMethod `protobuf:"varint,3,opt,name=<API key>,json=<API key>,proto3,enum=envoy.config.core.v3.RequestMethod" json:"<API key>,omitempty"`
}
func (x *VirtualCluster) Reset() {
*x = VirtualCluster{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *VirtualCluster) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VirtualCluster) ProtoMessage() {}
func (x *VirtualCluster) ProtoReflect() protoreflect.Message {
mi := &<API key>[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use VirtualCluster.ProtoReflect.Descriptor instead.
func (*VirtualCluster) Descriptor() ([]byte, []int) {
return <API key>(), []int{14}
}
func (x *VirtualCluster) GetHeaders() []*HeaderMatcher {
if x != nil {
return x.Headers
}
return nil
}
func (x *VirtualCluster) GetName() string {
if x != nil {
return x.Name
}
return ""
}
// Deprecated: Do not use.
func (x *VirtualCluster) <API key>() string {
if x != nil {
return x.<API key>
}
return ""
}
// Deprecated: Do not use.
func (x *VirtualCluster) <API key>() v3.RequestMethod {
if x != nil {
return x.<API key>
}
return v3.<API key>
}
// Global rate limiting :ref:`architecture overview <<API key>>`.
// Also applies to Local rate limiting :ref:`using descriptors <<API key>>`.
type RateLimit struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Refers to the stage set in the filter. The rate limit configuration only
// applies to filters with the same stage number. The default stage number is
// .. note::
// The filter supports a range of 0 - 10 inclusively for stage numbers.
Stage *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=stage,proto3" json:"stage,omitempty"`
// The key to be set in runtime to disable this rate limit configuration.
DisableKey string `protobuf:"bytes,2,opt,name=disable_key,json=disableKey,proto3" json:"disable_key,omitempty"`
// A list of actions that are to be applied for this rate limit configuration.
// Order matters as the actions are processed sequentially and the descriptor
// is composed by appending descriptor entries in that sequence. If an action
// cannot append a descriptor entry, no descriptor is generated for the
// configuration. See :ref:`composing actions
// <<API key>>` for additional documentation.
Actions []*RateLimit_Action `protobuf:"bytes,3,rep,name=actions,proto3" json:"actions,omitempty"`
// An optional limit override to be appended to the descriptor produced by this
// rate limit configuration. If the override value is invalid or cannot be resolved
// from metadata, no override is provided. See :ref:`rate limit override
// <<API key>>` for more information.
Limit *RateLimit_Override `protobuf:"bytes,4,opt,name=limit,proto3" json:"limit,omitempty"`
}
func (x *RateLimit) Reset() {
*x = RateLimit{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RateLimit) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RateLimit) ProtoMessage() {}
func (x *RateLimit) ProtoReflect() protoreflect.Message {
mi := &<API key>[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RateLimit.ProtoReflect.Descriptor instead.
func (*RateLimit) Descriptor() ([]byte, []int) {
return <API key>(), []int{15}
}
func (x *RateLimit) GetStage() *wrappers.UInt32Value {
if x != nil {
return x.Stage
}
return nil
}
func (x *RateLimit) GetDisableKey() string {
if x != nil {
return x.DisableKey
}
return ""
}
func (x *RateLimit) GetActions() []*RateLimit_Action {
if x != nil {
return x.Actions
}
return nil
}
func (x *RateLimit) GetLimit() *RateLimit_Override {
if x != nil {
return x.Limit
}
return nil
}
// .. attention::
// Internally, Envoy always uses the HTTP/2 *:authority* header to represent the HTTP/1 *Host*
// header. Thus, if attempting to match on *Host*, match on *:authority* instead.
// .. attention::
// To route on HTTP method, use the special HTTP/2 *:method* header. This works for both
// HTTP/1 and HTTP/2 as Envoy normalizes headers. E.g.,
// .. code-block:: json
// "name": ":method",
// "exact_match": "POST"
// .. attention::
// In the absence of any header match specifier, match will default to :ref:`present_match
// <<API key>.route.v3.HeaderMatcher.present_match>`. i.e, a request that has the :ref:`name
// <<API key>.route.v3.HeaderMatcher.name>` header will match, regardless of the header's
// value.
// [
// [#next-free-field: 13]
type HeaderMatcher struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the name of the header in the request.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Specifies how the header match will be performed to route the request.
// Types that are assignable to <API key>:
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
<API key> <API key> `protobuf_oneof:"<API key>"`
// If specified, the match result will be inverted before checking. Defaults to false.
// Examples:
// * The regex ``\d{3}`` does not match the value *1234*, so it will match when inverted.
// * The range [-10,0) will match the value -1, so it will not match when inverted.
InvertMatch bool `protobuf:"varint,8,opt,name=invert_match,json=invertMatch,proto3" json:"invert_match,omitempty"`
}
func (x *HeaderMatcher) Reset() {
*x = HeaderMatcher{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HeaderMatcher) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HeaderMatcher) ProtoMessage() {}
func (x *HeaderMatcher) ProtoReflect() protoreflect.Message {
mi := &<API key>[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HeaderMatcher.ProtoReflect.Descriptor instead.
func (*HeaderMatcher) Descriptor() ([]byte, []int) {
return <API key>(), []int{16}
}
func (x *HeaderMatcher) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (m *HeaderMatcher) <API key>() <API key> {
if m != nil {
return m.<API key>
}
return nil
}
func (x *HeaderMatcher) GetExactMatch() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.ExactMatch
}
return ""
}
func (x *HeaderMatcher) GetSafeRegexMatch() *v31.RegexMatcher {
if x, ok := x.<API key>().(*<API key>); ok {
return x.SafeRegexMatch
}
return nil
}
func (x *HeaderMatcher) GetRangeMatch() *v32.Int64Range {
if x, ok := x.<API key>().(*<API key>); ok {
return x.RangeMatch
}
return nil
}
func (x *HeaderMatcher) GetPresentMatch() bool {
if x, ok := x.<API key>().(*<API key>); ok {
return x.PresentMatch
}
return false
}
func (x *HeaderMatcher) GetPrefixMatch() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.PrefixMatch
}
return ""
}
func (x *HeaderMatcher) GetSuffixMatch() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.SuffixMatch
}
return ""
}
func (x *HeaderMatcher) GetContainsMatch() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.ContainsMatch
}
return ""
}
// Deprecated: Do not use.
func (x *HeaderMatcher) <API key>() string {
if x, ok := x.<API key>().(*<API key>); ok {
return x.<API key>
}
return ""
}
func (x *HeaderMatcher) GetInvertMatch() bool {
if x != nil {
return x.InvertMatch
}
return false
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// If specified, header match will be performed based on the value of the header.
ExactMatch string `protobuf:"bytes,4,opt,name=exact_match,json=exactMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, this regex string is a regular expression rule which implies the entire request
// header value must match the regex. The rule will not match if only a subsequence of the
// request header value matches the regex.
SafeRegexMatch *v31.RegexMatcher `protobuf:"bytes,11,opt,name=safe_regex_match,json=safeRegexMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, header match will be performed based on range.
// The rule will match if the request header value is within this range.
// The entire request header value must represent an integer in base 10 notation: consisting of
// an optional plus or minus sign followed by a sequence of digits. The rule will not match if
// the header value does not represent an integer. Match will fail for empty values, floating
// point numbers or if only a subsequence of the header value is an integer.
// Examples:
// * For range [-10,0), route will match for header value -1, but not for 0, "somestring", 10.9,
// "-1somestring"
RangeMatch *v32.Int64Range `protobuf:"bytes,6,opt,name=range_match,json=rangeMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, header match will be performed based on whether the header is in the
// request.
PresentMatch bool `protobuf:"varint,7,opt,name=present_match,json=presentMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, header match will be performed based on the prefix of the header value.
// Note: empty prefix is not allowed, please use present_match instead.
// Examples:
// * The prefix *abcd* matches the value *abcdxyz*, but not for *abcxyz*.
PrefixMatch string `protobuf:"bytes,9,opt,name=prefix_match,json=prefixMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, header match will be performed based on the suffix of the header value.
// Note: empty suffix is not allowed, please use present_match instead.
// Examples:
// * The suffix *abcd* matches the value *xyzabcd*, but not for *xyzbcd*.
SuffixMatch string `protobuf:"bytes,10,opt,name=suffix_match,json=suffixMatch,proto3,oneof"`
}
type <API key> struct {
// If specified, header match will be performed based on whether the header value contains
// the given value or not.
// Note: empty contains match is not allowed, please use present_match instead.
// Examples:
// * The value *abcd* matches the value *xyzabcdpqr*, but not for *xyzbcdpqr*.
ContainsMatch string `protobuf:"bytes,12,opt,name=contains_match,json=containsMatch,proto3,oneof"`
}
type <API key> struct {
// Deprecated: Do not use.
<API key> string `protobuf:"bytes,5,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// Query parameter matching treats the query string of a request's :path header
// as an ampersand-separated list of keys and/or key=value elements.
// [#next-free-field: 7]
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the name of a key that must be present in the requested
// *path*'s query string.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Types that are assignable to <API key>:
// *<API key>
// *<API key>
<API key> <API key> `protobuf_oneof:"<API key>"`
// Deprecated: Do not use.
<API key> string `protobuf:"bytes,3,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Deprecated: Do not use.
<API key> *wrappers.BoolValue `protobuf:"bytes,4,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[17]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{17}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (m *<API key>) <API key>() <API key> {
if m != nil {
return m.<API key>
}
return nil
}
func (x *<API key>) GetStringMatch() *v31.StringMatcher {
if x, ok := x.<API key>().(*<API key>); ok {
return x.StringMatch
}
return nil
}
func (x *<API key>) GetPresentMatch() bool {
if x, ok := x.<API key>().(*<API key>); ok {
return x.PresentMatch
}
return false
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() string {
if x != nil {
return x.<API key>
}
return ""
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() *wrappers.BoolValue {
if x != nil {
return x.<API key>
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Specifies whether a query parameter value should match against a string.
StringMatch *v31.StringMatcher `protobuf:"bytes,5,opt,name=string_match,json=stringMatch,proto3,oneof"`
}
type <API key> struct {
// Specifies whether a query parameter should be present.
PresentMatch bool `protobuf:"varint,6,opt,name=present_match,json=presentMatch,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// HTTP Internal Redirect :ref:`architecture overview <<API key>>`.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// An internal redirect is not handled, unless the number of previous internal redirects that a
// downstream request has encountered is lower than this value.
// In the case where a downstream request is bounced among multiple routes by internal redirect,
// the first route that hits this threshold, or does not set :ref:`<API key>
// <<API key>.route.v3.RouteAction.<API key>>`
// will pass the redirect back to downstream.
// If not specified, at most one redirect will be followed.
<API key> *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Defines what upstream response codes are allowed to trigger internal redirect. If unspecified,
// only 302 will be treated as internal redirect.
// Only 301, 302, 303, 307 and 308 are valid values. Any other codes will be ignored.
<API key> []uint32 `protobuf:"varint,2,rep,packed,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of predicates that are queried when an upstream response is deemed
// to trigger an internal redirect by all other criteria. Any predicate in the list can reject
// the redirect, causing the response to be proxied to downstream.
// [#extension-category: envoy.<API key>]
Predicates []*v3.<API key> `protobuf:"bytes,3,rep,name=predicates,proto3" json:"predicates,omitempty"`
// Allow internal redirect to follow a target URI with a different scheme than the value of
// x-forwarded-proto. The default is false.
<API key> bool `protobuf:"varint,4,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[18]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{18}
}
func (x *<API key>) <API key>() *wrappers.UInt32Value {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) <API key>() []uint32 {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) GetPredicates() []*v3.<API key> {
if x != nil {
return x.Predicates
}
return nil
}
func (x *<API key>) <API key>() bool {
if x != nil {
return x.<API key>
}
return false
}
// A simple wrapper for an HTTP filter config. This is intended to be used as a wrapper for the
// map value in
// :ref:`VirtualHost.<API key><<API key>.route.v3.VirtualHost.<API key>>`,
// :ref:`Route.<API key><<API key>.route.v3.Route.<API key>>`,
// or :ref:`WeightedCluster.ClusterWeight.<API key><<API key>.route.v3.WeightedCluster.ClusterWeight.<API key>>`
// to add additional flags to the filter.
// [#<API key>:]
type FilterConfig struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The filter config.
Config *any.Any `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
// If true, the filter is optional, meaning that if the client does
// not support the specified filter, it may ignore the map entry rather
// than rejecting the config.
IsOptional bool `protobuf:"varint,2,opt,name=is_optional,json=isOptional,proto3" json:"is_optional,omitempty"`
}
func (x *FilterConfig) Reset() {
*x = FilterConfig{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FilterConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FilterConfig) ProtoMessage() {}
func (x *FilterConfig) ProtoReflect() protoreflect.Message {
mi := &<API key>[19]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FilterConfig.ProtoReflect.Descriptor instead.
func (*FilterConfig) Descriptor() ([]byte, []int) {
return <API key>(), []int{19}
}
func (x *FilterConfig) GetConfig() *any.Any {
if x != nil {
return x.Config
}
return nil
}
func (x *FilterConfig) GetIsOptional() bool {
if x != nil {
return x.IsOptional
}
return false
}
// [#next-free-field: 11]
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the upstream cluster. The cluster must exist in the
// :ref:`cluster manager configuration <<API key>>`.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// An integer between 0 and :ref:`total_weight
// <<API key>.route.v3.WeightedCluster.total_weight>`. When a request matches the route,
// the choice of an upstream cluster is determined by its weight. The sum of weights across all
// entries in the clusters array must add up to the total_weight, which defaults to 100.
Weight *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=weight,proto3" json:"weight,omitempty"`
// Optional endpoint metadata match criteria used by the subset load balancer. Only endpoints in
// the upstream cluster with metadata matching what is set in this field will be considered for
// load balancing. Note that this will be merged with what's provided in
// :ref:`RouteAction.metadata_match <<API key>.route.v3.RouteAction.metadata_match>`, with
// values here taking precedence. The filter name should be specified as *envoy.lb*.
MetadataMatch *v3.Metadata `protobuf:"bytes,3,opt,name=metadata_match,json=metadataMatch,proto3" json:"metadata_match,omitempty"`
// Specifies a list of headers to be added to requests when this cluster is selected
// through the enclosing :ref:`<API key>.route.v3.RouteAction`.
// Headers specified at this level are applied before headers from the enclosing
// :ref:`<API key>.route.v3.Route`, :ref:`<API key>.route.v3.VirtualHost`, and
// :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including details on
// header value syntax, see the documentation on :ref:`custom request headers
// <<API key>>`.
RequestHeadersToAdd []*v3.HeaderValueOption `protobuf:"bytes,4,rep,name=<API key>,json=requestHeadersToAdd,proto3" json:"<API key>,omitempty"`
// Specifies a list of HTTP headers that should be removed from each request when
// this cluster is selected through the enclosing :ref:`<API key>.route.v3.RouteAction`.
<API key> []string `protobuf:"bytes,9,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of headers to be added to responses when this cluster is selected
// through the enclosing :ref:`<API key>.route.v3.RouteAction`.
// Headers specified at this level are applied before headers from the enclosing
// :ref:`<API key>.route.v3.Route`, :ref:`<API key>.route.v3.VirtualHost`, and
// :ref:`<API key>.route.v3.RouteConfiguration`. For more information, including details on
// header value syntax, see the documentation on :ref:`custom request headers
// <<API key>>`.
<API key> []*v3.HeaderValueOption `protobuf:"bytes,5,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// Specifies a list of headers to be removed from responses when this cluster is selected
// through the enclosing :ref:`<API key>.route.v3.RouteAction`.
<API key> []string `protobuf:"bytes,6,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// The per_filter_config field can be used to provide weighted cluster-specific
// configurations for filters. The key should match the filter name, such as
// *envoy.filters.http.buffer* for the HTTP buffer filter. Use of this field is filter
// specific; see the :ref:`HTTP filter documentation <config_http_filters>`
// for if and how it is utilized.
// [#comment: An entry's value may be wrapped in a
// :ref:`FilterConfig<<API key>.route.v3.FilterConfig>`
// message to specify additional options.]
<API key> map[string]*any.Any `protobuf:"bytes,10,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Deprecated: Do not use.
<API key> map[string]*_struct.Struct `protobuf:"bytes,8,rep,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[24]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{3, 0}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *<API key>) GetWeight() *wrappers.UInt32Value {
if x != nil {
return x.Weight
}
return nil
}
func (x *<API key>) GetMetadataMatch() *v3.Metadata {
if x != nil {
return x.MetadataMatch
}
return nil
}
func (x *<API key>) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.RequestHeadersToAdd
}
return nil
}
func (x *<API key>) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) <API key>() []*v3.HeaderValueOption {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) <API key>() []string {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) <API key>() map[string]*any.Any {
if x != nil {
return x.<API key>
}
return nil
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() map[string]*_struct.Struct {
if x != nil {
return x.<API key>
}
return nil
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[27]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{4, 0}
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// If specified, the route will match against whether or not a certificate is presented.
// If not specified, certificate presentation status (true or false) will not be considered when route matching.
Presented *wrappers.BoolValue `protobuf:"bytes,1,opt,name=presented,proto3" json:"presented,omitempty"`
// If specified, the route will match against whether or not a certificate is validated.
// If not specified, certificate validation status (true or false) will not be considered when route matching.
Validated *wrappers.BoolValue `protobuf:"bytes,2,opt,name=validated,proto3" json:"validated,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[28]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{4, 1}
}
func (x *<API key>) GetPresented() *wrappers.BoolValue {
if x != nil {
return x.Presented
}
return nil
}
func (x *<API key>) GetValidated() *wrappers.BoolValue {
if x != nil {
return x.Validated
}
return nil
}
// An extensible message for matching CONNECT requests.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[29]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{4, 2}
}
// The router is capable of shadowing traffic from one cluster to another. The current
// implementation is "fire and forget," meaning Envoy will not wait for the shadow cluster to
// respond before returning the response from the primary cluster. All normal statistics are
// collected for the shadow cluster making this feature useful for testing.
// During shadowing, the host/authority header is altered such that *-shadow* is appended. This is
// useful for logging. For example, *cluster1* becomes *cluster1-shadow*.
// .. note::
// Shadowing will not be triggered if the primary cluster does not exist.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the cluster that requests will be mirrored to. The cluster must
// exist in the cluster manager configuration.
Cluster string `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
// If not specified, all requests to the target cluster will be mirrored.
// If specified, this field takes precedence over the `runtime_key` field and requests must also
// fall under the percentage of matches indicated by this field.
// For some fraction N/D, a random number in the range [0,D) is selected. If the
// number is <= the value of the numerator N, or if the key is not present, the default
// value, the request will be mirrored.
RuntimeFraction *v3.<API key> `protobuf:"bytes,3,opt,name=runtime_fraction,json=runtimeFraction,proto3" json:"runtime_fraction,omitempty"`
// Determines if the trace span should be sampled. Defaults to true.
TraceSampled *wrappers.BoolValue `protobuf:"bytes,4,opt,name=trace_sampled,json=traceSampled,proto3" json:"trace_sampled,omitempty"`
// Deprecated: Do not use.
<API key> string `protobuf:"bytes,2,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[30]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 0}
}
func (x *<API key>) GetCluster() string {
if x != nil {
return x.Cluster
}
return ""
}
func (x *<API key>) GetRuntimeFraction() *v3.<API key> {
if x != nil {
return x.RuntimeFraction
}
return nil
}
func (x *<API key>) GetTraceSampled() *wrappers.BoolValue {
if x != nil {
return x.TraceSampled
}
return nil
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() string {
if x != nil {
return x.<API key>
}
return ""
}
// Specifies the route's hashing policy if the upstream cluster uses a hashing :ref:`load balancer
// <<API key>>`.
// [#next-free-field: 7]
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to PolicySpecifier:
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
PolicySpecifier <API key> `protobuf_oneof:"policy_specifier"`
// The flag that short-circuits the hash computing. This field provides a
// 'fallback' style of configuration: "if a terminal policy doesn't work,
// fallback to rest of the policy list", it saves time when the terminal
// policy works.
// If true, and there is already a hash computed, ignore rest of the
// list of hash polices.
// For example, if the following hash methods are configured:
// specifier terminal
// Header A true
// Header B false
// Header C false
// The generateHash process ends if policy "header A" generates a hash, as
// it's a terminal policy.
Terminal bool `protobuf:"varint,4,opt,name=terminal,proto3" json:"terminal,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[31]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1}
}
func (m *<API key>) GetPolicySpecifier() <API key> {
if m != nil {
return m.PolicySpecifier
}
return nil
}
func (x *<API key>) GetHeader() *<API key> {
if x, ok := x.GetPolicySpecifier().(*<API key>); ok {
return x.Header
}
return nil
}
func (x *<API key>) GetCookie() *<API key> {
if x, ok := x.GetPolicySpecifier().(*<API key>); ok {
return x.Cookie
}
return nil
}
func (x *<API key>) <API key>() *<API key> {
if x, ok := x.GetPolicySpecifier().(*<API key>); ok {
return x.<API key>
}
return nil
}
func (x *<API key>) GetQueryParameter() *<API key> {
if x, ok := x.GetPolicySpecifier().(*<API key>); ok {
return x.QueryParameter
}
return nil
}
func (x *<API key>) GetFilterState() *<API key> {
if x, ok := x.GetPolicySpecifier().(*<API key>); ok {
return x.FilterState
}
return nil
}
func (x *<API key>) GetTerminal() bool {
if x != nil {
return x.Terminal
}
return false
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Header hash policy.
Header *<API key> `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}
type <API key> struct {
// Cookie hash policy.
Cookie *<API key> `protobuf:"bytes,2,opt,name=cookie,proto3,oneof"`
}
type <API key> struct {
// Connection properties hash policy.
<API key> *<API key> `protobuf:"bytes,3,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
type <API key> struct {
// Query parameter hash policy.
QueryParameter *<API key> `protobuf:"bytes,5,opt,name=query_parameter,json=queryParameter,proto3,oneof"`
}
type <API key> struct {
// Filter state hash policy.
FilterState *<API key> `protobuf:"bytes,6,opt,name=filter_state,json=filterState,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
// Allows enabling and disabling upgrades on a per-route basis.
// This overrides any enabled/disabled upgrade filter chain specified in the
// <API key>
// :ref:`upgrade_configs
// <<API key>.filters.network.<API key>.v3.<API key>.upgrade_configs>`
// but does not affect any custom filter chain specified there.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The case-insensitive name of this upgrade, e.g. "websocket".
// For each upgrade type present in upgrade_configs, requests with
// Upgrade: [upgrade_type] will be proxied upstream.
UpgradeType string `protobuf:"bytes,1,opt,name=upgrade_type,json=upgradeType,proto3" json:"upgrade_type,omitempty"`
// Determines if upgrades are available on this route. Defaults to true.
Enabled *wrappers.BoolValue `protobuf:"bytes,2,opt,name=enabled,proto3" json:"enabled,omitempty"`
// Configuration for sending data upstream as a raw data payload. This is used for
// CONNECT requests, when forwarding CONNECT payload as raw TCP.
// Note that CONNECT support is currently considered alpha in Envoy.
// [#comment: TODO(htuch): Replace the above comment with an alpha tag.]
ConnectConfig *<API key> `protobuf:"bytes,3,opt,name=connect_config,json=connectConfig,proto3" json:"connect_config,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[32]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 2}
}
func (x *<API key>) GetUpgradeType() string {
if x != nil {
return x.UpgradeType
}
return ""
}
func (x *<API key>) GetEnabled() *wrappers.BoolValue {
if x != nil {
return x.Enabled
}
return nil
}
func (x *<API key>) GetConnectConfig() *<API key> {
if x != nil {
return x.ConnectConfig
}
return nil
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the maximum duration allowed for streams on the route. If not specified, the value
// from the :ref:`max_stream_duration
// <<API key>.core.v3.HttpProtocolOptions.max_stream_duration>` field in
// :ref:`<API key>.<API key>
// <<API key>.filters.network.<API key>.v3.<API key>.<API key>>`
// is used. If this field is set explicitly to zero, any
// <API key> max_stream_duration timeout will be disabled for
// this route.
MaxStreamDuration *duration.Duration `protobuf:"bytes,1,opt,name=max_stream_duration,json=maxStreamDuration,proto3" json:"max_stream_duration,omitempty"`
// If present, and the request contains a `grpc-timeout header
// *max_stream_duration*, but limit the applied timeout to the maximum value specified here.
// If set to 0, the `grpc-timeout` header is used without modification.
<API key> *duration.Duration `protobuf:"bytes,2,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
// If present, Envoy will adjust the timeout provided by the `grpc-timeout` header by
// subtracting the provided duration from the header. This is useful for allowing Envoy to set
// its global timeout to be less than that of the deadline imposed by the calling client, which
// makes it more likely that Envoy will handle the timeout instead of having the call canceled
// by the client. If, after applying the offset, the resulting timeout is zero or negative,
// the stream will timeout immediately.
<API key> *duration.Duration `protobuf:"bytes,3,opt,name=<API key>,json=<API key>,proto3" json:"<API key>,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[33]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 3}
}
func (x *<API key>) <API key>() *duration.Duration {
if x != nil {
return x.MaxStreamDuration
}
return nil
}
func (x *<API key>) <API key>() *duration.Duration {
if x != nil {
return x.<API key>
}
return nil
}
func (x *<API key>) <API key>() *duration.Duration {
if x != nil {
return x.<API key>
}
return nil
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the request header that will be used to obtain the hash
// key. If the request header is not present, no hash will be produced.
HeaderName string `protobuf:"bytes,1,opt,name=header_name,json=headerName,proto3" json:"header_name,omitempty"`
// If specified, the request header value will be rewritten and used
// to produce the hash key.
RegexRewrite *v31.<API key> `protobuf:"bytes,2,opt,name=regex_rewrite,json=regexRewrite,proto3" json:"regex_rewrite,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[34]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[34]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1, 0}
}
func (x *<API key>) GetHeaderName() string {
if x != nil {
return x.HeaderName
}
return ""
}
func (x *<API key>) GetRegexRewrite() *v31.<API key> {
if x != nil {
return x.RegexRewrite
}
return nil
}
// Envoy supports two types of cookie affinity:
// 1. Passive. Envoy takes a cookie that's present in the cookies header and
// hashes on its value.
// 2. Generated. Envoy generates and sets a cookie with an expiration (TTL)
// on the first request from the client in its response to the client,
// based on the endpoint the request gets sent to. The client then
// presents this on the next and all subsequent requests. The hash of
// this is sufficient to ensure these requests get sent to the same
// endpoint. The cookie is generated by hashing the source and
// destination ports and addresses so that multiple independent HTTP2
// streams on the same connection will independently receive the same
// cookie, even if they arrive at the Envoy simultaneously.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the cookie that will be used to obtain the hash key. If the
// cookie is not present and ttl below is not set, no hash will be
// produced.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// If specified, a cookie with the TTL will be generated if the cookie is
// not present. If the TTL is present and zero, the generated cookie will
// be a session cookie.
Ttl *duration.Duration `protobuf:"bytes,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
// The name of the path for the cookie. If no path is specified here, no path
// will be set for the cookie.
Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[35]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[35]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1, 1}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *<API key>) GetTtl() *duration.Duration {
if x != nil {
return x.Ttl
}
return nil
}
func (x *<API key>) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Hash on source IP address.
SourceIp bool `protobuf:"varint,1,opt,name=source_ip,json=sourceIp,proto3" json:"source_ip,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[36]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[36]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1, 2}
}
func (x *<API key>) GetSourceIp() bool {
if x != nil {
return x.SourceIp
}
return false
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the URL query parameter that will be used to obtain the hash
// key. If the parameter is not present, no hash will be produced. Query
// parameter names are case-sensitive.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[37]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[37]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1, 3}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the Object in the per-request filterState, which is an
// Envoy::Http::Hashable object. If there is no data associated with the key,
// or the stored object is not Envoy::Http::Hashable, no hash will be produced.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[38]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[38]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 1, 4}
}
func (x *<API key>) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
// Configuration for sending data upstream as a raw data payload. This is used for
// CONNECT or POST requests, when forwarding request payload as raw TCP.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// If present, the proxy protocol header will be prepended to the CONNECT payload sent upstream.
ProxyProtocolConfig *v3.ProxyProtocolConfig `protobuf:"bytes,1,opt,name=<API key>,json=proxyProtocolConfig,proto3" json:"<API key>,omitempty"`
// If set, the route will also allow forwarding POST payload as raw TCP.
AllowPost bool `protobuf:"varint,2,opt,name=allow_post,json=allowPost,proto3" json:"allow_post,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[39]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[39]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{6, 2, 0}
}
func (x *<API key>) <API key>() *v3.ProxyProtocolConfig {
if x != nil {
return x.ProxyProtocolConfig
}
return nil
}
func (x *<API key>) GetAllowPost() bool {
if x != nil {
return x.AllowPost
}
return false
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// [#extension-category: envoy.retry_priorities]
// Types that are assignable to ConfigType:
// *<API key>
// *<API key>
ConfigType <API key> `protobuf_oneof:"config_type"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[40]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[40]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{7, 0}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (m *<API key>) GetConfigType() <API key> {
if m != nil {
return m.ConfigType
}
return nil
}
func (x *<API key>) GetTypedConfig() *any.Any {
if x, ok := x.GetConfigType().(*<API key>); ok {
return x.TypedConfig
}
return nil
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() *_struct.Struct {
if x, ok := x.GetConfigType().(*<API key>); ok {
return x.<API key>
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
TypedConfig *any.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}
type <API key> struct {
// Deprecated: Do not use.
<API key> *_struct.Struct `protobuf:"bytes,2,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// [#extension-category: envoy.<API key>]
// Types that are assignable to ConfigType:
// *<API key>
// *<API key>
ConfigType <API key> `protobuf_oneof:"config_type"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[41]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[41]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{7, 1}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (m *<API key>) GetConfigType() <API key> {
if m != nil {
return m.ConfigType
}
return nil
}
func (x *<API key>) GetTypedConfig() *any.Any {
if x, ok := x.GetConfigType().(*<API key>); ok {
return x.TypedConfig
}
return nil
}
// Deprecated: Do not use.
func (x *<API key>) <API key>() *_struct.Struct {
if x, ok := x.GetConfigType().(*<API key>); ok {
return x.<API key>
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
TypedConfig *any.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}
type <API key> struct {
// Deprecated: Do not use.
<API key> *_struct.Struct `protobuf:"bytes,2,opt,name=<API key>,json=<API key>,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the base interval between retries. This parameter is required and must be greater
// than zero. Values less than 1 ms are rounded up to 1 ms.
// See :ref:`<API key>` for a discussion of Envoy's
// back-off algorithm.
BaseInterval *duration.Duration `protobuf:"bytes,1,opt,name=base_interval,json=baseInterval,proto3" json:"base_interval,omitempty"`
// Specifies the maximum interval between retries. This parameter is optional, but must be
// greater than or equal to the `base_interval` if set. The default is 10 times the
// `base_interval`. See :ref:`<API key>` for a discussion
// of Envoy's back-off algorithm.
MaxInterval *duration.Duration `protobuf:"bytes,2,opt,name=max_interval,json=maxInterval,proto3" json:"max_interval,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[42]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[42]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{7, 2}
}
func (x *<API key>) GetBaseInterval() *duration.Duration {
if x != nil {
return x.BaseInterval
}
return nil
}
func (x *<API key>) GetMaxInterval() *duration.Duration {
if x != nil {
return x.MaxInterval
}
return nil
}
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the reset header.
// .. note::
// If the header appears multiple times only the first value is used.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// The format of the reset header.
Format <API key> `protobuf:"varint,2,opt,name=format,proto3,enum=envoy.config.route.v3.<API key>" json:"format,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[43]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[43]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{7, 3}
}
func (x *<API key>) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *<API key>) GetFormat() <API key> {
if x != nil {
return x.Format
}
return RetryPolicy_SECONDS
}
// A retry back-off strategy that applies when the upstream server rate limits
// the request.
// Given this configuration:
// .. code-block:: yaml
// <API key>:
// reset_headers:
// - name: Retry-After
// format: SECONDS
// - name: X-RateLimit-Reset
// format: UNIX_TIMESTAMP
// max_interval: "300s"
// The following algorithm will apply:
// 1. If the response contains the header ``Retry-After`` its value must be on
// the form ``120`` (an integer that represents the number of seconds to
// wait before retrying). If so, this value is used as the back-off interval.
// 2. Otherwise, if the response contains the header ``X-RateLimit-Reset`` its
// value must be on the form ``1595320702`` (an integer that represents the
// point in time at which to retry, as a Unix timestamp in seconds). If so,
// the current time is subtracted from this value and the result is used as
// the back-off interval.
// 3. Otherwise, Envoy will use the default
// :ref:`exponential back-off <<API key>.route.v3.RetryPolicy.retry_back_off>`
// strategy.
// No matter which format is used, if the resulting back-off interval exceeds
// ``max_interval`` it is discarded and the next header in ``reset_headers``
// is tried. If a request timeout is configured for the route it will further
// limit how long the request will be allowed to run.
// To prevent many clients retrying at the same point in time jitter is added
// to the back-off interval, so the resulting interval is decided by taking:
// ``random(interval, interval * 1.5)``.
// .. attention::
// Configuring ``<API key>`` will not by itself cause a request
// to be retried. You will still need to configure the right retry policy to match
// the responses from the upstream server.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Specifies the reset headers (like ``Retry-After`` or ``X-RateLimit-Reset``)
// to match against the response. Headers are tried in order, and matched case
// insensitive. The first header to be parsed successfully is used. If no headers
// match the default exponential back-off is used instead.
ResetHeaders []*<API key> `protobuf:"bytes,1,rep,name=reset_headers,json=resetHeaders,proto3" json:"reset_headers,omitempty"`
// Specifies the maximum back off interval that Envoy will allow. If a reset
// header contains an interval longer than this then it will be discarded and
// the next header will be tried. Defaults to 300 seconds.
MaxInterval *duration.Duration `protobuf:"bytes,2,opt,name=max_interval,json=maxInterval,proto3" json:"max_interval,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[44]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[44]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{7, 4}
}
func (x *<API key>) GetResetHeaders() []*<API key> {
if x != nil {
return x.ResetHeaders
}
return nil
}
func (x *<API key>) GetMaxInterval() *duration.Duration {
if x != nil {
return x.MaxInterval
}
return nil
}
// [#next-free-field: 10]
type RateLimit_Action struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to ActionSpecifier:
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
// *<API key>
ActionSpecifier <API key> `protobuf_oneof:"action_specifier"`
}
func (x *RateLimit_Action) Reset() {
*x = RateLimit_Action{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[45]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RateLimit_Action) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RateLimit_Action) ProtoMessage() {}
func (x *RateLimit_Action) ProtoReflect() protoreflect.Message {
mi := &<API key>[45]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RateLimit_Action.ProtoReflect.Descriptor instead.
func (*RateLimit_Action) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0}
}
func (m *RateLimit_Action) GetActionSpecifier() <API key> {
if m != nil {
return m.ActionSpecifier
}
return nil
}
func (x *RateLimit_Action) GetSourceCluster() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.SourceCluster
}
return nil
}
func (x *RateLimit_Action) <API key>() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.DestinationCluster
}
return nil
}
func (x *RateLimit_Action) GetRequestHeaders() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.RequestHeaders
}
return nil
}
func (x *RateLimit_Action) GetRemoteAddress() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.RemoteAddress
}
return nil
}
func (x *RateLimit_Action) GetGenericKey() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.GenericKey
}
return nil
}
func (x *RateLimit_Action) GetHeaderValueMatch() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.HeaderValueMatch
}
return nil
}
// Deprecated: Do not use.
func (x *RateLimit_Action) GetDynamicMetadata() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.DynamicMetadata
}
return nil
}
func (x *RateLimit_Action) GetMetadata() *<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.Metadata
}
return nil
}
func (x *RateLimit_Action) GetExtension() *v3.<API key> {
if x, ok := x.GetActionSpecifier().(*<API key>); ok {
return x.Extension
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Rate limit on source cluster.
SourceCluster *<API key> `protobuf:"bytes,1,opt,name=source_cluster,json=sourceCluster,proto3,oneof"`
}
type <API key> struct {
// Rate limit on destination cluster.
DestinationCluster *<API key> `protobuf:"bytes,2,opt,name=destination_cluster,json=destinationCluster,proto3,oneof"`
}
type <API key> struct {
// Rate limit on request headers.
RequestHeaders *<API key> `protobuf:"bytes,3,opt,name=request_headers,json=requestHeaders,proto3,oneof"`
}
type <API key> struct {
// Rate limit on remote address.
RemoteAddress *<API key> `protobuf:"bytes,4,opt,name=remote_address,json=remoteAddress,proto3,oneof"`
}
type <API key> struct {
// Rate limit on a generic key.
GenericKey *<API key> `protobuf:"bytes,5,opt,name=generic_key,json=genericKey,proto3,oneof"`
}
type <API key> struct {
// Rate limit on the existence of request headers.
HeaderValueMatch *<API key> `protobuf:"bytes,6,opt,name=header_value_match,json=headerValueMatch,proto3,oneof"`
}
type <API key> struct {
// Rate limit on dynamic metadata.
// .. attention::
// This field has been deprecated in favor of the :ref:`metadata <<API key>.route.v3.RateLimit.Action.metadata>` field
// Deprecated: Do not use.
DynamicMetadata *<API key> `protobuf:"bytes,7,opt,name=dynamic_metadata,json=dynamicMetadata,proto3,oneof"`
}
type <API key> struct {
// Rate limit on metadata.
Metadata *<API key> `protobuf:"bytes,8,opt,name=metadata,proto3,oneof"`
}
type <API key> struct {
// Rate limit descriptor extension. See the rate limit descriptor extensions documentation.
// [#extension-category: envoy.<API key>]
Extension *v3.<API key> `protobuf:"bytes,9,opt,name=extension,proto3,oneof"`
}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
func (*<API key>) <API key>() {}
type RateLimit_Override struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to OverrideSpecifier:
// *<API key>
OverrideSpecifier <API key> `protobuf_oneof:"override_specifier"`
}
func (x *RateLimit_Override) Reset() {
*x = RateLimit_Override{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[46]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RateLimit_Override) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RateLimit_Override) ProtoMessage() {}
func (x *RateLimit_Override) ProtoReflect() protoreflect.Message {
mi := &<API key>[46]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RateLimit_Override.ProtoReflect.Descriptor instead.
func (*RateLimit_Override) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 1}
}
func (m *RateLimit_Override) <API key>() <API key> {
if m != nil {
return m.OverrideSpecifier
}
return nil
}
func (x *RateLimit_Override) GetDynamicMetadata() *<API key> {
if x, ok := x.<API key>().(*<API key>); ok {
return x.DynamicMetadata
}
return nil
}
type <API key> interface {
<API key>()
}
type <API key> struct {
// Limit override from dynamic metadata.
DynamicMetadata *<API key> `protobuf:"bytes,1,opt,name=dynamic_metadata,json=dynamicMetadata,proto3,oneof"`
}
func (*<API key>) <API key>() {}
// The following descriptor entry is appended to the descriptor:
// .. code-block:: cpp
// ("source_cluster", "<local service cluster>")
// <local service cluster> is derived from the :option:`--service-cluster` option.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[47]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[47]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 0}
}
// The following descriptor entry is appended to the descriptor:
// .. code-block:: cpp
// ("destination_cluster", "<routed target cluster>")
// Once a request matches against a route table rule, a routed cluster is determined by one of
// the following :ref:`route table configuration <<API key>.route.v3.RouteConfiguration>`
// settings:
// * :ref:`cluster <<API key>.route.v3.RouteAction.cluster>` indicates the upstream cluster
// to route to.
// * :ref:`weighted_clusters <<API key>.route.v3.RouteAction.weighted_clusters>`
// chooses a cluster randomly from a set of clusters with attributed weight.
// * :ref:`cluster_header <<API key>.route.v3.RouteAction.cluster_header>` indicates which
// header in the request contains the target cluster.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[48]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[48]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 1}
}
// The following descriptor entry is appended when a header contains a key that matches the
// *header_name*:
// .. code-block:: cpp
// ("<descriptor_key>", "<<API key>>")
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// value is used to populate the value of the descriptor entry for the
// descriptor_key.
HeaderName string `protobuf:"bytes,1,opt,name=header_name,json=headerName,proto3" json:"header_name,omitempty"`
// The key to use in the descriptor entry.
DescriptorKey string `protobuf:"bytes,2,opt,name=descriptor_key,json=descriptorKey,proto3" json:"descriptor_key,omitempty"`
// If set to true, Envoy skips the descriptor while calling rate limiting service
// when header is not present in the request. By default it skips calling the
// rate limiting service if this header is not present in the request.
SkipIfAbsent bool `protobuf:"varint,3,opt,name=skip_if_absent,json=skipIfAbsent,proto3" json:"skip_if_absent,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[49]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[49]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 2}
}
func (x *<API key>) GetHeaderName() string {
if x != nil {
return x.HeaderName
}
return ""
}
func (x *<API key>) GetDescriptorKey() string {
if x != nil {
return x.DescriptorKey
}
return ""
}
func (x *<API key>) GetSkipIfAbsent() bool {
if x != nil {
return x.SkipIfAbsent
}
return false
}
// The following descriptor entry is appended to the descriptor and is populated using the
// trusted address from :ref:`x-forwarded-for <<API key>>`:
// .. code-block:: cpp
// ("remote_address", "<trusted address from x-forwarded-for>")
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[50]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[50]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 3}
}
// The following descriptor entry is appended to the descriptor:
// .. code-block:: cpp
// ("generic_key", "<descriptor_value>")
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The value to use in the descriptor entry.
DescriptorValue string `protobuf:"bytes,1,opt,name=descriptor_value,json=descriptorValue,proto3" json:"descriptor_value,omitempty"`
// An optional key to use in the descriptor entry. If not set it defaults
// to 'generic_key' as the descriptor key.
DescriptorKey string `protobuf:"bytes,2,opt,name=descriptor_key,json=descriptorKey,proto3" json:"descriptor_key,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[51]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[51]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 4}
}
func (x *<API key>) GetDescriptorValue() string {
if x != nil {
return x.DescriptorValue
}
return ""
}
func (x *<API key>) GetDescriptorKey() string {
if x != nil {
return x.DescriptorKey
}
return ""
}
// The following descriptor entry is appended to the descriptor:
// .. code-block:: cpp
// ("header_match", "<descriptor_value>")
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The value to use in the descriptor entry.
DescriptorValue string `protobuf:"bytes,1,opt,name=descriptor_value,json=descriptorValue,proto3" json:"descriptor_value,omitempty"`
// If set to true, the action will append a descriptor entry when the
// request matches the headers. If set to false, the action will append a
// descriptor entry when the request does not match the headers. The
// default value is true.
ExpectMatch *wrappers.BoolValue `protobuf:"bytes,2,opt,name=expect_match,json=expectMatch,proto3" json:"expect_match,omitempty"`
// Specifies a set of headers that the rate limit action should match
// specified headers in the config. A match will happen if all the
// headers in the config are present in the request with the same values
// (or based on presence if the value field is not in the config).
Headers []*HeaderMatcher `protobuf:"bytes,3,rep,name=headers,proto3" json:"headers,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[52]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[52]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 5}
}
func (x *<API key>) GetDescriptorValue() string {
if x != nil {
return x.DescriptorValue
}
return ""
}
func (x *<API key>) GetExpectMatch() *wrappers.BoolValue {
if x != nil {
return x.ExpectMatch
}
return nil
}
func (x *<API key>) GetHeaders() []*HeaderMatcher {
if x != nil {
return x.Headers
}
return nil
}
// The following descriptor entry is appended when the
// :ref:`dynamic metadata <<API key>>` contains a key value:
// .. code-block:: cpp
// ("<descriptor_key>", "<<API key>>")
// .. attention::
// This action has been deprecated in favor of the :ref:`metadata <<API key>.route.v3.RateLimit.Action.MetaData>` action
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key to use in the descriptor entry.
DescriptorKey string `protobuf:"bytes,1,opt,name=descriptor_key,json=descriptorKey,proto3" json:"descriptor_key,omitempty"`
// Metadata struct that defines the key and path to retrieve the string value. A match will
// only happen if the value in the dynamic metadata is of type string.
MetadataKey *v34.MetadataKey `protobuf:"bytes,2,opt,name=metadata_key,json=metadataKey,proto3" json:"metadata_key,omitempty"`
// An optional value to use if *metadata_key* is empty. If not set and
// no value is present under the metadata_key then no descriptor is generated.
DefaultValue string `protobuf:"bytes,3,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[53]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[53]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 6}
}
func (x *<API key>) GetDescriptorKey() string {
if x != nil {
return x.DescriptorKey
}
return ""
}
func (x *<API key>) GetMetadataKey() *v34.MetadataKey {
if x != nil {
return x.MetadataKey
}
return nil
}
func (x *<API key>) GetDefaultValue() string {
if x != nil {
return x.DefaultValue
}
return ""
}
// The following descriptor entry is appended when the metadata contains a key value:
// .. code-block:: cpp
// ("<descriptor_key>", "<<API key>>")
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key to use in the descriptor entry.
DescriptorKey string `protobuf:"bytes,1,opt,name=descriptor_key,json=descriptorKey,proto3" json:"descriptor_key,omitempty"`
// Metadata struct that defines the key and path to retrieve the string value. A match will
// only happen if the value in the metadata is of type string.
MetadataKey *v34.MetadataKey `protobuf:"bytes,2,opt,name=metadata_key,json=metadataKey,proto3" json:"metadata_key,omitempty"`
// An optional value to use if *metadata_key* is empty. If not set and
// no value is present under the metadata_key then no descriptor is generated.
DefaultValue string `protobuf:"bytes,3,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
// Source of metadata
Source <API key> `protobuf:"varint,4,opt,name=source,proto3,enum=envoy.config.route.v3.<API key>" json:"source,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[54]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[54]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 0, 7}
}
func (x *<API key>) GetDescriptorKey() string {
if x != nil {
return x.DescriptorKey
}
return ""
}
func (x *<API key>) GetMetadataKey() *v34.MetadataKey {
if x != nil {
return x.MetadataKey
}
return nil
}
func (x *<API key>) GetDefaultValue() string {
if x != nil {
return x.DefaultValue
}
return ""
}
func (x *<API key>) GetSource() <API key> {
if x != nil {
return x.Source
}
return <API key>
}
// Fetches the override from the dynamic metadata.
type <API key> struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Metadata struct that defines the key and path to retrieve the struct value.
// The value must be a struct containing an integer "requests_per_unit" property
// and a "unit" property with a value parseable to :ref:`RateLimitUnit
// enum <<API key>.v3.RateLimitUnit>`
MetadataKey *v34.MetadataKey `protobuf:"bytes,1,opt,name=metadata_key,json=metadataKey,proto3" json:"metadata_key,omitempty"`
}
func (x *<API key>) Reset() {
*x = <API key>{}
if protoimpl.UnsafeEnabled {
mi := &<API key>[55]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *<API key>) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*<API key>) ProtoMessage() {}
func (x *<API key>) ProtoReflect() protoreflect.Message {
mi := &<API key>[55]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use <API key>.ProtoReflect.Descriptor instead.
func (*<API key>) Descriptor() ([]byte, []int) {
return <API key>(), []int{15, 1, 0}
}
func (x *<API key>) GetMetadataKey() *v34.MetadataKey {
if x != nil {
return x.MetadataKey
}
return nil
}
var <API key> protoreflect.FileDescriptor
var <API key> = []byte{
0x0a, 0x2c, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2f, 0x76, 0x33, 0x2f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75,
0x74, 0x65, 0x2e, 0x76, 0x33, 0x1a, 0x1f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x76, 0x33, 0x2f, 0x62, 0x61, 0x73, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x76, 0x33, 0x2f, 0x65, 0x78, 0x74,
0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x29, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f,
0x76, 0x33, 0x2f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x74,
0x79, 0x70, 0x65, 0x2f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2f, 0x76, 0x33, 0x2f, 0x72,
0x65, 0x67, 0x65, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x22, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2f, 0x76,
0x33, 0x2f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x2f, 0x76, 0x33, 0x2f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x74, 0x79, 0x70,
0x65, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x33, 0x2f, 0x63, 0x75, 0x73,
0x74, 0x6f, 0x6d, 0x5f, 0x74, 0x61, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x76, 0x33, 0x2f, 0x70, 0x65, 0x72,
0x63, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x76, 0x33, 0x2f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x23,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x2f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x75, 0x64, 0x70, 0x61, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x1a, 0x1d, 0x75, 0x64, 0x70, 0x61, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x1a, 0x21, 0x75, 0x64, 0x70, 0x61, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f,
0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe2,
0x0e, 0x0a, 0x0b, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x1b,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42,
0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x07, 0x64,
0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x42, 0x12, 0xfa, 0x42,
0x0f, 0x92, 0x01, 0x0c, 0x08, 0x01, 0x22, 0x08, 0x72, 0x06, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00,
0x52, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x34, 0x0a, 0x06, 0x72, 0x6f, 0x75,
0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12,
0x60, 0x0a, 0x0b, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x5f, 0x74, 0x6c, 0x73, 0x18, 0x04,
0x20, 0x01, 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x56, 0x69, 0x72,
0x74, 0x75, 0x61, 0x6c, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x54, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75,
0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x42, 0x08, 0xfa, 0x42, 0x05,
0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x54, 0x6c,
0x73, 0x12, 0x50, 0x0a, 0x10, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x63, 0x6c, 0x75,
0x73, 0x74, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x6c, 0x75, 0x73, 0x74,
0x65, 0x72, 0x52, 0x0f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x6c, 0x75, 0x73, 0x74,
0x65, 0x72, 0x73, 0x12, 0x41, 0x0a, 0x0b, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69,
0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x0a, 0x72, 0x61, 0x74, 0x65,
0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x12, 0x67, 0x0a, 0x16, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64,
0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65,
0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42,
0x09, 0xfa, 0x42, 0x06, 0x92, 0x01, 0x03, 0x10, 0xe8, 0x07, 0x52, 0x13, 0x72, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x41, 0x64, 0x64, 0x12,
0x4d, 0x0a, 0x19, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x0d, 0x20, 0x03,
0x28, 0x09, 0x42, 0x12, 0xfa, 0x42, 0x0f, 0x92, 0x01, 0x0c, 0x22, 0x0a, 0x72, 0x08, 0x10, 0x01,
0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x16, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48,
0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x69,
0x0a, 0x17, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x27, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63,
0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xfa, 0x42, 0x06, 0x92, 0x01, 0x03,
0x10, 0xe8, 0x07, 0x52, 0x14, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61,
0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x41, 0x64, 0x64, 0x12, 0x4f, 0x0a, 0x1a, 0x72, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f,
0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x09, 0x42, 0x12, 0xfa,
0x42, 0x0f, 0x92, 0x01, 0x0c, 0x22, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01,
0x00, 0x52, 0x17, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x54, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x35, 0x0a, 0x04, 0x63, 0x6f,
0x72, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x43, 0x6f, 0x72, 0x73, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x04, 0x63, 0x6f, 0x72,
0x73, 0x12, 0x73, 0x0a, 0x17, 0x74, 0x79, 0x70, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66,
0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x0f, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x56, 0x69, 0x72, 0x74, 0x75,
0x61, 0x6c, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46,
0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x14, 0x74, 0x79, 0x70, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x41, 0x0a, 0x1d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64,
0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70,
0x74, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x1a, 0x69,
0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x74, 0x74,
0x65, 0x6d, 0x70, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x48, 0x0a, 0x21, 0x69, 0x6e, 0x63,
0x6c, 0x75, 0x64, 0x65, 0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, 0x63, 0x6f, 0x75,
0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x13,
0x20, 0x01, 0x28, 0x08, 0x52, 0x1d, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x41, 0x74, 0x74,
0x65, 0x6d, 0x70, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x70, 0x6f, 0x6c,
0x69, 0x63, 0x79, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x72,
0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x4f, 0x0a, 0x19, 0x72, 0x65,
0x74, 0x72, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x64,
0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x41, 0x6e, 0x79, 0x52, 0x16, 0x72, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x54, 0x79, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x45, 0x0a, 0x0c, 0x68,
0x65, 0x64, 0x67, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x11, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x22, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x64, 0x67, 0x65, 0x50,
0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x68, 0x65, 0x64, 0x67, 0x65, 0x50, 0x6f, 0x6c, 0x69,
0x63, 0x79, 0x12, 0x60, 0x0a, 0x1e, 0x70, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x5f, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x62,
0x79, 0x74, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e,
0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x1a, 0x70, 0x65, 0x72, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x42,
0x79, 0x74, 0x65, 0x73, 0x12, 0xb2, 0x01, 0x0a, 0x29, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64,
0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4c, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x48, 0x6f, 0x73, 0x74, 0x2e, 0x48, 0x69, 0x64,
0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74,
0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03,
0x33, 0x2e, 0x30, 0x52, 0x24, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79,
0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c,
0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x5d, 0x0a, 0x19, 0x54, 0x79, 0x70,
0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x70, 0x0a, 0x29, 0x48, 0x69, 0x64, 0x64,
0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65,
0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3a, 0x0a, 0x12, 0x54, 0x6c,
0x73, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65,
0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x45, 0x58,
0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x01, 0x12, 0x07, 0x0a,
0x03, 0x41, 0x4c, 0x4c, 0x10, 0x02, 0x3a, 0x25, 0x9a, 0xc5, 0x88, 0x1e, 0x20, 0x0a, 0x1e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x2e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x48, 0x6f, 0x73, 0x74, 0x4a, 0x04, 0x08,
0x09, 0x10, 0x0a, 0x22, 0x64, 0x0a, 0x0c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x3a, 0x26, 0x9a, 0xc5, 0x88, 0x1e, 0x21, 0x0a, 0x1f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x46, 0x69, 0x6c,
0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x96, 0x0d, 0x0a, 0x05, 0x52, 0x6f,
0x75, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28,
0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x41, 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52,
0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, 0x01,
0x02, 0x10, 0x01, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x3a, 0x0a, 0x05, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52,
0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x43, 0x0a, 0x08, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65,
0x63, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48,
0x00, 0x52, 0x08, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x12, 0x56, 0x0a, 0x0f, 0x64,
0x69, 0x72, 0x65, 0x63, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x07,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x44, 0x69, 0x72,
0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x48, 0x00, 0x52, 0x0e, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x0d, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48,
0x00, 0x52, 0x0c, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12,
0x60, 0x0a, 0x15, 0x6e, 0x6f, 0x6e, 0x5f, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e,
0x67, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x4e, 0x6f, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72,
0x64, 0x69, 0x6e, 0x67, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x13, 0x6e, 0x6f,
0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x12, 0x3a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3e, 0x0a,
0x09, 0x64, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74,
0x6f, 0x72, 0x52, 0x09, 0x64, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x6d, 0x0a,
0x17, 0x74, 0x79, 0x70, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x54, 0x79, 0x70,
0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x74, 0x79, 0x70, 0x65, 0x64, 0x50, 0x65, 0x72,
0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x67, 0x0a, 0x16,
0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f,
0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xfa, 0x42, 0x06, 0x92, 0x01, 0x03, 0x10, 0xe8, 0x07,
0x52, 0x13, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73,
0x54, 0x6f, 0x41, 0x64, 0x64, 0x12, 0x4d, 0x0a, 0x19, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x6d, 0x6f,
0x76, 0x65, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x42, 0x12, 0xfa, 0x42, 0x0f, 0x92, 0x01, 0x0c,
0x22, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x16, 0x72, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x52, 0x65,
0x6d, 0x6f, 0x76, 0x65, 0x12, 0x69, 0x0a, 0x17, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64, 0x18,
0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61,
0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09,
0xfa, 0x42, 0x06, 0x92, 0x01, 0x03, 0x10, 0xe8, 0x07, 0x52, 0x14, 0x72, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x41, 0x64, 0x64, 0x12,
0x4f, 0x0a, 0x1a, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64,
0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x0b, 0x20,
0x03, 0x28, 0x09, 0x42, 0x12, 0xfa, 0x42, 0x0f, 0x92, 0x01, 0x0c, 0x22, 0x0a, 0x72, 0x08, 0x10,
0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x17, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65,
0x12, 0x38, 0x0a, 0x07, 0x74, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x69, 0x6e,
0x67, 0x52, 0x07, 0x74, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x12, 0x60, 0x0a, 0x1e, 0x70, 0x65,
0x72, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x10, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x52, 0x1a, 0x70, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x75, 0x66, 0x66,
0x65, 0x72, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0xac, 0x01, 0x0a,
0x29, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65,
0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x6c,
0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x46, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x48,
0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63,
0x61, 0x74, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8,
0x04, 0x03, 0x33, 0x2e, 0x30, 0x52, 0x24, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76,
0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46,
0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x5d, 0x0a, 0x19, 0x54,
0x79, 0x70, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x70, 0x0a, 0x29, 0x48, 0x69,
0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61,
0x74, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63,
0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a, 0x1f, 0x9a, 0xc5,
0x88, 0x1e, 0x1a, 0x0a, 0x18, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76,
0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x42, 0x0d, 0x0a,
0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x03, 0xf8, 0x42, 0x01, 0x4a, 0x04, 0x08, 0x06,
0x10, 0x07, 0x22, 0x8b, 0x0b, 0x0a, 0x0f, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43,
0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65,
0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x08,
0xfa, 0x42, 0x05, 0x92, 0x01, 0x02, 0x08, 0x01, 0x52, 0x08, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65,
0x72, 0x73, 0x12, 0x48, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x77, 0x65, 0x69, 0x67,
0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33,
0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x2a, 0x02, 0x28, 0x01, 0x52,
0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2c, 0x0a, 0x12,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x70, 0x72, 0x65, 0x66,
0x69, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x4b, 0x65, 0x79, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x1a, 0xf8, 0x08, 0x0a, 0x0d, 0x43,
0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1b, 0x0a, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72,
0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x77, 0x65, 0x69,
0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74,
0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12,
0x45, 0x0a, 0x0e, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6d, 0x61, 0x74, 0x63,
0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0d, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x67, 0x0a, 0x16, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64,
0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65,
0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42,
0x09, 0xfa, 0x42, 0x06, 0x92, 0x01, 0x03, 0x10, 0xe8, 0x07, 0x52, 0x13, 0x72, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x41, 0x64, 0x64, 0x12,
0x4b, 0x0a, 0x19, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x09, 0x20, 0x03,
0x28, 0x09, 0x42, 0x10, 0xfa, 0x42, 0x0d, 0x92, 0x01, 0x0a, 0x22, 0x08, 0x72, 0x06, 0xc0, 0x01,
0x01, 0xc8, 0x01, 0x00, 0x52, 0x16, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61,
0x64, 0x65, 0x72, 0x73, 0x54, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x69, 0x0a, 0x17,
0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73,
0x5f, 0x74, 0x6f, 0x5f, 0x61, 0x64, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72,
0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x09, 0xfa, 0x42, 0x06, 0x92, 0x01, 0x03, 0x10, 0xe8,
0x07, 0x52, 0x14, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x54, 0x6f, 0x41, 0x64, 0x64, 0x12, 0x4d, 0x0a, 0x1a, 0x72, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x72,
0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x42, 0x10, 0xfa, 0x42, 0x0d,
0x92, 0x01, 0x0a, 0x22, 0x08, 0x72, 0x06, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x17, 0x72,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x54, 0x6f,
0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x85, 0x01, 0x0a, 0x17, 0x74, 0x79, 0x70, 0x65, 0x64,
0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x4e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x54,
0x79, 0x70, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x14, 0x74, 0x79, 0x70, 0x65, 0x64, 0x50,
0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0xc4,
0x01, 0x0a, 0x29, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f,
0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x66,
0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x08, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x5e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x57, 0x65, 0x69, 0x67, 0x68,
0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74,
0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x48, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45,
0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50, 0x65,
0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0x52,
0x24, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72,
0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50, 0x65, 0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x5d, 0x0a, 0x19, 0x54, 0x79, 0x70, 0x65, 0x64, 0x50, 0x65,
0x72, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x03, 0x6b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x3a, 0x02, 0x38, 0x01, 0x1a, 0x70, 0x0a, 0x29, 0x48, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e,
0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50, 0x65, 0x72,
0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x2d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x3a, 0x37, 0x9a, 0xc5, 0x88, 0x1e, 0x32, 0x0a, 0x30, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
0x72, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x4a,
0x04, 0x08, 0x07, 0x10, 0x08, 0x3a, 0x29, 0x9a, 0xc5, 0x88, 0x1e, 0x24, 0x0a, 0x22, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x22, 0x9e, 0x09, 0x0a, 0x0a, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12,
0x18, 0x0a, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48,
0x00, 0x52, 0x06, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x14, 0x0a, 0x04, 0x70, 0x61, 0x74,
0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12,
0x4e, 0x0a, 0x0a, 0x73, 0x61, 0x66, 0x65, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x0a, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x67, 0x65,
0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, 0x01, 0x02,
0x10, 0x01, 0x48, 0x00, 0x52, 0x09, 0x73, 0x61, 0x66, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x12,
0x5b, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68,
0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x43, 0x6f, 0x6e, 0x6e,
0x65, 0x63, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0e, 0x63, 0x6f,
0x6e, 0x6e, 0x65, 0x63, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x12, 0x5e, 0x0a, 0x1d,
0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70,
0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x03, 0x20,
0x01, 0x28, 0x09, 0x42, 0x19, 0x18, 0x01, 0xfa, 0x42, 0x05, 0x72, 0x03, 0x28, 0x80, 0x08, 0x92,
0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x48, 0x00,
0x52, 0x1a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70,
0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x67, 0x65, 0x78, 0x12, 0x41, 0x0a, 0x0e,
0x63, 0x61, 0x73, 0x65, 0x5f, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x18, 0x04,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x52, 0x0d, 0x63, 0x61, 0x73, 0x65, 0x53, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x12,
0x59, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x52, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x07, 0x68, 0x65,
0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65,
0x72, 0x52, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x57, 0x0a, 0x10, 0x71, 0x75,
0x65, 0x72, 0x79, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x07,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x51, 0x75, 0x65,
0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68,
0x65, 0x72, 0x52, 0x0f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74,
0x65, 0x72, 0x73, 0x12, 0x4b, 0x0a, 0x04, 0x67, 0x72, 0x70, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x37, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61,
0x74, 0x63, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x04, 0x67, 0x72, 0x70, 0x63,
0x12, 0x59, 0x0a, 0x0b, 0x74, 0x6c, 0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18,
0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f,
0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x54, 0x6c, 0x73, 0x43, 0x6f, 0x6e, 0x74,
0x65, 0x78, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52,
0x0a, 0x74, 0x6c, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x1a, 0x53, 0x0a, 0x15, 0x47,
0x72, 0x70, 0x63, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x3a, 0x9a, 0xc5, 0x88, 0x1e, 0x35, 0x0a, 0x33, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x52,
0x6f, 0x75, 0x74, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1a, 0xc9, 0x01, 0x0a, 0x16, 0x54, 0x6c, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x38, 0x0a, 0x09, 0x70,
0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x70, 0x72, 0x65, 0x73,
0x65, 0x6e, 0x74, 0x65, 0x64, 0x12, 0x38, 0x0a, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x64, 0x3a,
0x3b, 0x9a, 0xc5, 0x88, 0x1e, 0x36, 0x0a, 0x34, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65,
0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x54, 0x6c, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x10, 0x0a, 0x0e,
0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x3a, 0x24,
0x9a, 0xc5, 0x88, 0x1e, 0x1f, 0x0a, 0x1d, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69,
0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x42, 0x15, 0x0a, 0x0e, 0x70, 0x61, 0x74, 0x68, 0x5f, 0x73, 0x70, 0x65,
0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x03, 0xf8, 0x42, 0x01, 0x4a, 0x04, 0x08, 0x05, 0x10,
0x06, 0x22, 0xfb, 0x06, 0x0a, 0x0a, 0x43, 0x6f, 0x72, 0x73, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x12, 0x5f, 0x0a, 0x19, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e,
0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x0b, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x53, 0x74, 0x72, 0x69,
0x6e, 0x67, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x52, 0x16, 0x61, 0x6c, 0x6c, 0x6f, 0x77,
0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x74, 0x63,
0x68, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f,
0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x4d,
0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61,
0x6c, 0x6c, 0x6f, 0x77, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x65,
0x78, 0x70, 0x6f, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x04, 0x20,
0x01, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x78, 0x70, 0x6f, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20,
0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x61, 0x78, 0x41, 0x67, 0x65, 0x12, 0x47, 0x0a, 0x11, 0x61,
0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73,
0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x52, 0x10, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74,
0x69, 0x61, 0x6c, 0x73, 0x12, 0x57, 0x0a, 0x0e, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x65,
0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0d,
0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x76, 0x0a,
0x1f, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65,
0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64,
0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8,
0xee, 0xf2, 0xd2, 0x05, 0x01, 0x48, 0x00, 0x52, 0x1c, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45,
0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x45, 0x6e,
0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x55, 0x0a, 0x0e, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x5f,
0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72,
0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x52, 0x0d, 0x73,
0x68, 0x61, 0x64, 0x6f, 0x77, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x61, 0x0a, 0x24,
0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70,
0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6f, 0x72,
0x69, 0x67, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7,
0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x52, 0x20, 0x68,
0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63,
0x61, 0x74, 0x65, 0x64, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x12,
0x73, 0x0a, 0x2a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f,
0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x6f, 0x77,
0x5f, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x08, 0x20,
0x03, 0x28, 0x09, 0x42, 0x18, 0x18, 0x01, 0xfa, 0x42, 0x0a, 0x92, 0x01, 0x07, 0x22, 0x05, 0x72,
0x03, 0x28, 0x80, 0x08, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0x52, 0x25, 0x68,
0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63,
0x61, 0x74, 0x65, 0x64, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x52,
0x65, 0x67, 0x65, 0x78, 0x3a, 0x24, 0x9a, 0xc5, 0x88, 0x1e, 0x1f, 0x0a, 0x1d, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x43, 0x6f, 0x72, 0x73, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x13, 0x0a, 0x11, 0x65, 0x6e,
0x61, 0x62, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x22,
0xce, 0x28, 0x0a, 0x0b, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12,
0x23, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x07, 0x63, 0x6c, 0x75,
0x73, 0x74, 0x65, 0x72, 0x12, 0x36, 0x0a, 0x0e, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0d, 0xfa, 0x42,
0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x48, 0x00, 0x52, 0x0d, 0x63,
0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x11,
0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e,
0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x48,
0x00, 0x52, 0x10, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x75, 0x73, 0x74,
0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x1f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x5f,
0x6e, 0x6f, 0x74, 0x5f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3e, 0x2e,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75,
0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e,
0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x42, 0x08, 0xfa,
0x42, 0x05, 0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x1b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x43, 0x6f, 0x64, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x0d, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x32, 0x0a, 0x0e, 0x70,
0x72, 0x65, 0x66, 0x69, 0x78, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x05, 0x20,
0x01, 0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42, 0x08, 0x72, 0x06, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00,
0x52, 0x0d, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x12,
0x53, 0x0a, 0x0d, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65,
0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74,
0x79, 0x70, 0x65, 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52,
0x65, 0x67, 0x65, 0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x41, 0x6e, 0x64, 0x53, 0x75, 0x62, 0x73,
0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x52, 0x0c, 0x72, 0x65, 0x67, 0x65, 0x78, 0x52, 0x65, 0x77,
0x72, 0x69, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x14, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x77,
0x72, 0x69, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x74, 0x65, 0x72, 0x61, 0x6c, 0x18, 0x06, 0x20, 0x01,
0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42, 0x08, 0x72, 0x06, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00, 0x48,
0x01, 0x52, 0x12, 0x68, 0x6f, 0x73, 0x74, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x4c, 0x69,
0x74, 0x65, 0x72, 0x61, 0x6c, 0x12, 0x48, 0x0a, 0x11, 0x61, 0x75, 0x74, 0x6f, 0x5f, 0x68, 0x6f,
0x73, 0x74, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x01, 0x52, 0x0f,
0x61, 0x75, 0x74, 0x6f, 0x48, 0x6f, 0x73, 0x74, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x12,
0x3d, 0x0a, 0x13, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42,
0x08, 0x72, 0x06, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x48, 0x01, 0x52, 0x11, 0x68, 0x6f, 0x73,
0x74, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x67,
0x0a, 0x17, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x70,
0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x23, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d, 0x61, 0x74,
0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d, 0x61, 0x74,
0x63, 0x68, 0x41, 0x6e, 0x64, 0x53, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x48,
0x01, 0x52, 0x14, 0x68, 0x6f, 0x73, 0x74, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x50, 0x61,
0x74, 0x68, 0x52, 0x65, 0x67, 0x65, 0x78, 0x12, 0x33, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f,
0x75, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x3c, 0x0a, 0x0c,
0x69, 0x64, 0x6c, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x18, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x69,
0x64, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x45, 0x0a, 0x0c, 0x72, 0x65,
0x74, 0x72, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x22, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f,
0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x72, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63,
0x79, 0x12, 0x4f, 0x0a, 0x19, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63,
0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x21,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x16, 0x72, 0x65, 0x74, 0x72,
0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x54, 0x79, 0x70, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x12, 0x6e, 0x0a, 0x17, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x69,
0x72, 0x72, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x18, 0x1e, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74,
0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d,
0x69, 0x72, 0x72, 0x6f, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x15, 0x72, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x69,
0x65, 0x73, 0x12, 0x4b, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x0b,
0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74,
0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x42, 0x08, 0xfa, 0x42, 0x05,
0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12,
0x41, 0x0a, 0x0b, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x0d,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61, 0x74,
0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x0a, 0x72, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69,
0x74, 0x73, 0x12, 0x5c, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x76, 0x68,
0x5f, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0b,
0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0x52, 0x13, 0x69, 0x6e, 0x63,
0x6c, 0x75, 0x64, 0x65, 0x56, 0x68, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x73,
0x12, 0x4e, 0x0a, 0x0b, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18,
0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f,
0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f,
0x6c, 0x69, 0x63, 0x79, 0x52, 0x0a, 0x68, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x12, 0x35, 0x0a, 0x04, 0x63, 0x6f, 0x72, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x43, 0x6f, 0x72, 0x73, 0x50, 0x6f, 0x6c, 0x69, 0x63,
0x79, 0x52, 0x04, 0x63, 0x6f, 0x72, 0x73, 0x12, 0x50, 0x0a, 0x10, 0x6d, 0x61, 0x78, 0x5f, 0x67,
0x72, 0x70, 0x63, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x17, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0b, 0x18, 0x01,
0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x47, 0x72,
0x70, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x56, 0x0a, 0x13, 0x67, 0x72, 0x70,
0x63, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74,
0x18, 0x1c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0x52, 0x11,
0x67, 0x72, 0x70, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65,
0x74, 0x12, 0x59, 0x0a, 0x0f, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x73, 0x18, 0x19, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x55,
0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0e, 0x75, 0x70,
0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x67, 0x0a, 0x18,
0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52,
0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x16, 0x69,
0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x50,
0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x80, 0x01, 0x0a, 0x18, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30,
0x52, 0x16, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65,
0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f,
0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x73, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33,
0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03,
0x33, 0x2e, 0x30, 0x52, 0x14, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x73, 0x12, 0x45, 0x0a, 0x0c, 0x68, 0x65, 0x64,
0x67, 0x65, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x22, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x64, 0x67, 0x65, 0x50, 0x6f, 0x6c,
0x69, 0x63, 0x79, 0x52, 0x0b, 0x68, 0x65, 0x64, 0x67, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x12, 0x64, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x64,
0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x24, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75,
0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x2e, 0x4d, 0x61, 0x78, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x44, 0x75, 0x72, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x44, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0xa4, 0x01, 0x0a, 0x2d, 0x68, 0x69, 0x64, 0x64, 0x65,
0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74,
0x65, 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x69, 0x72, 0x72, 0x6f,
0x72, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72,
0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03,
0x33, 0x2e, 0x30, 0x52, 0x28, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79,
0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x1a, 0xf0, 0x02,
0x0a, 0x13, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72, 0x50,
0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x21, 0x0a, 0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52,
0x07, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x59, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x5f, 0x66, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65,
0x6e, 0x74, 0x52, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x46, 0x72, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x12, 0x3f, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x63, 0x65, 0x5f, 0x73, 0x61, 0x6d,
0x70, 0x6c, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f,
0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x63, 0x65, 0x53, 0x61, 0x6d,
0x70, 0x6c, 0x65, 0x64, 0x12, 0x5f, 0x0a, 0x23, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee,
0xf2, 0xd2, 0x05, 0x01, 0x52, 0x1f, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f,
0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x4b, 0x65, 0x79, 0x3a, 0x39, 0x9a, 0xc5, 0x88, 0x1e, 0x34, 0x0a, 0x32, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x1a, 0x96, 0x0a, 0x0a, 0x0a, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12,
0x4e, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x34, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x48,
0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12,
0x4e, 0x0a, 0x06, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x34, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x43,
0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x48, 0x00, 0x52, 0x06, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x12,
0x79, 0x0a, 0x15, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72,
0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x42,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f,
0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x43, 0x6f,
0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69,
0x65, 0x73, 0x48, 0x00, 0x52, 0x14, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x12, 0x67, 0x0a, 0x0f, 0x71, 0x75,
0x65, 0x72, 0x79, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x05, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74,
0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69,
0x63, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65,
0x72, 0x48, 0x00, 0x52, 0x0e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65,
0x74, 0x65, 0x72, 0x12, 0x5e, 0x0a, 0x0c, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x74,
0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61,
0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53,
0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x74,
0x61, 0x74, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x18,
0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x1a,
0xc6, 0x01, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x0b, 0x68, 0x65,
0x61, 0x64, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42,
0x0d, 0xfa, 0x42, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x0a,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x53, 0x0a, 0x0d, 0x72, 0x65,
0x67, 0x65, 0x78, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d,
0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x41, 0x6e, 0x64, 0x53, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74,
0x65, 0x52, 0x0c, 0x72, 0x65, 0x67, 0x65, 0x78, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x3a,
0x37, 0x9a, 0xc5, 0x88, 0x1e, 0x32, 0x0a, 0x30, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63,
0x79, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x1a, 0x9f, 0x01, 0x0a, 0x06, 0x43, 0x6f, 0x6f,
0x6b, 0x69, 0x65, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
0x12, 0x2b, 0x0a, 0x03, 0x74, 0x74, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x74, 0x74, 0x6c, 0x12, 0x12, 0x0a,
0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74,
0x68, 0x3a, 0x37, 0x9a, 0xc5, 0x88, 0x1e, 0x32, 0x0a, 0x30, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75,
0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c,
0x69, 0x63, 0x79, 0x2e, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x1a, 0x7a, 0x0a, 0x14, 0x43, 0x6f,
0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69,
0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x70, 0x18,
0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x70, 0x3a,
0x45, 0x9a, 0xc5, 0x88, 0x1e, 0x40, 0x0a, 0x3e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65,
0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63,
0x79, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70,
0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x6e, 0x0a, 0x0e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50,
0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52,
0x04, 0x6e, 0x61, 0x6d, 0x65, 0x3a, 0x3f, 0x9a, 0xc5, 0x88, 0x1e, 0x3a, 0x0a, 0x38, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73,
0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72,
0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x1a, 0x66, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x3a, 0x3c, 0x9a, 0xc5, 0x88, 0x1e, 0x37, 0x0a, 0x35, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61,
0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74,
0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69,
0x63, 0x79, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x3a, 0x30,
0x9a, 0xc5, 0x88, 0x1e, 0x2b, 0x0a, 0x29, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69,
0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x42, 0x17, 0x0a, 0x10, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69,
0x66, 0x69, 0x65, 0x72, 0x12, 0x03, 0xf8, 0x42, 0x01, 0x1a, 0xa3, 0x03, 0x0a, 0x0d, 0x55, 0x70,
0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x30, 0x0a, 0x0c, 0x75,
0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x42, 0x0d, 0xfa, 0x42, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00,
0x52, 0x0b, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a,
0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62,
0x6c, 0x65, 0x64, 0x12, 0x65, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x5f, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x43, 0x6f,
0x6e, 0x6e, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0d, 0x63, 0x6f, 0x6e,
0x6e, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x8d, 0x01, 0x0a, 0x0d, 0x43,
0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x5d, 0x0a, 0x15,
0x70, 0x72, 0x6f, 0x78, 0x79, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x5f, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x50, 0x72, 0x6f,
0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x61,
0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, 0x6f, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52,
0x09, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x6f, 0x73, 0x74, 0x3a, 0x33, 0x9a, 0xc5, 0x88, 0x1e,
0x2e, 0x0a, 0x2c, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x2e, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a,
0x88, 0x02, 0x0a, 0x11, 0x4d, 0x61, 0x78, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x44, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x49, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x74, 0x72,
0x65, 0x61, 0x6d, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x6d,
0x61, 0x78, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x12, 0x50, 0x0a, 0x17, 0x67, 0x72, 0x70, 0x63, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x14, 0x67, 0x72,
0x70, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d,
0x61, 0x78, 0x12, 0x56, 0x0a, 0x1a, 0x67, 0x72, 0x70, 0x63, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f,
0x75, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74,
0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x52, 0x17, 0x67, 0x72, 0x70, 0x63, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x48, 0x65,
0x61, 0x64, 0x65, 0x72, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x45, 0x0a, 0x1b, 0x43, 0x6c,
0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52,
0x56, 0x49, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45,
0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, 0x54, 0x5f, 0x46, 0x4f, 0x55, 0x4e, 0x44, 0x10,
0x01, 0x22, 0x5e, 0x0a, 0x16, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x64,
0x69, 0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x1e, 0x50,
0x41, 0x53, 0x53, 0x5f, 0x54, 0x48, 0x52, 0x4f, 0x55, 0x47, 0x48, 0x5f, 0x49, 0x4e, 0x54, 0x45,
0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x52, 0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10, 0x00, 0x12,
0x1c, 0x0a, 0x18, 0x48, 0x41, 0x4e, 0x44, 0x4c, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e,
0x41, 0x4c, 0x5f, 0x52, 0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10, 0x01, 0x1a, 0x02, 0x18,
0x01, 0x3a, 0x25, 0x9a, 0xc5, 0x88, 0x1e, 0x20, 0x0a, 0x1e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x6f, 0x75,
0x74, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x18, 0x0a, 0x11, 0x63, 0x6c, 0x75, 0x73,
0x74, 0x65, 0x72, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x03, 0xf8,
0x42, 0x01, 0x42, 0x18, 0x0a, 0x16, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69,
0x74, 0x65, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4a, 0x04, 0x08, 0x0c,
0x10, 0x0d, 0x4a, 0x04, 0x08, 0x12, 0x10, 0x13, 0x4a, 0x04, 0x08, 0x13, 0x10, 0x14, 0x4a, 0x04,
0x08, 0x10, 0x10, 0x11, 0x4a, 0x04, 0x08, 0x16, 0x10, 0x17, 0x4a, 0x04, 0x08, 0x15, 0x10, 0x16,
0x22, 0xcb, 0x10, 0x0a, 0x0b, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x79, 0x4f, 0x6e, 0x12, 0x52, 0x0a, 0x0b, 0x6e,
0x75, 0x6d, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x13,
0xf2, 0x98, 0xfe, 0x8f, 0x05, 0x0d, 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f, 0x72, 0x65, 0x74, 0x72,
0x69, 0x65, 0x73, 0x52, 0x0a, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12,
0x41, 0x0a, 0x0f, 0x70, 0x65, 0x72, 0x5f, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f,
0x75, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x70, 0x65, 0x72, 0x54, 0x72, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x6f,
0x75, 0x74, 0x12, 0x57, 0x0a, 0x0e, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x70, 0x72, 0x69, 0x6f,
0x72, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52,
0x65, 0x74, 0x72, 0x79, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x52, 0x0d, 0x72, 0x65,
0x74, 0x72, 0x79, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x67, 0x0a, 0x14, 0x72,
0x65, 0x74, 0x72, 0x79, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63,
0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65,
0x74, 0x72, 0x79, 0x48, 0x6f, 0x73, 0x74, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65,
0x52, 0x12, 0x72, 0x65, 0x74, 0x72, 0x79, 0x48, 0x6f, 0x73, 0x74, 0x50, 0x72, 0x65, 0x64, 0x69,
0x63, 0x61, 0x74, 0x65, 0x12, 0x48, 0x0a, 0x21, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x73, 0x65, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x6d, 0x61, 0x78,
0x5f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52,
0x1d, 0x68, 0x6f, 0x73, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
0x74, 0x72, 0x79, 0x4d, 0x61, 0x78, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x12, 0x34,
0x0a, 0x16, 0x72, 0x65, 0x74, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74,
0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x14,
0x72, 0x65, 0x74, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43,
0x6f, 0x64, 0x65, 0x73, 0x12, 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x62, 0x61,
0x63, 0x6b, 0x5f, 0x6f, 0x66, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x52, 0x0c, 0x72,
0x65, 0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x12, 0x78, 0x0a, 0x1b, 0x72,
0x61, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x74, 0x72,
0x79, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x6f, 0x66, 0x66, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x3a, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f,
0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64,
0x52, 0x65, 0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x52, 0x17, 0x72, 0x61,
0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x52, 0x65, 0x74, 0x72, 0x79, 0x42, 0x61,
0x63, 0x6b, 0x4f, 0x66, 0x66, 0x12, 0x51, 0x0a, 0x11, 0x72, 0x65, 0x74, 0x72, 0x69, 0x61, 0x62,
0x6c, 0x65, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x24, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x52, 0x10, 0x72, 0x65, 0x74, 0x72, 0x69, 0x61, 0x62, 0x6c,
0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x60, 0x0a, 0x19, 0x72, 0x65, 0x74, 0x72,
0x69, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65,
0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65,
0x72, 0x52, 0x17, 0x72, 0x65, 0x74, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x1a, 0x98, 0x02, 0x0a, 0x0d, 0x52,
0x65, 0x74, 0x72, 0x79, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1b, 0x0a, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72,
0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x0c, 0x74, 0x79, 0x70,
0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2e, 0x41, 0x6e, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x79, 0x70, 0x65, 0x64, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x12, 0x6b, 0x0a, 0x1e, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53,
0x74, 0x72, 0x75, 0x63, 0x74, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33,
0x2e, 0x30, 0x48, 0x00, 0x52, 0x1b, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f,
0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x3a, 0x33, 0x9a, 0xc5, 0x88, 0x1e, 0x2e, 0x0a, 0x2c, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x74,
0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x72,
0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x42, 0x0d, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x1a, 0xa2, 0x02, 0x0a, 0x12, 0x52, 0x65, 0x74, 0x72, 0x79, 0x48,
0x6f, 0x73, 0x74, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72,
0x02, 0x10, 0x01, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x0c, 0x74, 0x79, 0x70,
0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2e, 0x41, 0x6e, 0x79, 0x48, 0x00, 0x52, 0x0b, 0x74, 0x79, 0x70, 0x65, 0x64, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x12, 0x6b, 0x0a, 0x1e, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53,
0x74, 0x72, 0x75, 0x63, 0x74, 0x42, 0x0b, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33,
0x2e, 0x30, 0x48, 0x00, 0x52, 0x1b, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f,
0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x3a, 0x38, 0x9a, 0xc5, 0x88, 0x1e, 0x33, 0x0a, 0x31, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x74,
0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x48, 0x6f,
0x73, 0x74, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x42, 0x0d, 0x0a, 0x0b, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x1a, 0xd6, 0x01, 0x0a, 0x0c, 0x52,
0x65, 0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x12, 0x4a, 0x0a, 0x0d, 0x62,
0x61, 0x73, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0a, 0xfa,
0x42, 0x07, 0xaa, 0x01, 0x04, 0x08, 0x01, 0x2a, 0x00, 0x52, 0x0c, 0x62, 0x61, 0x73, 0x65, 0x49,
0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x46, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x69,
0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08, 0xfa, 0x42, 0x05, 0xaa, 0x01, 0x02,
0x2a, 0x00, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x3a,
0x32, 0x9a, 0xc5, 0x88, 0x1e, 0x2d, 0x0a, 0x2b, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79,
0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b,
0x4f, 0x66, 0x66, 0x1a, 0x88, 0x01, 0x0a, 0x0b, 0x52, 0x65, 0x73, 0x65, 0x74, 0x48, 0x65, 0x61,
0x64, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x42, 0x0d, 0xfa, 0x42, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00,
0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x56, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52,
0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x65, 0x74,
0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x42, 0x08, 0xfa, 0x42,
0x05, 0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x1a, 0xc0,
0x01, 0x0a, 0x17, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x52, 0x65,
0x74, 0x72, 0x79, 0x42, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x12, 0x5d, 0x0a, 0x0d, 0x72, 0x65,
0x73, 0x65, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x2e, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50,
0x6f, 0x6c, 0x69, 0x63, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65,
0x72, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x92, 0x01, 0x02, 0x08, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x73,
0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x46, 0x0a, 0x0c, 0x6d, 0x61, 0x78,
0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x08, 0xfa, 0x42, 0x05, 0xaa,
0x01, 0x02, 0x2a, 0x00, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61,
0x6c, 0x22, 0x34, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72,
0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x45, 0x43, 0x4f, 0x4e, 0x44,
0x53, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x55, 0x4e, 0x49, 0x58, 0x5f, 0x54, 0x49, 0x4d, 0x45,
0x53, 0x54, 0x41, 0x4d, 0x50, 0x10, 0x01, 0x3a, 0x25, 0x9a, 0xc5, 0x88, 0x1e, 0x20, 0x0a, 0x1e,
0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75,
0x74, 0x65, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x22, 0x9c,
0x02, 0x0a, 0x0b, 0x48, 0x65, 0x64, 0x67, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x50,
0x0a, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33,
0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x2a, 0x02, 0x28, 0x01, 0x52,
0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73,
0x12, 0x5c, 0x0a, 0x19, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x72,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65,
0x72, 0x63, 0x65, 0x6e, 0x74, 0x52, 0x17, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x36,
0x0a, 0x18, 0x68, 0x65, 0x64, 0x67, 0x65, 0x5f, 0x6f, 0x6e, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x74,
0x72, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08,
0x52, 0x14, 0x68, 0x65, 0x64, 0x67, 0x65, 0x4f, 0x6e, 0x50, 0x65, 0x72, 0x54, 0x72, 0x79, 0x54,
0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x3a, 0x25, 0x9a, 0xc5, 0x88, 0x1e, 0x20, 0x0a, 0x1e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x2e, 0x48, 0x65, 0x64, 0x67, 0x65, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x22, 0xe1, 0x05,
0x0a, 0x0e, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x12, 0x27, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70, 0x73, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65,
0x63, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0d, 0x68, 0x74, 0x74, 0x70,
0x73, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x12, 0x29, 0x0a, 0x0f, 0x73, 0x63, 0x68,
0x65, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01,
0x28, 0x09, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x52, 0x65, 0x64, 0x69,
0x72, 0x65, 0x63, 0x74, 0x12, 0x30, 0x0a, 0x0d, 0x68, 0x6f, 0x73, 0x74, 0x5f, 0x72, 0x65, 0x64,
0x69, 0x72, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42, 0x08,
0x72, 0x06, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00, 0x52, 0x0c, 0x68, 0x6f, 0x73, 0x74, 0x52, 0x65,
0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x72,
0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x70,
0x6f, 0x72, 0x74, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x12, 0x32, 0x0a, 0x0d, 0x70,
0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42, 0x08, 0x72, 0x06, 0xc0, 0x01, 0x02, 0xc8, 0x01, 0x00, 0x48,
0x01, 0x52, 0x0c, 0x70, 0x61, 0x74, 0x68, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x12,
0x34, 0x0a, 0x0e, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74,
0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0b, 0xfa, 0x42, 0x08, 0x72, 0x06, 0xc0, 0x01,
0x02, 0xc8, 0x01, 0x00, 0x48, 0x01, 0x52, 0x0d, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x65,
0x77, 0x72, 0x69, 0x74, 0x65, 0x12, 0x55, 0x0a, 0x0d, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x72,
0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65,
0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x41,
0x6e, 0x64, 0x53, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65, 0x48, 0x01, 0x52, 0x0c,
0x72, 0x65, 0x67, 0x65, 0x78, 0x52, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x12, 0x69, 0x0a, 0x0d,
0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20,
0x01, 0x28, 0x0e, 0x32, 0x3a, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x64, 0x69,
0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x64, 0x69, 0x72,
0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x42,
0x08, 0xfa, 0x42, 0x05, 0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x70,
0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x73, 0x74,
0x72, 0x69, 0x70, 0x51, 0x75, 0x65, 0x72, 0x79, 0x22, 0x77, 0x0a, 0x14, 0x52, 0x65, 0x64, 0x69,
0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x64, 0x65,
0x12, 0x15, 0x0a, 0x11, 0x4d, 0x4f, 0x56, 0x45, 0x44, 0x5f, 0x50, 0x45, 0x52, 0x4d, 0x41, 0x4e,
0x45, 0x4e, 0x54, 0x4c, 0x59, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4f, 0x55, 0x4e, 0x44,
0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x45, 0x45, 0x5f, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10,
0x02, 0x12, 0x16, 0x0a, 0x12, 0x54, 0x45, 0x4d, 0x50, 0x4f, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x52,
0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, 0x50, 0x45, 0x52,
0x4d, 0x41, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10,
0x04, 0x3a, 0x28, 0x9a, 0xc5, 0x88, 0x1e, 0x23, 0x0a, 0x21, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x64,
0x69, 0x72, 0x65, 0x63, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x1a, 0x0a, 0x18, 0x73,
0x63, 0x68, 0x65, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x73, 0x70,
0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x18, 0x0a, 0x16, 0x70, 0x61, 0x74, 0x68, 0x5f,
0x72, 0x65, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65,
0x72, 0x22, 0xa0, 0x01, 0x0a, 0x14, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x06, 0x73, 0x74,
0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x0a, 0xfa, 0x42, 0x07, 0x2a,
0x05, 0x10, 0xd8, 0x04, 0x28, 0x64, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x34,
0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65,
0x2e, 0x76, 0x33, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x04,
0x62, 0x6f, 0x64, 0x79, 0x3a, 0x2e, 0x9a, 0xc5, 0x88, 0x1e, 0x29, 0x0a, 0x27, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x41, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x4e, 0x6f, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61,
0x72, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x91, 0x01, 0x0a, 0x09,
0x44, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x25, 0x0a, 0x09, 0x6f, 0x70, 0x65,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42,
0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x12, 0x38, 0x0a, 0x09, 0x70, 0x72, 0x6f, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52,
0x09, 0x70, 0x72, 0x6f, 0x70, 0x61, 0x67, 0x61, 0x74, 0x65, 0x3a, 0x23, 0x9a, 0xc5, 0x88, 0x1e,
0x1e, 0x0a, 0x1c, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x44, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x22,
0xd2, 0x02, 0x0a, 0x07, 0x54, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x12, 0x49, 0x0a, 0x0f, 0x63,
0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70,
0x65, 0x2e, 0x76, 0x33, 0x2e, 0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50,
0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x52, 0x0e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x61,
0x6d, 0x70, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x49, 0x0a, 0x0f, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d,
0x5f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x76, 0x33, 0x2e,
0x46, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e,
0x74, 0x52, 0x0e, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x69, 0x6e,
0x67, 0x12, 0x4b, 0x0a, 0x10, 0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x61, 0x6d,
0x70, 0x6c, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x46, 0x72, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x52, 0x0f, 0x6f,
0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x69, 0x6e, 0x67, 0x12, 0x41,
0x0a, 0x0b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x74, 0x61, 0x67, 0x73, 0x18, 0x04, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x74, 0x72, 0x61, 0x63, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x33, 0x2e, 0x43, 0x75, 0x73, 0x74,
0x6f, 0x6d, 0x54, 0x61, 0x67, 0x52, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x54, 0x61, 0x67,
0x73, 0x3a, 0x21, 0x9a, 0xc5, 0x88, 0x1e, 0x1c, 0x0a, 0x1a, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x54, 0x72, 0x61,
0x63, 0x69, 0x6e, 0x67, 0x22, 0xf6, 0x02, 0x0a, 0x0e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c,
0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x52, 0x07,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1b, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x12, 0x60, 0x0a, 0x1f, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f,
0x70, 0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x19, 0x18,
0x01, 0xfa, 0x42, 0x05, 0x72, 0x03, 0x28, 0x80, 0x08, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33,
0x2e, 0x30, 0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x52, 0x1c, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e,
0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x50,
0x61, 0x74, 0x74, 0x65, 0x72, 0x6e, 0x12, 0x7b, 0x0a, 0x1e, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e,
0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65,
0x64, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f,
0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x74,
0x68, 0x6f, 0x64, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30,
0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x52, 0x1b, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e,
0x76, 0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x74,
0x68, 0x6f, 0x64, 0x3a, 0x28, 0x9a, 0xc5, 0x88, 0x1e, 0x23, 0x0a, 0x21, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x56,
0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x22, 0xaa, 0x16,
0x0a, 0x09, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x3b, 0x0a, 0x05, 0x73,
0x74, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e,
0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x2a, 0x02, 0x18,
0x0a, 0x52, 0x05, 0x73, 0x74, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x69, 0x73, 0x61,
0x62, 0x6c, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x64,
0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x4b, 0x0a, 0x07, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x92, 0x01, 0x02, 0x08, 0x01, 0x52, 0x07, 0x61,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3f, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18,
0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61,
0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65,
0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x1a, 0x96, 0x12, 0x0a, 0x06, 0x41, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x12, 0x5e, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x75,
0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
0x72, 0x48, 0x00, 0x52, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74,
0x65, 0x72, 0x12, 0x6d, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x5f, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x3a, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69,
0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x12, 0x64,
0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65,
0x72, 0x12, 0x61, 0x0a, 0x0f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61,
0x64, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65,
0x72, 0x73, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61,
0x64, 0x65, 0x72, 0x73, 0x12, 0x5e, 0x0a, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x61,
0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x64, 0x64, 0x72,
0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x64, 0x64,
0x72, 0x65, 0x73, 0x73, 0x12, 0x55, 0x0a, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x48, 0x00, 0x52,
0x0a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x68, 0x0a, 0x12, 0x68,
0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6d, 0x61, 0x74, 0x63,
0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e,
0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x61, 0x74, 0x63,
0x68, 0x48, 0x00, 0x52, 0x10, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x77, 0x0a, 0x10, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63,
0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x37, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69,
0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63,
0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8,
0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x48, 0x00, 0x52, 0x0f, 0x64,
0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4e,
0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x30, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e,
0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d,
0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61,
0x74, 0x61, 0x48, 0x00, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4a,
0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x45, 0x78,
0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52,
0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x49, 0x0a, 0x0d, 0x53, 0x6f,
0x75, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x3a, 0x38, 0x9a, 0xc5, 0x88,
0x1e, 0x33, 0x0a, 0x31, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74,
0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6c,
0x75, 0x73, 0x74, 0x65, 0x72, 0x1a, 0x53, 0x0a, 0x12, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x3a, 0x3d, 0x9a, 0xc5, 0x88,
0x1e, 0x38, 0x0a, 0x36, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74,
0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x1a, 0xd1, 0x01, 0x0a, 0x0e, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x2e, 0x0a,
0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x42, 0x0d, 0xfa, 0x42, 0x0a, 0x72, 0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01,
0x00, 0x52, 0x0a, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a,
0x0e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0d,
0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a,
0x0e, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x69, 0x66, 0x5f, 0x61, 0x62, 0x73, 0x65, 0x6e, 0x74, 0x18,
0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x73, 0x6b, 0x69, 0x70, 0x49, 0x66, 0x41, 0x62, 0x73,
0x65, 0x6e, 0x74, 0x3a, 0x39, 0x9a, 0xc5, 0x88, 0x1e, 0x34, 0x0a, 0x32, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52,
0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x1a, 0x49,
0x0a, 0x0d, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x3a,
0x38, 0x9a, 0xc5, 0x88, 0x1e, 0x33, 0x0a, 0x31, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70,
0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c,
0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65, 0x6d, 0x6f,
0x74, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x1a, 0x9e, 0x01, 0x0a, 0x0a, 0x47, 0x65,
0x6e, 0x65, 0x72, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x32, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0f, 0x64, 0x65, 0x73,
0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x25, 0x0a, 0x0e,
0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
0x4b, 0x65, 0x79, 0x3a, 0x35, 0x9a, 0xc5, 0x88, 0x1e, 0x30, 0x0a, 0x2e, 0x65, 0x6e, 0x76, 0x6f,
0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52,
0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x1a, 0x8c, 0x02, 0x0a, 0x10, 0x48,
0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12,
0x32, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02,
0x10, 0x01, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x5f, 0x6d, 0x61,
0x74, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0b, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x4d, 0x61, 0x74,
0x63, 0x68, 0x12, 0x48, 0x0a, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x48, 0x65, 0x61, 0x64,
0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x92, 0x01,
0x02, 0x08, 0x01, 0x52, 0x07, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x3a, 0x3b, 0x9a, 0xc5,
0x88, 0x1e, 0x36, 0x0a, 0x34, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76,
0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69,
0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x1a, 0xb8, 0x01, 0x0a, 0x0f, 0x44, 0x79,
0x6e, 0x61, 0x6d, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2e, 0x0a,
0x0e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x52, 0x0d,
0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x4b, 0x65, 0x79, 0x12, 0x50, 0x0a,
0x0c, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x76, 0x33, 0x2e, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, 0x79, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, 0x01, 0x02,
0x10, 0x01, 0x52, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, 0x79, 0x12,
0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x1a, 0xb4, 0x02, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74,
0x61, 0x12, 0x2e, 0x0a, 0x0e, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42, 0x04, 0x72, 0x02,
0x10, 0x01, 0x52, 0x0d, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x4b, 0x65,
0x79, 0x12, 0x50, 0x0a, 0x0c, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6b, 0x65,
0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x76, 0x33,
0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, 0x79, 0x42, 0x08, 0xfa, 0x42,
0x05, 0x8a, 0x01, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61,
0x75, 0x6c, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x59, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72,
0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33,
0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x6f, 0x75, 0x72, 0x63,
0x65, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x06, 0x73, 0x6f, 0x75,
0x72, 0x63, 0x65, 0x22, 0x26, 0x0a, 0x06, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x0b, 0x0a,
0x07, 0x44, 0x59, 0x4e, 0x41, 0x4d, 0x49, 0x43, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x52, 0x4f,
0x55, 0x54, 0x45, 0x5f, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x10, 0x01, 0x3a, 0x2a, 0x9a, 0xc5, 0x88,
0x1e, 0x25, 0x0a, 0x23, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32,
0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74,
0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x17, 0x0a, 0x10, 0x61, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x03, 0xf8, 0x42, 0x01,
0x1a, 0xf2, 0x01, 0x0a, 0x08, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x12, 0x66, 0x0a,
0x10, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x2e,
0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x2e, 0x4f, 0x76, 0x65, 0x72, 0x72, 0x69,
0x64, 0x65, 0x2e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x48, 0x00, 0x52, 0x0f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x63, 0x0a, 0x0f, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63,
0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x50, 0x0a, 0x0c, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23,
0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x2e, 0x76, 0x33, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x4b, 0x65, 0x79, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, 0x01, 0x02, 0x10, 0x01, 0x52, 0x0b, 0x6d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4b, 0x65, 0x79, 0x42, 0x19, 0x0a, 0x12, 0x6f, 0x76,
0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72,
0x12, 0x03, 0xf8, 0x42, 0x01, 0x3a, 0x23, 0x9a, 0xc5, 0x88, 0x1e, 0x1e, 0x0a, 0x1c, 0x65, 0x6e,
0x76, 0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65,
0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0xf6, 0x04, 0x0a, 0x0d, 0x48,
0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0d, 0xfa, 0x42, 0x0a, 0x72,
0x08, 0x10, 0x01, 0xc0, 0x01, 0x01, 0xc8, 0x01, 0x00, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
0x21, 0x0a, 0x0b, 0x65, 0x78, 0x61, 0x63, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x04,
0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x65, 0x78, 0x61, 0x63, 0x74, 0x4d, 0x61, 0x74,
0x63, 0x68, 0x12, 0x4f, 0x0a, 0x10, 0x73, 0x61, 0x66, 0x65, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78,
0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x65,
0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65,
0x72, 0x2e, 0x76, 0x33, 0x2e, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65,
0x72, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x61, 0x66, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d, 0x61,
0x74, 0x63, 0x68, 0x12, 0x3c, 0x0a, 0x0b, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6d, 0x61, 0x74,
0x63, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79,
0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x76, 0x33, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x52, 0x61,
0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x4d, 0x61, 0x74, 0x63,
0x68, 0x12, 0x25, 0x0a, 0x0d, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x61, 0x74,
0x63, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x72, 0x65, 0x73,
0x65, 0x6e, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x2c, 0x0a, 0x0c, 0x70, 0x72, 0x65, 0x66,
0x69, 0x78, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07,
0xfa, 0x42, 0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x65, 0x66, 0x69,
0x78, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x2c, 0x0a, 0x0c, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78,
0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42,
0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x12, 0x30, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73,
0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x42, 0x07, 0xfa, 0x42,
0x04, 0x72, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
0x73, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x69, 0x0a, 0x23, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e,
0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65,
0x64, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x05, 0x20,
0x01, 0x28, 0x09, 0x42, 0x19, 0x18, 0x01, 0xfa, 0x42, 0x05, 0x72, 0x03, 0x28, 0x80, 0x08, 0x92,
0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee, 0xf2, 0xd2, 0x05, 0x01, 0x48, 0x00,
0x52, 0x1f, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79, 0x44, 0x65, 0x70,
0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x67, 0x65, 0x78, 0x4d, 0x61, 0x74, 0x63,
0x68, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x63,
0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x4d,
0x61, 0x74, 0x63, 0x68, 0x3a, 0x27, 0x9a, 0xc5, 0x88, 0x1e, 0x22, 0x0a, 0x20, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e,
0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x42, 0x18, 0x0a,
0x16, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x70,
0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, 0x04, 0x08,
0x03, 0x10, 0x04, 0x22, 0xcf, 0x03, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72,
0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x12, 0x1e, 0x0a,
0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, 0xfa, 0x42, 0x07,
0x72, 0x05, 0x10, 0x01, 0x28, 0x80, 0x08, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x53, 0x0a,
0x0c, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x05, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x74, 0x79, 0x70, 0x65,
0x2e, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x2e, 0x76, 0x33, 0x2e, 0x53, 0x74, 0x72, 0x69,
0x6e, 0x67, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, 0x01,
0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x61, 0x74,
0x63, 0x68, 0x12, 0x25, 0x0a, 0x0d, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x61,
0x74, 0x63, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x72, 0x65,
0x73, 0x65, 0x6e, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x54, 0x0a, 0x1d, 0x68, 0x69, 0x64,
0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
0x61, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8, 0xee, 0xf2,
0xd2, 0x05, 0x01, 0x52, 0x1a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76, 0x6f, 0x79,
0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12,
0x70, 0x0a, 0x1d, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x5f, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x5f,
0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78,
0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x42, 0x11, 0x18, 0x01, 0x92, 0xc7, 0x86, 0xd8, 0x04, 0x03, 0x33, 0x2e, 0x30, 0xb8,
0xee, 0xf2, 0xd2, 0x05, 0x01, 0x52, 0x1a, 0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x45, 0x6e, 0x76,
0x6f, 0x79, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x52, 0x65, 0x67, 0x65,
0x78, 0x3a, 0x2f, 0x9a, 0xc5, 0x88, 0x1e, 0x2a, 0x0a, 0x28, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e,
0x61, 0x70, 0x69, 0x2e, 0x76, 0x32, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x2e, 0x51, 0x75, 0x65,
0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68,
0x65, 0x72, 0x42, 0x21, 0x0a, 0x1f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x70, 0x61, 0x72, 0x61,
0x6d, 0x65, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x70, 0x65, 0x63,
0x69, 0x66, 0x69, 0x65, 0x72, 0x22, 0xb9, 0x02, 0x0a, 0x16, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79,
0x12, 0x52, 0x0a, 0x16, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x14,
0x6d, 0x61, 0x78, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x64, 0x69, 0x72,
0x65, 0x63, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x17, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x73, 0x18,
0x02, 0x20, 0x03, 0x28, 0x0d, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x92, 0x01, 0x02, 0x10, 0x05, 0x52,
0x15, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63,
0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x6e, 0x76,
0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x76,
0x33, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74,
0x65, 0x73, 0x12, 0x3d, 0x0a, 0x1b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x72, 0x6f, 0x73,
0x73, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x43, 0x72,
0x6f, 0x73, 0x73, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x22, 0x5d, 0x0a, 0x0c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x12, 0x2c, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12,
0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x18, 0x02,
0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
0x42, 0x45, 0x0a, 0x23, 0x69, 0x6f, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x70, 0x72, 0x6f, 0x78,
0x79, 0x2e, 0x65, 0x6e, 0x76, 0x6f, 0x79, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x72,
0x6f, 0x75, 0x74, 0x65, 0x2e, 0x76, 0x33, 0x42, 0x14, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x43, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0xba,
0x80, 0xc8, 0xd1, 0x06, 0x02, 0x10, 0x02, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
<API key> sync.Once
<API key> = <API key>
)
func <API key>() []byte {
<API key>.Do(func() {
<API key> = protoimpl.X.CompressGZIP(<API key>)
})
return <API key>
}
var <API key> = make([]protoimpl.EnumInfo, 6)
var <API key> = make([]protoimpl.MessageInfo, 56)
var <API key> = []interface{}{
(<API key>)(0), // 0: envoy.config.route.v3.VirtualHost.TlsRequirementType
(<API key>)(0), // 1: envoy.config.route.v3.RouteAction.<API key>
(<API key>)(0), // 2: envoy.config.route.v3.RouteAction.<API key>
(<API key>)(0), // 3: envoy.config.route.v3.RetryPolicy.ResetHeaderFormat
(<API key>)(0), // 4: envoy.config.route.v3.RedirectAction.<API key>
(<API key>)(0), // 5: envoy.config.route.v3.RateLimit.Action.MetaData.Source
(*VirtualHost)(nil), // 6: envoy.config.route.v3.VirtualHost
(*FilterAction)(nil), // 7: envoy.config.route.v3.FilterAction
(*Route)(nil), // 8: envoy.config.route.v3.Route
(*WeightedCluster)(nil), // 9: envoy.config.route.v3.WeightedCluster
(*RouteMatch)(nil), // 10: envoy.config.route.v3.RouteMatch
(*CorsPolicy)(nil), // 11: envoy.config.route.v3.CorsPolicy
(*RouteAction)(nil), // 12: envoy.config.route.v3.RouteAction
(*RetryPolicy)(nil), // 13: envoy.config.route.v3.RetryPolicy
(*HedgePolicy)(nil), // 14: envoy.config.route.v3.HedgePolicy
(*RedirectAction)(nil), // 15: envoy.config.route.v3.RedirectAction
(*<API key>)(nil), // 16: envoy.config.route.v3.<API key>
(*NonForwardingAction)(nil), // 17: envoy.config.route.v3.NonForwardingAction
(*Decorator)(nil), // 18: envoy.config.route.v3.Decorator
(*Tracing)(nil), // 19: envoy.config.route.v3.Tracing
(*VirtualCluster)(nil), // 20: envoy.config.route.v3.VirtualCluster
(*RateLimit)(nil), // 21: envoy.config.route.v3.RateLimit
(*HeaderMatcher)(nil), // 22: envoy.config.route.v3.HeaderMatcher
(*<API key>)(nil), // 23: envoy.config.route.v3.<API key>
(*<API key>)(nil), // 24: envoy.config.route.v3.<API key>
(*FilterConfig)(nil), // 25: envoy.config.route.v3.FilterConfig
nil, // 26: envoy.config.route.v3.VirtualHost.<API key>
nil, // 27: envoy.config.route.v3.VirtualHost.<API key>
nil, // 28: envoy.config.route.v3.Route.<API key>
nil, // 29: envoy.config.route.v3.Route.<API key>
(*<API key>)(nil), // 30: envoy.config.route.v3.WeightedCluster.ClusterWeight
nil, // 31: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>
nil, // 32: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>
(*<API key>)(nil), // 33: envoy.config.route.v3.RouteMatch.<API key>
(*<API key>)(nil), // 34: envoy.config.route.v3.RouteMatch.<API key>
(*<API key>)(nil), // 35: envoy.config.route.v3.RouteMatch.ConnectMatcher
(*<API key>)(nil), // 36: envoy.config.route.v3.RouteAction.RequestMirrorPolicy
(*<API key>)(nil), // 37: envoy.config.route.v3.RouteAction.HashPolicy
(*<API key>)(nil), // 38: envoy.config.route.v3.RouteAction.UpgradeConfig
(*<API key>)(nil), // 39: envoy.config.route.v3.RouteAction.MaxStreamDuration
(*<API key>)(nil), // 40: envoy.config.route.v3.RouteAction.HashPolicy.Header
(*<API key>)(nil), // 41: envoy.config.route.v3.RouteAction.HashPolicy.Cookie
(*<API key>)(nil), // 42: envoy.config.route.v3.RouteAction.HashPolicy.<API key>
(*<API key>)(nil), // 43: envoy.config.route.v3.RouteAction.HashPolicy.QueryParameter
(*<API key>)(nil), // 44: envoy.config.route.v3.RouteAction.HashPolicy.FilterState
(*<API key>)(nil), // 45: envoy.config.route.v3.RouteAction.UpgradeConfig.ConnectConfig
(*<API key>)(nil), // 46: envoy.config.route.v3.RetryPolicy.RetryPriority
(*<API key>)(nil), // 47: envoy.config.route.v3.RetryPolicy.RetryHostPredicate
(*<API key>)(nil), // 48: envoy.config.route.v3.RetryPolicy.RetryBackOff
(*<API key>)(nil), // 49: envoy.config.route.v3.RetryPolicy.ResetHeader
(*<API key>)(nil), // 50: envoy.config.route.v3.RetryPolicy.<API key>
(*RateLimit_Action)(nil), // 51: envoy.config.route.v3.RateLimit.Action
(*RateLimit_Override)(nil), // 52: envoy.config.route.v3.RateLimit.Override
(*<API key>)(nil), // 53: envoy.config.route.v3.RateLimit.Action.SourceCluster
(*<API key>)(nil), // 54: envoy.config.route.v3.RateLimit.Action.DestinationCluster
(*<API key>)(nil), // 55: envoy.config.route.v3.RateLimit.Action.RequestHeaders
(*<API key>)(nil), // 56: envoy.config.route.v3.RateLimit.Action.RemoteAddress
(*<API key>)(nil), // 57: envoy.config.route.v3.RateLimit.Action.GenericKey
(*<API key>)(nil), // 58: envoy.config.route.v3.RateLimit.Action.HeaderValueMatch
(*<API key>)(nil), // 59: envoy.config.route.v3.RateLimit.Action.DynamicMetaData
(*<API key>)(nil), // 60: envoy.config.route.v3.RateLimit.Action.MetaData
(*<API key>)(nil), // 61: envoy.config.route.v3.RateLimit.Override.DynamicMetadata
(*v3.HeaderValueOption)(nil), // 62: envoy.config.core.v3.HeaderValueOption
(*any.Any)(nil), // 63: google.protobuf.Any
(*wrappers.UInt32Value)(nil), // 64: google.protobuf.UInt32Value
(*v3.Metadata)(nil), // 65: envoy.config.core.v3.Metadata
(*v31.RegexMatcher)(nil), // 66: envoy.type.matcher.v3.RegexMatcher
(*wrappers.BoolValue)(nil), // 67: google.protobuf.BoolValue
(*v3.<API key>)(nil), // 68: envoy.config.core.v3.<API key>
(*v31.StringMatcher)(nil), // 69: envoy.type.matcher.v3.StringMatcher
(*v31.<API key>)(nil), // 70: envoy.type.matcher.v3.<API key>
(*duration.Duration)(nil), // 71: google.protobuf.Duration
(v3.RoutingPriority)(0), // 72: envoy.config.core.v3.RoutingPriority
(*v32.FractionalPercent)(nil), // 73: envoy.type.v3.FractionalPercent
(*v3.DataSource)(nil), // 74: envoy.config.core.v3.DataSource
(*v33.CustomTag)(nil), // 75: envoy.type.tracing.v3.CustomTag
(v3.RequestMethod)(0), // 76: envoy.config.core.v3.RequestMethod
(*v32.Int64Range)(nil), // 77: envoy.type.v3.Int64Range
(*v3.<API key>)(nil), // 78: envoy.config.core.v3.<API key>
(*_struct.Struct)(nil), // 79: google.protobuf.Struct
(*v3.ProxyProtocolConfig)(nil), // 80: envoy.config.core.v3.ProxyProtocolConfig
(*v34.MetadataKey)(nil), // 81: envoy.type.metadata.v3.MetadataKey
}
var <API key> = []int32{
8, // 0: envoy.config.route.v3.VirtualHost.routes:type_name -> envoy.config.route.v3.Route
0, // 1: envoy.config.route.v3.VirtualHost.require_tls:type_name -> envoy.config.route.v3.VirtualHost.TlsRequirementType
20, // 2: envoy.config.route.v3.VirtualHost.virtual_clusters:type_name -> envoy.config.route.v3.VirtualCluster
21, // 3: envoy.config.route.v3.VirtualHost.rate_limits:type_name -> envoy.config.route.v3.RateLimit
62, // 4: envoy.config.route.v3.VirtualHost.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
62, // 5: envoy.config.route.v3.VirtualHost.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
11, // 6: envoy.config.route.v3.VirtualHost.cors:type_name -> envoy.config.route.v3.CorsPolicy
26, // 7: envoy.config.route.v3.VirtualHost.<API key>:type_name -> envoy.config.route.v3.VirtualHost.<API key>
13, // 8: envoy.config.route.v3.VirtualHost.retry_policy:type_name -> envoy.config.route.v3.RetryPolicy
63, // 9: envoy.config.route.v3.VirtualHost.<API key>:type_name -> google.protobuf.Any
14, // 10: envoy.config.route.v3.VirtualHost.hedge_policy:type_name -> envoy.config.route.v3.HedgePolicy
64, // 11: envoy.config.route.v3.VirtualHost.<API key>:type_name -> google.protobuf.UInt32Value
27, // 12: envoy.config.route.v3.VirtualHost.<API key>:type_name -> envoy.config.route.v3.VirtualHost.<API key>
63, // 13: envoy.config.route.v3.FilterAction.action:type_name -> google.protobuf.Any
10, // 14: envoy.config.route.v3.Route.match:type_name -> envoy.config.route.v3.RouteMatch
12, // 15: envoy.config.route.v3.Route.route:type_name -> envoy.config.route.v3.RouteAction
15, // 16: envoy.config.route.v3.Route.redirect:type_name -> envoy.config.route.v3.RedirectAction
16, // 17: envoy.config.route.v3.Route.direct_response:type_name -> envoy.config.route.v3.<API key>
7, // 18: envoy.config.route.v3.Route.filter_action:type_name -> envoy.config.route.v3.FilterAction
17, // 19: envoy.config.route.v3.Route.<API key>:type_name -> envoy.config.route.v3.NonForwardingAction
65, // 20: envoy.config.route.v3.Route.metadata:type_name -> envoy.config.core.v3.Metadata
18, // 21: envoy.config.route.v3.Route.decorator:type_name -> envoy.config.route.v3.Decorator
28, // 22: envoy.config.route.v3.Route.<API key>:type_name -> envoy.config.route.v3.Route.<API key>
62, // 23: envoy.config.route.v3.Route.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
62, // 24: envoy.config.route.v3.Route.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
19, // 25: envoy.config.route.v3.Route.tracing:type_name -> envoy.config.route.v3.Tracing
64, // 26: envoy.config.route.v3.Route.<API key>:type_name -> google.protobuf.UInt32Value
29, // 27: envoy.config.route.v3.Route.<API key>:type_name -> envoy.config.route.v3.Route.<API key>
30, // 28: envoy.config.route.v3.WeightedCluster.clusters:type_name -> envoy.config.route.v3.WeightedCluster.ClusterWeight
64, // 29: envoy.config.route.v3.WeightedCluster.total_weight:type_name -> google.protobuf.UInt32Value
66, // 30: envoy.config.route.v3.RouteMatch.safe_regex:type_name -> envoy.type.matcher.v3.RegexMatcher
35, // 31: envoy.config.route.v3.RouteMatch.connect_matcher:type_name -> envoy.config.route.v3.RouteMatch.ConnectMatcher
67, // 32: envoy.config.route.v3.RouteMatch.case_sensitive:type_name -> google.protobuf.BoolValue
68, // 33: envoy.config.route.v3.RouteMatch.runtime_fraction:type_name -> envoy.config.core.v3.<API key>
22, // 34: envoy.config.route.v3.RouteMatch.headers:type_name -> envoy.config.route.v3.HeaderMatcher
23, // 35: envoy.config.route.v3.RouteMatch.query_parameters:type_name -> envoy.config.route.v3.<API key>
33, // 36: envoy.config.route.v3.RouteMatch.grpc:type_name -> envoy.config.route.v3.RouteMatch.<API key>
34, // 37: envoy.config.route.v3.RouteMatch.tls_context:type_name -> envoy.config.route.v3.RouteMatch.<API key>
69, // 38: envoy.config.route.v3.CorsPolicy.<API key>:type_name -> envoy.type.matcher.v3.StringMatcher
67, // 39: envoy.config.route.v3.CorsPolicy.allow_credentials:type_name -> google.protobuf.BoolValue
68, // 40: envoy.config.route.v3.CorsPolicy.filter_enabled:type_name -> envoy.config.core.v3.<API key>
67, // 41: envoy.config.route.v3.CorsPolicy.<API key>:type_name -> google.protobuf.BoolValue
68, // 42: envoy.config.route.v3.CorsPolicy.shadow_enabled:type_name -> envoy.config.core.v3.<API key>
9, // 43: envoy.config.route.v3.RouteAction.weighted_clusters:type_name -> envoy.config.route.v3.WeightedCluster
1, // 44: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.config.route.v3.RouteAction.<API key>
65, // 45: envoy.config.route.v3.RouteAction.metadata_match:type_name -> envoy.config.core.v3.Metadata
70, // 46: envoy.config.route.v3.RouteAction.regex_rewrite:type_name -> envoy.type.matcher.v3.<API key>
67, // 47: envoy.config.route.v3.RouteAction.auto_host_rewrite:type_name -> google.protobuf.BoolValue
70, // 48: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.type.matcher.v3.<API key>
71, // 49: envoy.config.route.v3.RouteAction.timeout:type_name -> google.protobuf.Duration
71, // 50: envoy.config.route.v3.RouteAction.idle_timeout:type_name -> google.protobuf.Duration
13, // 51: envoy.config.route.v3.RouteAction.retry_policy:type_name -> envoy.config.route.v3.RetryPolicy
63, // 52: envoy.config.route.v3.RouteAction.<API key>:type_name -> google.protobuf.Any
36, // 53: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.config.route.v3.RouteAction.RequestMirrorPolicy
72, // 54: envoy.config.route.v3.RouteAction.priority:type_name -> envoy.config.core.v3.RoutingPriority
21, // 55: envoy.config.route.v3.RouteAction.rate_limits:type_name -> envoy.config.route.v3.RateLimit
67, // 56: envoy.config.route.v3.RouteAction.<API key>:type_name -> google.protobuf.BoolValue
37, // 57: envoy.config.route.v3.RouteAction.hash_policy:type_name -> envoy.config.route.v3.RouteAction.HashPolicy
11, // 58: envoy.config.route.v3.RouteAction.cors:type_name -> envoy.config.route.v3.CorsPolicy
71, // 59: envoy.config.route.v3.RouteAction.max_grpc_timeout:type_name -> google.protobuf.Duration
71, // 60: envoy.config.route.v3.RouteAction.grpc_timeout_offset:type_name -> google.protobuf.Duration
38, // 61: envoy.config.route.v3.RouteAction.upgrade_configs:type_name -> envoy.config.route.v3.RouteAction.UpgradeConfig
24, // 62: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.config.route.v3.<API key>
2, // 63: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.config.route.v3.RouteAction.<API key>
64, // 64: envoy.config.route.v3.RouteAction.<API key>:type_name -> google.protobuf.UInt32Value
14, // 65: envoy.config.route.v3.RouteAction.hedge_policy:type_name -> envoy.config.route.v3.HedgePolicy
39, // 66: envoy.config.route.v3.RouteAction.max_stream_duration:type_name -> envoy.config.route.v3.RouteAction.MaxStreamDuration
36, // 67: envoy.config.route.v3.RouteAction.<API key>:type_name -> envoy.config.route.v3.RouteAction.RequestMirrorPolicy
64, // 68: envoy.config.route.v3.RetryPolicy.num_retries:type_name -> google.protobuf.UInt32Value
71, // 69: envoy.config.route.v3.RetryPolicy.per_try_timeout:type_name -> google.protobuf.Duration
46, // 70: envoy.config.route.v3.RetryPolicy.retry_priority:type_name -> envoy.config.route.v3.RetryPolicy.RetryPriority
47, // 71: envoy.config.route.v3.RetryPolicy.<API key>:type_name -> envoy.config.route.v3.RetryPolicy.RetryHostPredicate
48, // 72: envoy.config.route.v3.RetryPolicy.retry_back_off:type_name -> envoy.config.route.v3.RetryPolicy.RetryBackOff
50, // 73: envoy.config.route.v3.RetryPolicy.<API key>:type_name -> envoy.config.route.v3.RetryPolicy.<API key>
22, // 74: envoy.config.route.v3.RetryPolicy.retriable_headers:type_name -> envoy.config.route.v3.HeaderMatcher
22, // 75: envoy.config.route.v3.RetryPolicy.<API key>:type_name -> envoy.config.route.v3.HeaderMatcher
64, // 76: envoy.config.route.v3.HedgePolicy.initial_requests:type_name -> google.protobuf.UInt32Value
73, // 77: envoy.config.route.v3.HedgePolicy.<API key>:type_name -> envoy.type.v3.FractionalPercent
70, // 78: envoy.config.route.v3.RedirectAction.regex_rewrite:type_name -> envoy.type.matcher.v3.<API key>
4, // 79: envoy.config.route.v3.RedirectAction.response_code:type_name -> envoy.config.route.v3.RedirectAction.<API key>
74, // 80: envoy.config.route.v3.<API key>.body:type_name -> envoy.config.core.v3.DataSource
67, // 81: envoy.config.route.v3.Decorator.propagate:type_name -> google.protobuf.BoolValue
73, // 82: envoy.config.route.v3.Tracing.client_sampling:type_name -> envoy.type.v3.FractionalPercent
73, // 83: envoy.config.route.v3.Tracing.random_sampling:type_name -> envoy.type.v3.FractionalPercent
73, // 84: envoy.config.route.v3.Tracing.overall_sampling:type_name -> envoy.type.v3.FractionalPercent
75, // 85: envoy.config.route.v3.Tracing.custom_tags:type_name -> envoy.type.tracing.v3.CustomTag
22, // 86: envoy.config.route.v3.VirtualCluster.headers:type_name -> envoy.config.route.v3.HeaderMatcher
76, // 87: envoy.config.route.v3.VirtualCluster.<API key>:type_name -> envoy.config.core.v3.RequestMethod
64, // 88: envoy.config.route.v3.RateLimit.stage:type_name -> google.protobuf.UInt32Value
51, // 89: envoy.config.route.v3.RateLimit.actions:type_name -> envoy.config.route.v3.RateLimit.Action
52, // 90: envoy.config.route.v3.RateLimit.limit:type_name -> envoy.config.route.v3.RateLimit.Override
66, // 91: envoy.config.route.v3.HeaderMatcher.safe_regex_match:type_name -> envoy.type.matcher.v3.RegexMatcher
77, // 92: envoy.config.route.v3.HeaderMatcher.range_match:type_name -> envoy.type.v3.Int64Range
69, // 93: envoy.config.route.v3.<API key>.string_match:type_name -> envoy.type.matcher.v3.StringMatcher
67, // 94: envoy.config.route.v3.<API key>.<API key>:type_name -> google.protobuf.BoolValue
64, // 95: envoy.config.route.v3.<API key>.<API key>:type_name -> google.protobuf.UInt32Value
78, // 96: envoy.config.route.v3.<API key>.predicates:type_name -> envoy.config.core.v3.<API key>
63, // 97: envoy.config.route.v3.FilterConfig.config:type_name -> google.protobuf.Any
63, // 98: envoy.config.route.v3.VirtualHost.<API key>.value:type_name -> google.protobuf.Any
79, // 99: envoy.config.route.v3.VirtualHost.<API key>.value:type_name -> google.protobuf.Struct
63, // 100: envoy.config.route.v3.Route.<API key>.value:type_name -> google.protobuf.Any
79, // 101: envoy.config.route.v3.Route.<API key>.value:type_name -> google.protobuf.Struct
64, // 102: envoy.config.route.v3.WeightedCluster.ClusterWeight.weight:type_name -> google.protobuf.UInt32Value
65, // 103: envoy.config.route.v3.WeightedCluster.ClusterWeight.metadata_match:type_name -> envoy.config.core.v3.Metadata
62, // 104: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
62, // 105: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>:type_name -> envoy.config.core.v3.HeaderValueOption
31, // 106: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>:type_name -> envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>
32, // 107: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>:type_name -> envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>
63, // 108: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>.value:type_name -> google.protobuf.Any
79, // 109: envoy.config.route.v3.WeightedCluster.ClusterWeight.<API key>.value:type_name -> google.protobuf.Struct
67, // 110: envoy.config.route.v3.RouteMatch.<API key>.presented:type_name -> google.protobuf.BoolValue
67, // 111: envoy.config.route.v3.RouteMatch.<API key>.validated:type_name -> google.protobuf.BoolValue
68, // 112: envoy.config.route.v3.RouteAction.RequestMirrorPolicy.runtime_fraction:type_name -> envoy.config.core.v3.<API key>
67, // 113: envoy.config.route.v3.RouteAction.RequestMirrorPolicy.trace_sampled:type_name -> google.protobuf.BoolValue
40, // 114: envoy.config.route.v3.RouteAction.HashPolicy.header:type_name -> envoy.config.route.v3.RouteAction.HashPolicy.Header
41, // 115: envoy.config.route.v3.RouteAction.HashPolicy.cookie:type_name -> envoy.config.route.v3.RouteAction.HashPolicy.Cookie
42, // 116: envoy.config.route.v3.RouteAction.HashPolicy.<API key>:type_name -> envoy.config.route.v3.RouteAction.HashPolicy.<API key>
43, // 117: envoy.config.route.v3.RouteAction.HashPolicy.query_parameter:type_name -> envoy.config.route.v3.RouteAction.HashPolicy.QueryParameter
44, // 118: envoy.config.route.v3.RouteAction.HashPolicy.filter_state:type_name -> envoy.config.route.v3.RouteAction.HashPolicy.FilterState
67, // 119: envoy.config.route.v3.RouteAction.UpgradeConfig.enabled:type_name -> google.protobuf.BoolValue
45, // 120: envoy.config.route.v3.RouteAction.UpgradeConfig.connect_config:type_name -> envoy.config.route.v3.RouteAction.UpgradeConfig.ConnectConfig
71, // 121: envoy.config.route.v3.RouteAction.MaxStreamDuration.max_stream_duration:type_name -> google.protobuf.Duration
71, // 122: envoy.config.route.v3.RouteAction.MaxStreamDuration.<API key>:type_name -> google.protobuf.Duration
71, // 123: envoy.config.route.v3.RouteAction.MaxStreamDuration.<API key>:type_name -> google.protobuf.Duration
70, // 124: envoy.config.route.v3.RouteAction.HashPolicy.Header.regex_rewrite:type_name -> envoy.type.matcher.v3.<API key>
71, // 125: envoy.config.route.v3.RouteAction.HashPolicy.Cookie.ttl:type_name -> google.protobuf.Duration
80, // 126: envoy.config.route.v3.RouteAction.UpgradeConfig.ConnectConfig.<API key>:type_name -> envoy.config.core.v3.ProxyProtocolConfig
63, // 127: envoy.config.route.v3.RetryPolicy.RetryPriority.typed_config:type_name -> google.protobuf.Any
79, // 128: envoy.config.route.v3.RetryPolicy.RetryPriority.<API key>:type_name -> google.protobuf.Struct
63, // 129: envoy.config.route.v3.RetryPolicy.RetryHostPredicate.typed_config:type_name -> google.protobuf.Any
79, // 130: envoy.config.route.v3.RetryPolicy.RetryHostPredicate.<API key>:type_name -> google.protobuf.Struct
71, // 131: envoy.config.route.v3.RetryPolicy.RetryBackOff.base_interval:type_name -> google.protobuf.Duration
71, // 132: envoy.config.route.v3.RetryPolicy.RetryBackOff.max_interval:type_name -> google.protobuf.Duration
3, // 133: envoy.config.route.v3.RetryPolicy.ResetHeader.format:type_name -> envoy.config.route.v3.RetryPolicy.ResetHeaderFormat
49, // 134: envoy.config.route.v3.RetryPolicy.<API key>.reset_headers:type_name -> envoy.config.route.v3.RetryPolicy.ResetHeader
71, // 135: envoy.config.route.v3.RetryPolicy.<API key>.max_interval:type_name -> google.protobuf.Duration
53, // 136: envoy.config.route.v3.RateLimit.Action.source_cluster:type_name -> envoy.config.route.v3.RateLimit.Action.SourceCluster
54, // 137: envoy.config.route.v3.RateLimit.Action.destination_cluster:type_name -> envoy.config.route.v3.RateLimit.Action.DestinationCluster
55, // 138: envoy.config.route.v3.RateLimit.Action.request_headers:type_name -> envoy.config.route.v3.RateLimit.Action.RequestHeaders
56, // 139: envoy.config.route.v3.RateLimit.Action.remote_address:type_name -> envoy.config.route.v3.RateLimit.Action.RemoteAddress
57, // 140: envoy.config.route.v3.RateLimit.Action.generic_key:type_name -> envoy.config.route.v3.RateLimit.Action.GenericKey
58, // 141: envoy.config.route.v3.RateLimit.Action.header_value_match:type_name -> envoy.config.route.v3.RateLimit.Action.HeaderValueMatch
59, // 142: envoy.config.route.v3.RateLimit.Action.dynamic_metadata:type_name -> envoy.config.route.v3.RateLimit.Action.DynamicMetaData
60, // 143: envoy.config.route.v3.RateLimit.Action.metadata:type_name -> envoy.config.route.v3.RateLimit.Action.MetaData
78, // 144: envoy.config.route.v3.RateLimit.Action.extension:type_name -> envoy.config.core.v3.<API key>
61, // 145: envoy.config.route.v3.RateLimit.Override.dynamic_metadata:type_name -> envoy.config.route.v3.RateLimit.Override.DynamicMetadata
67, // 146: envoy.config.route.v3.RateLimit.Action.HeaderValueMatch.expect_match:type_name -> google.protobuf.BoolValue
22, // 147: envoy.config.route.v3.RateLimit.Action.HeaderValueMatch.headers:type_name -> envoy.config.route.v3.HeaderMatcher
81, // 148: envoy.config.route.v3.RateLimit.Action.DynamicMetaData.metadata_key:type_name -> envoy.type.metadata.v3.MetadataKey
81, // 149: envoy.config.route.v3.RateLimit.Action.MetaData.metadata_key:type_name -> envoy.type.metadata.v3.MetadataKey
5, // 150: envoy.config.route.v3.RateLimit.Action.MetaData.source:type_name -> envoy.config.route.v3.RateLimit.Action.MetaData.Source
81, // 151: envoy.config.route.v3.RateLimit.Override.DynamicMetadata.metadata_key:type_name -> envoy.type.metadata.v3.MetadataKey
152, // [152:152] is the sub-list for method output_type
152, // [152:152] is the sub-list for method input_type
152, // [152:152] is the sub-list for extension type_name
152, // [152:152] is the sub-list for extension extendee
0, // [0:152] is the sub-list for field type_name
}
func init() { <API key>() }
func <API key>() {
if <API key> != nil {
return
}
if !protoimpl.UnsafeEnabled {
<API key>[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*VirtualHost); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FilterAction); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Route); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*WeightedCluster); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RouteMatch); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CorsPolicy); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RouteAction); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RetryPolicy); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HedgePolicy); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RedirectAction); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*NonForwardingAction); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Decorator); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Tracing); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*VirtualCluster); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RateLimit); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HeaderMatcher); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[17].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[18].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[19].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FilterConfig); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[24].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[27].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[28].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[29].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[30].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[31].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[32].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[33].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[34].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[35].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[36].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[37].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[38].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[39].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[40].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[41].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[42].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[43].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[44].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[45].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RateLimit_Action); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[46].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RateLimit_Override); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[47].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[48].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[49].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[50].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[51].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[52].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[53].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[54].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
<API key>[55].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*<API key>); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
<API key>[2].OneofWrappers = []interface{}{
(*Route_Route)(nil),
(*Route_Redirect)(nil),
(*<API key>)(nil),
(*Route_FilterAction)(nil),
(*<API key>)(nil),
}
<API key>[4].OneofWrappers = []interface{}{
(*RouteMatch_Prefix)(nil),
(*RouteMatch_Path)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[5].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[6].OneofWrappers = []interface{}{
(*RouteAction_Cluster)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[9].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[16].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[17].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[31].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[40].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[41].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[45].OneofWrappers = []interface{}{
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
(*<API key>)(nil),
}
<API key>[46].OneofWrappers = []interface{}{
(*<API key>)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: <API key>,
NumEnums: 6,
NumMessages: 56,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: <API key>,
DependencyIndexes: <API key>,
EnumInfos: <API key>,
MessageInfos: <API key>,
}.Build()
<API key> = out.File
<API key> = nil
<API key> = nil
<API key> = nil
}
|
<div class="md-whiteframe-z1" flex layout-margin layout="column" style="position: relative;">
<table st-fixed-header st-table="rows" class="table table-striped header-fixed">
<thead>
<tr>
<th st-sort="index">Index</th>
<th st-sort="internalFlows">Internal Flows</th>
<th st-sort="externalFlows">External Flows</th>
<th st-sort="size">Size</th>
</tr>
</thead>
<tbody>
<tr ng-repeat="row in rows">
<td>Activity #{{row.index}}</td>
<td>{{row.internalFlows}}</td>
<td>{{row.externalFlows}}</td>
<td>{{row.size}}</td>
</tr>
</tbody>
</table>
</div>
|
namespace Foundatio.Parsers.LuceneQueries.Visitors {
public interface <API key> : <API key> {
<API key> ValidationOptions { get; set; }
QueryValidationInfo ValidationInfo { get; set; }
}
}
|
from PB.recipes.recipe_engine.engine_tests import proto_properties
<API key> = 'PY2+3'
DEPS = [
'assertions',
'properties',
]
PROPERTIES = proto_properties.TestProperties
ENV_PROPERTIES = proto_properties.EnvProperties
def RunSteps(api, properties, env_props):
api.assertions.assertEqual(properties.an_int, 100)
api.assertions.assertEqual(properties.some_string, 'hey there')
api.assertions.assertEqual(env_props.STR_ENV, "sup")
api.assertions.assertEqual(env_props.INT_ENV, 9000)
def GenTests(api):
yield (
api.test('full')
+ api.properties(
proto_properties.TestProperties(
an_int=100,
some_string='hey there',
),
ignored_prop='yo')
+ api.properties.environ(
proto_properties.EnvProperties(
STR_ENV="sup",
INT_ENV=9000,
))
+ api.post_process(lambda _check, _steps: {}))
|
<!DOCTYPE html>
<html lang="en">
<head>
<!-- staic resources path in spring-boot
classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/
<script src="/common/js/jquery-3.3.1.js" th:src="@{/common/js/jquery-3.3.1.js}" type="application/javascript" ></script>
</head>
<body th:text="|${message}|">No Message
</body>
</html>
|
// Code generated by protoc-gen-gogo.
// source: pdpb.proto
// DO NOT EDIT!
/*
Package pdpb is a generated protocol buffer package.
It is generated from these files:
pdpb.proto
It has these top-level messages:
RequestHeader
ResponseHeader
Error
TsoRequest
Timestamp
TsoResponse
BootstrapRequest
BootstrapResponse
<API key>
<API key>
AllocIDRequest
AllocIDResponse
GetStoreRequest
GetStoreResponse
PutStoreRequest
PutStoreResponse
GetAllStoresRequest
<API key>
GetRegionRequest
GetRegionResponse
<API key>
<API key>
<API key>
<API key>
<API key>
Member
GetMembersRequest
GetMembersResponse
PeerStats
<API key>
ChangePeer
TransferLeader
Merge
SplitRegion
<API key>
AskSplitRequest
AskSplitResponse
ReportSplitRequest
ReportSplitResponse
<API key>
SplitID
<API key>
<API key>
<API key>
TimeInterval
StoreStats
<API key>
<API key>
<API key>
<API key>
<API key>
<API key>
<API key>
<API key>
*/
package pdpb
import (
"fmt"
"io"
"math"
proto "github.com/golang/protobuf/proto"
metapb "github.com/pingcap/kvproto/pkg/metapb"
eraftpb "github.com/pingcap/kvproto/pkg/eraftpb"
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.<API key> // please upgrade the proto package
type ErrorType int32
const (
ErrorType_OK ErrorType = 0
ErrorType_UNKNOWN ErrorType = 1
<API key> ErrorType = 2
<API key> ErrorType = 3
<API key> ErrorType = 4
<API key> ErrorType = 5
)
var ErrorType_name = map[int32]string{
0: "OK",
1: "UNKNOWN",
2: "NOT_BOOTSTRAPPED",
3: "STORE_TOMBSTONE",
4: "<API key>",
5: "<API key>",
}
var ErrorType_value = map[string]int32{
"OK": 0,
"UNKNOWN": 1,
"NOT_BOOTSTRAPPED": 2,
"STORE_TOMBSTONE": 3,
"<API key>": 4,
"<API key>": 5,
}
func (x ErrorType) String() string {
return proto.EnumName(ErrorType_name, int32(x))
}
func (ErrorType) EnumDescriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{0} }
type CheckPolicy int32
const (
CheckPolicy_SCAN CheckPolicy = 0
<API key> CheckPolicy = 1
)
var CheckPolicy_name = map[int32]string{
0: "SCAN",
1: "APPROXIMATE",
}
var CheckPolicy_value = map[string]int32{
"SCAN": 0,
"APPROXIMATE": 1,
}
func (x CheckPolicy) String() string {
return proto.EnumName(CheckPolicy_name, int32(x))
}
func (CheckPolicy) EnumDescriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{1} }
type RequestHeader struct {
// cluster_id is the ID of the cluster which be sent to.
ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
}
func (m *RequestHeader) Reset() { *m = RequestHeader{} }
func (m *RequestHeader) String() string { return proto.CompactTextString(m) }
func (*RequestHeader) ProtoMessage() {}
func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{0} }
func (m *RequestHeader) GetClusterId() uint64 {
if m != nil {
return m.ClusterId
}
return 0
}
type ResponseHeader struct {
// cluster_id is the ID of the cluster which sent the response.
ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"`
}
func (m *ResponseHeader) Reset() { *m = ResponseHeader{} }
func (m *ResponseHeader) String() string { return proto.CompactTextString(m) }
func (*ResponseHeader) ProtoMessage() {}
func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{1} }
func (m *ResponseHeader) GetClusterId() uint64 {
if m != nil {
return m.ClusterId
}
return 0
}
func (m *ResponseHeader) GetError() *Error {
if m != nil {
return m.Error
}
return nil
}
type Error struct {
Type ErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=pdpb.ErrorType" json:"type,omitempty"`
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}
func (m *Error) Reset() { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage() {}
func (*Error) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{2} }
func (m *Error) GetType() ErrorType {
if m != nil {
return m.Type
}
return ErrorType_OK
}
func (m *Error) GetMessage() string {
if m != nil {
return m.Message
}
return ""
}
type TsoRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
}
func (m *TsoRequest) Reset() { *m = TsoRequest{} }
func (m *TsoRequest) String() string { return proto.CompactTextString(m) }
func (*TsoRequest) ProtoMessage() {}
func (*TsoRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{3} }
func (m *TsoRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *TsoRequest) GetCount() uint32 {
if m != nil {
return m.Count
}
return 0
}
type Timestamp struct {
Physical int64 `protobuf:"varint,1,opt,name=physical,proto3" json:"physical,omitempty"`
Logical int64 `protobuf:"varint,2,opt,name=logical,proto3" json:"logical,omitempty"`
}
func (m *Timestamp) Reset() { *m = Timestamp{} }
func (m *Timestamp) String() string { return proto.CompactTextString(m) }
func (*Timestamp) ProtoMessage() {}
func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{4} }
func (m *Timestamp) GetPhysical() int64 {
if m != nil {
return m.Physical
}
return 0
}
func (m *Timestamp) GetLogical() int64 {
if m != nil {
return m.Logical
}
return 0
}
type TsoResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
Timestamp *Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"`
}
func (m *TsoResponse) Reset() { *m = TsoResponse{} }
func (m *TsoResponse) String() string { return proto.CompactTextString(m) }
func (*TsoResponse) ProtoMessage() {}
func (*TsoResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{5} }
func (m *TsoResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *TsoResponse) GetCount() uint32 {
if m != nil {
return m.Count
}
return 0
}
func (m *TsoResponse) GetTimestamp() *Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
type BootstrapRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"`
Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"`
}
func (m *BootstrapRequest) Reset() { *m = BootstrapRequest{} }
func (m *BootstrapRequest) String() string { return proto.CompactTextString(m) }
func (*BootstrapRequest) ProtoMessage() {}
func (*BootstrapRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{6} }
func (m *BootstrapRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *BootstrapRequest) GetStore() *metapb.Store {
if m != nil {
return m.Store
}
return nil
}
func (m *BootstrapRequest) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
type BootstrapResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *BootstrapResponse) Reset() { *m = BootstrapResponse{} }
func (m *BootstrapResponse) String() string { return proto.CompactTextString(m) }
func (*BootstrapResponse) ProtoMessage() {}
func (*BootstrapResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{7} }
func (m *BootstrapResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{8} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Bootstrapped bool `protobuf:"varint,2,opt,name=bootstrapped,proto3" json:"bootstrapped,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{9} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetBootstrapped() bool {
if m != nil {
return m.Bootstrapped
}
return false
}
type AllocIDRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *AllocIDRequest) Reset() { *m = AllocIDRequest{} }
func (m *AllocIDRequest) String() string { return proto.CompactTextString(m) }
func (*AllocIDRequest) ProtoMessage() {}
func (*AllocIDRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{10} }
func (m *AllocIDRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type AllocIDResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
}
func (m *AllocIDResponse) Reset() { *m = AllocIDResponse{} }
func (m *AllocIDResponse) String() string { return proto.CompactTextString(m) }
func (*AllocIDResponse) ProtoMessage() {}
func (*AllocIDResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{11} }
func (m *AllocIDResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *AllocIDResponse) GetId() uint64 {
if m != nil {
return m.Id
}
return 0
}
type GetStoreRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
}
func (m *GetStoreRequest) Reset() { *m = GetStoreRequest{} }
func (m *GetStoreRequest) String() string { return proto.CompactTextString(m) }
func (*GetStoreRequest) ProtoMessage() {}
func (*GetStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{12} }
func (m *GetStoreRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetStoreRequest) GetStoreId() uint64 {
if m != nil {
return m.StoreId
}
return 0
}
type GetStoreResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"`
}
func (m *GetStoreResponse) Reset() { *m = GetStoreResponse{} }
func (m *GetStoreResponse) String() string { return proto.CompactTextString(m) }
func (*GetStoreResponse) ProtoMessage() {}
func (*GetStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{13} }
func (m *GetStoreResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetStoreResponse) GetStore() *metapb.Store {
if m != nil {
return m.Store
}
return nil
}
type PutStoreRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"`
}
func (m *PutStoreRequest) Reset() { *m = PutStoreRequest{} }
func (m *PutStoreRequest) String() string { return proto.CompactTextString(m) }
func (*PutStoreRequest) ProtoMessage() {}
func (*PutStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{14} }
func (m *PutStoreRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *PutStoreRequest) GetStore() *metapb.Store {
if m != nil {
return m.Store
}
return nil
}
type PutStoreResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *PutStoreResponse) Reset() { *m = PutStoreResponse{} }
func (m *PutStoreResponse) String() string { return proto.CompactTextString(m) }
func (*PutStoreResponse) ProtoMessage() {}
func (*PutStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{15} }
func (m *PutStoreResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type GetAllStoresRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *GetAllStoresRequest) Reset() { *m = GetAllStoresRequest{} }
func (m *GetAllStoresRequest) String() string { return proto.CompactTextString(m) }
func (*GetAllStoresRequest) ProtoMessage() {}
func (*GetAllStoresRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{16} }
func (m *GetAllStoresRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Stores []*metapb.Store `protobuf:"bytes,2,rep,name=stores" json:"stores,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{17} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetStores() []*metapb.Store {
if m != nil {
return m.Stores
}
return nil
}
type GetRegionRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
RegionKey []byte `protobuf:"bytes,2,opt,name=region_key,json=regionKey,proto3" json:"region_key,omitempty"`
}
func (m *GetRegionRequest) Reset() { *m = GetRegionRequest{} }
func (m *GetRegionRequest) String() string { return proto.CompactTextString(m) }
func (*GetRegionRequest) ProtoMessage() {}
func (*GetRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{18} }
func (m *GetRegionRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetRegionRequest) GetRegionKey() []byte {
if m != nil {
return m.RegionKey
}
return nil
}
type GetRegionResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"`
}
func (m *GetRegionResponse) Reset() { *m = GetRegionResponse{} }
func (m *GetRegionResponse) String() string { return proto.CompactTextString(m) }
func (*GetRegionResponse) ProtoMessage() {}
func (*GetRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{19} }
func (m *GetRegionResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetRegionResponse) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
func (m *GetRegionResponse) GetLeader() *metapb.Peer {
if m != nil {
return m.Leader
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{20} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetRegionId() uint64 {
if m != nil {
return m.RegionId
}
return 0
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{21} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{22} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetCluster() *metapb.Cluster {
if m != nil {
return m.Cluster
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{23} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetCluster() *metapb.Cluster {
if m != nil {
return m.Cluster
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{24} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type Member struct {
// name is the name of the PD member.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// member_id is the unique id of the PD member.
MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
PeerUrls []string `protobuf:"bytes,3,rep,name=peer_urls,json=peerUrls" json:"peer_urls,omitempty"`
ClientUrls []string `protobuf:"bytes,4,rep,name=client_urls,json=clientUrls" json:"client_urls,omitempty"`
LeaderPriority int32 `protobuf:"varint,5,opt,name=leader_priority,json=leaderPriority,proto3" json:"leader_priority,omitempty"`
}
func (m *Member) Reset() { *m = Member{} }
func (m *Member) String() string { return proto.CompactTextString(m) }
func (*Member) ProtoMessage() {}
func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{25} }
func (m *Member) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Member) GetMemberId() uint64 {
if m != nil {
return m.MemberId
}
return 0
}
func (m *Member) GetPeerUrls() []string {
if m != nil {
return m.PeerUrls
}
return nil
}
func (m *Member) GetClientUrls() []string {
if m != nil {
return m.ClientUrls
}
return nil
}
func (m *Member) GetLeaderPriority() int32 {
if m != nil {
return m.LeaderPriority
}
return 0
}
type GetMembersRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *GetMembersRequest) Reset() { *m = GetMembersRequest{} }
func (m *GetMembersRequest) String() string { return proto.CompactTextString(m) }
func (*GetMembersRequest) ProtoMessage() {}
func (*GetMembersRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{26} }
func (m *GetMembersRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type GetMembersResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
Leader *Member `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"`
EtcdLeader *Member `protobuf:"bytes,4,opt,name=etcd_leader,json=etcdLeader" json:"etcd_leader,omitempty"`
}
func (m *GetMembersResponse) Reset() { *m = GetMembersResponse{} }
func (m *GetMembersResponse) String() string { return proto.CompactTextString(m) }
func (*GetMembersResponse) ProtoMessage() {}
func (*GetMembersResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{27} }
func (m *GetMembersResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetMembersResponse) GetMembers() []*Member {
if m != nil {
return m.Members
}
return nil
}
func (m *GetMembersResponse) GetLeader() *Member {
if m != nil {
return m.Leader
}
return nil
}
func (m *GetMembersResponse) GetEtcdLeader() *Member {
if m != nil {
return m.EtcdLeader
}
return nil
}
type PeerStats struct {
Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"`
DownSeconds uint64 `protobuf:"varint,2,opt,name=down_seconds,json=downSeconds,proto3" json:"down_seconds,omitempty"`
}
func (m *PeerStats) Reset() { *m = PeerStats{} }
func (m *PeerStats) String() string { return proto.CompactTextString(m) }
func (*PeerStats) ProtoMessage() {}
func (*PeerStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{28} }
func (m *PeerStats) GetPeer() *metapb.Peer {
if m != nil {
return m.Peer
}
return nil
}
func (m *PeerStats) GetDownSeconds() uint64 {
if m != nil {
return m.DownSeconds
}
return 0
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
// Leader Peer sending the heartbeat.
Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"`
// Leader considers that these peers are down.
DownPeers []*PeerStats `protobuf:"bytes,4,rep,name=down_peers,json=downPeers" json:"down_peers,omitempty"`
// Pending peers are the peers that the leader can't consider as
// working followers.
PendingPeers []*metapb.Peer `protobuf:"bytes,5,rep,name=pending_peers,json=pendingPeers" json:"pending_peers,omitempty"`
// Bytes read/written during this period.
BytesWritten uint64 `protobuf:"varint,6,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"`
BytesRead uint64 `protobuf:"varint,7,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"`
// Keys read/written during this period.
KeysWritten uint64 `protobuf:"varint,8,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"`
KeysRead uint64 `protobuf:"varint,9,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"`
// Approximate region size.
ApproximateSize uint64 `protobuf:"varint,10,opt,name=approximate_size,json=approximateSize,proto3" json:"approximate_size,omitempty"`
// Actually reported time interval
Interval *TimeInterval `protobuf:"bytes,12,opt,name=interval" json:"interval,omitempty"`
// Approximate number of keys.
ApproximateKeys uint64 `protobuf:"varint,13,opt,name=approximate_keys,json=approximateKeys,proto3" json:"approximate_keys,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{29} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
func (m *<API key>) GetLeader() *metapb.Peer {
if m != nil {
return m.Leader
}
return nil
}
func (m *<API key>) GetDownPeers() []*PeerStats {
if m != nil {
return m.DownPeers
}
return nil
}
func (m *<API key>) GetPendingPeers() []*metapb.Peer {
if m != nil {
return m.PendingPeers
}
return nil
}
func (m *<API key>) GetBytesWritten() uint64 {
if m != nil {
return m.BytesWritten
}
return 0
}
func (m *<API key>) GetBytesRead() uint64 {
if m != nil {
return m.BytesRead
}
return 0
}
func (m *<API key>) GetKeysWritten() uint64 {
if m != nil {
return m.KeysWritten
}
return 0
}
func (m *<API key>) GetKeysRead() uint64 {
if m != nil {
return m.KeysRead
}
return 0
}
func (m *<API key>) GetApproximateSize() uint64 {
if m != nil {
return m.ApproximateSize
}
return 0
}
func (m *<API key>) GetInterval() *TimeInterval {
if m != nil {
return m.Interval
}
return nil
}
func (m *<API key>) GetApproximateKeys() uint64 {
if m != nil {
return m.ApproximateKeys
}
return 0
}
type ChangePeer struct {
Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"`
ChangeType eraftpb.ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"`
}
func (m *ChangePeer) Reset() { *m = ChangePeer{} }
func (m *ChangePeer) String() string { return proto.CompactTextString(m) }
func (*ChangePeer) ProtoMessage() {}
func (*ChangePeer) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{30} }
func (m *ChangePeer) GetPeer() *metapb.Peer {
if m != nil {
return m.Peer
}
return nil
}
func (m *ChangePeer) GetChangeType() eraftpb.ConfChangeType {
if m != nil {
return m.ChangeType
}
return eraftpb.<API key>
}
type TransferLeader struct {
Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"`
}
func (m *TransferLeader) Reset() { *m = TransferLeader{} }
func (m *TransferLeader) String() string { return proto.CompactTextString(m) }
func (*TransferLeader) ProtoMessage() {}
func (*TransferLeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{31} }
func (m *TransferLeader) GetPeer() *metapb.Peer {
if m != nil {
return m.Peer
}
return nil
}
type Merge struct {
Target *metapb.Region `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
}
func (m *Merge) Reset() { *m = Merge{} }
func (m *Merge) String() string { return proto.CompactTextString(m) }
func (*Merge) ProtoMessage() {}
func (*Merge) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{32} }
func (m *Merge) GetTarget() *metapb.Region {
if m != nil {
return m.Target
}
return nil
}
type SplitRegion struct {
Policy CheckPolicy `protobuf:"varint,1,opt,name=policy,proto3,enum=pdpb.CheckPolicy" json:"policy,omitempty"`
}
func (m *SplitRegion) Reset() { *m = SplitRegion{} }
func (m *SplitRegion) String() string { return proto.CompactTextString(m) }
func (*SplitRegion) ProtoMessage() {}
func (*SplitRegion) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{33} }
func (m *SplitRegion) GetPolicy() CheckPolicy {
if m != nil {
return m.Policy
}
return CheckPolicy_SCAN
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
// Notice, Pd only allows handling reported epoch >= current pd's.
// Leader peer reports region status with <API key>
// to pd regularly, pd will determine whether this region
// should do ChangePeer or not.
// E,g, max peer number is 3, region A, first only peer 1 in A.
// 1. Pd region state -> Peers (1), ConfVer (1).
// 2. Leader peer 1 reports region state to pd, pd finds the
// peer number is < 3, so first changes its current region
// state -> Peers (1, 2), ConfVer (1), and returns ChangePeer Adding 2.
// 3. Leader does ChangePeer, then reports Peers (1, 2), ConfVer (2),
// pd updates its state -> Peers (1, 2), ConfVer (2).
// 4. Leader may report old Peers (1), ConfVer (1) to pd before ConfChange
// finished, pd stills responses ChangePeer Adding 2, of course, we must
// guarantee the second ChangePeer can't be applied in TiKV.
ChangePeer *ChangePeer `protobuf:"bytes,2,opt,name=change_peer,json=changePeer" json:"change_peer,omitempty"`
// Pd can return transfer_leader to let TiKV does leader transfer itself.
TransferLeader *TransferLeader `protobuf:"bytes,3,opt,name=transfer_leader,json=transferLeader" json:"transfer_leader,omitempty"`
// ID of the region
RegionId uint64 `protobuf:"varint,4,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,5,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"`
// Leader of the region at the moment of the corresponding request was made.
TargetPeer *metapb.Peer `protobuf:"bytes,6,opt,name=target_peer,json=targetPeer" json:"target_peer,omitempty"`
Merge *Merge `protobuf:"bytes,7,opt,name=merge" json:"merge,omitempty"`
// PD sends split_region to let TiKV split a region into two regions.
SplitRegion *SplitRegion `protobuf:"bytes,8,opt,name=split_region,json=splitRegion" json:"split_region,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{34} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetChangePeer() *ChangePeer {
if m != nil {
return m.ChangePeer
}
return nil
}
func (m *<API key>) GetTransferLeader() *TransferLeader {
if m != nil {
return m.TransferLeader
}
return nil
}
func (m *<API key>) GetRegionId() uint64 {
if m != nil {
return m.RegionId
}
return 0
}
func (m *<API key>) GetRegionEpoch() *metapb.RegionEpoch {
if m != nil {
return m.RegionEpoch
}
return nil
}
func (m *<API key>) GetTargetPeer() *metapb.Peer {
if m != nil {
return m.TargetPeer
}
return nil
}
func (m *<API key>) GetMerge() *Merge {
if m != nil {
return m.Merge
}
return nil
}
func (m *<API key>) GetSplitRegion() *SplitRegion {
if m != nil {
return m.SplitRegion
}
return nil
}
type AskSplitRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
}
func (m *AskSplitRequest) Reset() { *m = AskSplitRequest{} }
func (m *AskSplitRequest) String() string { return proto.CompactTextString(m) }
func (*AskSplitRequest) ProtoMessage() {}
func (*AskSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{35} }
func (m *AskSplitRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *AskSplitRequest) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
type AskSplitResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
// We split the region into two, first uses the origin
// parent region id, and the second uses the new_region_id.
// We must guarantee that the new_region_id is global unique.
NewRegionId uint64 `protobuf:"varint,2,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"`
// The peer ids for the new split region.
NewPeerIds []uint64 `protobuf:"varint,3,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"`
}
func (m *AskSplitResponse) Reset() { *m = AskSplitResponse{} }
func (m *AskSplitResponse) String() string { return proto.CompactTextString(m) }
func (*AskSplitResponse) ProtoMessage() {}
func (*AskSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{36} }
func (m *AskSplitResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *AskSplitResponse) GetNewRegionId() uint64 {
if m != nil {
return m.NewRegionId
}
return 0
}
func (m *AskSplitResponse) GetNewPeerIds() []uint64 {
if m != nil {
return m.NewPeerIds
}
return nil
}
type ReportSplitRequest struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"`
Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"`
}
func (m *ReportSplitRequest) Reset() { *m = ReportSplitRequest{} }
func (m *ReportSplitRequest) String() string { return proto.CompactTextString(m) }
func (*ReportSplitRequest) ProtoMessage() {}
func (*ReportSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{37} }
func (m *ReportSplitRequest) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *ReportSplitRequest) GetLeft() *metapb.Region {
if m != nil {
return m.Left
}
return nil
}
func (m *ReportSplitRequest) GetRight() *metapb.Region {
if m != nil {
return m.Right
}
return nil
}
type ReportSplitResponse struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *ReportSplitResponse) Reset() { *m = ReportSplitResponse{} }
func (m *ReportSplitResponse) String() string { return proto.CompactTextString(m) }
func (*ReportSplitResponse) ProtoMessage() {}
func (*ReportSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{38} }
func (m *ReportSplitResponse) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"`
SplitCount uint32 `protobuf:"varint,3,opt,name=split_count,json=splitCount,proto3" json:"split_count,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{39} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
func (m *<API key>) GetSplitCount() uint32 {
if m != nil {
return m.SplitCount
}
return 0
}
type SplitID struct {
NewRegionId uint64 `protobuf:"varint,1,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"`
NewPeerIds []uint64 `protobuf:"varint,2,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"`
}
func (m *SplitID) Reset() { *m = SplitID{} }
func (m *SplitID) String() string { return proto.CompactTextString(m) }
func (*SplitID) ProtoMessage() {}
func (*SplitID) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{40} }
func (m *SplitID) GetNewRegionId() uint64 {
if m != nil {
return m.NewRegionId
}
return 0
}
func (m *SplitID) GetNewPeerIds() []uint64 {
if m != nil {
return m.NewPeerIds
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Ids []*SplitID `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{41} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetIds() []*SplitID {
if m != nil {
return m.Ids
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{42} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetRegions() []*metapb.Region {
if m != nil {
return m.Regions
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{43} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type TimeInterval struct {
// The unix timestamp in seconds of the start of this period.
StartTimestamp uint64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"`
// The unix timestamp in seconds of the end of this period.
EndTimestamp uint64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"`
}
func (m *TimeInterval) Reset() { *m = TimeInterval{} }
func (m *TimeInterval) String() string { return proto.CompactTextString(m) }
func (*TimeInterval) ProtoMessage() {}
func (*TimeInterval) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{44} }
func (m *TimeInterval) GetStartTimestamp() uint64 {
if m != nil {
return m.StartTimestamp
}
return 0
}
func (m *TimeInterval) GetEndTimestamp() uint64 {
if m != nil {
return m.EndTimestamp
}
return 0
}
type StoreStats struct {
StoreId uint64 `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
// Capacity for the store.
Capacity uint64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"`
// Available size for the store.
Available uint64 `protobuf:"varint,3,opt,name=available,proto3" json:"available,omitempty"`
// Total region count in this store.
RegionCount uint32 `protobuf:"varint,4,opt,name=region_count,json=regionCount,proto3" json:"region_count,omitempty"`
// Current sending snapshot count.
SendingSnapCount uint32 `protobuf:"varint,5,opt,name=sending_snap_count,json=sendingSnapCount,proto3" json:"sending_snap_count,omitempty"`
// Current receiving snapshot count.
ReceivingSnapCount uint32 `protobuf:"varint,6,opt,name=<API key>,json=receivingSnapCount,proto3" json:"<API key>,omitempty"`
// When the store is started (unix timestamp in seconds).
StartTime uint32 `protobuf:"varint,7,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
// How many region is applying snapshot.
ApplyingSnapCount uint32 `protobuf:"varint,8,opt,name=applying_snap_count,json=applyingSnapCount,proto3" json:"applying_snap_count,omitempty"`
// If the store is busy
IsBusy bool `protobuf:"varint,9,opt,name=is_busy,json=isBusy,proto3" json:"is_busy,omitempty"`
// Actually used space by db
UsedSize uint64 `protobuf:"varint,10,opt,name=used_size,json=usedSize,proto3" json:"used_size,omitempty"`
// Bytes written for the store during this period.
BytesWritten uint64 `protobuf:"varint,11,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"`
// Keys written for the store during this period.
KeysWritten uint64 `protobuf:"varint,12,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"`
// Bytes read for the store during this period.
BytesRead uint64 `protobuf:"varint,13,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"`
// Keys read for the store during this period.
KeysRead uint64 `protobuf:"varint,14,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"`
// Actually reported time interval
Interval *TimeInterval `protobuf:"bytes,15,opt,name=interval" json:"interval,omitempty"`
}
func (m *StoreStats) Reset() { *m = StoreStats{} }
func (m *StoreStats) String() string { return proto.CompactTextString(m) }
func (*StoreStats) ProtoMessage() {}
func (*StoreStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{45} }
func (m *StoreStats) GetStoreId() uint64 {
if m != nil {
return m.StoreId
}
return 0
}
func (m *StoreStats) GetCapacity() uint64 {
if m != nil {
return m.Capacity
}
return 0
}
func (m *StoreStats) GetAvailable() uint64 {
if m != nil {
return m.Available
}
return 0
}
func (m *StoreStats) GetRegionCount() uint32 {
if m != nil {
return m.RegionCount
}
return 0
}
func (m *StoreStats) GetSendingSnapCount() uint32 {
if m != nil {
return m.SendingSnapCount
}
return 0
}
func (m *StoreStats) <API key>() uint32 {
if m != nil {
return m.ReceivingSnapCount
}
return 0
}
func (m *StoreStats) GetStartTime() uint32 {
if m != nil {
return m.StartTime
}
return 0
}
func (m *StoreStats) <API key>() uint32 {
if m != nil {
return m.ApplyingSnapCount
}
return 0
}
func (m *StoreStats) GetIsBusy() bool {
if m != nil {
return m.IsBusy
}
return false
}
func (m *StoreStats) GetUsedSize() uint64 {
if m != nil {
return m.UsedSize
}
return 0
}
func (m *StoreStats) GetBytesWritten() uint64 {
if m != nil {
return m.BytesWritten
}
return 0
}
func (m *StoreStats) GetKeysWritten() uint64 {
if m != nil {
return m.KeysWritten
}
return 0
}
func (m *StoreStats) GetBytesRead() uint64 {
if m != nil {
return m.BytesRead
}
return 0
}
func (m *StoreStats) GetKeysRead() uint64 {
if m != nil {
return m.KeysRead
}
return 0
}
func (m *StoreStats) GetInterval() *TimeInterval {
if m != nil {
return m.Interval
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
Stats *StoreStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{46} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetStats() *StoreStats {
if m != nil {
return m.Stats
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{47} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
// PD will use these region information if it can't find the region.
// For example, the region is just split and hasn't report to PD yet.
Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"`
Leader *metapb.Peer `protobuf:"bytes,4,opt,name=leader" json:"leader,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{48} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetRegionId() uint64 {
if m != nil {
return m.RegionId
}
return 0
}
func (m *<API key>) GetRegion() *metapb.Region {
if m != nil {
return m.Region
}
return nil
}
func (m *<API key>) GetLeader() *metapb.Peer {
if m != nil {
return m.Leader
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{49} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{50} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{51} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetSafePoint() uint64 {
if m != nil {
return m.SafePoint
}
return 0
}
type <API key> struct {
Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{52} }
func (m *<API key>) GetHeader() *RequestHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetSafePoint() uint64 {
if m != nil {
return m.SafePoint
}
return 0
}
type <API key> struct {
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
NewSafePoint uint64 `protobuf:"varint,2,opt,name=new_safe_point,json=newSafePoint,proto3" json:"new_safe_point,omitempty"`
}
func (m *<API key>) Reset() { *m = <API key>{} }
func (m *<API key>) String() string { return proto.CompactTextString(m) }
func (*<API key>) ProtoMessage() {}
func (*<API key>) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{53} }
func (m *<API key>) GetHeader() *ResponseHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *<API key>) GetNewSafePoint() uint64 {
if m != nil {
return m.NewSafePoint
}
return 0
}
func init() {
proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader")
proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader")
proto.RegisterType((*Error)(nil), "pdpb.Error")
proto.RegisterType((*TsoRequest)(nil), "pdpb.TsoRequest")
proto.RegisterType((*Timestamp)(nil), "pdpb.Timestamp")
proto.RegisterType((*TsoResponse)(nil), "pdpb.TsoResponse")
proto.RegisterType((*BootstrapRequest)(nil), "pdpb.BootstrapRequest")
proto.RegisterType((*BootstrapResponse)(nil), "pdpb.BootstrapResponse")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*AllocIDRequest)(nil), "pdpb.AllocIDRequest")
proto.RegisterType((*AllocIDResponse)(nil), "pdpb.AllocIDResponse")
proto.RegisterType((*GetStoreRequest)(nil), "pdpb.GetStoreRequest")
proto.RegisterType((*GetStoreResponse)(nil), "pdpb.GetStoreResponse")
proto.RegisterType((*PutStoreRequest)(nil), "pdpb.PutStoreRequest")
proto.RegisterType((*PutStoreResponse)(nil), "pdpb.PutStoreResponse")
proto.RegisterType((*GetAllStoresRequest)(nil), "pdpb.GetAllStoresRequest")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*GetRegionRequest)(nil), "pdpb.GetRegionRequest")
proto.RegisterType((*GetRegionResponse)(nil), "pdpb.GetRegionResponse")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*Member)(nil), "pdpb.Member")
proto.RegisterType((*GetMembersRequest)(nil), "pdpb.GetMembersRequest")
proto.RegisterType((*GetMembersResponse)(nil), "pdpb.GetMembersResponse")
proto.RegisterType((*PeerStats)(nil), "pdpb.PeerStats")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*ChangePeer)(nil), "pdpb.ChangePeer")
proto.RegisterType((*TransferLeader)(nil), "pdpb.TransferLeader")
proto.RegisterType((*Merge)(nil), "pdpb.Merge")
proto.RegisterType((*SplitRegion)(nil), "pdpb.SplitRegion")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*AskSplitRequest)(nil), "pdpb.AskSplitRequest")
proto.RegisterType((*AskSplitResponse)(nil), "pdpb.AskSplitResponse")
proto.RegisterType((*ReportSplitRequest)(nil), "pdpb.ReportSplitRequest")
proto.RegisterType((*ReportSplitResponse)(nil), "pdpb.ReportSplitResponse")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*SplitID)(nil), "pdpb.SplitID")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*TimeInterval)(nil), "pdpb.TimeInterval")
proto.RegisterType((*StoreStats)(nil), "pdpb.StoreStats")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterType((*<API key>)(nil), "pdpb.<API key>")
proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value)
proto.RegisterEnum("pdpb.CheckPolicy", CheckPolicy_name, CheckPolicy_value)
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.<API key>
// Client API for PD service
type PDClient interface {
// GetMembers get the member list of this cluster. It does not require
// the cluster_id in request matchs the id of this cluster.
GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error)
Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error)
Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error)
IsBootstrapped(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error)
GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error)
PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error)
GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*<API key>, error)
StoreHeartbeat(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (<API key>, error)
GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error)
GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error)
GetRegionByID(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*GetRegionResponse, error)
AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error)
ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error)
AskBatchSplit(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
ReportBatchSplit(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
GetClusterConfig(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
PutClusterConfig(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
ScatterRegion(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
GetGCSafePoint(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
UpdateGCSafePoint(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error)
}
type pDClient struct {
cc *grpc.ClientConn
}
func NewPDClient(cc *grpc.ClientConn) PDClient {
return &pDClient{cc}
}
func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) {
out := new(GetMembersResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) {
stream, err := grpc.NewClientStream(ctx, &_PD_serviceDesc.Streams[0], c.cc, "/pdpb.PD/Tso", opts...)
if err != nil {
return nil, err
}
x := &pDTsoClient{stream}
return x, nil
}
type PD_TsoClient interface {
Send(*TsoRequest) error
Recv() (*TsoResponse, error)
grpc.ClientStream
}
type pDTsoClient struct {
grpc.ClientStream
}
func (x *pDTsoClient) Send(m *TsoRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *pDTsoClient) Recv() (*TsoResponse, error) {
m := new(TsoResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) {
out := new(BootstrapResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) IsBootstrapped(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) {
out := new(AllocIDResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) {
out := new(GetStoreResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) {
out := new(PutStoreResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) StoreHeartbeat(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (<API key>, error) {
stream, err := grpc.NewClientStream(ctx, &_PD_serviceDesc.Streams[1], c.cc, "/pdpb.PD/RegionHeartbeat", opts...)
if err != nil {
return nil, err
}
x := &<API key>{stream}
return x, nil
}
type <API key> interface {
Send(*<API key>) error
Recv() (*<API key>, error)
grpc.ClientStream
}
type <API key> struct {
grpc.ClientStream
}
func (x *<API key>) Send(m *<API key>) error {
return x.ClientStream.SendMsg(m)
}
func (x *<API key>) Recv() (*<API key>, error) {
m := new(<API key>)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) {
out := new(GetRegionResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) {
out := new(GetRegionResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetRegionByID(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*GetRegionResponse, error) {
out := new(GetRegionResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) {
out := new(AskSplitResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) {
out := new(ReportSplitResponse)
err := grpc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) AskBatchSplit(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) ReportBatchSplit(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetClusterConfig(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) PutClusterConfig(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) ScatterRegion(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) GetGCSafePoint(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *<API key>, opts ...grpc.CallOption) (*<API key>, error) {
out := new(<API key>)
err := grpc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for PD service
type PDServer interface {
// GetMembers get the member list of this cluster. It does not require
// the cluster_id in request matchs the id of this cluster.
GetMembers(context.Context, *GetMembersRequest) (*GetMembersResponse, error)
Tso(PD_TsoServer) error
Bootstrap(context.Context, *BootstrapRequest) (*BootstrapResponse, error)
IsBootstrapped(context.Context, *<API key>) (*<API key>, error)
AllocID(context.Context, *AllocIDRequest) (*AllocIDResponse, error)
GetStore(context.Context, *GetStoreRequest) (*GetStoreResponse, error)
PutStore(context.Context, *PutStoreRequest) (*PutStoreResponse, error)
GetAllStores(context.Context, *GetAllStoresRequest) (*<API key>, error)
StoreHeartbeat(context.Context, *<API key>) (*<API key>, error)
RegionHeartbeat(<API key>) error
GetRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error)
GetPrevRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error)
GetRegionByID(context.Context, *<API key>) (*GetRegionResponse, error)
AskSplit(context.Context, *AskSplitRequest) (*AskSplitResponse, error)
ReportSplit(context.Context, *ReportSplitRequest) (*ReportSplitResponse, error)
AskBatchSplit(context.Context, *<API key>) (*<API key>, error)
ReportBatchSplit(context.Context, *<API key>) (*<API key>, error)
GetClusterConfig(context.Context, *<API key>) (*<API key>, error)
PutClusterConfig(context.Context, *<API key>) (*<API key>, error)
ScatterRegion(context.Context, *<API key>) (*<API key>, error)
GetGCSafePoint(context.Context, *<API key>) (*<API key>, error)
UpdateGCSafePoint(context.Context, *<API key>) (*<API key>, error)
}
func RegisterPDServer(s *grpc.Server, srv PDServer) {
s.RegisterService(&_PD_serviceDesc, srv)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(GetMembersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetMembers",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetMembers(ctx, req.(*GetMembersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PD_Tso_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(PDServer).Tso(&pDTsoServer{stream})
}
type PD_TsoServer interface {
Send(*TsoResponse) error
Recv() (*TsoRequest, error)
grpc.ServerStream
}
type pDTsoServer struct {
grpc.ServerStream
}
func (x *pDTsoServer) Send(m *TsoResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *pDTsoServer) Recv() (*TsoRequest, error) {
m := new(TsoRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(BootstrapRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).Bootstrap(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/Bootstrap",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).Bootstrap(ctx, req.(*BootstrapRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).IsBootstrapped(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/IsBootstrapped",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).IsBootstrapped(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func _PD_AllocID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(AllocIDRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).AllocID(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/AllocID",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).AllocID(ctx, req.(*AllocIDRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(GetStoreRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetStore(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetStore",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetStore(ctx, req.(*GetStoreRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(PutStoreRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).PutStore(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/PutStore",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).PutStore(ctx, req.(*PutStoreRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(GetAllStoresRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetAllStores(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetAllStores",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetAllStores(ctx, req.(*GetAllStoresRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).StoreHeartbeat(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/StoreHeartbeat",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).StoreHeartbeat(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, stream grpc.ServerStream) error {
return srv.(PDServer).RegionHeartbeat(&<API key>{stream})
}
type <API key> interface {
Send(*<API key>) error
Recv() (*<API key>, error)
grpc.ServerStream
}
type <API key> struct {
grpc.ServerStream
}
func (x *<API key>) Send(m *<API key>) error {
return x.ServerStream.SendMsg(m)
}
func (x *<API key>) Recv() (*<API key>, error) {
m := new(<API key>)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(GetRegionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetRegion(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetRegion",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetRegion(ctx, req.(*GetRegionRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(GetRegionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetPrevRegion(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetPrevRegion",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetPrevRegion(ctx, req.(*GetRegionRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetRegionByID(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetRegionByID",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetRegionByID(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(AskSplitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).AskSplit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/AskSplit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).AskSplit(ctx, req.(*AskSplitRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(ReportSplitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).ReportSplit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/ReportSplit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).ReportSplit(ctx, req.(*ReportSplitRequest))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).AskBatchSplit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/AskBatchSplit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).AskBatchSplit(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).ReportBatchSplit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/ReportBatchSplit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).ReportBatchSplit(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetClusterConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetClusterConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetClusterConfig(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).PutClusterConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/PutClusterConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).PutClusterConfig(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).ScatterRegion(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/ScatterRegion",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).ScatterRegion(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).GetGCSafePoint(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/GetGCSafePoint",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).GetGCSafePoint(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
func <API key>(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.<API key>) (interface{}, error) {
in := new(<API key>)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PDServer).UpdateGCSafePoint(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/pdpb.PD/UpdateGCSafePoint",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*<API key>))
}
return interceptor(ctx, in, info, handler)
}
var _PD_serviceDesc = grpc.ServiceDesc{
ServiceName: "pdpb.PD",
HandlerType: (*PDServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetMembers",
Handler: <API key>,
},
{
MethodName: "Bootstrap",
Handler: <API key>,
},
{
MethodName: "IsBootstrapped",
Handler: <API key>,
},
{
MethodName: "AllocID",
Handler: _PD_AllocID_Handler,
},
{
MethodName: "GetStore",
Handler: <API key>,
},
{
MethodName: "PutStore",
Handler: <API key>,
},
{
MethodName: "GetAllStores",
Handler: <API key>,
},
{
MethodName: "StoreHeartbeat",
Handler: <API key>,
},
{
MethodName: "GetRegion",
Handler: <API key>,
},
{
MethodName: "GetPrevRegion",
Handler: <API key>,
},
{
MethodName: "GetRegionByID",
Handler: <API key>,
},
{
MethodName: "AskSplit",
Handler: <API key>,
},
{
MethodName: "ReportSplit",
Handler: <API key>,
},
{
MethodName: "AskBatchSplit",
Handler: <API key>,
},
{
MethodName: "ReportBatchSplit",
Handler: <API key>,
},
{
MethodName: "GetClusterConfig",
Handler: <API key>,
},
{
MethodName: "PutClusterConfig",
Handler: <API key>,
},
{
MethodName: "ScatterRegion",
Handler: <API key>,
},
{
MethodName: "GetGCSafePoint",
Handler: <API key>,
},
{
MethodName: "UpdateGCSafePoint",
Handler: <API key>,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "Tso",
Handler: _PD_Tso_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "RegionHeartbeat",
Handler: <API key>,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "pdpb.proto",
}
func (m *RequestHeader) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.ClusterId != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId))
}
return i, nil
}
func (m *ResponseHeader) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.ClusterId != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId))
}
if m.Error != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Error.Size()))
n1, err := m.Error.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
return i, nil
}
func (m *Error) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Error) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Type != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Type))
}
if len(m.Message) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(len(m.Message)))
i += copy(dAtA[i:], m.Message)
}
return i, nil
}
func (m *TsoRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n2, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n2
}
if m.Count != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Count))
}
return i, nil
}
func (m *Timestamp) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Physical != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Physical))
}
if m.Logical != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Logical))
}
return i, nil
}
func (m *TsoResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n3, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n3
}
if m.Count != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Count))
}
if m.Timestamp != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp.Size()))
n4, err := m.Timestamp.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n4
}
return i, nil
}
func (m *BootstrapRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *BootstrapRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n5, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
}
if m.Store != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size()))
n6, err := m.Store.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n6
}
if m.Region != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n7, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n7
}
return i, nil
}
func (m *BootstrapResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n8, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n8
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n9, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n9
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n10, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n10
}
if m.Bootstrapped {
dAtA[i] = 0x10
i++
if m.Bootstrapped {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
return i, nil
}
func (m *AllocIDRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AllocIDRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n11, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n11
}
return i, nil
}
func (m *AllocIDResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AllocIDResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n12, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n12
}
if m.Id != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Id))
}
return i, nil
}
func (m *GetStoreRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetStoreRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n13, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n13
}
if m.StoreId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId))
}
return i, nil
}
func (m *GetStoreResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetStoreResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n14, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n14
}
if m.Store != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size()))
n15, err := m.Store.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n15
}
return i, nil
}
func (m *PutStoreRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PutStoreRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n16, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n16
}
if m.Store != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Store.Size()))
n17, err := m.Store.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n17
}
return i, nil
}
func (m *PutStoreResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n18, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n18
}
return i, nil
}
func (m *GetAllStoresRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetAllStoresRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n19, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n19
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n20, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n20
}
if len(m.Stores) > 0 {
for _, msg := range m.Stores {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *GetRegionRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetRegionRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n21, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n21
}
if len(m.RegionKey) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(len(m.RegionKey)))
i += copy(dAtA[i:], m.RegionKey)
}
return i, nil
}
func (m *GetRegionResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetRegionResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n22, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n22
}
if m.Region != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n23, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n23
}
if m.Leader != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size()))
n24, err := m.Leader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n24
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n25, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n25
}
if m.RegionId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId))
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n26, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n26
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n27, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n27
}
if m.Cluster != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Cluster.Size()))
n28, err := m.Cluster.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n28
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n29, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n29
}
if m.Cluster != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Cluster.Size()))
n30, err := m.Cluster.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n30
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n31, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n31
}
return i, nil
}
func (m *Member) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Member) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Name) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name)))
i += copy(dAtA[i:], m.Name)
}
if m.MemberId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.MemberId))
}
if len(m.PeerUrls) > 0 {
for _, s := range m.PeerUrls {
dAtA[i] = 0x1a
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if len(m.ClientUrls) > 0 {
for _, s := range m.ClientUrls {
dAtA[i] = 0x22
i++
l = len(s)
for l >= 1<<7 {
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
l >>= 7
i++
}
dAtA[i] = uint8(l)
i++
i += copy(dAtA[i:], s)
}
}
if m.LeaderPriority != 0 {
dAtA[i] = 0x28
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.LeaderPriority))
}
return i, nil
}
func (m *GetMembersRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetMembersRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n32, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n32
}
return i, nil
}
func (m *GetMembersResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *GetMembersResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n33, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n33
}
if len(m.Members) > 0 {
for _, msg := range m.Members {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.Leader != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size()))
n34, err := m.Leader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n34
}
if m.EtcdLeader != nil {
dAtA[i] = 0x22
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.EtcdLeader.Size()))
n35, err := m.EtcdLeader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n35
}
return i, nil
}
func (m *PeerStats) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PeerStats) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Peer != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size()))
n36, err := m.Peer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n36
}
if m.DownSeconds != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.DownSeconds))
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n37, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n37
}
if m.Region != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n38, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n38
}
if m.Leader != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size()))
n39, err := m.Leader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n39
}
if len(m.DownPeers) > 0 {
for _, msg := range m.DownPeers {
dAtA[i] = 0x22
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if len(m.PendingPeers) > 0 {
for _, msg := range m.PendingPeers {
dAtA[i] = 0x2a
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.BytesWritten != 0 {
dAtA[i] = 0x30
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten))
}
if m.BytesRead != 0 {
dAtA[i] = 0x38
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead))
}
if m.KeysWritten != 0 {
dAtA[i] = 0x40
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten))
}
if m.KeysRead != 0 {
dAtA[i] = 0x48
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead))
}
if m.ApproximateSize != 0 {
dAtA[i] = 0x50
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateSize))
}
if m.Interval != nil {
dAtA[i] = 0x62
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Interval.Size()))
n40, err := m.Interval.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n40
}
if m.ApproximateKeys != 0 {
dAtA[i] = 0x68
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKeys))
}
return i, nil
}
func (m *ChangePeer) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ChangePeer) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Peer != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size()))
n41, err := m.Peer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n41
}
if m.ChangeType != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ChangeType))
}
return i, nil
}
func (m *TransferLeader) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Peer != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Peer.Size()))
n42, err := m.Peer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n42
}
return i, nil
}
func (m *Merge) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Merge) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Target != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Target.Size()))
n43, err := m.Target.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n43
}
return i, nil
}
func (m *SplitRegion) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Policy != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Policy))
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n44, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n44
}
if m.ChangePeer != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ChangePeer.Size()))
n45, err := m.ChangePeer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n45
}
if m.TransferLeader != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.TransferLeader.Size()))
n46, err := m.TransferLeader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n46
}
if m.RegionId != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId))
}
if m.RegionEpoch != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.RegionEpoch.Size()))
n47, err := m.RegionEpoch.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n47
}
if m.TargetPeer != nil {
dAtA[i] = 0x32
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.TargetPeer.Size()))
n48, err := m.TargetPeer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n48
}
if m.Merge != nil {
dAtA[i] = 0x3a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Merge.Size()))
n49, err := m.Merge.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n49
}
if m.SplitRegion != nil {
dAtA[i] = 0x42
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.SplitRegion.Size()))
n50, err := m.SplitRegion.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n50
}
return i, nil
}
func (m *AskSplitRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n51, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n51
}
if m.Region != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n52, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n52
}
return i, nil
}
func (m *AskSplitResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n53, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n53
}
if m.NewRegionId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId))
}
if len(m.NewPeerIds) > 0 {
dAtA55 := make([]byte, len(m.NewPeerIds)*10)
var j54 int
for _, num := range m.NewPeerIds {
for num >= 1<<7 {
dAtA55[j54] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j54++
}
dAtA55[j54] = uint8(num)
j54++
}
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(j54))
i += copy(dAtA[i:], dAtA55[:j54])
}
return i, nil
}
func (m *ReportSplitRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n56, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n56
}
if m.Left != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Left.Size()))
n57, err := m.Left.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n57
}
if m.Right != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Right.Size()))
n58, err := m.Right.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n58
}
return i, nil
}
func (m *ReportSplitResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n59, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n59
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n60, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n60
}
if m.Region != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n61, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n61
}
if m.SplitCount != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.SplitCount))
}
return i, nil
}
func (m *SplitID) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SplitID) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.NewRegionId != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId))
}
if len(m.NewPeerIds) > 0 {
dAtA63 := make([]byte, len(m.NewPeerIds)*10)
var j62 int
for _, num := range m.NewPeerIds {
for num >= 1<<7 {
dAtA63[j62] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j62++
}
dAtA63[j62] = uint8(num)
j62++
}
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(j62))
i += copy(dAtA[i:], dAtA63[:j62])
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n64, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n64
}
if len(m.Ids) > 0 {
for _, msg := range m.Ids {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n65, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n65
}
if len(m.Regions) > 0 {
for _, msg := range m.Regions {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n66, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n66
}
return i, nil
}
func (m *TimeInterval) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TimeInterval) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.StartTimestamp != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.StartTimestamp))
}
if m.EndTimestamp != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.EndTimestamp))
}
return i, nil
}
func (m *StoreStats) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *StoreStats) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.StoreId != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId))
}
if m.Capacity != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Capacity))
}
if m.Available != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Available))
}
if m.RegionCount != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.RegionCount))
}
if m.SendingSnapCount != 0 {
dAtA[i] = 0x28
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.SendingSnapCount))
}
if m.ReceivingSnapCount != 0 {
dAtA[i] = 0x30
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ReceivingSnapCount))
}
if m.StartTime != 0 {
dAtA[i] = 0x38
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.StartTime))
}
if m.ApplyingSnapCount != 0 {
dAtA[i] = 0x40
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.ApplyingSnapCount))
}
if m.IsBusy {
dAtA[i] = 0x48
i++
if m.IsBusy {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if m.UsedSize != 0 {
dAtA[i] = 0x50
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.UsedSize))
}
if m.BytesWritten != 0 {
dAtA[i] = 0x58
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten))
}
if m.KeysWritten != 0 {
dAtA[i] = 0x60
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten))
}
if m.BytesRead != 0 {
dAtA[i] = 0x68
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead))
}
if m.KeysRead != 0 {
dAtA[i] = 0x70
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead))
}
if m.Interval != nil {
dAtA[i] = 0x7a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Interval.Size()))
n67, err := m.Interval.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n67
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n68, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n68
}
if m.Stats != nil {
dAtA[i] = 0x12
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Stats.Size()))
n69, err := m.Stats.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n69
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n70, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n70
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n71, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n71
}
if m.RegionId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId))
}
if m.Region != nil {
dAtA[i] = 0x1a
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Region.Size()))
n72, err := m.Region.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n72
}
if m.Leader != nil {
dAtA[i] = 0x22
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Leader.Size()))
n73, err := m.Leader.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n73
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n74, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n74
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n75, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n75
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n76, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n76
}
if m.SafePoint != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint))
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n77, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n77
}
if m.SafePoint != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint))
}
return i, nil
}
func (m *<API key>) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *<API key>) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Header != nil {
dAtA[i] = 0xa
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size()))
n78, err := m.Header.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n78
}
if m.NewSafePoint != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint))
}
return i, nil
}
func encodeFixed64Pdpb(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
dAtA[offset+4] = uint8(v >> 32)
dAtA[offset+5] = uint8(v >> 40)
dAtA[offset+6] = uint8(v >> 48)
dAtA[offset+7] = uint8(v >> 56)
return offset + 8
}
func encodeFixed32Pdpb(dAtA []byte, offset int, v uint32) int {
dAtA[offset] = uint8(v)
dAtA[offset+1] = uint8(v >> 8)
dAtA[offset+2] = uint8(v >> 16)
dAtA[offset+3] = uint8(v >> 24)
return offset + 4
}
func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *RequestHeader) Size() (n int) {
var l int
_ = l
if m.ClusterId != 0 {
n += 1 + sovPdpb(uint64(m.ClusterId))
}
return n
}
func (m *ResponseHeader) Size() (n int) {
var l int
_ = l
if m.ClusterId != 0 {
n += 1 + sovPdpb(uint64(m.ClusterId))
}
if m.Error != nil {
l = m.Error.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *Error) Size() (n int) {
var l int
_ = l
if m.Type != 0 {
n += 1 + sovPdpb(uint64(m.Type))
}
l = len(m.Message)
if l > 0 {
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *TsoRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Count != 0 {
n += 1 + sovPdpb(uint64(m.Count))
}
return n
}
func (m *Timestamp) Size() (n int) {
var l int
_ = l
if m.Physical != 0 {
n += 1 + sovPdpb(uint64(m.Physical))
}
if m.Logical != 0 {
n += 1 + sovPdpb(uint64(m.Logical))
}
return n
}
func (m *TsoResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Count != 0 {
n += 1 + sovPdpb(uint64(m.Count))
}
if m.Timestamp != nil {
l = m.Timestamp.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *BootstrapRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Store != nil {
l = m.Store.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *BootstrapResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Bootstrapped {
n += 2
}
return n
}
func (m *AllocIDRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *AllocIDResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Id != 0 {
n += 1 + sovPdpb(uint64(m.Id))
}
return n
}
func (m *GetStoreRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.StoreId != 0 {
n += 1 + sovPdpb(uint64(m.StoreId))
}
return n
}
func (m *GetStoreResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Store != nil {
l = m.Store.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *PutStoreRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Store != nil {
l = m.Store.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *PutStoreResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *GetAllStoresRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if len(m.Stores) > 0 {
for _, e := range m.Stores {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
return n
}
func (m *GetRegionRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
l = len(m.RegionKey)
if l > 0 {
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *GetRegionResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Leader != nil {
l = m.Leader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.RegionId != 0 {
n += 1 + sovPdpb(uint64(m.RegionId))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Cluster != nil {
l = m.Cluster.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Cluster != nil {
l = m.Cluster.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *Member) Size() (n int) {
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovPdpb(uint64(l))
}
if m.MemberId != 0 {
n += 1 + sovPdpb(uint64(m.MemberId))
}
if len(m.PeerUrls) > 0 {
for _, s := range m.PeerUrls {
l = len(s)
n += 1 + l + sovPdpb(uint64(l))
}
}
if len(m.ClientUrls) > 0 {
for _, s := range m.ClientUrls {
l = len(s)
n += 1 + l + sovPdpb(uint64(l))
}
}
if m.LeaderPriority != 0 {
n += 1 + sovPdpb(uint64(m.LeaderPriority))
}
return n
}
func (m *GetMembersRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *GetMembersResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if len(m.Members) > 0 {
for _, e := range m.Members {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
if m.Leader != nil {
l = m.Leader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.EtcdLeader != nil {
l = m.EtcdLeader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *PeerStats) Size() (n int) {
var l int
_ = l
if m.Peer != nil {
l = m.Peer.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.DownSeconds != 0 {
n += 1 + sovPdpb(uint64(m.DownSeconds))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Leader != nil {
l = m.Leader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if len(m.DownPeers) > 0 {
for _, e := range m.DownPeers {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
if len(m.PendingPeers) > 0 {
for _, e := range m.PendingPeers {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
if m.BytesWritten != 0 {
n += 1 + sovPdpb(uint64(m.BytesWritten))
}
if m.BytesRead != 0 {
n += 1 + sovPdpb(uint64(m.BytesRead))
}
if m.KeysWritten != 0 {
n += 1 + sovPdpb(uint64(m.KeysWritten))
}
if m.KeysRead != 0 {
n += 1 + sovPdpb(uint64(m.KeysRead))
}
if m.ApproximateSize != 0 {
n += 1 + sovPdpb(uint64(m.ApproximateSize))
}
if m.Interval != nil {
l = m.Interval.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.ApproximateKeys != 0 {
n += 1 + sovPdpb(uint64(m.ApproximateKeys))
}
return n
}
func (m *ChangePeer) Size() (n int) {
var l int
_ = l
if m.Peer != nil {
l = m.Peer.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.ChangeType != 0 {
n += 1 + sovPdpb(uint64(m.ChangeType))
}
return n
}
func (m *TransferLeader) Size() (n int) {
var l int
_ = l
if m.Peer != nil {
l = m.Peer.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *Merge) Size() (n int) {
var l int
_ = l
if m.Target != nil {
l = m.Target.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *SplitRegion) Size() (n int) {
var l int
_ = l
if m.Policy != 0 {
n += 1 + sovPdpb(uint64(m.Policy))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.ChangePeer != nil {
l = m.ChangePeer.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.TransferLeader != nil {
l = m.TransferLeader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.RegionId != 0 {
n += 1 + sovPdpb(uint64(m.RegionId))
}
if m.RegionEpoch != nil {
l = m.RegionEpoch.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.TargetPeer != nil {
l = m.TargetPeer.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Merge != nil {
l = m.Merge.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.SplitRegion != nil {
l = m.SplitRegion.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *AskSplitRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *AskSplitResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.NewRegionId != 0 {
n += 1 + sovPdpb(uint64(m.NewRegionId))
}
if len(m.NewPeerIds) > 0 {
l = 0
for _, e := range m.NewPeerIds {
l += sovPdpb(uint64(e))
}
n += 1 + sovPdpb(uint64(l)) + l
}
return n
}
func (m *ReportSplitRequest) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Left != nil {
l = m.Left.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Right != nil {
l = m.Right.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *ReportSplitResponse) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.SplitCount != 0 {
n += 1 + sovPdpb(uint64(m.SplitCount))
}
return n
}
func (m *SplitID) Size() (n int) {
var l int
_ = l
if m.NewRegionId != 0 {
n += 1 + sovPdpb(uint64(m.NewRegionId))
}
if len(m.NewPeerIds) > 0 {
l = 0
for _, e := range m.NewPeerIds {
l += sovPdpb(uint64(e))
}
n += 1 + sovPdpb(uint64(l)) + l
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if len(m.Ids) > 0 {
for _, e := range m.Ids {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if len(m.Regions) > 0 {
for _, e := range m.Regions {
l = e.Size()
n += 1 + l + sovPdpb(uint64(l))
}
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *TimeInterval) Size() (n int) {
var l int
_ = l
if m.StartTimestamp != 0 {
n += 1 + sovPdpb(uint64(m.StartTimestamp))
}
if m.EndTimestamp != 0 {
n += 1 + sovPdpb(uint64(m.EndTimestamp))
}
return n
}
func (m *StoreStats) Size() (n int) {
var l int
_ = l
if m.StoreId != 0 {
n += 1 + sovPdpb(uint64(m.StoreId))
}
if m.Capacity != 0 {
n += 1 + sovPdpb(uint64(m.Capacity))
}
if m.Available != 0 {
n += 1 + sovPdpb(uint64(m.Available))
}
if m.RegionCount != 0 {
n += 1 + sovPdpb(uint64(m.RegionCount))
}
if m.SendingSnapCount != 0 {
n += 1 + sovPdpb(uint64(m.SendingSnapCount))
}
if m.ReceivingSnapCount != 0 {
n += 1 + sovPdpb(uint64(m.ReceivingSnapCount))
}
if m.StartTime != 0 {
n += 1 + sovPdpb(uint64(m.StartTime))
}
if m.ApplyingSnapCount != 0 {
n += 1 + sovPdpb(uint64(m.ApplyingSnapCount))
}
if m.IsBusy {
n += 2
}
if m.UsedSize != 0 {
n += 1 + sovPdpb(uint64(m.UsedSize))
}
if m.BytesWritten != 0 {
n += 1 + sovPdpb(uint64(m.BytesWritten))
}
if m.KeysWritten != 0 {
n += 1 + sovPdpb(uint64(m.KeysWritten))
}
if m.BytesRead != 0 {
n += 1 + sovPdpb(uint64(m.BytesRead))
}
if m.KeysRead != 0 {
n += 1 + sovPdpb(uint64(m.KeysRead))
}
if m.Interval != nil {
l = m.Interval.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Stats != nil {
l = m.Stats.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.RegionId != 0 {
n += 1 + sovPdpb(uint64(m.RegionId))
}
if m.Region != nil {
l = m.Region.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.Leader != nil {
l = m.Leader.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.SafePoint != 0 {
n += 1 + sovPdpb(uint64(m.SafePoint))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.SafePoint != 0 {
n += 1 + sovPdpb(uint64(m.SafePoint))
}
return n
}
func (m *<API key>) Size() (n int) {
var l int
_ = l
if m.Header != nil {
l = m.Header.Size()
n += 1 + l + sovPdpb(uint64(l))
}
if m.NewSafePoint != 0 {
n += 1 + sovPdpb(uint64(m.NewSafePoint))
}
return n
}
func sovPdpb(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozPdpb(x uint64) (n int) {
return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RequestHeader) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: RequestHeader: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
}
m.ClusterId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ClusterId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ResponseHeader) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ResponseHeader: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
}
m.ClusterId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ClusterId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Error == nil {
m.Error = &Error{}
}
if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Error) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Error: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= (ErrorType(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return <API key>
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Message = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TsoRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: TsoRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TsoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
}
m.Count = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Count |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Timestamp) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Timestamp: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType)
}
m.Physical = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Physical |= (int64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType)
}
m.Logical = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Logical |= (int64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TsoResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: TsoResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TsoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
}
m.Count = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Count |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Timestamp == nil {
m.Timestamp = &Timestamp{}
}
if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *BootstrapRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: BootstrapRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Store == nil {
m.Store = &metapb.Store{}
}
if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *BootstrapResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: BootstrapResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Bootstrapped", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Bootstrapped = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AllocIDRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AllocIDRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AllocIDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AllocIDResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AllocIDResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AllocIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
m.Id = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Id |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetStoreRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetStoreRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType)
}
m.StoreId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.StoreId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetStoreResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetStoreResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Store == nil {
m.Store = &metapb.Store{}
}
if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PutStoreRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PutStoreRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PutStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Store == nil {
m.Store = &metapb.Store{}
}
if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PutStoreResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PutStoreResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PutStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetAllStoresRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetAllStoresRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stores", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Stores = append(m.Stores, &metapb.Store{})
if err := m.Stores[len(m.Stores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetRegionRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetRegionRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionKey", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return <API key>
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RegionKey = append(m.RegionKey[:0], dAtA[iNdEx:postIndex]...)
if m.RegionKey == nil {
m.RegionKey = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetRegionResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetRegionResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Leader == nil {
m.Leader = &metapb.Peer{}
}
if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
}
m.RegionId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.RegionId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Cluster == nil {
m.Cluster = &metapb.Cluster{}
}
if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Cluster == nil {
m.Cluster = &metapb.Cluster{}
}
if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Member) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Member: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return <API key>
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType)
}
m.MemberId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MemberId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PeerUrls", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return <API key>
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PeerUrls = append(m.PeerUrls, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ClientUrls", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return <API key>
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ClientUrls = append(m.ClientUrls, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field LeaderPriority", wireType)
}
m.LeaderPriority = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.LeaderPriority |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetMembersRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetMembersRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetMembersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetMembersResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: GetMembersResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: GetMembersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Members = append(m.Members, &Member{})
if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Leader == nil {
m.Leader = &Member{}
}
if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EtcdLeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.EtcdLeader == nil {
m.EtcdLeader = &Member{}
}
if err := m.EtcdLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PeerStats) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PeerStats: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PeerStats: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Peer == nil {
m.Peer = &metapb.Peer{}
}
if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field DownSeconds", wireType)
}
m.DownSeconds = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.DownSeconds |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Leader == nil {
m.Leader = &metapb.Peer{}
}
if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.DownPeers = append(m.DownPeers, &PeerStats{})
if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PendingPeers = append(m.PendingPeers, &metapb.Peer{})
if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType)
}
m.BytesWritten = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BytesWritten |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType)
}
m.BytesRead = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BytesRead |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType)
}
m.KeysWritten = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.KeysWritten |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType)
}
m.KeysRead = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.KeysRead |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 10:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ApproximateSize", wireType)
}
m.ApproximateSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ApproximateSize |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 12:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Interval == nil {
m.Interval = &TimeInterval{}
}
if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 13:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKeys", wireType)
}
m.ApproximateKeys = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ApproximateKeys |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ChangePeer) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ChangePeer: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ChangePeer: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Peer == nil {
m.Peer = &metapb.Peer{}
}
if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType)
}
m.ChangeType = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ChangeType |= (eraftpb.ConfChangeType(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TransferLeader) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: TransferLeader: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TransferLeader: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Peer == nil {
m.Peer = &metapb.Peer{}
}
if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Merge) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Merge: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Target == nil {
m.Target = &metapb.Region{}
}
if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SplitRegion) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: SplitRegion: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SplitRegion: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
}
m.Policy = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Policy |= (CheckPolicy(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.ChangePeer == nil {
m.ChangePeer = &ChangePeer{}
}
if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TransferLeader == nil {
m.TransferLeader = &TransferLeader{}
}
if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
}
m.RegionId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.RegionId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.RegionEpoch == nil {
m.RegionEpoch = &metapb.RegionEpoch{}
}
if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field TargetPeer", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.TargetPeer == nil {
m.TargetPeer = &metapb.Peer{}
}
if err := m.TargetPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Merge == nil {
m.Merge = &Merge{}
}
if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SplitRegion", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.SplitRegion == nil {
m.SplitRegion = &SplitRegion{}
}
if err := m.SplitRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AskSplitRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AskSplitRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AskSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AskSplitResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AskSplitResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AskSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType)
}
m.NewRegionId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.NewRegionId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return <API key>
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
for iNdEx < postIndex {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.NewPeerIds = append(m.NewPeerIds, v)
}
} else if wireType == 0 {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.NewPeerIds = append(m.NewPeerIds, v)
} else {
return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType)
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ReportSplitRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ReportSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Left == nil {
m.Left = &metapb.Region{}
}
if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Right == nil {
m.Right = &metapb.Region{}
}
if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ReportSplitResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ReportSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SplitCount", wireType)
}
m.SplitCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.SplitCount |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SplitID) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: SplitID: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SplitID: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType)
}
m.NewRegionId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.NewRegionId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return <API key>
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
for iNdEx < postIndex {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.NewPeerIds = append(m.NewPeerIds, v)
}
} else if wireType == 0 {
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.NewPeerIds = append(m.NewPeerIds, v)
} else {
return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType)
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Ids = append(m.Ids, &SplitID{})
if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Regions = append(m.Regions, &metapb.Region{})
if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TimeInterval) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: TimeInterval: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TimeInterval: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field StartTimestamp", wireType)
}
m.StartTimestamp = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.StartTimestamp |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EndTimestamp", wireType)
}
m.EndTimestamp = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.EndTimestamp |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *StoreStats) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: StoreStats: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: StoreStats: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType)
}
m.StoreId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.StoreId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
}
m.Capacity = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Capacity |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
}
m.Available = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Available |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionCount", wireType)
}
m.RegionCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.RegionCount |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SendingSnapCount", wireType)
}
m.SendingSnapCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.SendingSnapCount |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ReceivingSnapCount", wireType)
}
m.ReceivingSnapCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ReceivingSnapCount |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
}
m.StartTime = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.StartTime |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ApplyingSnapCount", wireType)
}
m.ApplyingSnapCount = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ApplyingSnapCount |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field IsBusy", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.IsBusy = bool(v != 0)
case 10:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field UsedSize", wireType)
}
m.UsedSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.UsedSize |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 11:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType)
}
m.BytesWritten = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BytesWritten |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 12:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType)
}
m.KeysWritten = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.KeysWritten |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 13:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType)
}
m.BytesRead = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BytesRead |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 14:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType)
}
m.KeysRead = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.KeysRead |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 15:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Interval == nil {
m.Interval = &TimeInterval{}
}
if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Stats == nil {
m.Stats = &StoreStats{}
}
if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
}
m.RegionId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.RegionId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Region == nil {
m.Region = &metapb.Region{}
}
if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Leader == nil {
m.Leader = &metapb.Peer{}
}
if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType)
}
m.SafePoint = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.SafePoint |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &RequestHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType)
}
m.SafePoint = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.SafePoint |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *<API key>) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: <API key>: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: <API key>: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return <API key>
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Header == nil {
m.Header = &ResponseHeader{}
}
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NewSafePoint", wireType)
}
m.NewSafePoint = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowPdpb
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.NewSafePoint |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipPdpb(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return <API key>
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipPdpb(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowPdpb
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowPdpb
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowPdpb
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, <API key>
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowPdpb
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipPdpb(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
<API key> = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowPdpb = fmt.Errorf("proto: integer overflow")
)
func init() { proto.RegisterFile("pdpb.proto", fileDescriptorPdpb) }
var fileDescriptorPdpb = []byte{
// 2328 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
0x15, 0xd6, 0x52, 0x24, 0x45, 0x1e, 0x5e, 0x35, 0xd6, 0x85, 0xa6, 0x6f, 0xca, 0xd8, 0x6d, 0x65,
0x37, 0x61, 0x1c, 0xb7, 0x28, 0x0c, 0x14, 0x09, 0x42, 0x5d, 0x2c, 0x33, 0xb6, 0x44, 0x62, 0x48,
0x27, 0x0d, 0x50, 0x94, 0x5d, 0x91, 0x23, 0x6a, 0x2b, 0x6a, 0x77, 0xb3, 0x3b, 0x92, 0xcb, 0xbc,
0xb4, 0x4f, 0x41, 0x81, 0x06, 0xe8, 0x5b, 0xd1, 0x97, 0x02, 0xfd, 0x05, 0xfd, 0x07, 0x45, 0x5f,
0xfb, 0xd8, 0x9f, 0x50, 0xb8, 0x7f, 0xa4, 0x98, 0xdb, 0xde, 0x48, 0xd9, 0xee, 0x3a, 0x79, 0x32,
0xf7, 0x9c, 0x33, 0xdf, 0xcc, 0x7c, 0xe7, 0x9c, 0x99, 0x33, 0x47, 0x06, 0x70, 0xc7, 0xee, 0x71,
0xcb, 0xf5, 0x1c, 0xe6, 0xa0, 0x2c, 0xff, 0xdd, 0x2c, 0x9f, 0x53, 0x66, 0x6a, 0x59, 0xb3, 0x42,
0x3d, 0xf3, 0x84, 0x05, 0x9f, 0x6b, 0x13, 0x67, 0xe2, 0x88, 0x9f, 0x1f, 0xf2, 0x5f, 0x52, 0x8a,
0x5b, 0x50, 0x21, 0xf4, 0xab, 0x0b, 0xea, 0xb3, 0xa7, 0xd4, 0x1c, 0x53, 0x0f, 0xdd, 0x02, 0x18,
0x4d, 0x2f, 0x7c, 0x46, 0xbd, 0xa1, 0x35, 0x6e, 0x18, 0x5b, 0xc6, 0x76, 0x96, 0x14, 0x95, 0xa4,
0x33, 0xc6, 0x04, 0xaa, 0x84, 0xfa, 0xae, 0x63, 0xfb, 0xf4, 0xad, 0x06, 0xa0, 0xf7, 0x20, 0x47,
0x3d, 0xcf, 0xf1, 0x1a, 0x99, 0x2d, 0x63, 0xbb, 0xf4, 0xa8, 0xd4, 0x12, 0xab, 0xde, 0xe7, 0x22,
0x22, 0x35, 0xf8, 0x09, 0xe4, 0xc4, 0x37, 0xba, 0x0b, 0x59, 0x36, 0x73, 0xa9, 0x00, 0xa9, 0x3e,
0xaa, 0x45, 0x4c, 0x07, 0x33, 0x97, 0x12, 0xa1, 0x44, 0x0d, 0x58, 0x39, 0xa7, 0xbe, 0x6f, 0x4e,
0xa8, 0x80, 0x2c, 0x12, 0xfd, 0x89, 0xbb, 0x00, 0x03, 0xdf, 0x51, 0xdb, 0x41, 0x3f, 0x86, 0xfc,
0xa9, 0x58, 0xa1, 0x80, 0x2b, 0x3d, 0xba, 0x26, 0xe1, 0x62, 0xbb, 0x25, 0xca, 0x04, 0xad, 0x41,
0x6e, 0xe4, 0x5c, 0xd8, 0x4c, 0x40, 0x56, 0x88, 0xfc, 0xc0, 0x6d, 0x28, 0x0e, 0xac, 0x73, 0xea,
0x33, 0xf3, 0xdc, 0x45, 0x4d, 0x28, 0xb8, 0xa7, 0x33, 0xdf, 0x1a, 0x99, 0x53, 0x81, 0xb8, 0x4c,
0x82, 0x6f, 0xbe, 0xa6, 0xa9, 0x33, 0x11, 0xaa, 0x8c, 0x50, 0xe9, 0x4f, 0xfc, 0x7b, 0x03, 0x4a,
0x62, 0x51, 0x92, 0x33, 0xf4, 0x7e, 0x62, 0x55, 0x6b, 0x7a, 0x55, 0x51, 0x4e, 0x5f, 0xbf, 0x2c,
0xf4, 0x01, 0x14, 0x99, 0x5e, 0x56, 0x63, 0x59, 0xc0, 0x28, 0xae, 0x82, 0xd5, 0x92, 0xd0, 0x02,
0x7f, 0x6b, 0x40, 0x7d, 0xc7, 0x71, 0x98, 0xcf, 0x3c, 0xd3, 0x4d, 0xc5, 0xce, 0x5d, 0xc8, 0xf9,
0xcc, 0xf1, 0xa8, 0xf2, 0x61, 0xa5, 0xa5, 0xe2, 0xac, 0xcf, 0x85, 0x44, 0xea, 0xd0, 0x0f, 0x21,
0xef, 0xd1, 0x89, 0xe5, 0xd8, 0x6a, 0x49, 0x55, 0x6d, 0x45, 0x84, 0x94, 0x28, 0x2d, 0x6e, 0xc3,
0x6a, 0x64, 0x35, 0x69, 0x68, 0xc1, 0x7b, 0xb0, 0xde, 0xf1, 0x03, 0x10, 0x97, 0x8e, 0xd3, 0xec,
0x0a, 0xff, 0x06, 0x36, 0x92, 0x28, 0xa9, 0x9c, 0x84, 0xa1, 0x7c, 0x1c, 0x41, 0x11, 0x24, 0x15,
0x48, 0x4c, 0x86, 0x3f, 0x86, 0x6a, 0x7b, 0x3a, 0x75, 0x46, 0x9d, 0xbd, 0x54, 0x4b, 0xed, 0x42,
0x2d, 0x18, 0x9e, 0x6a, 0x8d, 0x55, 0xc8, 0x58, 0x72, 0x65, 0x59, 0x92, 0xb1, 0xc6, 0xf8, 0x4b,
0xa8, 0x1d, 0x50, 0x26, 0xfd, 0x97, 0x26, 0x22, 0xae, 0x43, 0x41, 0x78, 0x7d, 0x18, 0xa0, 0xae,
0x88, 0xef, 0xce, 0x18, 0x53, 0xa8, 0x87, 0xd0, 0xa9, 0x16, 0xfb, 0x36, 0xe1, 0x86, 0x47, 0x50,
0xeb, 0x5d, 0xbc, 0xc3, 0x0e, 0xde, 0x6a, 0x92, 0x4f, 0xa1, 0x1e, 0x4e, 0x92, 0x2a, 0x54, 0x77,
0xe0, 0xda, 0x01, 0x65, 0xed, 0xe9, 0x54, 0x80, 0xf8, 0xa9, 0xbc, 0x7f, 0x06, 0x6b, 0x71, 0x8c,
0x54, 0xac, 0xfe, 0x00, 0xf2, 0x62, 0x53, 0x7e, 0x23, 0xb3, 0xb5, 0x3c, 0xbf, 0x63, 0xa5, 0xc4,
0xbf, 0x12, 0xee, 0x53, 0x39, 0x9b, 0x86, 0xd8, 0x5b, 0x00, 0x32, 0xd3, 0x87, 0x67, 0x74, 0x26,
0xd8, 0x2d, 0x93, 0xa2, 0x94, 0x3c, 0xa3, 0x33, 0xfc, 0x27, 0x03, 0x56, 0x23, 0x13, 0xa4, 0xda,
0x4a, 0x78, 0xd4, 0x64, 0x5e, 0x77, 0xd4, 0xa0, 0x7b, 0x90, 0x9f, 0x4a, 0x54, 0x79, 0x24, 0x95,
0xb5, 0x5d, 0x8f, 0x72, 0x34, 0xa9, 0xc3, 0xbf, 0x16, 0xf4, 0xca, 0xa1, 0x3b, 0xb3, 0x74, 0x19,
0x8a, 0x6e, 0x80, 0xda, 0x63, 0x98, 0x11, 0x05, 0x29, 0xe8, 0x8c, 0xf1, 0x13, 0xd8, 0x3c, 0xa0,
0x6c, 0x57, 0xde, 0x89, 0xbb, 0x8e, 0x7d, 0x62, 0x4d, 0x52, 0x05, 0x82, 0x0f, 0x8d, 0x79, 0x9c,
0x54, 0x0c, 0xde, 0x87, 0x15, 0x75, 0x45, 0x2b, 0x0a, 0x6b, 0x9a, 0x1a, 0x85, 0x4e, 0xb4, 0x1e,
0x7f, 0x05, 0x9b, 0xbd, 0x8b, 0x77, 0x5f, 0xfc, 0xff, 0x33, 0xe5, 0x53, 0x68, 0xcc, 0x4f, 0x99,
0x2a, 0xfd, 0xfe, 0x66, 0x40, 0xfe, 0x90, 0x9e, 0x1f, 0x53, 0x0f, 0x21, 0xc8, 0xda, 0xe6, 0xb9,
0x2c, 0x2e, 0x8a, 0x44, 0xfc, 0xe6, 0x5e, 0x3b, 0x17, 0xda, 0x88, 0xd7, 0xa4, 0xa0, 0x33, 0xe6,
0x4a, 0x97, 0x52, 0x6f, 0x78, 0xe1, 0x4d, 0xfd, 0xc6, 0xf2, 0xd6, 0xf2, 0x76, 0x91, 0x14, 0xb8,
0xe0, 0x85, 0x37, 0xf5, 0xd1, 0x1d, 0x28, 0x8d, 0xa6, 0x16, 0xb5, 0x99, 0x54, 0x67, 0x85, 0x1a,
0xa4, 0x48, 0x18, 0xfc, 0x08, 0x6a, 0x32, 0xbe, 0x86, 0xae, 0x67, 0x39, 0x9e, 0xc5, 0x66, 0x8d,
0xdc, 0x96, 0xb1, 0x9d, 0x23, 0x55, 0x29, 0xee, 0x29, 0x29, 0xfe, 0x54, 0xe4, 0x83, 0x5c, 0x64,
0xba, 0xf3, 0xe1, 0x9f, 0x06, 0xa0, 0x28, 0x44, 0xca, 0x9c, 0x5a, 0x91, 0x3b, 0xd7, 0xe7, 0x43,
0x59, 0x9a, 0x4b, 0x54, 0xa2, 0x95, 0x0b, 0x72, 0x2a, 0x6a, 0xa6, 0x74, 0xe8, 0x03, 0x28, 0x51,
0x36, 0x1a, 0x0f, 0x95, 0x69, 0x76, 0x81, 0x29, 0x70, 0x83, 0xe7, 0x72, 0x07, 0x3d, 0x28, 0xf2,
0x94, 0xec, 0x33, 0x93, 0xf9, 0x68, 0x0b, 0xb2, 0x9c, 0x66, 0xb5, 0xea, 0x78, 0xce, 0x0a, 0x0d,
0x7a, 0x0f, 0xca, 0x63, 0xe7, 0xa5, 0x3d, 0xf4, 0xe9, 0xc8, 0xb1, 0xc7, 0xbe, 0xf2, 0x5c, 0x89,
0xcb, 0xfa, 0x52, 0x84, 0xbf, 0xc9, 0xc2, 0x86, 0x4c, 0xe9, 0xa7, 0xd4, 0xf4, 0xd8, 0x31, 0x35,
0x59, 0xaa, 0xa8, 0xfd, 0x4e, 0x8f, 0x1a, 0xd4, 0x02, 0x10, 0x0b, 0xe7, 0xbb, 0x90, 0x41, 0x13,
0x94, 0x6e, 0xc1, 0xfe, 0x49, 0x91, 0x9b, 0xf0, 0x4f, 0x1f, 0x7d, 0x04, 0x15, 0x97, 0xda, 0x63,
0xcb, 0x9e, 0xa8, 0x21, 0x39, 0xe5, 0x9a, 0x28, 0x78, 0x59, 0x99, 0xc8, 0x21, 0x77, 0xa1, 0x72,
0x3c, 0x63, 0xd4, 0x1f, 0xbe, 0xf4, 0x2c, 0xc6, 0xa8, 0xdd, 0xc8, 0x0b, 0x72, 0xca, 0x42, 0xf8,
0x85, 0x94, 0xf1, 0x33, 0x5a, 0x1a, 0x79, 0xd4, 0x1c, 0x37, 0x56, 0x64, 0xcd, 0x2e, 0x24, 0x84,
0x9a, 0xbc, 0x66, 0x2f, 0x9f, 0xd1, 0x59, 0x08, 0x51, 0x90, 0xfc, 0x72, 0x99, 0x46, 0xb8, 0x01,
0x45, 0x61, 0x22, 0x00, 0x8a, 0x32, 0x73, 0xb8, 0x40, 0x8c, 0xbf, 0x0f, 0x75, 0xd3, 0x75, 0x3d,
0xe7, 0xb7, 0xd6, 0xb9, 0xc9, 0xe8, 0xd0, 0xb7, 0xbe, 0xa6, 0x0d, 0x10, 0x36, 0xb5, 0x88, 0xbc,
0x6f, 0x7d, 0x4d, 0x51, 0x0b, 0x0a, 0x96, 0xcd, 0xa8, 0x77, 0x69, 0x4e, 0x1b, 0x65, 0xc1, 0x1c,
0x0a, 0x4b, 0xd9, 0x8e, 0xd2, 0x90, 0xc0, 0x26, 0x09, 0xcd, 0xa7, 0x6c, 0x54, 0xe6, 0xa0, 0x9f,
0xd1, 0x99, 0xff, 0x59, 0xb6, 0x50, 0xaa, 0x97, 0xf1, 0x29, 0xc0, 0xee, 0xa9, 0x69, 0x4f, 0x28,
0xa7, 0xe7, 0x2d, 0x62, 0xeb, 0x31, 0x94, 0x46, 0xc2, 0x7e, 0x28, 0x9e, 0x22, 0x19, 0xf1, 0x14,
0xd9, 0x6c, 0xe9, 0xb7, 0x14, 0x3f, 0x8d, 0x24, 0x9e, 0x78, 0x92, 0xc0, 0x28, 0xf8, 0x8d, 0x1f,
0x41, 0x75, 0xe0, 0x99, 0xb6, 0x7f, 0x42, 0x3d, 0x19, 0xd6, 0x6f, 0x9e, 0x0d, 0x7f, 0x08, 0xb9,
0x43, 0xea, 0x4d, 0x44, 0xf5, 0xcc, 0x4c, 0x6f, 0x42, 0x99, 0x32, 0x9e, 0x8b, 0x33, 0xa9, 0xc5,
0x8f, 0xa1, 0xd4, 0x77, 0xa7, 0x96, 0xba, 0xae, 0xd0, 0x7d, 0xc8, 0xbb, 0xce, 0xd4, 0x1a, 0xcd,
0xd4, 0x9b, 0x69, 0x55, 0x92, 0xb7, 0x7b, 0x4a, 0x47, 0x67, 0x3d, 0xa1, 0x20, 0xca, 0x00, 0xff,
0x79, 0x19, 0x36, 0xe7, 0x32, 0x22, 0xd5, 0x51, 0xf1, 0x51, 0x40, 0x91, 0xd8, 0x9d, 0x4c, 0x8c,
0xba, 0x9e, 0x59, 0x73, 0xad, 0xb9, 0x11, 0xbc, 0x7f, 0x0c, 0x35, 0xa6, 0xb8, 0x19, 0xc6, 0xf2,
0x44, 0xcd, 0x14, 0x27, 0x8e, 0x54, 0x59, 0x9c, 0xc8, 0xd8, 0xed, 0x9a, 0x8d, 0xdf, 0xae, 0xe8,
0x67, 0x50, 0x56, 0x4a, 0xea, 0x3a, 0xa3, 0x53, 0x71, 0xcc, 0xf2, 0xac, 0x8e, 0x11, 0xb8, 0xcf,
0x55, 0xa4, 0xe4, 0x85, 0x1f, 0xfc, 0x8c, 0x92, 0xa4, 0xca, 0x6d, 0xe4, 0x17, 0x38, 0x09, 0xa4,
0x41, 0x4f, 0x1e, 0x3a, 0xb9, 0x73, 0xee, 0x2a, 0x91, 0x2e, 0xc1, 0x43, 0x56, 0x78, 0x8f, 0x48,
0x0d, 0xfa, 0x29, 0x94, 0x7d, 0xee, 0x9c, 0xa1, 0x3a, 0x32, 0x0a, 0xc2, 0x52, 0xf9, 0x24, 0xe2,
0x36, 0x52, 0xf2, 0xc3, 0x0f, 0x7c, 0x02, 0xb5, 0xb6, 0x7f, 0xa6, 0xd4, 0xdf, 0xdf, 0x11, 0x85,
0xbf, 0x31, 0xa0, 0x1e, 0x4e, 0x94, 0xf2, 0xa9, 0x53, 0xb1, 0xe9, 0xcb, 0x61, 0xb2, 0xd2, 0x29,
0xd9, 0xf4, 0x25, 0xd1, 0xee, 0xd8, 0x82, 0x32, 0xb7, 0x11, 0x57, 0xa7, 0x35, 0x96, 0x37, 0x67,
0x96, 0x80, 0x4d, 0x5f, 0x72, 0x1a, 0x3b, 0x63, 0x1f, 0xff, 0xd1, 0x00, 0x44, 0xa8, 0xeb, 0x78,
0x2c, 0xfd, 0xa6, 0x31, 0x64, 0xa7, 0xf4, 0x84, 0x5d, 0xb1, 0x65, 0xa1, 0x43, 0xf7, 0x20, 0xe7,
0x59, 0x93, 0x53, 0x76, 0xc5, 0x83, 0x54, 0x2a, 0xf1, 0x2e, 0x5c, 0x8b, 0x2d, 0x26, 0x55, 0x9d,
0xf1, 0xad, 0x01, 0x6b, 0x6d, 0xff, 0x6c, 0xc7, 0x64, 0xa3, 0xd3, 0xef, 0xdd, 0x93, 0xbc, 0xf8,
0x90, 0x71, 0x26, 0x9b, 0x03, 0xcb, 0xa2, 0x39, 0x00, 0x42, 0xb4, 0x2b, 0x1a, 0x17, 0x5d, 0x58,
0x11, 0xab, 0xe8, 0xec, 0xcd, 0xbb, 0xcc, 0x78, 0xb3, 0xcb, 0x32, 0x73, 0x2e, 0x3b, 0x81, 0xf5,
0xc4, 0xf6, 0x52, 0xc5, 0xcf, 0x1d, 0x58, 0xd6, 0xf8, 0xfc, 0x01, 0x12, 0xe6, 0x45, 0x67, 0x8f,
0x70, 0x0d, 0x76, 0xf9, 0x19, 0xc5, 0x9d, 0xf1, 0x8e, 0x4c, 0x6e, 0xc3, 0x8a, 0xdc, 0xb1, 0x9e,
0x2c, 0x49, 0xa5, 0x56, 0xf3, 0x5a, 0x73, 0x7e, 0xc6, 0x54, 0x31, 0xf0, 0x4b, 0x28, 0x47, 0x2f,
0x2d, 0x5e, 0x01, 0xfa, 0xcc, 0xf4, 0xd8, 0x30, 0x6c, 0xd6, 0x48, 0xee, 0xab, 0x42, 0x1c, 0x76,
0x96, 0xee, 0x42, 0x85, 0xda, 0xe3, 0x88, 0x99, 0xcc, 0xaa, 0x32, 0xb5, 0xc7, 0x81, 0x11, 0xfe,
0x6b, 0x16, 0x40, 0xbc, 0xd4, 0x64, 0x91, 0x14, 0x7d, 0x80, 0x1b, 0xb1, 0x07, 0x38, 0x6a, 0x42,
0x61, 0x64, 0xba, 0xe6, 0x88, 0x97, 0x9c, 0xaa, 0xa6, 0xd5, 0xdf, 0xe8, 0x26, 0x14, 0xcd, 0x4b,
0xd3, 0x9a, 0x9a, 0xc7, 0x53, 0x2a, 0xe2, 0x26, 0x4b, 0x42, 0x01, 0xbf, 0xf7, 0x55, 0x9c, 0xc8,
0xc0, 0xca, 0x8a, 0xc0, 0x52, 0x87, 0xa6, 0x88, 0x2c, 0xf4, 0x3e, 0x20, 0x5f, 0x55, 0x24, 0xbe,
0x6d, 0xba, 0xca, 0x30, 0x27, 0x0c, 0xeb, 0x4a, 0xd3, 0xb7, 0x4d, 0x57, 0x5a, 0x3f, 0x84, 0x35,
0x8f, 0x8e, 0xa8, 0x75, 0x99, 0xb0, 0xcf, 0x0b, 0x7b, 0x14, 0xe8, 0xc2, 0x11, 0xb7, 0x00, 0x42,
0xd2, 0xc4, 0x51, 0x5b, 0x21, 0xc5, 0x80, 0x2f, 0xd4, 0x82, 0x6b, 0xa6, 0xeb, 0x4e, 0x67, 0x09,
0xbc, 0x82, 0xb0, 0x5b, 0xd5, 0xaa, 0x10, 0x6e, 0x13, 0x56, 0x2c, 0x7f, 0x78, 0x7c, 0xe1, 0xcf,
0x44, 0x91, 0x52, 0x20, 0x79, 0xcb, 0xdf, 0xb9, 0xf0, 0x67, 0xfc, 0x46, 0xb9, 0xf0, 0xe9, 0x38,
0x5a, 0x9b, 0x14, 0xb8, 0x40, 0x14, 0x25, 0x73, 0x35, 0x54, 0x69, 0x41, 0x0d, 0x95, 0x2c, 0x92,
0xca, 0xf3, 0x45, 0x52, 0xbc, 0xcc, 0xaa, 0x24, 0xcb, 0xac, 0x58, 0x0d, 0x55, 0x4d, 0xd4, 0x50,
0xd1, 0xc2, 0xa8, 0xf6, 0xe6, 0xc2, 0x08, 0x4f, 0x61, 0x5d, 0x84, 0xc7, 0xbb, 0x96, 0xbb, 0x39,
0x9f, 0xc7, 0x57, 0xfc, 0x52, 0x0f, 0xe3, 0x8e, 0x48, 0x35, 0x7e, 0x02, 0x1b, 0xc9, 0xd9, 0x52,
0xe5, 0xcc, 0xdf, 0x0d, 0x58, 0xeb, 0x8f, 0x4c, 0xc6, 0x9f, 0x7f, 0xe9, 0x5b, 0x0e, 0xaf, 0x7b,
0x7c, 0xbf, 0x6d, 0x5f, 0x32, 0x52, 0xc1, 0x67, 0x5f, 0xd3, 0x2c, 0xd8, 0x87, 0xf5, 0xc4, 0x7a,
0xd3, 0x76, 0x30, 0x0f, 0x28, 0x3b, 0xd8, 0xed, 0x9b, 0x27, 0xb4, 0xe7, 0x58, 0x76, 0x2a, 0x6f,
0x61, 0x0a, 0x1b, 0x49, 0x94, 0x54, 0xc7, 0x32, 0x4f, 0x3a, 0xf3, 0x84, 0x0e, 0x5d, 0x8e, 0xa1,
0x08, 0x2c, 0xfa, 0x1a, 0x14, 0x9f, 0x40, 0xe3, 0x85, 0x3b, 0x36, 0x19, 0x7d, 0xc7, 0xf5, 0xbe,
0x69, 0x1e, 0x07, 0xae, 0x2f, 0x98, 0x27, 0xd5, 0x8e, 0xee, 0x41, 0x95, 0xdf, 0x68, 0x73, 0xb3,
0xf1, 0x7b, 0x2e, 0xc0, 0x7e, 0xf0, 0x3b, 0x28, 0x06, 0x7f, 0x5d, 0x40, 0x79, 0xc8, 0x74, 0x9f,
0xd5, 0x97, 0x50, 0x09, 0x56, 0x5e, 0x1c, 0x3d, 0x3b, 0xea, 0x7e, 0x71, 0x54, 0x37, 0xd0, 0x1a,
0xd4, 0x8f, 0xba, 0x83, 0xe1, 0x4e, 0xb7, 0x3b, 0xe8, 0x0f, 0x48, 0xbb, 0xd7, 0xdb, 0xdf, 0xab,
0x67, 0xd0, 0x35, 0xa8, 0xf5, 0x07, 0x5d, 0xb2, 0x3f, 0x1c, 0x74, 0x0f, 0x77, 0xfa, 0x83, 0xee,
0xd1, 0x7e, 0x7d, 0x19, 0x35, 0x60, 0xad, 0xfd, 0x9c, 0xec, 0xb7, 0xf7, 0xbe, 0x8c, 0x9b, 0x67,
0xb9, 0xa6, 0x73, 0xb4, 0xdb, 0x3d, 0xec, 0xb5, 0x07, 0x9d, 0x9d, 0xe7, 0xfb, 0xc3, 0xcf, 0xf7,
0x49, 0xbf, 0xd3, 0x3d, 0xaa, 0xe7, 0x1e, 0x6c, 0x43, 0x29, 0x52, 0xaa, 0xa3, 0x02, 0x64, 0xfb,
0xbb, 0xed, 0xa3, 0xfa, 0x12, 0xaa, 0x41, 0xa9, 0xdd, 0xeb, 0x91, 0xee, 0x2f, 0x3a, 0x87, 0xed,
0xc1, 0x7e, 0xdd, 0x78, 0xf4, 0x8f, 0x32, 0x64, 0x7a, 0x7b, 0xa8, 0x0d, 0x10, 0xbe, 0xf4, 0xd1,
0xa6, 0xe4, 0x60, 0xae, 0x7d, 0xd0, 0x6c, 0xcc, 0x2b, 0x24, 0x4d, 0x78, 0x09, 0x3d, 0x84, 0xe5,
0x81, 0xef, 0x20, 0x95, 0xda, 0xe1, 0x1f, 0x4c, 0x9a, 0xab, 0x11, 0x89, 0xb6, 0xde, 0x36, 0x1e,
0x1a, 0xe8, 0x13, 0x28, 0x06, 0x6d, 0x72, 0xb4, 0x21, 0xad, 0x92, 0x7f, 0x50, 0x68, 0x6e, 0xce,
0xc9, 0x83, 0x19, 0x0f, 0xa1, 0x1a, 0x6f, 0xb4, 0xa3, 0x1b, 0xd2, 0x78, 0x61, 0x13, 0xbf, 0x79,
0x73, 0xb1, 0x32, 0x80, 0x7b, 0x0c, 0x2b, 0xaa, 0x19, 0x8e, 0x54, 0x10, 0xc4, 0x5b, 0xeb, 0xcd,
0xf5, 0x84, 0x34, 0x18, 0xf9, 0x73, 0x28, 0xe8, 0xd6, 0x34, 0x5a, 0x0f, 0x28, 0x8a, 0xf6, 0x90,
0x9b, 0x1b, 0x49, 0x71, 0x74, 0xb0, 0xee, 0x05, 0xeb, 0xc1, 0x89, 0x06, 0xb4, 0x1e, 0x9c, 0x6c,
0x19, 0xe3, 0x25, 0x74, 0x00, 0xe5, 0x68, 0x0b, 0x17, 0x5d, 0x0f, 0xa6, 0x49, 0xb6, 0x86, 0x9b,
0xcd, 0x45, 0xaa, 0x28, 0x97, 0xf1, 0x83, 0x57, 0x73, 0xb9, 0xf0, 0xf0, 0xd7, 0x5c, 0x2e, 0x3e,
0xab, 0xf1, 0x12, 0x1a, 0x40, 0x2d, 0xf1, 0x26, 0x44, 0x37, 0x75, 0x62, 0x2d, 0x6a, 0x9e, 0x34,
0x6f, 0x5d, 0xa1, 0x4d, 0x06, 0x4c, 0xd0, 0x51, 0x45, 0x21, 0xa3, 0xb1, 0x13, 0xbe, 0xb9, 0x39,
0x27, 0x0f, 0x56, 0xb5, 0x03, 0x95, 0x03, 0xca, 0x7a, 0x1e, 0xbd, 0x4c, 0x8f, 0xf1, 0x44, 0x60,
0x84, 0x5d, 0x5d, 0xd4, 0x4c, 0xd8, 0x46, 0x5a, 0xbd, 0xaf, 0xc3, 0xf9, 0x04, 0x0a, 0xfa, 0xd1,
0xa4, 0xdd, 0x9e, 0x78, 0xad, 0x69, 0xb7, 0x27, 0xdf, 0x56, 0x78, 0xf9, 0x0f, 0x19, 0x03, 0x1d,
0x40, 0x29, 0xf2, 0xbc, 0x40, 0x0d, 0xcd, 0x5f, 0xf2, 0xf9, 0xd3, 0xbc, 0xbe, 0x40, 0x13, 0x05,
0xfa, 0x0c, 0x2a, 0xb1, 0x12, 0x5c, 0x6f, 0x68, 0xd1, 0xb3, 0xa3, 0x79, 0x63, 0xa1, 0x2e, 0xd8,
0x54, 0x1f, 0xea, 0xc9, 0xa2, 0x17, 0xdd, 0x8a, 0xce, 0x3f, 0x8f, 0x78, 0xfb, 0x2a, 0x75, 0x14,
0x34, 0xd9, 0x9d, 0xd6, 0xa0, 0x57, 0x74, 0xbf, 0x35, 0xe8, 0x55, 0x4d, 0x6d, 0x09, 0x9a, 0x6c,
0x05, 0x6b, 0xd0, 0x2b, 0xba, 0xd2, 0x1a, 0xf4, 0xaa, 0x0e, 0x32, 0x5e, 0xe2, 0x54, 0xc6, 0x2e,
0x71, 0x4d, 0xe5, 0xa2, 0x4a, 0x44, 0x53, 0xb9, 0xf0, 0xd6, 0x97, 0x09, 0x19, 0xbf, 0x83, 0x75,
0x42, 0x2e, 0xbc, 0xdf, 0x75, 0x42, 0x2e, 0xbe, 0xb6, 0xf1, 0x12, 0xfa, 0x1c, 0x56, 0xe7, 0xee,
0x40, 0xa4, 0x76, 0x74, 0xd5, 0x25, 0xdc, 0xbc, 0x73, 0xa5, 0x5e, 0xe3, 0xee, 0x3c, 0xf8, 0xd7,
0xab, 0xdb, 0xc6, 0xbf, 0x5f, 0xdd, 0x36, 0xfe, 0xf3, 0xea, 0xb6, 0xf1, 0x97, 0xff, 0xde, 0x5e,
0x82, 0xc6, 0xc8, 0x39, 0x6f, 0xb9, 0x96, 0x3d, 0x19, 0x99, 0x6e, 0x8b, 0x59, 0x67, 0x97, 0xad,
0xb3, 0x4b, 0xf1, 0x7f, 0x02, 0x8e, 0xf3, 0xe2, 0x9f, 0x9f, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff,
0x64, 0x88, 0xec, 0x1f, 0x61, 0x20, 0x00, 0x00,
}
|
\hypertarget{attrconverters_8py}{\section{odf/attrconverters.py File Reference}
\label{attrconverters_8py}\index{odf/attrconverters.\+py@{odf/attrconverters.\+py}}
}
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item
class \hyperlink{<API key>}{odf.\+attrconverters.\+Attr\+Converters}
\end{DoxyCompactItemize}
\subsection*{Namespaces}
\begin{DoxyCompactItemize}
\item
\hyperlink{<API key>}{odf.\+attrconverters}
\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+make\+\_\+\+N\+C\+Name}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+angle}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+any\+U\+R\+I}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+boolean}
\begin{DoxyCompactList}\small\item\em X\+M\+L Schema Part 2\+: Datatypes Second Edition An instance of a datatype that is defined as boolean can have the following legal literals \{true, false, 1, 0\}. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+color}
\begin{DoxyCompactList}\small\item\em A R\+G\+B color in conformance with §5.9.\+11 of \mbox{[}X\+S\+L\mbox{]}, that is a R\+G\+B color in notation “\+::rrggbb”, where rr, gg and bb are 8-\/bit hexadecimal digits. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+configtype}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+data\+\_\+source\+\_\+has\+\_\+labels}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+date}
\begin{DoxyCompactList}\small\item\em A date\+Or\+Date\+Time value is either an \mbox{[}xmlschema-\/2\mbox{]} date value or an \mbox{[}xmlschema-\/2\mbox{]} date\+Time value. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+date\+Time}
\begin{DoxyCompactList}\small\item\em A date\+Or\+Date\+Time value is either an \mbox{[}xmlschema-\/2\mbox{]} date value or an \mbox{[}xmlschema-\/2\mbox{]} date\+Time value. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+double}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+draw\+\_\+aspect}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+duration}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+family}
\begin{DoxyCompactList}\small\item\em A style family. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+formula}
\begin{DoxyCompactList}\small\item\em A string containing a formula. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+I\+D}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+I\+D\+R\+E\+F}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+integer}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+language}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+legend\+\_\+position}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+length}
\begin{DoxyCompactList}\small\item\em A (positive or negative) physical length, consisting of magnitude and unit, in conformance with the Units of Measure defined in §5.9.\+13 of \mbox{[}X\+S\+L\mbox{]}. \end{DoxyCompactList}\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+lengthorpercent}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+list\+\_\+linkage\+\_\+type}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+metavaluetype}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+major\+\_\+minor}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+namespaced\+Token}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+N\+C\+Name}
\begin{DoxyCompactList}\small\item\em N\+C\+Name is defined in \href{http://www.w3.org/TR/REC-xml-names/
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+Style\+Name\+Ref}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+Draw\+Name\+Ref}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+\+N\+C\+Names}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+non\+Negative\+Integer}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+percent}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+points}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+positive\+Integer}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+row\+Or\+Col}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+string}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+stroke\+\_\+linecap}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+textnoteclass}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+time}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+token}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+viewbox}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+xlinkshow}
\item
def \hyperlink{<API key>}{odf.\+attrconverters.\+cnv\+\_\+xlinktype}
\end{DoxyCompactItemize}
\subsection*{Variables}
\begin{DoxyCompactItemize}
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+color} = re.\+compile(r'\#\mbox{[}0-\/9a-\/f\+A-\/\+F\mbox{]}\{6\}')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+vector3\+D} = re.\+compile(r'\textbackslash{}(\mbox{[} \mbox{]}$\ast$-\/?(\mbox{[}0-\/9\mbox{]}+(\textbackslash{}.\mbox{[}0-\/9\mbox{]}$\ast$)?$\vert$\textbackslash{}.\mbox{[}0-\/9\mbox{]}+)(\mbox{[} \mbox{]}+-\/?(\mbox{[}0-\/9\mbox{]}+(\textbackslash{}.\mbox{[}0-\/9\mbox{]}$\ast$)?$\vert$\textbackslash{}.\mbox{[}0-\/9\mbox{]}+))\{2\}\mbox{[} \mbox{]}$\ast$\textbackslash{})')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+language} = re.\+compile(r'\mbox{[}a-\/z\+A-\/Z\mbox{]}\{1,8\}(-\/\mbox{[}a-\/z\+A-\/Z0-\/9\mbox{]}\{1,8\})$\ast$')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+length} = re.\+compile(r'-\/?(\mbox{[}0-\/9\mbox{]}+(\textbackslash{}.\mbox{[}0-\/9\mbox{]}$\ast$)?$\vert$\textbackslash{}.\mbox{[}0-\/9\mbox{]}+)((cm)$\vert$(mm)$\vert$(in)$\vert$(pt)$\vert$(pc)$\vert$(px))')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+namespaced\+Token} = re.\+compile(r'\mbox{[}0-\/9a-\/z\+A-\/\+Z\+\_\+\mbox{]}+\+:\mbox{[}0-\/9a-\/z\+A-\/\+Z.\+\_\+\textbackslash{}-\/\mbox{]}+')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+percent} = re.\+compile(r'-\/?(\mbox{[}0-\/9\mbox{]}+(\textbackslash{}.\mbox{[}0-\/9\mbox{]}$\ast$)?$\vert$\textbackslash{}.\mbox{[}0-\/9\mbox{]}+)\%')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+points} = re.\+compile(r'-\/?\mbox{[}0-\/9\mbox{]}+,-\/?\mbox{[}0-\/9\mbox{]}+(\mbox{[} \mbox{]}+-\/?\mbox{[}0-\/9\mbox{]}+,-\/?\mbox{[}0-\/9\mbox{]}+)$\ast$')
\item
tuple \hyperlink{<API key>}{odf.\+attrconverters.\+pattern\+\_\+viewbox} = re.\+compile(r'-\/?\mbox{[}0-\/9\mbox{]}+(\mbox{[} \mbox{]}+-\/?\mbox{[}0-\/9\mbox{]}+)\{3\}\$')
\item
dictionary \hyperlink{<API key>}{odf.\+attrconverters.\+attrconverters}
\end{DoxyCompactItemize}
|
<!DOCTYPE html>
<html itemscope lang="en-us">
<head><meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta charset="utf-8">
<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no"><meta name="generator" content="Hugo 0.57.2" />
<meta property="og:title" content="Propose" />
<meta name="twitter:title" content="Propose"/>
<meta itemprop="name" content="Propose"><meta property="og:description" content="Propose a talk for devopsdays Copenhagen 2018" />
<meta name="<TwitterConsumerkey>" content="Propose a talk for devopsdays Copenhagen 2018" />
<meta itemprop="description" content="Propose a talk for devopsdays Copenhagen 2018"><meta name="twitter:site" content="@devopsdays">
<meta property="og:type" content="event" />
<meta property="og:url" content="/events/2018-copenhagen/propose/" /><meta name="twitter:creator" content="@devopsdayscph" /><meta name="twitter:label1" value="Event" />
<meta name="twitter:data1" value="devopsdays Copenhagen 2018" /><meta name="twitter:label2" value="Dates" />
<meta name="twitter:data2" value="April 24 - 25, 2018" /><meta property="og:image" content="https:
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:image" content="https:
<meta itemprop="image" content="https:
<meta property="fb:app_id" content="1904065206497317" /><meta itemprop="wordCount" content="419">
<title>devopsdays Copenhagen 2018 - propose a talk
</title>
<script>
window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
ga('create', 'UA-9713393-1', 'auto');
ga('send', 'pageview');
</script>
<script async src='https:
<link href="/css/site.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Roboto+Condensed:300,400,700" rel="stylesheet"><link rel="apple-touch-icon" sizes="57x57" href="/apple-icon-57x57.png">
<link rel="apple-touch-icon" sizes="60x60" href="/apple-icon-60x60.png">
<link rel="apple-touch-icon" sizes="72x72" href="/apple-icon-72x72.png">
<link rel="apple-touch-icon" sizes="76x76" href="/apple-icon-76x76.png">
<link rel="apple-touch-icon" sizes="114x114" href="/apple-icon-114x114.png">
<link rel="apple-touch-icon" sizes="120x120" href="/apple-icon-120x120.png">
<link rel="apple-touch-icon" sizes="144x144" href="/apple-icon-144x144.png">
<link rel="apple-touch-icon" sizes="152x152" href="/apple-icon-152x152.png">
<link rel="apple-touch-icon" sizes="180x180" href="/apple-icon-180x180.png">
<link rel="icon" type="image/png" sizes="192x192" href="/<API key>.png">
<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="96x96" href="/favicon-96x96.png">
<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
<link rel="manifest" href="/manifest.json">
<meta name="<API key>" content="#ffffff">
<meta name="<API key>" content="/ms-icon-144x144.png">
<meta name="theme-color" content="#ffffff">
<link href="/events/index.xml" rel="alternate" type="application/rss+xml" title="DevOpsDays" />
<link href="/events/index.xml" rel="feed" type="application/rss+xml" title="DevOpsDays" />
<script src=/js/devopsdays-min.js></script></head>
<body lang="">
<nav class="navbar navbar-expand-md navbar-light">
<a class="navbar-brand" href="/">
<img src="/img/devopsdays-brain.png" height="30" class="d-inline-block align-top" alt="devopsdays Logo">
DevOpsDays
</a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#<API key>" aria-controls="<API key>" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="<API key>">
<ul class="navbar-nav mr-auto"><li class="nav-item global-navigation"><a class = "nav-link" href="/events">events</a></li><li class="nav-item global-navigation"><a class = "nav-link" href="/blog">blog</a></li><li class="nav-item global-navigation"><a class = "nav-link" href="/sponsor">sponsor</a></li><li class="nav-item global-navigation"><a class = "nav-link" href="/speaking">speaking</a></li><li class="nav-item global-navigation"><a class = "nav-link" href="/organizing">organizing</a></li><li class="nav-item global-navigation"><a class = "nav-link" href="/about">about</a></li></ul>
</div>
</nav>
<nav class="navbar event-navigation navbar-expand-md navbar-light">
<a href="/events/2018-copenhagen" class="nav-link">Copenhagen</a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar2">
<span class="navbar-toggler-icon"></span>
</button>
<div class="navbar-collapse collapse" id="navbar2">
<ul class="navbar-nav"><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/location">location</a>
</li><li class="nav-item active">
<a class="nav-link" href="https:
</li><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/program">program</a>
</li><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/speakers">speakers</a>
</li><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/sponsor">sponsor</a>
</li><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/contact">contact</a>
</li><li class="nav-item active">
<a class="nav-link" href="/events/2018-copenhagen/conduct">conduct</a>
</li></ul>
</div>
</nav>
<div class="container-fluid">
<div class="row">
<div class="col-md-12"><div class="row">
<div class="col-md-12 content-text"><h1>devopsdays Copenhagen - Propose</h1>
<center>
<b>Call for proposals opens Wednesday, Jan 10, 2018.</b><br>
<b>Call for proposals closes Sunday, Feb 11, 2018.</b><br>
Selected proposals will be announced on Wednesday, Feb 28, 2018.
</center>
<hr>
<p>There are three ways to propose a topic at devopsdays:
<ol>
<li><strong><em>A 30-minute talk</em></strong> presented during the conference, usually in the mornings.</li>
<li><strong><em>An Ignite talk</em></strong> presented during the <a href="/pages/ignite-talks-format">Ignite sessions</a> (scheduling varies). These are 5 minutes slots with slides changing every 15 seconds (20 slides total).</li>
<li><strong><em>Open Space</em></strong>: If you’d like to lead a group discussion during the attendee-suggested <a href="/pages/open-space-format">Open Space</a> breakout sessions, it is not necessary to propose it ahead of time. Those topics are suggested in person at the conference. If you’d like to demo your product or service, you should <a href="../sponsor">sponsor the event</a> and demo it at your table.
</ol></p>
<hr>
<p>Choosing talks is part art, part science; here are some factors we consider when trying to assemble the best possible program for our local audience:</p>
<ul>
<li><em>broad appeal</em>: How will your talk play out in a room of people with a variety of backgrounds? Technical deep dives need more levels to provide value for the whole room, some of whom might not use your specific tool.</li>
<li><em>new local presenters</em>: You are the only one who can tell your story. We are very interested in the challenges and successes being experienced in our local area. We are happy to provide guidance/coaching for new speakers upon request.</li>
<li><em>under-represented voices</em>: We want to hear all voices, including those that may speak less frequently at similar events. Whether you’re in a field not typically thought of as a technology field, you’re in a large, traditional organization, or you’re the only person at your organization with your background, we are interested in your unique experience.</li>
<li><em>original content</em>: We will consider talks that have already been presented elsewhere, but we prefer talks that the local area isn’t likely to have already seen.</li>
<li><em>no third-party submissions</em>: This is a small community-driven event, and speakers need to be directly engaged with the organizers and attendees. If a PR firm or your marketing department is proposing the talk, you’ve already shown that as a speaker you’re distant from the process.</li>
<li><em>no vendor pitches</em>: As much as we value vendors and sponsors, we are not going to accept a talk that appears to be a pitch for your product.</li>
</ul>
<hr>
<p><strong>How to submit a proposal:</strong> Send an email to [<a href='mailto:<API key>@devopsdays.org?subject='><API key>@devopsdays.org</a>
] with the following information
<ol>
<li>Type (presentation, panel discussion, ignite)</li>
<li>Proposal Title (can be changed later)</li>
<li>Description (several sentences explaining what attendees will learn)</li>
</ol></p>
<br /><div class="row cta-row">
<div class="col-md-12"><h4 class="sponsor-cta">Gold Sponsors</h4></div>
</div><div class="row sponsor-row"><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "http://chef.io"><img src = "/img/sponsors/chef.png" alt = "Chef Software, Inc" title = "Chef Software, Inc" class="img-fluid"></a>
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "http:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div></div><div class="row cta-row">
<div class="col-md-12"><h4 class="sponsor-cta">Silver Sponsors</h4><a href = "/events/2018-copenhagen/sponsor" class="sponsor-cta"><i>Join as Silver Sponsor!</i>
</a></div>
</div><div class="row sponsor-row"><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https://platform.sh"><img src = "/img/sponsors/platformsh.png" alt = "Platform.sh" title = "Platform.sh" class="img-fluid"></a>
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "http:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https://phable.io/"><img src = "/img/sponsors/phable.png" alt = "phable" title = "phable" class="img-fluid"></a>
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https://unity3d.com/"><img src = "/img/sponsors/unity.png" alt = "unity" title = "unity" class="img-fluid"></a>
</div></div><div class="row cta-row">
<div class="col-md-12"><h4 class="sponsor-cta">Community Sponsors</h4><a href = "/events/2018-copenhagen/sponsor" class="sponsor-cta"><i>Join as Community Sponsor!</i>
</a></div>
</div><div class="row sponsor-row"><div class = "col-lg-1 col-md-2 col-4">
<a href = "https://technologydenmark.dk/"><img src = "/img/sponsors/technologydenmark.png" alt = "technologydenmark" title = "technologydenmark" class="img-fluid"></a>
</div><div class = "col-lg-1 col-md-2 col-4">
<a href = "https:
</div></div><br />
</div>
</div>
</div></div>
</div>
<nav class="navbar bottom navbar-light footer-nav-row" style="background-color: #bfbfc1;">
<div class = "row">
<div class = "col-md-12 <API key>">
<div class = "row">
<div class = "col-md-6 col-lg-3 footer-nav-col">
<h3 class="footer-nav">@DEVOPSDAYS</h3>
<div>
<a class="twitter-timeline" data-dnt="true" href="https://twitter.com/devopsdays/lists/devopsdays" data-chrome="noheader" height="440"></a>
<script>
! function(d, s, id) {
var js, fjs = d.<API key>(s)[0],
p = /^http:/.test(d.location) ? 'http' : 'https';
if (!d.getElementById(id)) {
js = d.createElement(s);
js.id = id;
js.src = p + "://platform.twitter.com/widgets.js";
fjs.parentNode.insertBefore(js, fjs);
}
}(document, "script", "twitter-wjs");
</script>
</div>
</div>
<div class="col-md-6 col-lg-3 footer-nav-col footer-content">
<h3 class="footer-nav">BLOG</h3><a href = "https://www.devopsdays.org/blog/2019/05/10/<API key>/"><h1 class = "footer-heading">10 years of devopsdays</h1></a><h2 class="footer-heading">by Kris Buytaert - 10 May, 2019</h2><p class="footer-content">It’s hard to believe but it is almost 10 years ago since #devopsdays happened for the first time in Gent. Back then there were almost 70 of us talking about topics that were of interest to both Operations and Development, we were exchanging our ideas and experiences `on how we were improving the quality of software delivery.
Our ideas got started on the crossroads of Open Source, Agile and early Cloud Adoption.</p><a href = "https:
</div>
<div class="col-md-6 col-lg-3 footer-nav-col">
<h3 class="footer-nav">CFP OPEN</h3><a href = "/events/2019-campinas" class = "footer-content">Campinas</a><br /><a href = "/events/2019-macapa" class = "footer-content">Macapá</a><br /><a href = "/events/2019-shanghai" class = "footer-content">Shanghai</a><br /><a href = "/events/2019-recife" class = "footer-content">Recife</a><br /><a href = "/events/2020-charlotte" class = "footer-content">Charlotte</a><br /><a href = "/events/2020-prague" class = "footer-content">Prague</a><br /><a href = "/events/2020-tokyo" class = "footer-content">Tokyo</a><br /><a href = "/events/2020-salt-lake-city" class = "footer-content">Salt Lake City</a><br />
<br />Propose a talk at an event near you!<br />
</div>
<div class="col-md-6 col-lg-3 footer-nav-col">
<h3 class="footer-nav">About</h3>
devopsdays is a worldwide community conference series for anyone interested in IT improvement.<br /><br />
<a href="/about/" class = "footer-content">About devopsdays</a><br />
<a href="/privacy/" class = "footer-content">Privacy Policy</a><br />
<a href="/conduct/" class = "footer-content">Code of Conduct</a>
<br />
<br />
<a href="https:
<img src="/img/netlify-light.png" alt="Deploys by Netlify">
</a>
</div>
</div>
</div>
</div>
</nav>
<script>
$(document).ready(function () {
$("#share").jsSocials({
shares: ["email", {share: "twitter", via: 'devopsdayscph'}, "facebook", "linkedin"],
text: 'devopsdays Copenhagen - 2018',
showLabel: false,
showCount: false
});
});
</script>
</body>
</html>
|
#include "source/extensions/filters/listener/original_src/config.h"
#include "envoy/extensions/filters/listener/original_src/v3/original_src.pb.h"
namespace Envoy {
namespace Extensions {
namespace ListenerFilters {
namespace OriginalSrc {
Config::Config(const envoy::extensions::filters::listener::original_src::v3::OriginalSrc& config)
: use_port_(config.bind_port()), mark_(config.mark()) {}
} // namespace OriginalSrc
} // namespace ListenerFilters
} // namespace Extensions
} // namespace Envoy
|
program t
C test for nested information in format-item-list
integer::ierr
1234 format ()
5678 format (((((a)))))
write (*,1234,iostat=ierr) 'hello'
if (ierr .ne. 0) then
print *,'ok'
endif
write (*,5678) 'yes'
endprogram t
|
package expr.relational;
import java.util.Map;
import ast.Visitor;
import ast.type.Booltype;
import ast.type.Type;
import expr.Expr;
import expr.Ident;
import expr.operation.Operation;
public class Eq extends Operation {
public Eq(Expr lhs, Expr rhs){
super(lhs,rhs);
}
@Override
public Type typeof(Map<Ident,Type> symboles) {
return new Booltype();
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
}
|
package org.apache.hadoop.hive.cli;
import org.apache.hadoop.hive.cli.control.CliAdapter;
import org.apache.hadoop.hive.cli.control.CliConfigs;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.io.File;
import java.util.List;
/**
* This is used only for dev debugging if needed
*/
@RunWith(Parameterized.class)
public class <API key> {
static CliAdapter adapter = new CliConfigs.<API key>().getCliAdapter();
@Parameterized.Parameters(name = "{0}")
public static List<Object[]> getParameters() throws Exception {
return adapter.getParameters();
}
@ClassRule
public static TestRule cliClassRule = adapter.buildClassRule();
@Rule
public TestRule cliTestRule = adapter.buildTestRule();
private String name;
private File qfile;
public <API key>(String name, File qfile) {
this.name = name;
this.qfile = qfile;
}
@Test
public void testCliDriver() throws Exception {
adapter.runTest(name, qfile);
}
}
|
<include file='public:header'/>
<div class="mainBt">
<ul>
<li class="li1"></li>
<li class="li2"></li>
<li class="li2 li3"></li>
</ul>
</div>
<div class="mainScAdd ">
<div class="tableBox">
<form target="baocms_frm" action="<{:U('goods/edit',array('goods_id'=>$detail['goods_id']))}>" method="post">
<table bordercolor="#e1e6eb" cellspacing="0" width="100%" border="1px" style=" border-collapse: collapse; margin:0px; vertical-align:middle; background-color:#FFF;" >
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[title]" value="<{$detail.title|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[intro]" value="<{$detail.intro|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[guige]" value="<{$detail.guige|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[num]" value="<{$detail.num|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"> <div class="lt">
<input type="hidden" id="shop_id" name="data[shop_id]" value="<{$detail.shop_id|default=''}>"/>
<input type="text" id="shop_name" name="shop_name" value="<{$shop.shop_name}>" class="manageInput" />
</div>
<a mini="select" w="1000" h="600" href="<{:U('shop/select')}>" class="remberBtn"></a>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt">
<select name="parent_id" id="parent_id" class="seleFl w100" style="display: inline-block; margin-right: 10px;">
<option value="0">...</option>
<foreach name="cates" item="var">
<eq name="var.parent_id" value="0">
<option value="<{$var.cate_id}>" <eq name="var.cate_id" value="$parent_id">selected="selected"</eq> ><{$var.cate_name}>(<{$var.rate}>‰)</option>
</eq>
</foreach>
</select>
<select id="cate_id" name="data[cate_id]" class="seleFl w100" style="display: inline-block; margin-right: 10px;">
<option value="0">...</option>
<foreach name="cates" item="var">
<eq name="var.parent_id" value="0">
<eq name="var.cate_id" value="$parent_id">
<foreach name="cates" item="var2">
<eq name="var2.parent_id" value="$var.cate_id">
<option value="<{$var2.cate_id}>" <eq name="var2.cate_id" value="$detail.cate_id">selected="selected"</eq> ><{$var2.cate_name}>(<{$var.rate}>‰)</option>
<foreach name="cates" item="var3">
<eq name="var3.parent_id" value="$var2.cate_id">
<option value="<{$var3.cate_id}>" <eq name="var3.cate_id" value="$detail.cate_id">selected="selected"</eq> > -<{$var3.cate_name}>(<{$var.rate}>‰)</option>
</eq>
</foreach>
</eq>
</foreach>
</eq>
</eq>
</foreach>
</select>
<script>
$(document).ready(function(e){
$("#parent_id").change(function(){
var url = '<{:U("goodscate/child",array("parent_id"=>"0000"))}>';
if($(this).val() > 0){
var url2 = url.replace('0000',$(this).val());
$.get(url2,function(data){
$("#cate_id").html(data);
},'html');
}
});
});
</script>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt" id="jq_setting">
<table>
<if condition="!empty($cate['select1'])">
<tr>
<td align="right"><{$cate.select1}></td>
<td>
<select name="data[select1]" class="manageSelect">
<foreach name="attrs" item="item">
<eq name="item.type" value="select1">
<option value="<{$item.attr_id}>" <eq name="detail.select1" value="$item.attr_id">selected="selected"</eq> ><{$item.attr_name}></option>
</eq>
</foreach>
</select>
</td>
</tr>
</if>
<if condition="!empty($cate['select2'])">
<tr>
<td align="right"><{$cate.select2}></td>
<td>
<select name="data[select2]" class="manageSelect">
<foreach name="attrs" item="item">
<eq name="item.type" value="select2">
<option value="<{$item.attr_id}>" <eq name="detail.select2" value="$item.attr_id">selected="selected"</eq> ><{$item.attr_name}></option>
</eq>
</foreach>
</select>
</td>
</tr>
</if>
<if condition="!empty($cate['select3'])">
<tr>
<td align="right"><{$cate.select3}></td>
<td>
<select name="data[select3]" class="manageSelect">
<foreach name="attrs" item="item">
<eq name="item.type" value="select3">
<option value="<{$item.attr_id}>" <eq name="detail.select3" value="$item.attr_id">selected="selected"</eq> ><{$item.attr_name}></option>
</eq>
</foreach>
</select>
</td>
</tr>
</if>
<if condition="!empty($cate['select4'])">
<tr>
<td align="right"><{$cate.select4}></td>
<td>
<select name="data[select4]" class="manageSelect">
<foreach name="attrs" item="item">
<eq name="item.type" value="select4">
<option value="<{$item.attr_id}>" <eq name="detail.select4" value="$item.attr_id">selected="selected"</eq> ><{$item.attr_name}></option>
</eq>
</foreach>
</select>
</td>
</tr>
</if>
<if condition="!empty($cate['select5'])">
<tr>
<td align="right"><{$cate.select5}></td>
<td>
<select name="data[select5]" class="manageSelect">
<foreach name="attrs" item="item">
<eq name="item.type" value="select5">
<option value="<{$item.attr_id}>" <eq name="detail.select5" value="$item.attr_id">selected="selected"</eq> ><{$item.attr_name}></option>
</eq>
</foreach>
</select>
</td>
</tr>
</if>
</table>
</td>
</tr>
<script>
var ajaxurl = '<{:U("goodscate/ajax",array("cate_id"=>"0000","goods_id"=>$detail["goods_id"]))}>';
$(document).ready(function () {
$("#cate_id").change(function () {
if ($(this).val() > 0) {
var link = ajaxurl.replace('0000', $(this).val());
$.get(link, function (data) {
$("#jq_setting").html(data);
}, 'html');
} else {
alert("");
}
});
});
</script>
<tr>
<td class="lfTdBt">
<js file='__PUBLIC__/js/uploadify/jquery.uploadify.min.js'/>
<link rel="stylesheet" href="__PUBLIC__/js/uploadify/uploadify.css">
</td>
<td class="rgTdBt">
<div style="width: 300px;height: 100px; float: left;">
<input type="hidden" name="data[photo]" value="<{$detail.photo}>" id="data_photo" />
<input id="photo_file" name="photo_file" type="file" multiple="true" value="" />
</div>
<div style="width: 300px;height: 100px; float: left;">
<img id="photo_img" width="80" height="80" src="__ROOT__/attachs/<{$detail.photo|default='default.jpg'}>" />
<a href="<{:U('setting/attachs')}>"></a>
<{$CONFIG.attachs.goods.thumb}>
</div>
<script>
$("#photo_file").uploadify({
'swf': '__PUBLIC__/js/uploadify/uploadify.swf?t=<{$nowtime}>',
'uploader': '<{:U("app/upload/uploadify",array("model"=>"goods"))}>',
'cancelImg': '__PUBLIC__/js/uploadify/uploadify-cancel.png',
'buttonText': '',
'fileTypeExts': '*.gif;*.jpg;*.png',
'queueSizeLimit': 1,
'onUploadSuccess': function (file, data, response) {
$("#data_photo").val(data);
$("#photo_img").attr('src', '__ROOT__/attachs/' + data).show();
}
});
</script>
</td>
</tr>
<tr>
<td class="lfTdBt">
</td>
<td class="rgTdBt">
<div>
<input id="logo_file" name="logo_file" type="file" multiple="true" value="" />
</div>
<div class="jq_uploads_img">
<foreach name="photos" item="item">
<span style="width: 200px; height: 120px; float: left; margin-left: 5px; margin-top: 10px;">
<img width="100" height="100" src="__ROOT__/attachs/<{$item.photo}>">
<input type="hidden" name="photos[]" value="<{$item.photo}>" />
<a href="javascript:void(0);"></a>
</span>
</foreach>
</div>
<script>
$("#logo_file").uploadify({
'swf': '__PUBLIC__/js/uploadify/uploadify.swf?t=<{$nowtime}>',
'uploader': '<{:U("app/upload/uploadify",array("model"=>"goods"))}>',
'cancelImg': '__PUBLIC__/js/uploadify/uploadify-cancel.png',
'buttonText': '',
'fileTypeExts': '*.gif;*.jpg;*.png',
'queueSizeLimit': 10,
'onUploadSuccess': function (file, data, response) {
var str = '<span style="width: 200px; height: 120px; float: left; margin-left: 5px; margin-top: 10px;"> <img width="200" height="100" src="__ROOT__/attachs/' + data + '"> <input type="hidden" name="photos[]" value="' + data + '" /> <a href="javascript:void(0);"></a> </span>';
$(".jq_uploads_img").append(str);
}
});
$(document).on("click", ".jq_uploads_img a", function () {
$(this).parent().remove();
});
</script>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt">
<label><span></span><input type="checkbox" name="data[is_vs1]" <if condition="$detail['is_vs1'] eq 1"> checked="checked" </if> value="1" /></label>
<label><span style="margin-left: 20px;"></span><input type="checkbox" name="data[is_vs2]" <if condition="$detail['is_vs2'] eq 1"> checked="checked" </if> value="1" /></label>
<label><span style="margin-left: 20px;"></span><input type="checkbox" name="data[is_vs3]" <if condition="$detail['is_vs3'] eq 1"> checked="checked" </if> value="1" /></label>
<label><span style="margin-left: 20px;"></span><input type="checkbox" name="data[is_vs4]" <if condition="$detail['is_vs4'] eq 1"> checked="checked" </if> value="1" /></label>
<label><span style="margin-left: 20px;"></span><input type="checkbox" name="data[is_vs5]" <if condition="$detail['is_vs5'] eq 1"> checked="checked" </if> value="1" /></label>
<label><span style="margin-left: 20px;"></span><input type="checkbox" name="data[is_vs6]" <if condition="$detail['is_vs6'] eq 1"> checked="checked" </if> value="1" /></label>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[price]" value="<{$detail.price|default=''}>" class="manageInput" />
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[mall_price]" value="<{$detail.mall_price|default=''}>" class="manageInput" />
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[mobile_fan]" value="<{$detail.mobile_fan|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[use_integral]" value="<{$detail.use_integral|default=''}>" class="manageInput" />
<code>1001</code>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[settlement_price]" value="<{$detail.settlement_price|default=''}>" class="manageInput" />
<code></code>
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[commission]" value="<{$detail.commission|default=''}>" class="manageInput" />
<code>0</code>
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[sold_num]" value="<{$detail.sold_num|default=''}>" class="manageInput" />
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[views]" value="<{$detail.views|default=''}>" class="manageInput" />
</td>
</tr><tr>
<td class="lfTdBt"></td>
<td class="rgTdBt">
<script type="text/plain" id="data_instructions" name="data[instructions]" style="width:800px;height:360px;"><{$detail.instructions}></script>
</td>
</tr>
<link rel="stylesheet" href="__PUBLIC__/umeditor/themes/default/css/umeditor.min.css" type="text/css">
<script type="text/javascript" charset="utf-8" src="__PUBLIC__/umeditor/umeditor.config.js"></script>
<script type="text/javascript" charset="utf-8" src="__PUBLIC__/umeditor/umeditor.min.js"></script>
<script type="text/javascript" src="__PUBLIC__/umeditor/lang/zh-cn/zh-cn.js"></script>
<script>
um = UM.getEditor('data_instructions', {
imageUrl: "<{:U('app/upload/editor')}>",
imagePath: '__ROOT__/attachs/editor/',
lang: 'zh-cn',
langPath: UMEDITOR_CONFIG.UMEDITOR_HOME_URL + "lang/",
focus: false
});
</script>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt">
<script type="text/plain" id="data_details" name="data[details]" style="width:800px;height:360px;"><{$detail.details}></script>
</td>
</tr>
<script>
um = UM.getEditor('data_details', {
imageUrl: "<{:U('app/upload/editor')}>",
imagePath: '__ROOT__/attachs/editor/',
lang: 'zh-cn',
langPath: UMEDITOR_CONFIG.UMEDITOR_HOME_URL + "lang/",
focus: false
});
</script>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[end_date]" value="<{$detail.end_date|default=''}>" onfocus="WdatePicker();" class="inputData" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="text" name="data[orderby]" value="<{$detail.orderby|default=''}>" class="manageInput" />
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="checkbox" name="data[profit_enable]" value='1' <if condition="$detail['profit_enable'] eq 1"> checked="checked" </if> /></td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt">
<select name="data[profit_rank_id]" class="seleFl w200">
<option value="0"></option>
<foreach name="ranks" item="item">
<option <eq name="item.rank_id" value="$detail.profit_rank_id">selected="selected"</eq> value="<{$item.rank_id}>"><{$item.rank_name}></option>
</foreach>
</select>
</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="number" min="0" max="100" name="data[profit_rate1]" value='<{$detail.profit_rate1}>' class="manageInput " />%</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="number" min="0" max="100" name="data[profit_rate2]" value='<{$detail.profit_rate2}>' class="manageInput " />%</td>
</tr>
<tr>
<td class="lfTdBt"></td>
<td class="rgTdBt"><input type="number" min="0" max="100" name="data[profit_rate3]" value='<{$detail.profit_rate3}>' class="manageInput " />%</td>
</tr>
</table>
<div style="margin-left:140px;margin-top:20px">
<input type="submit" value="" class="smtQrIpt" />
<div>
</form>
</div>
</div>
<include file='public:footer'/>
|
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_151) on Thu Jan 18 00:59:45 GMT 2018 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Class org.apache.taverna.server.master.rest.handler.NoUpdateHandler (Apache Taverna Server 3.1.0-incubating API)</title>
<meta name="date" content="2018-01-18">
<link rel="stylesheet" type="text/css" href="../../../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.taverna.server.master.rest.handler.NoUpdateHandler (Apache Taverna Server 3.1.0-incubating API)";
}
}
catch(err) {
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar.top">
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../../org/apache/taverna/server/master/rest/handler/NoUpdateHandler.html" title="class in org.apache.taverna.server.master.rest.handler">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../../index.html?org/apache/taverna/server/master/rest/handler/class-use/NoUpdateHandler.html" target="_top">Frames</a></li>
<li><a href="NoUpdateHandler.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.top">
</a></div>
<div class="header">
<h2 title="Uses of Class org.apache.taverna.server.master.rest.handler.NoUpdateHandler" class="title">Uses of Class<br>org.apache.taverna.server.master.rest.handler.NoUpdateHandler</h2>
</div>
<div class="classUseContainer">No usage of org.apache.taverna.server.master.rest.handler.NoUpdateHandler</div>
<div class="bottomNav"><a name="navbar.bottom">
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../../org/apache/taverna/server/master/rest/handler/NoUpdateHandler.html" title="class in org.apache.taverna.server.master.rest.handler">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../../index.html?org/apache/taverna/server/master/rest/handler/class-use/NoUpdateHandler.html" target="_top">Frames</a></li>
<li><a href="NoUpdateHandler.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip.navbar.bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html>
|
package fake
import (
v1 "github.com/openshift/origin/pkg/sdn/clientset/release_v3_6/typed/sdn/v1"
restclient "k8s.io/kubernetes/pkg/client/restclient"
core "k8s.io/kubernetes/pkg/client/testing/core"
)
type FakeSdnV1 struct {
*core.Fake
}
func (c *FakeSdnV1) ClusterNetworks(namespace string) v1.<API key> {
return &FakeClusterNetworks{c, namespace}
}
// RESTClient returns a RESTClient that is used to communicate
// with API server by this client implementation.
func (c *FakeSdnV1) RESTClient() restclient.Interface {
var ret *restclient.RESTClient
return ret
}
|
module PmxRunner
class Application
def initialize(template, client = :docker)
@images = template['images'].each_with_object([]) do |image, memo|
memo << TemplateImage.create(image, client)
end
@images = ImageSorter.sort(@images)
end
def run
@images.each(&:run)
end
end
end
|
using Bridge.Test.NUnit;
using System;
namespace Bridge.ClientTest.Exceptions
{
[Category(Constants.<API key>)]
[TestFixture(TestNameFormat = "<API key> - {0}")]
public class <API key>
{
[Test]
public void <API key>()
{
Assert.AreEqual("System.<API key>", typeof(<API key>).FullName, "Name");
Assert.True(typeof(<API key>).IsClass, "IsClass");
Assert.AreEqual(typeof(ArgumentException), typeof(<API key>).BaseType, "BaseType");
object d = new <API key>();
Assert.True(d is <API key>, "is <API key>");
Assert.True(d is ArgumentException, "is ArgumentException");
Assert.True(d is Exception, "is Exception");
var interfaces = typeof(<API key>).GetInterfaces();
Assert.AreEqual(0, interfaces.Length, "Interfaces length");
}
[Test]
public void <API key>()
{
var ex = new <API key>();
Assert.True((object)ex is <API key>, "is <API key>");
Assert.AreEqual(null, ex.ParamName, "ParamName");
Assert.AreEqual(null, ex.InnerException, "InnerException");
Assert.AreEqual(null, ex.ActualValue, "ActualValue");
Assert.AreEqual("Specified argument was out of the range of valid values.", ex.Message);
}
[Test]
public void <API key>()
{
var ex = new <API key>("someParam");
Assert.True((object)ex is <API key>, "is <API key>");
Assert.AreEqual("someParam", ex.ParamName, "ParamName");
Assert.AreEqual(null, ex.InnerException, "InnerException");
Assert.AreEqual(null, ex.ActualValue, "ActualValue");
Assert.AreEqual("Specified argument was out of the range of valid values.\nParameter name: someParam", ex.Message);
}
[Test]
public void <API key>()
{
var ex = new <API key>("someParam", "The message");
Assert.True((object)ex is <API key>, "is <API key>");
Assert.AreEqual("someParam", ex.ParamName, "ParamName");
Assert.AreEqual(null, ex.InnerException, "InnerException");
Assert.AreEqual(null, ex.ActualValue, "ActualValue");
//Assert.AreEqual("The message", ex.Message);
}
[Test]
public void <API key>()
{
var inner = new Exception("a");
var ex = new <API key>("The message", inner);
Assert.True((object)ex is <API key>, "is <API key>");
Assert.Null(ex.ParamName, "ParamName");
Assert.True(ReferenceEquals(ex.InnerException, inner), "InnerException");
Assert.AreEqual(null, ex.ActualValue, "ActualValue");
Assert.AreEqual("The message", ex.Message);
}
[Test]
public void <API key>()
{
var ex = new <API key>("someParam", 42, "The message");
Assert.True((object)ex is <API key>, "is <API key>");
Assert.AreEqual("someParam", ex.ParamName, "ParamName");
Assert.Null(ex.InnerException, "InnerException");
Assert.AreEqual(42, ex.ActualValue, "ActualValue");
//Assert.AreEqual("The message", ex.Message);
}
// NDN
// [Test(ExpectedCount = 2)]
// public void <API key>()
// int size = -1;
// try
//#pragma warning disable 219
// var arr = new int[size];
//#pragma warning restore 219
// Assert.Fail("Should throw");
// catch (<API key> ex)
// Exception inner = ex.InnerException;
// Assert.NotNull(inner, "Inner Exception");
// Assert.True(inner is ErrorException, "Inner is ErrorException");
// catch (Exception ex)
// Assert.Fail("Expected <API key>, got " + ex.GetType());
}
}
|
package build
import (
"fmt"
"time"
kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"
"github.com/GoogleCloudPlatform/kubernetes/pkg/fields"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util/fielderrors"
"github.com/openshift/origin/pkg/build/api"
"github.com/openshift/origin/pkg/build/api/validation"
buildutil "github.com/openshift/origin/pkg/build/util"
)
// strategy implements behavior for Build objects
type strategy struct {
runtime.ObjectTyper
kapi.NameGenerator
}
// Decorator is used to compute duration of a build since its not stored in etcd yet
var Decorator = func(obj runtime.Object) error {
build, ok := obj.(*api.Build)
if !ok {
return errors.NewBadRequest(fmt.Sprintf("not a build: %v", build))
}
if build.StartTimestamp == nil {
build.Duration = time.Duration(0)
} else {
completionTimestamp := build.CompletionTimestamp
if completionTimestamp == nil {
dummy := util.Now()
completionTimestamp = &dummy
}
build.Duration = completionTimestamp.Rfc3339Copy().Time.Sub(build.StartTimestamp.Rfc3339Copy().Time)
}
return nil
}
// Strategy is the default logic that applies when creating and updating Build objects.
var Strategy = strategy{kapi.Scheme, kapi.SimpleNameGenerator}
func (strategy) NamespaceScoped() bool {
return true
}
// AllowCreateOnUpdate is false for Build objects.
func (strategy) AllowCreateOnUpdate() bool {
return false
}
// PrepareForCreate clears fields that are not allowed to be set by end users on creation.
func (strategy) PrepareForCreate(obj runtime.Object) {
build := obj.(*api.Build)
if len(build.Status) == 0 {
build.Status = api.BuildStatusNew
}
}
// PrepareForUpdate clears fields that are not allowed to be set by end users on update.
func (strategy) PrepareForUpdate(obj, old runtime.Object) {
_ = obj.(*api.Build)
}
// Validate validates a new policy.
func (strategy) Validate(ctx kapi.Context, obj runtime.Object) fielderrors.ValidationErrorList {
return validation.ValidateBuild(obj.(*api.Build))
}
// ValidateUpdate is the default update validation for an end user.
func (strategy) ValidateUpdate(ctx kapi.Context, obj, old runtime.Object) fielderrors.ValidationErrorList {
return validation.ValidateBuildUpdate(obj.(*api.Build), old.(*api.Build))
}
// CheckGracefulDelete allows a build to be gracefully deleted.
func (strategy) CheckGracefulDelete(obj runtime.Object, options *kapi.DeleteOptions) bool {
return false
}
// Matcher returns a generic matcher for a given label and field selector.
func Matcher(label labels.Selector, field fields.Selector) generic.Matcher {
return &generic.SelectionPredicate{
Label: label,
Field: field,
GetAttrs: func(obj runtime.Object) (labels.Set, fields.Set, error) {
build, ok := obj.(*api.Build)
if !ok {
return nil, nil, fmt.Errorf("not a build")
}
return labels.Set(build.ObjectMeta.Labels), SelectableFields(build), nil
},
}
}
// SelectableFields returns a label set that represents the object
func SelectableFields(build *api.Build) fields.Set {
return fields.Set{
"metadata.name": build.Name,
"status": string(build.Status),
"podName": buildutil.GetBuildPodName(build),
}
}
|
#pragma once
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/ExportTask.h>
#include <aws/ec2/model/ResponseMetadata.h>
#include <utility>
namespace Aws
{
template<typename RESULT_TYPE>
class <API key>;
namespace Utils
{
namespace Xml
{
class XmlDocument;
} // namespace Xml
} // namespace Utils
namespace EC2
{
namespace Model
{
class AWS_EC2_API <API key>
{
public:
<API key>();
<API key>(const Aws::<API key><Aws::Utils::Xml::XmlDocument>& result);
<API key>& operator=(const Aws::<API key><Aws::Utils::Xml::XmlDocument>& result);
/**
* <p>Information about the export instance task.</p>
*/
inline const ExportTask& GetExportTask() const{ return m_exportTask; }
/**
* <p>Information about the export instance task.</p>
*/
inline void SetExportTask(const ExportTask& value) { m_exportTask = value; }
/**
* <p>Information about the export instance task.</p>
*/
inline void SetExportTask(ExportTask&& value) { m_exportTask = std::move(value); }
/**
* <p>Information about the export instance task.</p>
*/
inline <API key>& WithExportTask(const ExportTask& value) { SetExportTask(value); return *this;}
/**
* <p>Information about the export instance task.</p>
*/
inline <API key>& WithExportTask(ExportTask&& value) { SetExportTask(std::move(value)); return *this;}
inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
inline <API key>& <API key>(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
inline <API key>& <API key>(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
private:
ExportTask m_exportTask;
ResponseMetadata m_responseMetadata;
};
} // namespace Model
} // namespace EC2
} // namespace Aws
|
define(
({
_widgetLabel: "", // Shown as a widget label
searchHeaderText: "", // Shown as a label in widget panel for search an address.
<API key>: "", //Shown as title in infowindow after selecting location from map click
mouseOverTooltip: "", // Tooltip for location address button
<API key>: "", //Shown as error message when no result found at the selected/searched location
<API key>: "", //Shown as error message when no feature found at the selected/searched location for the configured chart
noChatsConfigured: "" //Shown as error message if no charts configured
})
);
|
var assert = require('assert');
include("binary");
exports.testByteArraySlice = function() {
var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
var b = new ByteArray(a);
var s = b.slice();
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(10, s.length);
assert.deepEqual(a, s.toArray());
s = b.slice(3, 6);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(3, s.length);
assert.deepEqual(a.slice(3, 6), s.toArray());
s = b.slice(3, 4);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(1, s.length);
assert.deepEqual(a.slice(3, 4), s.toArray());
s = b.slice(3, 3);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(0, s.length);
assert.deepEqual(a.slice(3, 3), s.toArray());
s = b.slice(3, 2);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(0, s.length);
assert.deepEqual(a.slice(3, 2), s.toArray());
s = b.slice(7);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(3, s.length);
assert.deepEqual(a.slice(7), s.toArray());
s = b.slice(3, -2);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(5, s.length);
assert.deepEqual(a.slice(3, -2), s.toArray());
s = b.slice(-2);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(2, s.length);
assert.deepEqual(a.slice(-2), s.toArray());
s = b.slice(50);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(0, s.length);
assert.deepEqual(a.slice(50), s.toArray());
s = b.slice(-100, 100);
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(10, s.length);
assert.deepEqual(a.slice(-100, 100), s.toArray());
s = b.slice("foo");
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(10, s.length);
assert.deepEqual(a.slice("foo"), s.toArray());
s = b.slice("foo", "bar");
assert.isTrue(s instanceof ByteArray);
assert.strictEqual(0, s.length);
assert.deepEqual(a.slice("foo", "bar"), s.toArray());
};
if (require.main === module) {
require('system').exit(require('test').run(module.id));
}
|
# <API key> / data / mil2525d / utilities / pairwise-testing
====================================
## Purpose
These files are the configuration and output files used with the Pairwise Independent Combinatorial Testing (PICT) test application. PICT is used by Military Features to generate combinations of symbol codes for testing.
* For more information on Pairwise Testing using PICT see: http://msdn.microsoft.com/en-us/library/cc150619.aspx
* To obtain the PICT application: http://download.microsoft.com/download/f/5/5/<API key>/pict33.msi
|
#include "system.h"
#include "uart.h"
#include <yfuns.h>
extern "C" int __low_level_init(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
return (1);
}
extern "C" size_t __write(int handle, const unsigned char * buffer, size_t size)
{
size_t nChars = 0;
if (buffer == 0)
{
return 0;
}
if (handle != _LLIO_STDOUT && handle != _LLIO_STDERR)
{
return _LLIO_ERROR;
}
for (; size != 0; --size)
{
UART_SendByte(*buffer++);
++nChars;
}
return nChars;
}
void Sys_Init(void)
{
volatile unsigned int i;
// 8MHz with auto-calibration by the FLL+.
// ACLK = LFXT1 = 32768Hz, MCLK = SMCLK = DCO = (121+1) x 2 x ACLK = 7995392Hz
// //* An external watch crystal between XIN & XOUT is required for ACLK *//
// MSP430xG461x
// /|\| XIN|-
// | | | 32kHz
// --|RST XOUT|-
// | P1.1|--> MCLK = 8MHz
// | P1.5|--> ACLK = 32kHz
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
// Loop until 32kHz crystal stabilizes
do
{
IFG1 &= ~OFIFG; // Clear oscillator fault flag
for (i = 50000; i; i--); // Delay
}
while (IFG1 & OFIFG); // Test osc fault flag
FLL_CTL0 |= DCOPLUS + XCAP18PF; // DCO+ set, freq = xtal x D x N+1
SCFI0 = FLLD_2 | FN_4; // x2 DCO freq, 8MHz nominal DCO
SCFQCTL = 121; // (121+1) x 32768 x 2 = 7.99 MHz
// WatchDog interval timer mode (15.625 ms period)
WDTCTL = WDT_ADLY_16;
IE1 |= 0x01;
// Superviser, 2.4V
SVSCTL=0x00; //off SVS
SVSCTL=0x50; //on SVS 0x10~1.9V 0x20~2.1V 0x30~2.2V 0x40~2.3 0x50~2.4V 0x60~2.5V 0x70~2.65V 0x80~2.8V 0x90~2.9V 0xA0~3.05V 0xB0~3.2V 0xC0~3.35V 0xD0~3.5V 0xE0~3.7V
}
void Sys_Sleep(TTimeout Ticks)
{
if (Ticks > 0)
{
OS::TBaseProcess::Sleep(Ticks);
}
}
void Sys_SleepMsec(unsigned int MSec)
{
Sys_Sleep(MSEC_TO_TICKS(MSec));
}
void Sys_SleepSec(unsigned int Sec)
{
Sys_Sleep(SEC_TO_TICKS(Sec));
}
void Sys_Delay(unsigned int Cycles)
{
Cycles >>= 3;
while (Cycles
{
__no_operation();
__no_operation();
__no_operation();
}
}
void Sys_DelayUsec(unsigned int USec)
{
#define <API key> 0
Sys_Delay((<API key>) * CYCLES_PER_USEC);
}
void Sys_DelayMsec(unsigned int MSec)
{
Sys_Delay(MSec * CYCLES_PER_MSEC);
}
|
#include <stdio.h>
#include "ali_api_core.h"
#include "ali_string_utils.h"
#include "ali_otsfinance.h"
#include "json/value.h"
#include "json/reader.h"
using namespace aliyun;
namespace {
void Json2Type(const Json::Value& value, std::string* item);
void Json2Type(const Json::Value& value, <API key>* item);
template<typename T>
class Json2Array {
public:
Json2Array(const Json::Value& value, std::vector<T>* vec) {
if(!value.isArray()) {
return;
}
for(int i = 0; i < value.size(); i++) {
T val;
Json2Type(value[i], &val);
vec->push_back(val);
}
}
};
void Json2Type(const Json::Value& value, std::string* item) {
*item = value.asString();
}
void Json2Type(const Json::Value& value, <API key>* item) {
}
}
int OtsFinance::DeleteUser(<API key>* response,
OtsFinanceErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = this->use_tls_ ? "https" : "http";
AliRpcRequest* req_rpc = new AliRpcRequest(version_,
appid_,
secret_,
secheme + "://" + host_);
if((!this->use_tls_) && this->proxy_host_ && this->proxy_host_[0]) {
req_rpc->SetHttpProxy( this->proxy_host_);
}
Json::Value val;
Json::Reader reader;
req_rpc->AddRequestQuery("Action","DeleteUser");
if(this->region_id_ && this->region_id_[0]) {
req_rpc->AddRequestQuery("RegionId", this->region_id_);
}
if(req_rpc->CommitRequest() != 0) {
if(error_info) {
error_info->code = "connect to host failed";
}
ret = -1;
goto out;
}
status_code = req_rpc-><API key>();
req_rpc->ReadResponseBody(str_response);
if(status_code > 0 && !str_response.empty()){
parse_success = reader.parse(str_response, val);
}
if(!parse_success) {
if(error_info) {
error_info->code = "parse response failed";
}
ret = -1;
goto out;
}
if(status_code!= 200 && error_info && parse_success) {
error_info->request_id = val.isMember("RequestId") ? val["RequestId"].asString(): "";
error_info->code = val.isMember("Code") ? val["Code"].asString(): "";
error_info->host_id = val.isMember("HostId") ? val["HostId"].asString(): "";
error_info->message = val.isMember("Message") ? val["Message"].asString(): "";
}
if(status_code== 200 && response) {
Json2Type(val, response);
}
ret = status_code;
out:
delete req_rpc;
return ret;
}
|
#ifndef TCP_HH_
# define TCP_HH_
# include <SDL2/SDL_net.h>
# include <string>
# include <iostream>
bool sendTCP(const char *data, TCPsocket socket);
bool receiveTCP(TCPsocket socket, char *buffer, int size);
#endif
|
<!-- This file is machine generated: DO NOT EDIT! -->
# Math
Note: Functions taking `Tensor` arguments can also take anything accepted by
[`tf.convert_to_tensor`](framework.md#convert_to_tensor).
[TOC]
Note: Elementwise binary operations in TensorFlow follow [numpy-style
broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).
## Arithmetic Operators
TensorFlow provides several operations that you can use to add basic arithmetic
operators to your graph.
- - -
`tf.add(x, y, name=None)` {#add}
Returns x + y element-wise.
*NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `complex64`, `complex128`, `string`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.subtract(x, y, name=None)` {#subtract}
Returns x - y element-wise.
*NOTE*: `Sub` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.multiply(x, y, name=None)` {#multiply}
Returns x * y element-wise.
*NOTE*: `Mul` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.scalar_mul(scalar, x)` {#scalar_mul}
Multiplies a scalar times a `Tensor` or `IndexedSlices` object.
Intended for use in gradient code which might deal with `IndexedSlices`
objects, which are easy to multiply by a scalar but more expensive to
multiply with arbitrary tensors.
## Args:
* <b>`scalar`</b>: A 0-D scalar `Tensor`. Must have known shape.
* <b>`x`</b>: A `Tensor` or `IndexedSlices` to be scaled.
## Returns:
`scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`.
## Raises:
* <b>`ValueError`</b>: if scalar is not a 0-D `scalar`.
- - -
`tf.div(x, y, name=None)` {#div}
- - -
`tf.divide(x, y, name=None)` {#divide}
Computes Python style division of `x` by `y`.
- - -
`tf.truediv(x, y, name=None)` {#truediv}
Divides x / y elementwise, always producing floating point results.
The same as `tf.div` for floating point arguments, but casts integer arguments
to floating point before dividing so that the result is always floating point.
This op is generated by normal `x / y` division in Python 3 and in Python 2.7
with `from __future__ import division`. If you want integer division that
rounds down, use `x // y` or `tf.floordiv`.
`x` and `y` must have the same numeric type. If the inputs are floating
point, the output will have the same type. If the inputs are integral, the
inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32`
and `int64` (matching the behavior of Numpy).
## Args:
* <b>`x`</b>: `Tensor` numerator of numeric type.
* <b>`y`</b>: `Tensor` denominator of numeric type.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
`x / y` evaluated in floating point.
## Raises:
* <b>`TypeError`</b>: If `x` and `y` have different dtypes.
- - -
`tf.floordiv(x, y, name=None)` {#floordiv}
Divides `x / y` elementwise, rounding toward the most negative integer.
The same as `tf.div(x,y)` for integers, but uses `tf.floor(tf.div(x,y))` for
floating point arguments so that the result is always an integer (though
possibly an integer represented as floating point). This op is generated by
`x // y` floor division in Python 3 and in Python 2.7 with
`from __future__ import division`.
Note that for efficiency, `floordiv` uses C semantics for negative numbers
(unlike Python and Numpy).
`x` and `y` must have the same type, and the result will have the same type
as well.
## Args:
* <b>`x`</b>: `Tensor` numerator of real numeric type.
* <b>`y`</b>: `Tensor` denominator of real numeric type.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
`x / y` rounded down (except possibly towards zero for negative integers).
## Raises:
* <b>`TypeError`</b>: If the inputs are complex.
- - -
`tf.realdiv(x, y, name=None)` {#realdiv}
Returns x / y element-wise for real types.
If `x` and `y` are reals, this will return the floating-point division.
*NOTE*: `Div` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.truncatediv(x, y, name=None)` {#truncatediv}
Returns x / y element-wise for integer types.
Truncation designates that negative numbers will round fractional quantities
toward zero. I.e. -7 / 5 = 1. This matches C semantics but it is different
than Python semantics. See `FloorDiv` for a division function that matches
Python Semantics.
*NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.floor_div(x, y, name=None)` {#floor_div}
Returns x // y element-wise.
*NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.truncatemod(x, y, name=None)` {#truncatemod}
Returns element-wise remainder of division. This emulates C semantics where
true, this follows C semantics in that the result here is consistent
with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
*NOTE*: `Mod` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.floormod(x, y, name=None)` {#floormod}
Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
true, this follows Python semantics in that the result here is consistent
with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
*NOTE*: `FloorMod` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.mod(x, y, name=None)` {#mod}
Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
true, this follows Python semantics in that the result here is consistent
with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
*NOTE*: `FloorMod` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`, `float32`, `float64`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.cross(a, b, name=None)` {#cross}
Compute the pairwise cross product.
`a` and `b` must be the same shape; they can either be simple 3-element vectors,
or any shape where the innermost dimension is 3. In the latter case, each pair
of corresponding 3-element vectors is cross-multiplied independently.
## Args:
* <b>`a`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`.
A tensor containing 3-element vectors.
* <b>`b`</b>: A `Tensor`. Must have the same type as `a`.
Another tensor, of same type and shape as `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `a`.
Pairwise cross product of the vectors in `a` and `b`.
## Basic Math Functions
TensorFlow provides several operations that you can use to add basic
mathematical functions to your graph.
- - -
`tf.add_n(inputs, name=None)` {#add_n}
Adds all input tensors element-wise.
## Args:
* <b>`inputs`</b>: A list of `Tensor` objects, each with same shape and type.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of same shape and type as the elements of `inputs`.
## Raises:
* <b>`ValueError`</b>: If `inputs` don't all have same shape and dtype or the shape
cannot be inferred.
- - -
`tf.abs(x, name=None)` {#abs}
Computes the absolute value of a tensor.
Given a tensor of real numbers `x`, this operation returns a tensor
containing the absolute value of each element in `x`. For example, if x is
an input element and y is an output element, this operation computes
\\(y = |x|\\).
See [`tf.complex_abs()`](#tf_complex_abs) to compute the absolute value of a
complex
number.
## Args:
* <b>`x`</b>: A `Tensor` or `SparseTensor` of type `float32`, `float64`, `int32`, or
`int64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor` the same size and type as `x` with absolute
values.
- - -
`tf.negative(x, name=None)` {#negative}
Computes numerical negative value element-wise.
I.e., \\(y = -x\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.sign(x, name=None)` {#sign}
Returns an element-wise indication of the sign of a number.
`y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
## Args:
* <b>`x`</b>: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,
`float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.
- - -
`tf.reciprocal(x, name=None)` {#reciprocal}
Computes the reciprocal of x element-wise.
I.e., \\(y = 1 / x\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.square(x, name=None)` {#square}
Computes square of x element-wise.
I.e., \(y = x * x = x^2\).
## Args:
* <b>`x`</b>: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,
`float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor`. Has the same type as `x`.
- - -
`tf.round(x, name=None)` {#round}
Rounds the values of a tensor to the nearest integer, element-wise.
Rounds half to even. Also known as bankers rounding. If you want to round
according to the current system rounding mode use tf::cint.
For example:
python
# 'a' is [0.9, 2.5, 2.3, 1.5, -4.5]
tf.round(a) ==> [ 1.0, 2.0, 2.0, 2.0, -4.0 ]
## Args:
* <b>`x`</b>: A `Tensor` of type `float32` or `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of same shape and type as `x`.
- - -
`tf.sqrt(x, name=None)` {#sqrt}
Computes square root of x element-wise.
I.e., \(y = \sqrt{x} = x^{1/2}\).
## Args:
* <b>`x`</b>: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,
`float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.
- - -
`tf.rsqrt(x, name=None)` {#rsqrt}
Computes reciprocal of square root of x element-wise.
I.e., \\(y = 1 / \sqrt{x}\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.pow(x, y, name=None)` {#pow}
Computes the power of one value to another.
Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
corresponding elements in `x` and `y`. For example:
# tensor 'x' is [[2, 2], [3, 3]]
# tensor 'y' is [[8, 16], [2, 3]]
tf.pow(x, y) ==> [[256, 65536], [9, 27]]
## Args:
* <b>`x`</b>: A `Tensor` of type `float32`, `float64`, `int32`, `int64`, `complex64`,
or `complex128`.
* <b>`y`</b>: A `Tensor` of type `float32`, `float64`, `int32`, `int64`, `complex64`,
or `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`.
- - -
`tf.exp(x, name=None)` {#exp}
Computes exponential of x element-wise. \\(y = e^x\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.log(x, name=None)` {#log}
Computes natural logarithm of x element-wise.
I.e., \\(y = \log_e x\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.log1p(x, name=None)` {#log1p}
Computes natural logarithm of (1 + x) element-wise.
I.e., \\(y = \log_e (1 + x)\\).
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.ceil(x, name=None)` {#ceil}
Returns element-wise smallest integer in not less than x.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.floor(x, name=None)` {#floor}
Returns element-wise largest integer not greater than x.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.maximum(x, y, name=None)` {#maximum}
Returns the max of x and y (i.e. x > y ? x : y) element-wise.
*NOTE*: `Maximum` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.minimum(x, y, name=None)` {#minimum}
Returns the min of x and y (i.e. x < y ? x : y) element-wise.
*NOTE*: `Minimum` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.cos(x, name=None)` {#cos}
Computes cos of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.sin(x, name=None)` {#sin}
Computes sin of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.lbeta(x, name='lbeta')` {#lbeta}
Computes `ln(|Beta(x)|)`, reducing along the last dimension.
Given one-dimensional `z = [z_0,...,z_{K-1}]`, we define
Beta(z) = \prod_j Gamma(z_j) / Gamma(\sum_j z_j)```
And for `n + 1` dimensional `x` with shape `[N1, ..., Nn, K]`, we define
`lbeta(x)[i1, ..., in] = Log(|Beta(x[i1, ..., in, :])|)`. In other words,
the last dimension is treated as the `z` vector.
Note that if `z = [u, v]`, then
`Beta(z) = int_0^1 t^{u-1} (1 - t)^{v-1} dt`, which defines the traditional
bivariate beta function.
## Args:
* <b>`x`</b>: A rank `n + 1` `Tensor` with type `float`, or `double`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
The logarithm of `|Beta(x)|` reducing along the last dimension.
## Raises:
* <b>`ValueError`</b>: If `x` is empty with rank one or less.
- - -
`tf.tan(x, name=None)` {#tan}
Computes tan of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.acos(x, name=None)` {#acos}
Computes acos of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.asin(x, name=None)` {#asin}
Computes asin of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.atan(x, name=None)` {#atan}
Computes atan of x element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.lgamma(x, name=None)` {#lgamma}
Computes the log of the absolute value of `Gamma(x)` element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.digamma(x, name=None)` {#digamma}
Computes Psi, the derivative of Lgamma (the log of the absolute value of
`Gamma(x)`), element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.erf(x, name=None)` {#erf}
Computes the Gauss error function of `x` element-wise.
## Args:
* <b>`x`</b>: A `Tensor` of `SparseTensor`. Must be one of the following types: `half`,
`float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.
- - -
`tf.erfc(x, name=None)` {#erfc}
Computes the complementary error function of `x` element-wise.
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.squared_difference(x, y, name=None)` {#squared_difference}
Returns (x - y)(x - y) element-wise.
*NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.igamma(a, x, name=None)` {#igamma}
Compute the lower regularized incomplete Gamma function `Q(a, x)`.
The lower regularized incomplete Gamma function is defined as:
P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)
where
gamma(a, x) = int_{0}^{x} t^{a-1} exp(-t) dt
is the lower incomplete Gamma function.
Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
Gamma function.
## Args:
* <b>`a`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`x`</b>: A `Tensor`. Must have the same type as `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `a`.
- - -
`tf.igammac(a, x, name=None)` {#igammac}
Compute the upper regularized incomplete Gamma function `Q(a, x)`.
The upper regularized incomplete Gamma function is defined as:
Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)
where
Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt
is the upper incomplete Gama function.
Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
Gamma function.
## Args:
* <b>`a`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`x`</b>: A `Tensor`. Must have the same type as `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `a`.
- - -
`tf.zeta(x, q, name=None)` {#zeta}
Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
The Hurwitz zeta function is defined as:
\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`q`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.polygamma(a, x, name=None)` {#polygamma}
Compute the polygamma function \\(\psi^{(n)}(x)\\).
The polygamma function is defined as:
\psi^{(n)}(x) = \frac{d^n}{dx^n} \psi(x)
where \\(\psi(x)\\) is the digamma function.
## Args:
* <b>`a`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`x`</b>: A `Tensor`. Must have the same type as `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `a`.
- - -
`tf.betainc(a, b, x, name=None)` {#betainc}
Compute the regularized incomplete beta integral \\(I_x(a, b)\\).
The regularized incomplete beta integral is defined as:
I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}
where
B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt
is the incomplete beta function and \\(B(a, b)\\) is the *complete*
beta function.
## Args:
* <b>`a`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`b`</b>: A `Tensor`. Must have the same type as `a`.
* <b>`x`</b>: A `Tensor`. Must have the same type as `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `a`.
- - -
`tf.rint(x, name=None)` {#rint}
Returns element-wise integer closest to x.
If the result is midway between two representable values,
the even representable is chosen.
For example:
rint(-1.5) ==> -2.0
rint(0.5000001) ==> 1.0
rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
## Matrix Math Functions
TensorFlow provides several operations that you can use to add linear algebra
functions on matrices to your graph.
- - -
`tf.diag(diagonal, name=None)` {#diag}
Returns a diagonal tensor with a given diagonal values.
Given a `diagonal`, this operation returns a tensor with the `diagonal` and
everything else padded with zeros. The diagonal is computed as follows:
Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
`output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
For example:
prettyprint
# 'diagonal' is [1, 2, 3, 4]
tf.diag(diagonal) ==> [[1, 0, 0, 0]
[0, 2, 0, 0]
[0, 0, 3, 0]
[0, 0, 0, 4]]
## Args:
* <b>`diagonal`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
Rank k tensor where k is at most 3.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `diagonal`.
- - -
`tf.diag_part(input, name=None)` {#diag_part}
Returns the diagonal part of the tensor.
This operation returns a tensor with the `diagonal` part
of the `input`. The `diagonal` part is computed as follows:
Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
tensor of rank `k` with dimensions `[D1,..., Dk]` where:
`diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
For example:
prettyprint
# 'input' is [[1, 0, 0, 0]
[0, 2, 0, 0]
[0, 0, 3, 0]
[0, 0, 0, 4]]
tf.diag_part(input) ==> [1, 2, 3, 4]
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
Rank k tensor where k is 2, 4, or 6.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`. The extracted diagonal.
- - -
`tf.trace(x, name=None)` {#trace}
Compute the trace of a tensor `x`.
`trace(x)` returns the sum along the main diagonal of each inner-most matrix
in x. If x is of rank `k` with shape `[I, J, K, ..., L, M, N]`, then output
is a tensor of rank `k-2` with dimensions `[I, J, K, ..., L]` where
`output[i, j, k, ..., l] = trace(x[i, j, i, ..., l, :, :])`
For example:
python
# 'x' is [[1, 2],
# [3, 4]]
tf.trace(x) ==> 5
# 'x' is [[1,2,3],
# [4,5,6],
# [7,8,9]]
tf.trace(x) ==> 15
# 'x' is [[[1,2,3],
# [4,5,6],
# [7,8,9]],
# [[-1,-2,-3],
# [-4,-5,-6],
# [-7,-8,-9]]]
tf.trace(x) ==> [15,-15]
## Args:
* <b>`x`</b>: tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
The trace of input tensor.
- - -
`tf.transpose(a, perm=None, name='transpose')` {#transpose}
Transposes `a`. Permutes the dimensions according to `perm`.
The returned tensor's dimension i will correspond to the input dimension
`perm[i]`. If `perm` is not given, it is set to (n-1...0), where n is
the rank of the input tensor. Hence by default, this operation performs a
regular matrix transpose on 2-D input Tensors.
For example:
python
# 'x' is [[1 2 3]
# [4 5 6]]
tf.transpose(x) ==> [[1 4]
[2 5]
[3 6]]
# Equivalently
tf.transpose(x, perm=[1, 0]) ==> [[1 4]
[2 5]
[3 6]]
# 'perm' is more useful for n-dimensional tensors, for n > 2
# 'x' is [[[1 2 3]
# [4 5 6]]
# [[7 8 9]
# [10 11 12]]]
# Take the transpose of the matrices in dimension-0
tf.transpose(x, perm=[0, 2, 1]) ==> [[[1 4]
[2 5]
[3 6]]
[[7 10]
[8 11]
[9 12]]]
## Args:
* <b>`a`</b>: A `Tensor`.
* <b>`perm`</b>: A permutation of the dimensions of `a`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A transposed `Tensor`.
- - -
`tf.eye(num_rows, num_columns=None, batch_shape=None, dtype=tf.float32, name=None)` {#eye}
Construct an identity matrix, or a batch of matrices.
python
# Construct one identity matrix.
tf.eye(2)
==> [[1., 0.],
[0., 1.]]
# Construct a batch of 3 identity matricies, each 2 x 2.
# batch_identity[i, :, :] is a 2 x 2 identity matrix, i = 0, 1, 2.
batch_identity = tf.eye(2, batch_shape=[3])
# Construct one 2 x 3 "identity" matrix
tf.eye(2, num_columns=3)
==> [[ 1., 0., 0.],
[ 0., 1., 0.]]
## Args:
* <b>`num_rows`</b>: Non-negative `int32` scalar `Tensor` giving the number of rows
in each batch matrix.
* <b>`num_columns`</b>: Optional non-negative `int32` scalar `Tensor` giving the number
of columns in each batch matrix. Defaults to `num_rows`.
* <b>`batch_shape`</b>: `int32` `Tensor`. If provided, returned `Tensor` will have
leading batch dimensions of this shape.
* <b>`dtype`</b>: The type of an element in the resulting `Tensor`
* <b>`name`</b>: A name for this `Op`. Defaults to "eye".
## Returns:
A `Tensor` of shape `batch_shape + [num_rows, num_columns]`
- - -
`tf.matrix_diag(diagonal, name=None)` {#matrix_diag}
Returns a batched diagonal tensor with a given batched diagonal values.
Given a `diagonal`, this operation returns a tensor with the `diagonal` and
everything else padded with zeros. The diagonal is computed as follows:
Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
`output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
For example:
prettyprint
# 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
and diagonal.shape = (2, 4)
tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
[0, 2, 0, 0]
[0, 0, 3, 0]
[0, 0, 0, 4]],
[[5, 0, 0, 0]
[0, 6, 0, 0]
[0, 0, 7, 0]
[0, 0, 0, 8]]]
which has shape (2, 4, 4)
## Args:
* <b>`diagonal`</b>: A `Tensor`. Rank `k`, where `k >= 1`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `diagonal`.
Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
- - -
`tf.matrix_diag_part(input, name=None)` {#matrix_diag_part}
Returns the batched diagonal part of a batched tensor.
This operation returns a tensor with the `diagonal` part
of the batched `input`. The `diagonal` part is computed as follows:
Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
`diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
The input must be at least a matrix.
For example:
prettyprint
# 'input' is [[[1, 0, 0, 0]
[0, 2, 0, 0]
[0, 0, 3, 0]
[0, 0, 0, 4]],
[[5, 0, 0, 0]
[0, 6, 0, 0]
[0, 0, 7, 0]
[0, 0, 0, 8]]]
and input.shape = (2, 4, 4)
tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
which has shape (2, 4)
## Args:
* <b>`input`</b>: A `Tensor`. Rank `k` tensor where `k >= 2`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`.
The extracted diagonal(s) having shape
`diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
- - -
`tf.matrix_band_part(input, num_lower, num_upper, name=None)` {#matrix_band_part}
Copy a tensor setting everything outside a central band in each innermost matrix
to zero.
The `band` part is computed as follows:
Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
tensor with the same shape where
`band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
The indicator function
`in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
(num_upper < 0 || (n-m) <= num_upper)`.
For example:
prettyprint
# if 'input' is [[ 0, 1, 2, 3]
[-1, 0, 1, 2]
[-2, -1, 0, 1]
[-3, -2, -1, 0]],
tf.matrix_band_part(input, 1, -1) ==> [[ 0, 1, 2, 3]
[-1, 0, 1, 2]
[ 0, -1, 0, 1]
[ 0, 0, -1, 0]],
tf.matrix_band_part(input, 2, 1) ==> [[ 0, 1, 0, 0]
[-1, 0, 1, 0]
[-2, -1, 0, 1]
[ 0, -2, -1, 0]]
Useful special cases:
prettyprint
tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
tf.matrix_band_part(input, 0, 0) ==> Diagonal.
## Args:
* <b>`input`</b>: A `Tensor`. Rank `k` tensor.
* <b>`num_lower`</b>: A `Tensor` of type `int64`.
0-D tensor. Number of subdiagonals to keep. If negative, keep entire
lower triangle.
* <b>`num_upper`</b>: A `Tensor` of type `int64`.
0-D tensor. Number of superdiagonals to keep. If negative, keep
entire upper triangle.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`.
Rank `k` tensor of the same shape as input. The extracted banded tensor.
- - -
`tf.matrix_set_diag(input, diagonal, name=None)` {#matrix_set_diag}
Returns a batched matrix tensor with new batched diagonal values.
Given `input` and `diagonal`, this operation returns a tensor with the
same shape and values as `input`, except for the main diagonal of the
innermost matrices. These will be overwritten by the values in `diagonal`.
The output is computed as follows:
Assume `input` has `k+1` dimensions `[I, J, K, ..., M, N]` and `diagonal` has
`k` dimensions `[I, J, K, ..., min(M, N)]`. Then the output is a
tensor of rank `k+1` with dimensions `[I, J, K, ..., M, N]` where:
* `output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n]` for `m == n`.
* `output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n]` for `m != n`.
## Args:
* <b>`input`</b>: A `Tensor`. Rank `k+1`, where `k >= 1`.
* <b>`diagonal`</b>: A `Tensor`. Must have the same type as `input`.
Rank `k`, where `k >= 1`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`.
Rank `k+1`, with `output.shape = input.shape`.
- - -
`tf.matrix_transpose(a, name='matrix_transpose')` {#matrix_transpose}
Transposes last two dimensions of tensor `a`.
For example:
python
# Matrix with no batch dimension.
# 'x' is [[1 2 3]
# [4 5 6]]
tf.matrix_transpose(x) ==> [[1 4]
[2 5]
[3 6]]
# Matrix with two batch dimensions.
# x.shape is [1, 2, 3, 4]
# tf.matrix_transpose(x) is shape [1, 2, 4, 3]
## Args:
* <b>`a`</b>: A `Tensor` with `rank >= 2`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A transposed batch matrix `Tensor`.
## Raises:
* <b>`ValueError`</b>: If `a` is determined statically to have `rank < 2`.
- - -
`tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)` {#matmul}
Multiplies matrix `a` by matrix `b`, producing `a` * `b`.
The inputs must be matrices (or tensors of rank > 2, representing batches of
matrices), with matching inner dimensions, possibly after transposition.
Both matrices must be of the same type. The supported types are:
`float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.
Either matrix can be transposed or adjointed (conjugated and transposed) on
the fly by setting one of the corresponding flag to `True`. These are `False`
by default.
If one or both of the matrices contain a lot of zeros, a more efficient
multiplication algorithm can be used by setting the corresponding
`a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.
This optimization is only available for plain matrices (rank-2 tensors) with
datatypes `bfloat16` or `float32`.
For example:
python
# 2-D tensor `a`
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) => [[1. 2. 3.]
[4. 5. 6.]]
# 2-D tensor `b`
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2]) => [[7. 8.]
[9. 10.]
[11. 12.]]
c = tf.matmul(a, b) => [[58 64]
[139 154]]
# 3-D tensor `a`
a = tf.constant(np.arange(1,13), shape=[2, 2, 3]) => [[[ 1. 2. 3.]
[ 4. 5. 6.]],
[[ 7. 8. 9.]
[10. 11. 12.]]]
# 3-D tensor `b`
b = tf.constant(np.arange(13,25), shape=[2, 3, 2]) => [[[13. 14.]
[15. 16.]
[17. 18.]],
[[19. 20.]
[21. 22.]
[23. 24.]]]
c = tf.matmul(a, b) => [[[ 94 100]
[229 244]],
[[508 532]
[697 730]]]
## Args:
* <b>`a`</b>: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,
`complex128` and rank > 1.
* <b>`b`</b>: `Tensor` with same type and rank as `a`.
* <b>`transpose_a`</b>: If `True`, `a` is transposed before multiplication.
* <b>`transpose_b`</b>: If `True`, `b` is transposed before multiplication.
* <b>`adjoint_a`</b>: If `True`, `a` is conjugated and transposed before
multiplication.
* <b>`adjoint_b`</b>: If `True`, `b` is conjugated and transposed before
multiplication.
* <b>`a_is_sparse`</b>: If `True`, `a` is treated as a sparse matrix.
* <b>`b_is_sparse`</b>: If `True`, `b` is treated as a sparse matrix.
* <b>`name`</b>: Name for the operation (optional).
## Returns:
A `Tensor` of the same type as `a` and `b` where each inner-most matrix is
the product of the corresponding matrices in `a` and `b, e.g. if all
transpose or adjoint attributes are `False`:
output[..., :, :] = a[..., :, :] * b[..., :, :] ,
## Raises:
* <b>`ValueError`</b>: If transpose_a and adjoint_a, or transpose_b and adjoint_b
are both set to True.
- - -
`tf.batch_matmul(x, y, adj_x=None, adj_y=None, name=None)` {#batch_matmul}
Multiplies slices of two tensors in batches.
Multiplies all slices of `Tensor` `x` and `y` (each slice can be
viewed as an element of a batch), and arranges the individual results
in a single output tensor of the same batch size. Each of the
individual slices can optionally be adjointed (to adjoint a matrix
means to transpose and conjugate it) before multiplication by setting
the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
The input tensors `x` and `y` are 3-D or higher with shape `[..., r_x, c_x]`
and `[..., r_y, c_y]`.
The output tensor is 3-D or higher with shape `[..., r_o, c_o]`, where:
r_o = c_x if adj_x else r_x
c_o = r_y if adj_y else c_y
It is computed as:
output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `complex64`, `complex128`.
3-D or higher with shape `[..., r_x, c_x]`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
3-D or higher with shape `[..., r_y, c_y]`.
* <b>`adj_x`</b>: An optional `bool`. Defaults to `False`.
If `True`, adjoint the slices of `x`. Defaults to `False`.
* <b>`adj_y`</b>: An optional `bool`. Defaults to `False`.
If `True`, adjoint the slices of `y`. Defaults to `False`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
3-D or higher with shape `[..., r_o, c_o]`
- - -
`tf.matrix_determinant(input, name=None)` {#matrix_determinant}
Computes the determinant of one ore more square matrices.
The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
form square matrices. The output is a tensor containing the determinants
for all input submatrices `[..., :, :]`.
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
Shape is `[..., M, M]`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`. Shape is `[...]`.
- - -
`tf.matrix_inverse(input, adjoint=None, name=None)` {#matrix_inverse}
Computes the inverse of one or more square invertible matrices or their
adjoints (conjugate transposes).
The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
form square matrices. The output is a tensor of the same shape as the input
containing the inverse for all input submatrices `[..., :, :]`.
The op uses LU decomposition with partial pivoting to compute the inverses.
If a matrix is not invertible there is no guarantee what the op does. It
may detect the condition and raise an exception or it may simply return a
garbage result.
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float64`, `float32`.
Shape is `[..., M, M]`.
* <b>`adjoint`</b>: An optional `bool`. Defaults to `False`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`. Shape is `[..., M, M]`.
@compatibility(numpy)
Equivalent to np.linalg.inv
@end_compatibility
- - -
`tf.cholesky(input, name=None)` {#cholesky}
Computes the Cholesky decomposition of one or more square matrices.
The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
form square matrices, with the same constraints as the single matrix Cholesky
decomposition above. The output is a tensor of the same shape as the input
containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float64`, `float32`.
Shape is `[..., M, M]`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `input`. Shape is `[..., M, M]`.
- - -
`tf.cholesky_solve(chol, rhs, name=None)` {#cholesky_solve}
Solves systems of linear eqns `A X = RHS`, given Cholesky factorizations.
python
# Solve 10 separate 2x2 linear systems:
A = ... # shape 10 x 2 x 2
RHS = ... # shape 10 x 2 x 1
chol = tf.cholesky(A) # shape 10 x 2 x 2
X = tf.cholesky_solve(chol, RHS) # shape 10 x 2 x 1
# tf.matmul(A, X) ~ RHS
X[3, :, 0] # Solution to the linear system A[3, :, :] x = RHS[3, :, 0]
# Solve five linear systems (K = 5) for every member of the length 10 batch.
A = ... # shape 10 x 2 x 2
RHS = ... # shape 10 x 2 x 5
X[3, :, 2] # Solution to the linear system A[3, :, :] x = RHS[3, :, 2]
## Args:
* <b>`chol`</b>: A `Tensor`. Must be `float32` or `float64`, shape is `[..., M, M]`.
Cholesky factorization of `A`, e.g. `chol = tf.cholesky(A)`.
For that reason, only the lower triangular parts (including the diagonal)
of the last two dimensions of `chol` are used. The strictly upper part is
assumed to be zero and not accessed.
* <b>`rhs`</b>: A `Tensor`, same type as `chol`, shape is `[..., M, K]`.
* <b>`name`</b>: A name to give this `Op`. Defaults to `cholesky_solve`.
## Returns:
Solution to `A x = rhs`, shape `[..., M, K]`.
- - -
`tf.matrix_solve(matrix, rhs, adjoint=None, name=None)` {#matrix_solve}
Solves systems of linear equations.
`Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
a tensor shape `[..., M, K]`. If `adjoint` is `False` then each output matrix
satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
If `adjoint` is `True` then each output matrix satisfies
`adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
## Args:
* <b>`matrix`</b>: A `Tensor`. Must be one of the following types: `float64`, `float32`, `complex64`, `complex128`.
Shape is `[..., M, M]`.
* <b>`rhs`</b>: A `Tensor`. Must have the same type as `matrix`.
Shape is `[..., M, K]`.
* <b>`adjoint`</b>: An optional `bool`. Defaults to `False`.
Boolean indicating whether to solve with `matrix` or its (block-wise)
adjoint.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `matrix`. Shape is `[..., M, K]`.
- - -
`tf.<API key>(matrix, rhs, lower=None, adjoint=None, name=None)` {#<API key>}
Solves systems of linear equations with upper or lower triangular matrices by
backsubstitution.
`matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
square matrices. If `lower` is `True` then the strictly upper triangular part
of each inner-most matrix is assumed to be zero and not accessed.
If `lower` is False then the strictly lower triangular part of each inner-most
matrix is assumed to be zero and not accessed.
`rhs` is a tensor of shape `[..., M, K]`.
The output is a tensor of shape `[..., M, K]`. If `adjoint` is
`True` then the innermost matrices in output` satisfy matrix equations
`matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
If `adjoint` is `False` then the strictly then the innermost matrices in
`output` satisfy matrix equations
`adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
## Args:
* <b>`matrix`</b>: A `Tensor`. Must be one of the following types: `float64`, `float32`.
Shape is `[..., M, M]`.
* <b>`rhs`</b>: A `Tensor`. Must have the same type as `matrix`.
Shape is `[..., M, K]`.
* <b>`lower`</b>: An optional `bool`. Defaults to `True`.
Boolean indicating whether the innermost matrices in `matrix` are
lower or upper triangular.
* <b>`adjoint`</b>: An optional `bool`. Defaults to `False`.
Boolean indicating whether to solve with `matrix` or its (block-wise)
adjoint.
@compatibility(numpy)
Equivalent to np.linalg.triangular_solve
@end_compatibility
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `matrix`. Shape is `[..., M, K]`.
- - -
`tf.matrix_solve_ls(matrix, rhs, l2_regularizer=0.0, fast=True, name=None)` {#matrix_solve_ls}
Solves one or more linear least-squares problems.
`matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
form `M`-by-`N` matrices. Rhs is a tensor of shape `[..., M, K]` whose
inner-most 2 dimensions form `M`-by-`K` matrices. The computed output is a
`Tensor` of shape `[..., N, K]` whose inner-most 2 dimensions form `M`-by-`K`
matrices that solve the equations
`matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]` in the least squares
sense.
Below we will use the following notation for each pair of matrix and
right-hand sides in the batch:
`matrix`=\\(A \in \Re^{m \times n}\\),
`rhs`=\\(B \in \Re^{m \times k}\\),
`output`=\\(X \in \Re^{n \times k}\\),
`l2_regularizer`=\\(\lambda\\).
If `fast` is `True`, then the solution is computed by solving the normal
equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
\\(X = (A^T A + \lambda I)^{-1} A^T B\\), which solves the least-squares
problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k}} ||A Z - B||_F^2 +
\lambda ||Z||_F^2\\). If \\(m \lt n\\) then `output` is computed as
\\(X = A^T (A A^T + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is
the minimum-norm solution to the under-determined linear system, i.e.
\\(X = \mathrm{argmin}_{Z \in \Re^{n \times k}} ||Z||_F^2 \\), subject to
\\(A Z = B\\). Notice that the fast path is only numerically stable when
\\(A\\) is numerically full rank and has a condition number
\\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach}}}\\) or\\(\lambda\\)
is sufficiently large.
If `fast` is `False` an algorithm based on the numerically robust complete
orthogonal decomposition is used. This computes the minimum-norm
least-squares solution, even when \\(A\\) is rank deficient. This path is
typically 6-7 times slower than the fast path. If `fast` is `False` then
`l2_regularizer` is ignored.
## Args:
* <b>`matrix`</b>: `Tensor` of shape `[..., M, N]`.
* <b>`rhs`</b>: `Tensor` of shape `[..., M, K]`.
* <b>`l2_regularizer`</b>: 0-D `double` `Tensor`. Ignored if `fast=False`.
* <b>`fast`</b>: bool. Defaults to `True`.
* <b>`name`</b>: string, optional name of the operation.
## Returns:
* <b>`output`</b>: `Tensor` of shape `[..., N, K]` whose inner-most 2 dimensions form
`M`-by-`K` matrices that solve the equations
`matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]` in the least
squares sense.
- - -
`tf.qr(input, full_matrices=None, name=None)` {
Computes the QR decompositions of one or more matrices.
Computes the QR decomposition of each inner matrix in `tensor` such that
`tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
prettyprint
# a is a tensor.
# q is a tensor of orthonormal matrices.
# r is a tensor of upper triangular matrices.
q, r = qr(a)
q_full, r_full = qr(a, full_matrices=True)
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float64`, `float32`, `complex64`, `complex128`.
A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
* <b>`full_matrices`</b>: An optional `bool`. Defaults to `False`.
If true, compute full-sized `q` and `r`. If false
(the default), compute only the leading `P` columns of `q`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A tuple of `Tensor` objects (q, r).
* <b>`q`</b>: A `Tensor`. Has the same type as `input`. Orthonormal basis for range of `a`. If `full_matrices` is `False` then
shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
`[..., M, M]`.
* <b>`r`</b>: A `Tensor`. Has the same type as `input`. Triangular factor. If `full_matrices` is `False` then shape is
`[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
- - -
`tf.self_adjoint_eig(tensor, name=None)` {#self_adjoint_eig}
Computes the eigen decomposition of a batch of self-adjoint matrices.
Computes the eigenvalues and eigenvectors of the innermost N-by-N matrices
in `tensor` such that
`tensor[...,:,:] * v[..., :,i] = e[..., i] * v[...,:,i]`, for i=0...N-1.
## Args:
* <b>`tensor`</b>: `Tensor` of shape `[..., N, N]`. Only the lower triangular part of
each inner inner matrix is referenced.
* <b>`name`</b>: string, optional name of the operation.
## Returns:
* <b>`e`</b>: Eigenvalues. Shape is `[..., N]`.
* <b>`v`</b>: Eigenvectors. Shape is `[..., N, N]`. The columns of the inner most
matrices contain eigenvectors of the corresponding matrices in `tensor`
- - -
`tf.<API key>(tensor, name=None)` {#<API key>}
Computes the eigenvalues of one or more self-adjoint matrices.
## Args:
* <b>`tensor`</b>: `Tensor` of shape `[..., N, N]`.
* <b>`name`</b>: string, optional name of the operation.
## Returns:
* <b>`e`</b>: Eigenvalues. Shape is `[..., N]`. The vector `e[..., :]` contains the `N`
eigenvalues of `tensor[..., :, :]`.
- - -
`tf.svd(tensor, full_matrices=False, compute_uv=True, name=None)` {#svd}
Computes the singular value decompositions of one or more matrices.
Computes the SVD of each inner matrix in `tensor` such that
`tensor[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :,
:])`
prettyprint
# a is a tensor.
# s is a tensor of singular values.
# u is a tensor of left singular vectors.
# v is a tensor of right singular vectors.
s, u, v = svd(a)
s = svd(a, compute_uv=False)
## Args:
* <b>`matrix`</b>: `Tensor` of shape `[..., M, N]`. Let `P` be the minimum of `M` and
`N`.
* <b>`full_matrices`</b>: If true, compute full-sized `u` and `v`. If false
(the default), compute only the leading `P` singular vectors.
Ignored if `compute_uv` is `False`.
* <b>`compute_uv`</b>: If `True` then left and right singular vectors will be
computed and returned in `u` and `v`, respectively. Otherwise, only the
singular values will be computed, which can be significantly faster.
* <b>`name`</b>: string, optional name of the operation.
## Returns:
* <b>`s`</b>: Singular values. Shape is `[..., P]`.
* <b>`u`</b>: Right singular vectors. If `full_matrices` is `False` (default) then
shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
`[..., M, M]`. Not returned if `compute_uv` is `False`.
* <b>`v`</b>: Left singular vectors. If `full_matrices` is `False` (default) then
shape is `[..., N, P]`. If `full_matrices` is `True` then shape is
`[..., N, N]`. Not returned if `compute_uv` is `False`.
## Complex Number Functions
TensorFlow provides several operations that you can use to add complex number
functions to your graph.
- - -
`tf.complex(real, imag, name=None)` {#complex}
Converts two real numbers to a complex number.
Given a tensor `real` representing the real part of a complex number, and a
tensor `imag` representing the imaginary part of a complex number, this
operation returns complex numbers elementwise of the form \(a + bj\), where
*a* represents the `real` part and *b* represents the `imag` part.
The input tensors `real` and `imag` must have the same shape.
For example:
# tensor 'real' is [2.25, 3.25]
# tensor `imag` is [4.75, 5.75]
tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
## Args:
* <b>`real`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`imag`</b>: A `Tensor`. Must have the same type as `real`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64` or `complex128`.
- - -
`tf.complex_abs(x, name=None)` {#complex_abs}
Computes the complex absolute value of a tensor.
Given a tensor `x` of complex numbers, this operation returns a tensor of type
`float32` or `float64` that is the absolute value of each element in `x`. All
elements in `x` must be complex numbers of the form \\(a + bj\\). The
absolute value is computed as \\( \sqrt{a^2 + b^2}\\).
For example:
# tensor 'x' is [[-2.25 + 4.75j], [-3.25 + 5.75j]]
tf.complex_abs(x) ==> [5.25594902, 6.60492229]
## Args:
* <b>`x`</b>: A `Tensor` of type `complex64` or `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `float32` or `float64`.
- - -
`tf.conj(x, name=None)` {#conj}
Returns the complex conjugate of a complex number.
Given a tensor `input` of complex numbers, this operation returns a tensor of
complex numbers that are the complex conjugate of each element in `input`. The
complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
real part and *b* is the imaginary part.
The complex conjugate returned by this operation is of the form \\(a - bj\\).
For example:
# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
If `x` is real, it is returned unchanged.
## Args:
* <b>`x`</b>: `Tensor` to conjugate. Must have numeric type.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` that is the conjugate of `x` (with the same type).
## Raises:
* <b>`TypeError`</b>: If `x` is not a numeric tensor.
- - -
`tf.imag(input, name=None)` {#imag}
Returns the imaginary part of a complex number.
Given a tensor `input` of complex numbers, this operation returns a tensor of
type `float32` or `float64` that is the imaginary part of each element in
`input`. All elements in `input` must be complex numbers of the form \(a +
bj\), where *a* is the real part and *b* is the imaginary part returned by
this operation.
For example:
# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.imag(input) ==> [4.75, 5.75]
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `complex64`,
`complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `float32` or `float64`.
- - -
`tf.real(input, name=None)` {#real}
Returns the real part of a complex number.
Given a tensor `input` of complex numbers, this operation returns a tensor of
type `float32` or `float64` that is the real part of each element in `input`.
All elements in `input` must be complex numbers of the form \(a + bj\),
where *a* is the real part returned by this operation and *b* is the
imaginary part.
For example:
# tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.real(input) ==> [-2.25, 3.25]
If `input` is already real, it is returned unchanged.
## Args:
* <b>`input`</b>: A `Tensor`. Must have numeric type.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `float32` or `float64`.
## Fourier Transform Functions
TensorFlow provides several operations that you can use to add discrete
Fourier transform functions to your graph.
- - -
`tf.fft(input, name=None)` {#fft}
Compute the 1-dimensional discrete Fourier Transform over the inner-most
dimension of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most
dimension of `input` is replaced with its 1D Fourier Transform.
- - -
`tf.ifft(input, name=None)` {#ifft}
Compute the inverse 1-dimensional discrete Fourier Transform over the inner-most
dimension of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most
dimension of `input` is replaced with its inverse 1D Fourier Transform.
- - -
`tf.fft2d(input, name=None)` {#fft2d}
Compute the 2-dimensional discrete Fourier Transform over the inner-most
2 dimensions of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most 2
dimensions of `input` are replaced with their 2D Fourier Transform.
@compatibility(numpy)
Equivalent to np.fft2
@end_compatibility
- - -
`tf.ifft2d(input, name=None)` {#ifft2d}
Compute the inverse 2-dimensional discrete Fourier Transform over the inner-most
2 dimensions of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most 2
dimensions of `input` are replaced with their inverse 2D Fourier Transform.
@compatibility(numpy)
Equivalent to np.ifft2
@end_compatibility
- - -
`tf.fft3d(input, name=None)` {#fft3d}
Compute the 3-dimensional discrete Fourier Transform over the inner-most 3
dimensions of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most 3
dimensions of `input` are replaced with their 3D Fourier Transform.
@compatibility(numpy)
Equivalent to np.fft3
@end_compatibility
- - -
`tf.ifft3d(input, name=None)` {#ifft3d}
Compute the inverse 3-dimensional discrete Fourier Transform over the inner-most
3 dimensions of `input`.
## Args:
* <b>`input`</b>: A `Tensor` of type `complex64`. A complex64 tensor.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `complex64`.
A complex64 tensor of the same shape as `input`. The inner-most 3
dimensions of `input` are replaced with their inverse 3D Fourier Transform.
@compatibility(numpy)
Equivalent to np.fft3
@end_compatibility
## Reduction
TensorFlow provides several operations that you can use to perform
common math computations that reduce various dimensions of a tensor.
- - -
`tf.reduce_sum(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_sum}
Computes the sum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
For example:
python
# 'x' is [[1, 1, 1]
# [1, 1, 1]]
tf.reduce_sum(x) ==> 6
tf.reduce_sum(x, 0) ==> [2, 2, 2]
tf.reduce_sum(x, 1) ==> [3, 3]
tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
tf.reduce_sum(x, [0, 1]) ==> 6
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.sum
@end_compatibility
- - -
`tf.reduce_prod(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_prod}
Computes the product of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.prod
@end_compatibility
- - -
`tf.reduce_min(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_min}
Computes the minimum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.min
@end_compatibility
- - -
`tf.reduce_max(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_max}
Computes the maximum of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.max
@end_compatibility
- - -
`tf.reduce_mean(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_mean}
Computes the mean of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
For example:
python
# 'x' is [[1., 1.]
# [2., 2.]]
tf.reduce_mean(x) ==> 1.5
tf.reduce_mean(x, 0) ==> [1.5, 1.5]
tf.reduce_mean(x, 1) ==> [1., 2.]
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.mean
@end_compatibility
- - -
`tf.reduce_all(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_all}
Computes the "logical and" of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
For example:
python
# 'x' is [[True, True]
# [False, False]]
tf.reduce_all(x) ==> False
tf.reduce_all(x, 0) ==> [False, False]
tf.reduce_all(x, 1) ==> [True, False]
## Args:
* <b>`input_tensor`</b>: The boolean tensor to reduce.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.all
@end_compatibility
- - -
`tf.reduce_any(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_any}
Computes the "logical or" of elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
For example:
python
# 'x' is [[True, True]
# [False, False]]
tf.reduce_any(x) ==> True
tf.reduce_any(x, 0) ==> [True, True]
tf.reduce_any(x, 1) ==> [True, False]
## Args:
* <b>`input_tensor`</b>: The boolean tensor to reduce.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
@compatibility(numpy)
Equivalent to np.any
@end_compatibility
- - -
`tf.reduce_logsumexp(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)` {#reduce_logsumexp}
Computes log(sum(exp(elements across dimensions of a tensor))).
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
This function is more numerically stable than log(sum(exp(input))). It avoids
overflows caused by taking the exp of large inputs and underflows caused by
taking the log of small inputs.
For example:
python
# 'x' is [[0, 0, 0]]
# [0, 0, 0]]
tf.reduce_logsumexp(x) ==> log(6)
tf.reduce_logsumexp(x, 0) ==> [log(2), log(2), log(2)]
tf.reduce_logsumexp(x, 1) ==> [log(3), log(3)]
tf.reduce_logsumexp(x, 1, keep_dims=True) ==> [[log(3)], [log(3)]]
tf.reduce_logsumexp(x, [0, 1]) ==> log(6)
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should have numeric type.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor.
- - -
`tf.count_nonzero(input_tensor, axis=None, keep_dims=False, dtype=tf.int64, name=None, reduction_indices=None)` {#count_nonzero}
Computes number of nonzero elements across dimensions of a tensor.
Reduces `input_tensor` along the dimensions given in `axis`.
Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each
entry in `axis`. If `keep_dims` is true, the reduced dimensions
are retained with length 1.
If `axis` has no entries, all dimensions are reduced, and a
tensor with a single element is returned.
**NOTE** Floating point comparison to zero is done by exact floating point
equality check. Small values are **not** rounded to zero for purposes of
the nonzero check.
For example:
python
# 'x' is [[0, 1, 0]
# [1, 1, 0]]
tf.count_nonzero(x) ==> 3
tf.count_nonzero(x, 0) ==> [1, 2, 0]
tf.count_nonzero(x, 1) ==> [1, 2]
tf.count_nonzero(x, 1, keep_dims=True) ==> [[1], [2]]
tf.count_nonzero(x, [0, 1]) ==> 3
## Args:
* <b>`input_tensor`</b>: The tensor to reduce. Should be of numeric type, or `bool`.
* <b>`axis`</b>: The dimensions to reduce. If `None` (the default),
reduces all dimensions.
* <b>`keep_dims`</b>: If true, retains reduced dimensions with length 1.
* <b>`dtype`</b>: The output dtype; defaults to `tf.int64`.
* <b>`name`</b>: A name for the operation (optional).
* <b>`reduction_indices`</b>: The old (deprecated) name for axis.
## Returns:
The reduced tensor (number of nonzero values).
- - -
`tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)` {#accumulate_n}
Returns the element-wise sum of a list of tensors.
Optionally, pass `shape` and `tensor_dtype` for shape and type checking,
otherwise, these are inferred.
NOTE: This operation is not differentiable and cannot be used if inputs depend
on trainable variables. Please use `tf.add_n` for such cases.
For example:
python
# tensor 'a' is [[1, 2], [3, 4]]
# tensor `b` is [[5, 0], [0, 6]]
tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]
# Explicitly pass shape and type
tf.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)
==> [[7, 4], [6, 14]]
## Args:
* <b>`inputs`</b>: A list of `Tensor` objects, each with same shape and type.
* <b>`shape`</b>: Shape of elements of `inputs`.
* <b>`tensor_dtype`</b>: The type of `inputs`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of same shape and type as the elements of `inputs`.
## Raises:
* <b>`ValueError`</b>: If `inputs` don't all have same shape and dtype or the shape
cannot be inferred.
- - -
`tf.einsum(equation, *inputs)` {#einsum}
A generalized contraction between tensors of arbitrary dimension.
This function returns a tensor whose elements are defined by `equation`,
which is written in a shorthand form inspired by the Einstein summation
convention. As an example, consider multiplying two matrices
A and B to form a matrix C. The elements of C are given by:
C[i,k] = sum_j A[i,j] * B[j,k]
The corresponding `equation` is:
ij,jk->ik
In general, the `equation` is obtained from the more familiar element-wise
equation by
1. removing variable names, brackets, and commas,
2. replacing "*" with ",",
3. dropping summation signs, and
4. moving the output to the right, and replacing "=" with "->".
Many common operations can be expressed in this way. For example:
# Matrix multiplication
einsum('ij,jk->ik', m0, m1) # output[i,k] = sum_j m0[i,j] * m1[j, k]
# Dot product
einsum('i,i->', u, v) # output = sum_i u[i]*v[i]
# Outer product
einsum('i,j->ij', u, v) # output[i,j] = u[i]*v[j]
# Transpose
einsum('ij->ji', m) # output[j,i] = m[i,j]
# Batch matrix multiplication
einsum('aij,ajk->aik', s, t) # out[a,i,k] = sum_j s[a,i,j] * t[a, j, k]
This function behaves like `numpy.einsum`, but does not support:
* Ellipses (subscripts like `ij...,jk...->ik...`)
* Subscripts where an axis appears more than once for a single input
(e.g. `ijj,k->ik`).
* Subscripts that are summed across multiple inputs (e.g., `ij,ij,jk->ik`).
## Args:
* <b>`equation`</b>: a `str` describing the contraction, in the same format as
`numpy.einsum`.
* <b>`inputs`</b>: the inputs to contract (each one a `Tensor`), whose shapes should
be consistent with `equation`.
## Returns:
The contracted `Tensor`, with shape determined by `equation`.
## Raises:
* <b>`ValueError`</b>: If
- the format of `equation` is incorrect,
- the number of inputs implied by `equation` does not match `len(inputs)`,
- an axis appears in the output subscripts but not in any of the inputs,
- the number of dimensions of an input differs from the number of
indices in its subscript, or
- the input shapes are inconsistent along a particular axis.
## Scan
TensorFlow provides several operations that you can use to perform scans
(running totals) across one axis of a tensor.
- - -
`tf.cumsum(x, axis=0, exclusive=False, reverse=False, name=None)` {#cumsum}
Compute the cumulative sum of the tensor `x` along `axis`.
By default, this op performs an inclusive cumsum, which means that the first
element of the input is identical to the first element of the output:
prettyprint
tf.cumsum([a, b, c]) ==> [a, a + b, a + b + c]
By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed
instead:
prettyprint
tf.cumsum([a, b, c], exclusive=True) ==> [0, a, a + b]
By setting the `reverse` kwarg to `True`, the cumsum is performed in the
opposite direction:
prettyprint
tf.cumsum([a, b, c], reverse=True) ==> [a + b + c, b + c, c]
This is more efficient than using separate `tf.reverse` ops.
The `reverse` and `exclusive` kwargs can also be combined:
prettyprint
tf.cumsum([a, b, c], exclusive=True, reverse=True) ==> [b + c, c, 0]
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`,
`int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
`complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`axis`</b>: A `Tensor` of type `int32` (default: 0).
* <b>`reverse`</b>: A `bool` (default: False).
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.cumprod(x, axis=0, exclusive=False, reverse=False, name=None)` {#cumprod}
Compute the cumulative product of the tensor `x` along `axis`.
By default, this op performs an inclusive cumprod, which means that the
first
element of the input is identical to the first element of the output:
prettyprint
tf.cumprod([a, b, c]) ==> [a, a * b, a * b * c]
By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
performed
instead:
prettyprint
tf.cumprod([a, b, c], exclusive=True) ==> [1, a, a * b]
By setting the `reverse` kwarg to `True`, the cumprod is performed in the
opposite direction:
prettyprint
tf.cumprod([a, b, c], reverse=True) ==> [a * b * c, b * c, c]
This is more efficient than using separate `tf.reverse` ops.
The `reverse` and `exclusive` kwargs can also be combined:
prettyprint
tf.cumprod([a, b, c], exclusive=True, reverse=True) ==> [b * c, c, 1]
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`,
`int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
`complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`axis`</b>: A `Tensor` of type `int32` (default: 0).
* <b>`reverse`</b>: A `bool` (default: False).
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
## Segmentation
TensorFlow provides several operations that you can use to perform common
math computations on tensor segments.
Here a segmentation is a partitioning of a tensor along
the first dimension, i.e. it defines a mapping from the first dimension onto
`segment_ids`. The `segment_ids` tensor should be the size of
the first dimension, `d0`, with consecutive IDs in the range `0` to `k`,
where `k<d0`.
In particular, a segmentation of a matrix tensor is a mapping of rows to
segments.
For example:
python
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf.segment_sum(c, tf.constant([0, 0, 1]))
==> [[0 0 0 0]
[5 6 7 8]]
- - -
`tf.segment_sum(data, segment_ids, name=None)` {#segment_sum}
Computes the sum along segments of a tensor.
Read [the section on Segmentation](../../api_docs/python/math_ops.md#segmentation)
for an explanation of segments.
Computes a tensor such that
\\(output_i = \sum_j data_j\\) where sum is over `j` such
that `segment_ids[j] == i`.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/SegmentSum.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor whose rank is equal to the rank of `data`'s
first dimension. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.segment_prod(data, segment_ids, name=None)` {#segment_prod}
Computes the product along segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Computes a tensor such that
\\(output_i = \prod_j data_j\\) where the product is over `j` such
that `segment_ids[j] == i`.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/SegmentProd.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor whose rank is equal to the rank of `data`'s
first dimension. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.segment_min(data, segment_ids, name=None)` {#segment_min}
Computes the minimum along segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Computes a tensor such that
\\(output_i = \min_j(data_j)\\) where `min` is over `j` such
that `segment_ids[j] == i`.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/SegmentMin.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor whose rank is equal to the rank of `data`'s
first dimension. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.segment_max(data, segment_ids, name=None)` {#segment_max}
Computes the maximum along segments of a tensor.
Read [the section on Segmentation](../../api_docs/python/math_ops.md#segmentation)
for an explanation of segments.
Computes a tensor such that
\\(output_i = \max_j(data_j)\\) where `max` is over `j` such
that `segment_ids[j] == i`.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/SegmentMax.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor whose rank is equal to the rank of `data`'s
first dimension. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.segment_mean(data, segment_ids, name=None)` {#segment_mean}
Computes the mean along segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Computes a tensor such that
\\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
over `j` such that `segment_ids[j] == i` and `N` is the total number of
values summed.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/SegmentMean.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor whose rank is equal to the rank of `data`'s
first dimension. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.<API key>(data, segment_ids, num_segments, name=None)` {#<API key>}
Computes the sum along segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Computes a tensor such that
`(output[i] = sum_{j...} data[j...]` where the sum is over tuples `j...` such
that `segment_ids[j...] == i`. Unlike `SegmentSum`, `segment_ids`
need not be sorted and need not cover all values in the full
range of valid values.
If the sum is empty for a given segment ID `i`, `output[i] = 0`.
`num_segments` should equal the number of distinct segment IDs.
<div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
<img style="width:100%" src="../../images/UnsortedSegmentSum.png" alt>
</div>
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`segment_ids`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A tensor whose shape is a prefix of `data.shape`.
* <b>`num_segments`</b>: A `Tensor` of type `int32`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for the first `segment_ids.rank`
dimensions, which are replaced with a single dimension which has size
`num_segments`.
- - -
`tf.sparse_segment_sum(data, indices, segment_ids, name=None)` {#sparse_segment_sum}
Computes the sum along sparse segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
dimension, selecting a subset of dimension 0, specified by `indices`.
For example:
prettyprint
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
# Select two rows, one segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
==> [[0 0 0 0]]
# Select two rows, two segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
==> [[ 1 2 3 4]
[-1 -2 -3 -4]]
# Select all rows, two segments.
tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
==> [[0 0 0 0]
[5 6 7 8]]
# Which is equivalent to:
tf.segment_sum(c, tf.constant([0, 0, 1]))
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `int64`, `uint8`, `int16`, `int8`, `uint16`, `half`.
* <b>`indices`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor. Has same rank as `segment_ids`.
* <b>`segment_ids`</b>: A `Tensor` of type `int32`.
A 1-D tensor. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.sparse_segment_mean(data, indices, segment_ids, name=None)` {#sparse_segment_mean}
Computes the mean along sparse segments of a tensor.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
dimension, selecting a subset of dimension 0, specified by `indices`.
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`indices`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor. Has same rank as `segment_ids`.
* <b>`segment_ids`</b>: A `Tensor` of type `int32`.
A 1-D tensor. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
- - -
`tf.<API key>(data, indices, segment_ids, name=None)` {#<API key>}
Computes the sum along sparse segments of a tensor divided by the sqrt of N.
N is the size of the segment being reduced.
Read [the section on
Segmentation](../../api_docs/python/math_ops.md#segmentation) for an explanation
of segments.
## Args:
* <b>`data`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
* <b>`indices`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
A 1-D tensor. Has same rank as `segment_ids`.
* <b>`segment_ids`</b>: A `Tensor` of type `int32`.
A 1-D tensor. Values should be sorted and can be repeated.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `data`.
Has same shape as data, except for dimension 0 which
has size `k`, the number of segments.
## Sequence Comparison and Indexing
TensorFlow provides several operations that you can use to add sequence
comparison and index extraction to your graph. You can use these operations to
determine sequence differences and determine the indexes of specific values in
a tensor.
- - -
`tf.argmin(input, axis=None, name=None, dimension=None)` {#argmin}
Returns the index with the smallest value across axiss of a tensor.
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`axis`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
int32, 0 <= axis < rank(input). Describes which axis
of the input Tensor to reduce across. For vectors, use axis = 0.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `int64`.
- - -
`tf.argmax(input, axis=None, name=None, dimension=None)` {#argmax}
Returns the index with the largest value across axiss of a tensor.
## Args:
* <b>`input`</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`.
* <b>`axis`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`.
int32, 0 <= axis < rank(input). Describes which axis
of the input Tensor to reduce across. For vectors, use axis = 0.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` of type `int64`.
- - -
`tf.setdiff1d(x, y, index_dtype=tf.int32, name=None)` {#setdiff1d}
Computes the difference between two lists of numbers or strings.
Given a list `x` and a list `y`, this operation returns a list `out` that
represents all values that are in `x` but not in `y`. The returned list `out`
is sorted in the same order that the numbers appear in `x` (duplicates are
preserved). This operation also returns a list `idx` that represents the
position of each `out` element in `x`. In other words:
`out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
For example, given this input:
prettyprint
x = [1, 2, 3, 4, 5, 6]
y = [1, 3, 5]
This operation would return:
prettyprint
out ==> [2, 4, 6]
idx ==> [1, 3, 5]
## Args:
* <b>`x`</b>: A `Tensor`. 1-D. Values to keep.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`. 1-D. Values to remove.
* <b>`out_idx`</b>: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int32`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A tuple of `Tensor` objects (out, idx).
* <b>`out`</b>: A `Tensor`. Has the same type as `x`. 1-D. Values present in `x` but not in `y`.
* <b>`idx`</b>: A `Tensor` of type `out_idx`. 1-D. Positions of `x` values preserved in `out`.
- - -
`tf.where(condition, x=None, y=None, name=None)` {#where}
Return the elements, either from `x` or `y`, depending on the `condition`.
If both `x` and `y` are None, then this operation returns the coordinates of
true elements of `condition`. The coordinates are returned in a 2-D tensor
where the first dimension (rows) represents the number of true elements, and
the second dimension (columns) represents the coordinates of the true
elements. Keep in mind, the shape of the output tensor can vary depending on
how many true values there are in input. Indices are output in row-major
order.
If both non-None, `x` and `y` must have the same shape.
The `condition` tensor must be a scalar if `x` and `y` are scalar.
If `x` and `y` are vectors or higher rank, then `condition` must be either a
vector with size matching the first dimension of `x`, or must have the same
shape as `x`.
The `condition` tensor acts as a mask that chooses, based on the value at each
element, whether the corresponding element / row in the output should be taken
from `x` (if true) or `y` (if false).
If `condition` is a vector and `x` and `y` are higher rank matrices, then it
chooses which row (outer dimension) to copy from `x` and `y`. If `condition`
has the same shape as `x` and `y`, then it chooses which element to copy from
`x` and `y`.
## Args:
* <b>`condition`</b>: A `Tensor` of type `bool`
* <b>`x`</b>: A Tensor which may have the same shape as `condition`. If `condition` is
rank 1, `x` may have higher rank, but its first dimension must match the
size of `condition`.
* <b>`y`</b>: A `tensor` with the same shape and type as `x`.
* <b>`name`</b>: A name of the operation (optional)
## Returns:
A `Tensor` with the same type and shape as `x`, `y` if they are non-None.
A `Tensor` with shape `(num_true, dim_size(condition))`.
## Raises:
* <b>`ValueError`</b>: When exactly one of `x` or `y` is non-None.
- - -
`tf.unique(x, out_idx=None, name=None)` {#unique}
Finds unique elements in a 1-D tensor.
This operation returns a tensor `y` containing all of the unique elements of `x`
sorted in the same order that they occur in `x`. This operation also returns a
tensor `idx` the same size as `x` that contains the index of each value of `x`
in the unique output `y`. In other words:
`y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
For example:
prettyprint
# tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
y, idx = unique(x)
y ==> [1, 2, 4, 7, 8]
idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
## Args:
* <b>`x`</b>: A `Tensor`. 1-D.
* <b>`out_idx`</b>: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int32`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A tuple of `Tensor` objects (y, idx).
* <b>`y`</b>: A `Tensor`. Has the same type as `x`. 1-D.
* <b>`idx`</b>: A `Tensor` of type `out_idx`. 1-D.
- - -
`tf.edit_distance(hypothesis, truth, normalize=True, name='edit_distance')` {#edit_distance}
Computes the Levenshtein distance between sequences.
This operation takes variable-length sequences (`hypothesis` and `truth`),
each provided as a `SparseTensor`, and computes the Levenshtein distance.
You can normalize the edit distance by length of `truth` by setting
`normalize` to true.
For example, given the following input:
python
# 'hypothesis' is a tensor of shape `[2, 1]` with variable-length values:
# (0,0) = ["a"]
# (1,0) = ["b"]
hypothesis = tf.SparseTensor(
[[0, 0, 0],
[1, 0, 0]],
["a", "b"]
(2, 1, 1))
# 'truth' is a tensor of shape `[2, 2]` with variable-length values:
# (0,1) = ["a"]
# (1,0) = ["b", "c"]
# (1,1) = ["a"]
truth = tf.SparseTensor(
[[0, 1, 0],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0]]
["a", "b", "c", "a"],
(2, 2, 2))
normalize = True
This operation would return the following:
python
# 'output' is a tensor of shape `[2, 2]` with edit distances normalized
# by 'truth' lengths.
output ==> [[inf, 1.0], # (0,0): no truth, (0,1): no hypothesis
[0.5, 1.0]] # (1,0): addition, (1,1): no hypothesis
## Args:
* <b>`hypothesis`</b>: A `SparseTensor` containing hypothesis sequences.
* <b>`truth`</b>: A `SparseTensor` containing truth sequences.
* <b>`normalize`</b>: A `bool`. If `True`, normalizes the Levenshtein distance by
length of `truth.`
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A dense `Tensor` with rank `R - 1`, where R is the rank of the
`SparseTensor` inputs `hypothesis` and `truth`.
## Raises:
* <b>`TypeError`</b>: If either `hypothesis` or `truth` are not a `SparseTensor`.
- - -
`tf.invert_permutation(x, name=None)` {#invert_permutation}
Computes the inverse permutation of a tensor.
This operation computes the inverse of an index permutation. It takes a 1-D
integer tensor `x`, which represents the indices of a zero-based array, and
swaps each value with its index position. In other words, for an output tensor
`y` and an input tensor `x`, this operation computes the following:
`y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
The values must include 0. There can be no duplicate values or negative values.
For example:
prettyprint
# tensor `x` is [3, 4, 0, 2, 1]
invert_permutation(x) ==> [2, 4, 3, 0, 1]
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `int32`, `int64`. 1-D.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`. 1-D.
## Other Functions and Classes
- - -
`tf.mul(x, y, name=None)` {#mul}
Returns x * y element-wise.
*NOTE*: `Mul` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
- - -
`tf.neg(x, name=None)` {#neg}
Computes numerical negative value element-wise.
I.e., \(y = -x\).
## Args:
* <b>`x`</b>: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`,
`float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`.
- - -
`tf.sub(x, y, name=None)` {#sub}
Returns x - y element-wise.
*NOTE*: `Sub` supports broadcasting. More about broadcasting
[here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
## Args:
* <b>`x`</b>: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`.
* <b>`y`</b>: A `Tensor`. Must have the same type as `x`.
* <b>`name`</b>: A name for the operation (optional).
## Returns:
A `Tensor`. Has the same type as `x`.
|
/* globals utils */
// Run after the DOM loads
$(function () {
'use strict';
function lineAccessor(data, index) {
return data.data;
}
function positionAccessor(data, index) {
return {x: data[0], y: data[1]};
}
// Get query parameters
var query = utils.getQuery();
// Create a map centered on Clifton Park, NY
var map = geo.map({
node: '#map',
center: {
x: -73.7593015,
y: 42.8496799
},
zoom: 11
});
var osm, mapUrl, layer, lineFeature, lines, rawdata, reduceddata, skipdraw,
lastSimplifyZoom, resimplifyTimeout;
// By default, use the best renderer that supports lines. This can be
// changed on with the 'renderer' query parameter to force a particular
// renderer
var layerOptions = {
renderer: query.renderer ? (query.renderer === 'html' ? null : query.renderer) : undefined,
features: query.renderer ? undefined : ['line']
};
// Defaults for the line controls
var defaultStyles = {
antialiasing: 2,
lineCap: 'butt',
lineJoin: 'miter',
miterLimit: 10,
strokeColor: 'black',
strokeOffset: 0,
strokeOpacity: 1,
strokeWidth: 2
};
var lineOptions = {
style: $.extend({
// Our data set is a set of lines, some of which form closed loops. If
// a line is a series of points where the first and last point coincide,
// flag it as closed so that the end is properly mitered
closed: function (line, idx) {
return (line.data[0][0] === line.data[line.data.length - 1][0] &&
line.data[0][1] === line.data[line.data.length - 1][1]);
},
// If the query parameter 'debug=true' is added, pixels visited and
// discarded by the fragment shader will appear in red. This slows down
// rendering
debug: query.debug ? query.debug === 'true' : undefined
}, defaultStyles)
};
// Parse query parameters and adjust styles to match
$.each(query, function (key, value) {
var ctlvalue, ctlkey = key;
switch (key) {
case 'antialiasing':
value = value.length ? parseFloat(value) : undefined;
if (!isNaN(value) && value >= 0 && value !== undefined) {
lineOptions.style[key] = ctlvalue = value;
}
break;
case 'hovertext':
ctlvalue = value === 'true';
lineOptions.selectionAPI = value;
break;
case 'lineCap':
case 'lineJoin':
case 'strokeColor':
case 'strokeOffset':
case 'strokeOpacity':
case 'strokeWidth':
lineOptions.style[key] = getStyle(key, value);
ctlvalue = value;
break;
case 'lines':
if (value.length) {
lines = ctlvalue = parseInt(value, 10);
}
break;
case 'miterLimit':
value = value.length ? parseFloat(value) : undefined;
if (!isNaN(value) && value > 0 && value !== undefined) {
lineOptions.style[key] = ctlvalue = value;
}
break;
case 'resimplify':
case 'showmap':
case 'simplify':
ctlvalue = value !== 'false';
break;
case 'resimplify_delay':
ctlvalue = value.length ? parseInt(value) : undefined;
break;
case 'simplify_tolerance':
ctlvalue = value.length ? parseFloat(value) : undefined;
break;
}
if (ctlvalue !== undefined) {
if ($('#' + ctlkey).is('[type="checkbox"]')) {
$('#' + ctlkey).prop('checked', ctlvalue);
} else {
$('#' + ctlkey).val(ctlvalue);
}
}
});
// When a preset button is clicked, show the preset.
$('button.preset').on('click', select_preset);
/**
* Based on the current controls, fetch a data set and show it.
*/
function fetch_data() {
var url = '../../data/roads.json';
$.ajax(url, {
success: function (resp) {
window.example.rawdata = rawdata = resp;
var segments = 0;
for (var i = 0; i < rawdata.length; i += 1) {
segments += rawdata[i].data.length - 1;
}
var text = 'Loaded: ' + segments;
$('#lines-loaded').text(text).attr('title', text);
show_lines(rawdata);
}
});
}
/**
* Given a set of lines, optionally truncate or expand it, then show it as a
* lineFeature.
*
* @param {array} rawdata An array of lines to show. Each entry contains an
* object that has a 'data' element which is an array of points that form
* the line.
* @param {boolean} [simplify] If present, use this as the flag to decide if
* lines should be simplified.
*/
function show_lines(rawdata, simplify) {
$('#map').removeClass('ready').attr('segments', '');
if (!rawdata) {
return;
}
// The number of lines specified in the control is used to determine the
// number of line segments that are shown. Since lines can be composed of
// any number of segments, we have to keep a tally.
var maxsegments = parseInt(lines, 10) || 10000, numlines, segments = 0;
for (numlines = 0; numlines < rawdata.length && segments < maxsegments; numlines += 1) {
segments += rawdata[numlines].data.length - 1;
}
reduceddata = rawdata.slice(0, numlines);
if (simplify === undefined) {
simplify = query.simplify;
}
if (!simplify || simplify === 'false') {
// set the data, and reset the line and position accessors in case we
// changed them with the line simplication
lineFeature.data(reduceddata)
.line(lineAccessor)
.position(positionAccessor);
lineFeature.draw();
$('#simple-lines-shown').text('').attr('title', '');
} else {
simplify_lines(reduceddata);
}
var text = 'Shown: ' + segments;
$('#lines-shown').text(text).attr('title', text);
map.onIdle(function () {
$('#map').addClass('ready').attr('segments', maxsegments);
});
}
/**
* When the map is zoomed, if resimplifying lines is active, set a timer to
* do so after the currently specified delay.
*
* @param {geo.event} evt geojs event that triggered this call.
*/
function resimplifyOnZoom(evt) {
if (resimplifyTimeout) {
window.cancelTimeout(resimplifyTimeout);
resimplifyTimeout = null;
}
if (!query.simplify || query.simplify === 'false' ||
!query.resimplify || query.resimplify === 'false') {
return;
}
resimplifyTimeout = window.setTimeout(function () {
resimplifyTimeout = null;
if (map.zoom() !== lastSimplifyZoom) {
simplify_lines(reduceddata);
}
}, parseInt(query.resimplify_delay, 10) || 500);
}
/**
* Simplify lines based on the current zoom level.
*
* @param {array} data The data to simplify.
* @param {number} [tolerance=query.simplify_tolerance] The tolerance in
* pixels at the current map zoom level.
*/
function simplify_lines(data, tolerance) {
if (!data) {
return;
}
lastSimplifyZoom = map.zoom();
if (resimplifyTimeout) {
window.cancelTimeout(resimplifyTimeout);
resimplifyTimeout = null;
}
tolerance = parseFloat(tolerance !== undefined ? tolerance : query.simplify_tolerance || 0.5);
lineFeature.rdpSimplifyData(
data,
map.unitsPerPixel(map.zoom()) * tolerance,
positionAccessor,
lineAccessor);
lineFeature.draw();
var segments = 0,
lineFunc = lineFeature.line();
lineFeature.data().forEach(function (d, i) {
var len = lineFunc(d, i).length;
segments += len >= 2 ? len - 1 : 0;
});
var text = 'Shown: ' + segments;
$('#simple-lines-shown').text(text).attr('title', text);
text = $('#lines-shown').text();
if (text.indexOf('Shown') === 0) {
text = 'Used' + text.substr(5);
$('#lines-shown').text(text).attr('title', text);
}
}
/**
* For styles that can vary, parse the string and either return a simple
* string or a function that computes the value.
*
* @param {string} key the property key. Used to get a default value if
* needed.
* @param {string} value the string form of the value. If this has a { in
* it, it is parsed as a JSON dictionary, and expects to be a list of
* category names which are used to determine the values. These values
* applied uniformly per line. Otherwise, if this has a , in it, it is a
* comma-separated list. If prefixed with 'line:' these are applied in a
* cycle across lines. Without that prefix, these are applied in a cycle
* across vertices. If neither { or , are in the value, then the value is
* used as is, uniformly.
* @return {string|function} the style string or function.
*/
function getStyle(key, value) {
if (value === undefined || value === null || value === '') {
return undefined;
}
value = '' + value;
if (value.indexOf('{') >= 0) {
try {
value = JSON.parse(value);
} catch (err) {
return value;
}
return function (d, i, line, idx) {
line = rawdata[idx];
if (value[line.highway] !== undefined) {
return value[line.highway];
}
return value.other !== undefined ? value.other : defaultStyles[key];
};
}
if (value.indexOf(',') >= 0) {
if (value.substr(0, 5) === 'line:') {
value = value.substr(5).split(',');
return function (d, i, line, idx) {
return value[idx % value.length];
};
} else {
value = value.split(',');
return function (d, i) {
return value[i % value.length];
};
}
}
return value;
}
/**
* Handle changes to our controls.
*
* @param {object} evt jquery event that triggered this call.
*/
function change_controls(evt) {
var ctl = $(evt.target),
param = ctl.attr('id'),
value = ctl.val();
if (ctl.is('[type="checkbox"]')) {
value = ctl.is(':checked') ? 'true' : 'false';
}
if (value === '' && ctl.attr('placeholder')) {
value = ctl.attr('placeholder');
}
if (!param || value === query[param]) {
return;
}
var processedValue = (
ctl.is('[type="checkbox"]') ? (value === 'true') : value);
if (ctl.closest('table.gradient').length) {
param = 'gradient';
}
switch (param) {
case 'antialiasing':
value = value.length ? parseFloat(value) : undefined;
if (isNaN(value) || value < 0 || value === undefined) {
return;
}
lineOptions.style[param] = value;
lineFeature.style(param, value);
if (!skipdraw) {
lineFeature.draw();
}
break;
case 'hovertext':
lineOptions.selectionAPI = processedValue;
lineFeature.selectionAPI(processedValue);
break;
case 'lineCap':
case 'lineJoin':
case 'strokeColor':
case 'strokeOffset':
case 'strokeOpacity':
case 'strokeWidth':
processedValue = getStyle(param, processedValue);
lineOptions.style[param] = processedValue;
lineFeature.style(param, processedValue);
if (!skipdraw) {
lineFeature.draw();
}
break;
case 'lines':
lines = parseInt(value);
show_lines(rawdata);
break;
case 'miterLimit':
value = value.length ? parseFloat(value) : undefined;
if (isNaN(value) || value <= 0 || value === undefined) {
return;
}
lineOptions.style[param] = value;
lineFeature.style(param, value);
if (!skipdraw) {
lineFeature.draw();
}
break;
case 'showmap':
set_osm_url(value);
break;
case 'simplify':
if (!processedValue) {
show_lines(rawdata, false);
} else {
simplify_lines(reduceddata);
}
break;
case 'simplify_tolerance':
processedValue = value.length ? parseFloat(value) : undefined;
if (query.simplify) {
simplify_lines(reduceddata, processedValue);
}
break;
case 'resimplify':
if (processedValue && query.simplify && query.simplify !== 'false' &&
map.zoom() !== lastSimplifyZoom) {
simplify_lines(reduceddata);
}
break;
case 'resimplify_delay':
break;
}
// Update the url to reflect the changes
query[param] = value;
if (value === '' || (ctl.attr('placeholder') &&
'' + value === ctl.attr('placeholder'))) {
delete query[param];
}
var newurl = window.location.protocol + '//' + window.location.host +
window.location.pathname + '?' + $.param(query);
window.history.replaceState(query, '', newurl);
}
/**
* Handle selecting a preset button.
*
* @param {object} evt jquery event with the triggered button.
*/
function select_preset(evt) {
var update;
var ctl = $(evt.target);
var keys = [
'antialiasing', 'lineCap', 'lineJoin', 'lines', 'miterLimit', 'showmap',
'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
skipdraw = true;
$.each(keys, function (idx, key) {
var value = ctl.attr(key);
if (value !== undefined && $('#' + key).val() !== value) {
if (key === 'showmap') {
$('
} else {
$('#' + key).val(value).trigger('change');
}
}
update = true;
});
skipdraw = false;
if (update) {
lineFeature.draw();
}
}
/**
* Set the map to either use the original default url or a blank white image.
*
* @param {string} value 'false' to use a white image, anything else to use
* the original url.
*/
function set_osm_url(value) {
if (!mapUrl) {
mapUrl = {url: osm.url(), attribution: osm.attribution()};
}
osm.url(
value !== 'false' ? mapUrl.url :
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVQI12P4DwABAQEAG7buVgAAAABJRU5ErkJggg==' /* white 1x1 */
);
osm.attribution(value !== 'false' ? mapUrl.attribution : '');
}
// Create a tile layer
osm = map.createLayer('osm', {url: query.url || undefined});
set_osm_url(query.showmap);
// Create a feature layer for the lines
layer = map.createLayer('feature', layerOptions);
// Create a tool-tip layer above the line layer
var uiLayer = map.createLayer('ui', {zIndex: 2});
var tooltip = uiLayer.createWidget('dom', {position: {x: 0, y: 0}});
var tooltipElem = $(tooltip.canvas()).attr('id', 'tooltip').addClass(
'hidden');
// Create a line feature
lineFeature = layer.createFeature('line', lineOptions)
.line(lineAccessor)
.position(positionAccessor)
// add hover events -- use mouseon and mouseoff, since we only show one
// tooltip. If we showed one tooltip per item we were over, use mouseover
// and mouseout.
.geoOn(geo.event.feature.mouseon, function (evt) {
var text = (evt.data.name ? evt.data.name : '') +
(evt.data.highway ? ' (' + evt.data.highway + ')' : '');
if (text) {
tooltip.position(evt.mouse.geo);
tooltipElem.text(text);
}
tooltipElem.toggleClass('hidden', !text);
})
.geoOn(geo.event.feature.mouseoff, function (evt) {
tooltipElem.addClass('hidden');
})
.geoOn(geo.event.zoom, resimplifyOnZoom);
// Make some values available in the global context so curious people can
// play with them.
window.example = {
map: map,
osm: osm,
layer: layer,
layerOptions: layerOptions,
line: lineFeature,
lineOptions: lineOptions,
tooltip: tooltip,
tooltipElem: tooltipElem,
ui: uiLayer
};
// Load our data set
fetch_data();
$('#controls').on('change', change_controls);
});
|
include(AddSwift)
add_custom_target(SwiftUnitTests)
<API key>(SwiftUnitTests PROPERTIES FOLDER "Tests")
function(add_swift_unittest test_dirname)
# *NOTE* Even though "add_unittest" does not have llvm in its name, it is a
# function defined by AddLLVM.cmake.
add_unittest(SwiftUnitTests ${test_dirname} ${ARGN})
# TODO: <API key> and these tests should share some
# sort of logic.
# *NOTE* The unittests are never built for the target, so we always enable LTO
# *if we are asked to.
_compute_lto_flag("${<API key>}" _lto_flag_out)
if (_lto_flag_out)
set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY COMPILE_FLAGS " ${_lto_flag_out} ")
set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY LINK_FLAGS " ${_lto_flag_out} ")
endif()
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
# Add an @rpath to the swift library directory
# and one to the OS dylibs we require but
# are not building ourselves (e.g Foundation overlay)
<API key>(${test_dirname} PROPERTIES
BUILD_RPATH "${<API key>}/swift/macosx;${<API key>}")
# Force all the swift libraries to be found via rpath.
add_custom_command(TARGET "${test_dirname}" POST_BUILD
COMMAND "${SWIFT_SOURCE_DIR}/utils/swift-rpathize.py"
"$<TARGET_FILE:${test_dirname}>")
elseif("${SWIFT_HOST_VARIANT}" STREQUAL "android")
<API key>(${<API key>} android_system_libs)
set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_DIRECTORIES
"${android_system_libs}")
set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_LIBRARIES "log")
elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
if(<API key> MATCHES "x86_64|AMD64")
<API key>(${test_dirname} PRIVATE
-march=core2)
elseif(<API key> MATCHES "armv6|armv7|i686")
set_property(TARGET "${test_dirname}" APPEND PROPERTY LINK_LIBRARIES
"atomic")
endif()
elseif("${SWIFT_HOST_VARIANT}" STREQUAL "windows")
<API key>("${test_dirname}" PRIVATE
<API key>)
endif()
# some headers switch their inline implementations based on
# <API key> definition
if(<API key>)
<API key>("${test_dirname}" PRIVATE
<API key>)
endif()
if(NOT <API key>)
if(SWIFT_USE_LINKER)
target_link_options(${test_dirname} PRIVATE
-fuse-ld=${SWIFT_USE_LINKER}$<$<STREQUAL:${<API key>},Windows>:.exe>)
endif()
endif()
if(<API key>)
set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
LINK_FLAGS " -<API key> -fcoverage-mapping")
endif()
if(<API key>)
if("Thread" IN_LIST <API key>)
set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY COMPILE_FLAGS
" -fsanitize=thread")
set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
LINK_FLAGS " -fsanitize=thread")
endif()
endif()
endfunction()
|
package org.springframework.social.google.api.plus.posts;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.social.google.api.plus.Activity;
import java.util.ArrayList;
import java.util.List;
public class PostActivity extends Activity {
@JsonProperty
private PostObject object;
@JsonProperty
private PostAcl access;
@JsonProperty
private String verb = "post";
public PostActivity() {
}
public PostActivity(String message) {
object = new PostObject();
object.setOriginalContent(message);
PostAclResource aclResource = new PostAclResource();
aclResource.setType("domain");
List<PostAclResource> items = new ArrayList<PostAclResource>();
items.add(aclResource);
access = new PostAcl();
access.setItems(items);
access.setDomainRestricted(true);
}
public PostActivity(String message, List<PostAttachment> attachments) {
object = new PostObject();
object.setOriginalContent(message);
object.setAttachments(attachments);
PostAclResource aclResource = new PostAclResource();
aclResource.setType("domain");
List<PostAclResource> items = new ArrayList<PostAclResource>();
items.add(aclResource);
access = new PostAcl();
access.setItems(items);
access.setDomainRestricted(true);
}
@Override
public String getContent() {
return object.getOriginalContent();
}
@Override
public List<Attachment> getAttachments() {
if (object.getAttachments() == null){
return new ArrayList<Attachment>();
} else {
return new ArrayList<Attachment>(object.getAttachments());
}
}
@Override
public int getPlusOners() {
return 0;
}
@Override
public int getResharers() {
return 0;
}
@Override
public int getReplies() {
return 0;
}
}
|
package gov.va.medora.mdws.emrsvc;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"getIvMedsResult"
})
@XmlRootElement(name = "getIvMedsResponse")
public class GetIvMedsResponse {
protected <API key> getIvMedsResult;
/**
* Gets the value of the getIvMedsResult property.
*
* @return
* possible object is
* {@link <API key> }
*
*/
public <API key> getGetIvMedsResult() {
return getIvMedsResult;
}
/**
* Sets the value of the getIvMedsResult property.
*
* @param value
* allowed object is
* {@link <API key> }
*
*/
public void setGetIvMedsResult(<API key> value) {
this.getIvMedsResult = value;
}
}
|
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
package jeigen;
/**
* Timing methods
*/
public class TicToc {
static long startTime;
/**
* starts timer
*/
public static final void tic() {
startTime = System.nanoTime();
}
/**
* prints elapsed time, and resets timer
*/
public static final void toc() {
long elapsednano = System.nanoTime() - startTime;
int milliseconds = (int)(elapsednano / 1000 / 1000);
//double seconds = milliseconds / 1000.0;
System.out.println("Elapsed time: " + milliseconds + " ms" );
startTime = System.nanoTime();
}
/**
* prints elapsed time, and resets timer
* @param message to prefix time with
*/
public static final void toc(String message) {
long elapsednano = System.nanoTime() - startTime;
int milliseconds = (int)(elapsednano / 1000 / 1000);
//double seconds = milliseconds / 1000.0;
System.out.println(message + ": " + milliseconds + " ms" );
startTime = System.nanoTime();
}
}
|
// WARNING
// This file has been generated automatically by Xamarin Studio to store outlets and
// actions made in the UI designer. If it is removed, they will be lost.
// Manual changes to this file may not be handled correctly.
using MonoTouch.Foundation;
using System.CodeDom.Compiler;
namespace NuGetSearch.IOS
{
[Register ("PackageDetailScreen")]
partial class PackageDetailScreen
{
[Outlet]
MonoTouch.UIKit.UILabel authorsCaptionLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel authorsLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UITableView <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.NSLayoutConstraint <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel descriptionLabel { get; set; }
[Outlet]
MonoTouch.UIKit.NSLayoutConstraint <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UIScrollView detailScrollView { get; set; }
[Outlet]
MonoTouch.UIKit.UIView detailView { get; set; }
[Outlet]
MonoTouch.UIKit.NSLayoutConstraint <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UIView headerView { get; set; }
[Outlet]
MonoTouch.UIKit.NSLayoutConstraint <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UIImageView iconImageView { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel prereleaseLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UIButton projectSiteButton { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel tagsCaptionLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel tagsLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel titleLabel { get; set; }
[Outlet]
MonoTouch.UIKit.UITableView <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.NSLayoutConstraint <API key> { get; set; }
[Outlet]
MonoTouch.UIKit.UILabel versionLabel { get; set; }
void <API key> ()
{
if (authorsCaptionLabel != null) {
authorsCaptionLabel.Dispose ();
authorsCaptionLabel = null;
}
if (authorsLabel != null) {
authorsLabel.Dispose ();
authorsLabel = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (descriptionLabel != null) {
descriptionLabel.Dispose ();
descriptionLabel = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (detailScrollView != null) {
detailScrollView.Dispose ();
detailScrollView = null;
}
if (detailView != null) {
detailView.Dispose ();
detailView = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (headerView != null) {
headerView.Dispose ();
headerView = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (iconImageView != null) {
iconImageView.Dispose ();
iconImageView = null;
}
if (prereleaseLabel != null) {
prereleaseLabel.Dispose ();
prereleaseLabel = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (projectSiteButton != null) {
projectSiteButton.Dispose ();
projectSiteButton = null;
}
if (tagsCaptionLabel != null) {
tagsCaptionLabel.Dispose ();
tagsCaptionLabel = null;
}
if (tagsLabel != null) {
tagsLabel.Dispose ();
tagsLabel = null;
}
if (titleLabel != null) {
titleLabel.Dispose ();
titleLabel = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (<API key> != null) {
<API key>.Dispose ();
<API key> = null;
}
if (versionLabel != null) {
versionLabel.Dispose ();
versionLabel = null;
}
}
}
}
|
package docker
import (
"encoding/binary"
"errors"
"fmt"
"github.com/dotcloud/docker/iptables"
"github.com/dotcloud/docker/netlink"
"github.com/dotcloud/docker/proxy"
"github.com/dotcloud/docker/utils"
"log"
"net"
"strconv"
"sync"
)
const (
<API key> = "docker0"
<API key> = "none"
portRangeStart = 49153
portRangeEnd = 65535
)
// Calculates the first and last IP addresses in an IPNet
func networkRange(network *net.IPNet) (net.IP, net.IP) {
netIP := network.IP.To4()
firstIP := netIP.Mask(network.Mask)
lastIP := net.IPv4(0, 0, 0, 0).To4()
for i := 0; i < len(lastIP); i++ {
lastIP[i] = netIP[i] | ^network.Mask[i]
}
return firstIP, lastIP
}
// Detects overlap between one IPNet and another
func networkOverlaps(netX *net.IPNet, netY *net.IPNet) bool {
firstIP, _ := networkRange(netX)
if netY.Contains(firstIP) {
return true
}
firstIP, _ = networkRange(netY)
if netX.Contains(firstIP) {
return true
}
return false
}
// Converts a 4 bytes IP into a 32 bit integer
func ipToInt(ip net.IP) int32 {
return int32(binary.BigEndian.Uint32(ip.To4()))
}
// Converts 32 bit integer into a 4 bytes IP address
func intToIP(n int32) net.IP {
b := make([]byte, 4)
binary.BigEndian.PutUint32(b, uint32(n))
return net.IP(b)
}
// Given a netmask, calculates the number of available hosts
func networkSize(mask net.IPMask) int32 {
m := net.IPv4Mask(0, 0, 0, 0)
for i := 0; i < net.IPv4len; i++ {
m[i] = ^mask[i]
}
return int32(binary.BigEndian.Uint32(m)) + 1
}
func checkRouteOverlaps(networks []*net.IPNet, dockerNetwork *net.IPNet) error {
for _, network := range networks {
if networkOverlaps(dockerNetwork, network) {
return fmt.Errorf("Network %s is already routed: '%s'", dockerNetwork, network)
}
}
return nil
}
func <API key>(nameservers []string, dockerNetwork *net.IPNet) error {
if len(nameservers) > 0 {
for _, ns := range nameservers {
_, nsNetwork, err := net.ParseCIDR(ns)
if err != nil {
return err
}
if networkOverlaps(dockerNetwork, nsNetwork) {
return fmt.Errorf("%s overlaps nameserver %s", dockerNetwork, nsNetwork)
}
}
}
return nil
}
// CreateBridgeIface creates a network bridge interface on the host system with the name `ifaceName`,
// and attempts to configure it with an address which doesn't conflict with any other interface on the host.
// If it can't find an address which doesn't conflict, it will return an error.
func CreateBridgeIface(config *DaemonConfig) error {
addrs := []string{
// Here we don't follow the convention of using the 1st IP of the range for the gateway.
// This is to use the same gateway IPs as the /24 ranges, which predate the /16 ranges.
// In theory this shouldn't matter - in practice there's bound to be a few scripts relying
// on the internal addressing or other stupid things like that.
// The shouldn't, but hey, let's not break them unless we really have to.
"172.17.42.1/16", // Don't use 172.16.0.0/16, it conflicts with EC2 DNS 172.16.0.23
"10.0.42.1/16", // Don't even try using the entire /8, that's too intrusive
"10.1.42.1/16",
"10.42.42.1/16",
"172.16.42.1/24",
"172.16.43.1/24",
"172.16.44.1/24",
"10.0.42.1/24",
"10.0.43.1/24",
"192.168.42.1/24",
"192.168.43.1/24",
"192.168.44.1/24",
}
nameservers := []string{}
resolvConf, _ := utils.GetResolvConf()
// we don't check for an error here, because we don't really care
// if we can't read /etc/resolv.conf. So instead we skip the append
// if resolvConf is nil. It either doesn't exist, or we can't read it
// for some reason.
if resolvConf != nil {
nameservers = append(nameservers, utils.<API key>(resolvConf)...)
}
var ifaceAddr string
for _, addr := range addrs {
_, dockerNetwork, err := net.ParseCIDR(addr)
if err != nil {
return err
}
routes, err := netlink.NetworkGetRoutes()
if err != nil {
return err
}
if err := checkRouteOverlaps(routes, dockerNetwork); err == nil {
if err := <API key>(nameservers, dockerNetwork); err == nil {
ifaceAddr = addr
break
}
} else {
utils.Debugf("%s: %s", addr, err)
}
}
if ifaceAddr == "" {
return fmt.Errorf("Could not find a free IP address range for interface '%s'. Please configure its address manually and run 'docker -b %s'", config.BridgeIface, config.BridgeIface)
}
utils.Debugf("Creating bridge %s with network %s", config.BridgeIface, ifaceAddr)
if err := netlink.NetworkLinkAdd(config.BridgeIface, "bridge"); err != nil {
return fmt.Errorf("Error creating bridge: %s", err)
}
iface, err := net.InterfaceByName(config.BridgeIface)
if err != nil {
return err
}
ipAddr, ipNet, err := net.ParseCIDR(ifaceAddr)
if err != nil {
return err
}
if netlink.NetworkLinkAddIp(iface, ipAddr, ipNet); err != nil {
return fmt.Errorf("Unable to add private network: %s", err)
}
if err := netlink.NetworkLinkUp(iface); err != nil {
return fmt.Errorf("Unable to start network bridge: %s", err)
}
if config.EnableIptables {
// Enable NAT
if output, err := iptables.Raw("-t", "nat", "-A", "POSTROUTING", "-s", ifaceAddr,
"!", "-d", ifaceAddr, "-j", "MASQUERADE"); err != nil {
return fmt.Errorf("Unable to enable network bridge NAT: %s", err)
} else if len(output) != 0 {
return fmt.Errorf("Error iptables postrouting: %s", output)
}
// Accept incoming packets for existing connections
if output, err := iptables.Raw("-I", "FORWARD", "-o", config.BridgeIface, "-m", "conntrack", "--ctstate", "RELATED,ESTABLISHED", "-j", "ACCEPT"); err != nil {
return fmt.Errorf("Unable to allow incoming packets: %s", err)
} else if len(output) != 0 {
return fmt.Errorf("Error iptables allow incoming: %s", output)
}
// Accept all non-intercontainer outgoing packets
if output, err := iptables.Raw("-I", "FORWARD", "-i", config.BridgeIface, "!", "-o", config.BridgeIface, "-j", "ACCEPT"); err != nil {
return fmt.Errorf("Unable to allow outgoing packets: %s", err)
} else if len(output) != 0 {
return fmt.Errorf("Error iptables allow outgoing: %s", output)
}
}
return nil
}
// Return the IPv4 address of a network interface
func getIfaceAddr(name string) (net.Addr, error) {
iface, err := net.InterfaceByName(name)
if err != nil {
return nil, err
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
var addrs4 []net.Addr
for _, addr := range addrs {
ip := (addr.(*net.IPNet)).IP
if ip4 := ip.To4(); len(ip4) == net.IPv4len {
addrs4 = append(addrs4, addr)
}
}
switch {
case len(addrs4) == 0:
return nil, fmt.Errorf("Interface %v has no IP addresses", name)
case len(addrs4) > 1:
fmt.Printf("Interface %v has more than 1 IPv4 address. Defaulting to using %v\n",
name, (addrs4[0].(*net.IPNet)).IP)
}
return addrs4[0], nil
}
// Port mapper takes care of mapping external ports to containers by setting
// up iptables rules.
// It keeps track of all mappings and is able to unmap at will
type PortMapper struct {
tcpMapping map[int]*net.TCPAddr
tcpProxies map[int]proxy.Proxy
udpMapping map[int]*net.UDPAddr
udpProxies map[int]proxy.Proxy
iptables *iptables.Chain
defaultIp net.IP
}
func (mapper *PortMapper) Map(ip net.IP, port int, backendAddr net.Addr) error {
if _, isTCP := backendAddr.(*net.TCPAddr); isTCP {
backendPort := backendAddr.(*net.TCPAddr).Port
backendIP := backendAddr.(*net.TCPAddr).IP
if mapper.iptables != nil {
if err := mapper.iptables.Forward(iptables.Add, ip, port, "tcp", backendIP.String(), backendPort); err != nil {
return err
}
}
mapper.tcpMapping[port] = backendAddr.(*net.TCPAddr)
proxy, err := proxy.NewProxy(&net.TCPAddr{IP: ip, Port: port}, backendAddr)
if err != nil {
mapper.Unmap(ip, port, "tcp")
return err
}
mapper.tcpProxies[port] = proxy
go proxy.Run()
} else {
backendPort := backendAddr.(*net.UDPAddr).Port
backendIP := backendAddr.(*net.UDPAddr).IP
if mapper.iptables != nil {
if err := mapper.iptables.Forward(iptables.Add, ip, port, "udp", backendIP.String(), backendPort); err != nil {
return err
}
}
mapper.udpMapping[port] = backendAddr.(*net.UDPAddr)
proxy, err := proxy.NewProxy(&net.UDPAddr{IP: ip, Port: port}, backendAddr)
if err != nil {
mapper.Unmap(ip, port, "udp")
return err
}
mapper.udpProxies[port] = proxy
go proxy.Run()
}
return nil
}
func (mapper *PortMapper) Unmap(ip net.IP, port int, proto string) error {
if proto == "tcp" {
backendAddr, ok := mapper.tcpMapping[port]
if !ok {
return fmt.Errorf("Port tcp/%v is not mapped", port)
}
if proxy, exists := mapper.tcpProxies[port]; exists {
proxy.Close()
delete(mapper.tcpProxies, port)
}
if mapper.iptables != nil {
if err := mapper.iptables.Forward(iptables.Delete, ip, port, proto, backendAddr.IP.String(), backendAddr.Port); err != nil {
return err
}
}
delete(mapper.tcpMapping, port)
} else {
backendAddr, ok := mapper.udpMapping[port]
if !ok {
return fmt.Errorf("Port udp/%v is not mapped", port)
}
if proxy, exists := mapper.udpProxies[port]; exists {
proxy.Close()
delete(mapper.udpProxies, port)
}
if mapper.iptables != nil {
if err := mapper.iptables.Forward(iptables.Delete, ip, port, proto, backendAddr.IP.String(), backendAddr.Port); err != nil {
return err
}
}
delete(mapper.udpMapping, port)
}
return nil
}
func newPortMapper(config *DaemonConfig) (*PortMapper, error) {
// We can always try removing the iptables
if err := iptables.RemoveExistingChain("DOCKER"); err != nil {
return nil, err
}
var chain *iptables.Chain
if config.EnableIptables {
var err error
chain, err = iptables.NewChain("DOCKER", config.BridgeIface)
if err != nil {
return nil, fmt.Errorf("Failed to create DOCKER chain: %s", err)
}
}
mapper := &PortMapper{
tcpMapping: make(map[int]*net.TCPAddr),
tcpProxies: make(map[int]proxy.Proxy),
udpMapping: make(map[int]*net.UDPAddr),
udpProxies: make(map[int]proxy.Proxy),
iptables: chain,
defaultIp: config.DefaultIp,
}
return mapper, nil
}
// Port allocator: Automatically allocate and release networking ports
type PortAllocator struct {
sync.Mutex
inUse map[int]struct{}
fountain chan int
quit chan bool
}
func (alloc *PortAllocator) runFountain() {
for {
for port := portRangeStart; port < portRangeEnd; port++ {
select {
case alloc.fountain <- port:
case quit := <-alloc.quit:
if quit {
return
}
}
}
}
}
// FIXME: Release can no longer fail, change its prototype to reflect that.
func (alloc *PortAllocator) Release(port int) error {
utils.Debugf("Releasing %d", port)
alloc.Lock()
delete(alloc.inUse, port)
alloc.Unlock()
return nil
}
func (alloc *PortAllocator) Acquire(port int) (int, error) {
utils.Debugf("Acquiring %d", port)
if port == 0 {
// Allocate a port from the fountain
for port := range alloc.fountain {
if _, err := alloc.Acquire(port); err == nil {
return port, nil
}
}
return -1, fmt.Errorf("Port generator ended unexpectedly")
}
alloc.Lock()
defer alloc.Unlock()
if _, inUse := alloc.inUse[port]; inUse {
return -1, fmt.Errorf("Port already in use: %d", port)
}
alloc.inUse[port] = struct{}{}
return port, nil
}
func (alloc *PortAllocator) Close() error {
alloc.quit <- true
close(alloc.quit)
close(alloc.fountain)
return nil
}
func newPortAllocator() (*PortAllocator, error) {
allocator := &PortAllocator{
inUse: make(map[int]struct{}),
fountain: make(chan int),
quit: make(chan bool),
}
go allocator.runFountain()
return allocator, nil
}
// IP allocator: Automatically allocate and release networking ports
type IPAllocator struct {
network *net.IPNet
queueAlloc chan allocatedIP
queueReleased chan net.IP
inUse map[int32]struct{}
quit chan bool
}
type allocatedIP struct {
ip net.IP
err error
}
func (alloc *IPAllocator) run() {
firstIP, _ := networkRange(alloc.network)
ipNum := ipToInt(firstIP)
ownIP := ipToInt(alloc.network.IP)
size := networkSize(alloc.network.Mask)
pos := int32(1)
max := size - 2 // -1 for the broadcast address, -1 for the gateway address
for {
var (
newNum int32
inUse bool
)
// Find first unused IP, give up after one whole round
for attempt := int32(0); attempt < max; attempt++ {
newNum = ipNum + pos
pos = pos%max + 1
// The network's IP is never okay to use
if newNum == ownIP {
continue
}
if _, inUse = alloc.inUse[newNum]; !inUse {
// We found an unused IP
break
}
}
ip := allocatedIP{ip: intToIP(newNum)}
if inUse {
ip.err = errors.New("No unallocated IP available")
}
select {
case quit := <-alloc.quit:
if quit {
return
}
case alloc.queueAlloc <- ip:
alloc.inUse[newNum] = struct{}{}
case released := <-alloc.queueReleased:
r := ipToInt(released)
delete(alloc.inUse, r)
if inUse {
// If we couldn't allocate a new IP, the released one
// will be the only free one now, so instantly use it
// next time
pos = r - ipNum
} else {
// Use same IP as last time
if pos == 1 {
pos = max
} else {
pos
}
}
}
}
}
func (alloc *IPAllocator) Acquire() (net.IP, error) {
ip := <-alloc.queueAlloc
return ip.ip, ip.err
}
func (alloc *IPAllocator) Release(ip net.IP) {
alloc.queueReleased <- ip
}
func (alloc *IPAllocator) Close() error {
alloc.quit <- true
close(alloc.quit)
close(alloc.queueAlloc)
close(alloc.queueReleased)
return nil
}
func newIPAllocator(network *net.IPNet) *IPAllocator {
alloc := &IPAllocator{
network: network,
queueAlloc: make(chan allocatedIP),
queueReleased: make(chan net.IP),
inUse: make(map[int32]struct{}),
quit: make(chan bool),
}
go alloc.run()
return alloc
}
// Network interface represents the networking stack of a container
type NetworkInterface struct {
IPNet net.IPNet
Gateway net.IP
manager *NetworkManager
extPorts []*Nat
disabled bool
}
// Allocate an external port and map it to the interface
func (iface *NetworkInterface) AllocatePort(port Port, binding PortBinding) (*Nat, error) {
if iface.disabled {
return nil, fmt.Errorf("Trying to allocate port for interface %v, which is disabled", iface) // FIXME
}
ip := iface.manager.portMapper.defaultIp
if binding.HostIp != "" {
ip = net.ParseIP(binding.HostIp)
} else {
binding.HostIp = ip.String()
}
nat := &Nat{
Port: port,
Binding: binding,
}
containerPort, err := parsePort(port.Port())
if err != nil {
return nil, err
}
hostPort, _ := parsePort(nat.Binding.HostPort)
if nat.Port.Proto() == "tcp" {
extPort, err := iface.manager.tcpPortAllocator.Acquire(hostPort)
if err != nil {
return nil, err
}
backend := &net.TCPAddr{IP: iface.IPNet.IP, Port: containerPort}
if err := iface.manager.portMapper.Map(ip, extPort, backend); err != nil {
iface.manager.tcpPortAllocator.Release(extPort)
return nil, err
}
nat.Binding.HostPort = strconv.Itoa(extPort)
} else {
extPort, err := iface.manager.udpPortAllocator.Acquire(hostPort)
if err != nil {
return nil, err
}
backend := &net.UDPAddr{IP: iface.IPNet.IP, Port: containerPort}
if err := iface.manager.portMapper.Map(ip, extPort, backend); err != nil {
iface.manager.udpPortAllocator.Release(extPort)
return nil, err
}
nat.Binding.HostPort = strconv.Itoa(extPort)
}
iface.extPorts = append(iface.extPorts, nat)
return nat, nil
}
type Nat struct {
Port Port
Binding PortBinding
}
func (n *Nat) String() string {
return fmt.Sprintf("%s:%d:%d/%s", n.Binding.HostIp, n.Binding.HostPort, n.Port.Port(), n.Port.Proto())
}
// Release: Network cleanup - release all resources
func (iface *NetworkInterface) Release() {
if iface.disabled {
return
}
for _, nat := range iface.extPorts {
hostPort, err := parsePort(nat.Binding.HostPort)
if err != nil {
log.Printf("Unable to get host port: %s", err)
continue
}
ip := net.ParseIP(nat.Binding.HostIp)
utils.Debugf("Unmaping %s/%s", nat.Port.Proto, nat.Binding.HostPort)
if err := iface.manager.portMapper.Unmap(ip, hostPort, nat.Port.Proto()); err != nil {
log.Printf("Unable to unmap port %s: %s", nat, err)
}
if nat.Port.Proto() == "tcp" {
if err := iface.manager.tcpPortAllocator.Release(hostPort); err != nil {
log.Printf("Unable to release port %s", nat)
}
} else if err := iface.manager.udpPortAllocator.Release(hostPort); err != nil {
log.Printf("Unable to release port %s: %s", nat, err)
}
}
iface.manager.ipAllocator.Release(iface.IPNet.IP)
}
// Network Manager manages a set of network interfaces
// Only *one* manager per host machine should be used
type NetworkManager struct {
bridgeIface string
bridgeNetwork *net.IPNet
ipAllocator *IPAllocator
tcpPortAllocator *PortAllocator
udpPortAllocator *PortAllocator
portMapper *PortMapper
disabled bool
}
// Allocate a network interface
func (manager *NetworkManager) Allocate() (*NetworkInterface, error) {
if manager.disabled {
return &NetworkInterface{disabled: true}, nil
}
var ip net.IP
var err error
ip, err = manager.ipAllocator.Acquire()
if err != nil {
return nil, err
}
// avoid duplicate IP
ipNum := ipToInt(ip)
firstIP := manager.ipAllocator.network.IP.To4().Mask(manager.ipAllocator.network.Mask)
firstIPNum := ipToInt(firstIP) + 1
if firstIPNum == ipNum {
ip, err = manager.ipAllocator.Acquire()
if err != nil {
return nil, err
}
}
iface := &NetworkInterface{
IPNet: net.IPNet{IP: ip, Mask: manager.bridgeNetwork.Mask},
Gateway: manager.bridgeNetwork.IP,
manager: manager,
}
return iface, nil
}
func (manager *NetworkManager) Close() error {
err1 := manager.tcpPortAllocator.Close()
err2 := manager.udpPortAllocator.Close()
err3 := manager.ipAllocator.Close()
if err1 != nil {
return err1
}
if err2 != nil {
return err2
}
return err3
}
func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {
if config.BridgeIface == <API key> {
manager := &NetworkManager{
disabled: true,
}
return manager, nil
}
addr, err := getIfaceAddr(config.BridgeIface)
if err != nil {
// If the iface is not found, try to create it
if err := CreateBridgeIface(config); err != nil {
return nil, err
}
addr, err = getIfaceAddr(config.BridgeIface)
if err != nil {
return nil, err
}
}
network := addr.(*net.IPNet)
// Configure iptables for link support
if config.EnableIptables {
args := []string{"FORWARD", "-i", config.BridgeIface, "-o", config.BridgeIface, "-j"}
acceptArgs := append(args, "ACCEPT")
dropArgs := append(args, "DROP")
if !config.<API key> {
iptables.Raw(append([]string{"-D"}, acceptArgs...)...)
if !iptables.Exists(dropArgs...) {
utils.Debugf("Disable inter-container communication")
if output, err := iptables.Raw(append([]string{"-I"}, dropArgs...)...); err != nil {
return nil, fmt.Errorf("Unable to prevent intercontainer communication: %s", err)
} else if len(output) != 0 {
return nil, fmt.Errorf("Error disabling intercontainer communication: %s", output)
}
}
} else {
iptables.Raw(append([]string{"-D"}, dropArgs...)...)
if !iptables.Exists(acceptArgs...) {
utils.Debugf("Enable inter-container communication")
if output, err := iptables.Raw(append([]string{"-I"}, acceptArgs...)...); err != nil {
return nil, fmt.Errorf("Unable to allow intercontainer communication: %s", err)
} else if len(output) != 0 {
return nil, fmt.Errorf("Error enabling intercontainer communication: %s", output)
}
}
}
}
ipAllocator := newIPAllocator(network)
tcpPortAllocator, err := newPortAllocator()
if err != nil {
return nil, err
}
udpPortAllocator, err := newPortAllocator()
if err != nil {
return nil, err
}
portMapper, err := newPortMapper(config)
if err != nil {
return nil, err
}
manager := &NetworkManager{
bridgeIface: config.BridgeIface,
bridgeNetwork: network,
ipAllocator: ipAllocator,
tcpPortAllocator: tcpPortAllocator,
udpPortAllocator: udpPortAllocator,
portMapper: portMapper,
}
return manager, nil
}
|
FROM learninglayers/base
RUN apt-get update && apt-get install -y wget \
tar \
gcc \
make \
groff \
groff-base
WORKDIR /opt
RUN wget ftp://gd.tuwien.ac.at/infosys/network/OpenLDAP/openldap-release/openldap-2.4.40.tgz && \
mkdir src && \
mkdir openldap-2.4.40 && \
tar xfz openldap-2.4.40.tgz -C src/ && \
cd src/openldap-2.4.40 && \
./configure --enable-bdb=no --enable-hdb=no && \
make depend && \
make && \
make install
WORKDIR /usr/local/etc/openldap
EXPOSE 389
CMD /usr/local/libexec/slapd && \
while ! ping -c1 mysql &>/dev/null; do sleep 0.2; done && \
while ! timeout 1 bash -c 'cat < /dev/null > /dev/tcp/mysql/3306' 2>/dev/null; do sleep 0.5; done && \
ldapadd -x -w $LDAP_ROOT_PASSWORD -D "cn=LayersManager,dc=learning-layers,dc=eu" -f /usr/local/etc/openldap/ldap-init.ldif && \
pkill slapd && \
/usr/local/libexec/slapd -d 8
|
#include <aws/servicediscovery/model/HealthStatusFilter.h>
#include <aws/core/utils/HashingUtils.h>
#include <aws/core/Globals.h>
#include <aws/core/utils/<API key>.h>
using namespace Aws::Utils;
namespace Aws
{
namespace ServiceDiscovery
{
namespace Model
{
namespace <API key>
{
static const int HEALTHY_HASH = HashingUtils::HashString("HEALTHY");
static const int UNHEALTHY_HASH = HashingUtils::HashString("UNHEALTHY");
static const int ALL_HASH = HashingUtils::HashString("ALL");
static const int <API key> = HashingUtils::HashString("HEALTHY_OR_ELSE_ALL");
HealthStatusFilter <API key>(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == HEALTHY_HASH)
{
return HealthStatusFilter::HEALTHY;
}
else if (hashCode == UNHEALTHY_HASH)
{
return HealthStatusFilter::UNHEALTHY;
}
else if (hashCode == ALL_HASH)
{
return HealthStatusFilter::ALL;
}
else if (hashCode == <API key>)
{
return HealthStatusFilter::HEALTHY_OR_ELSE_ALL;
}
<API key>* overflowContainer = Aws::<API key>();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<HealthStatusFilter>(hashCode);
}
return HealthStatusFilter::NOT_SET;
}
Aws::String <API key>(HealthStatusFilter enumValue)
{
switch(enumValue)
{
case HealthStatusFilter::HEALTHY:
return "HEALTHY";
case HealthStatusFilter::UNHEALTHY:
return "UNHEALTHY";
case HealthStatusFilter::ALL:
return "ALL";
case HealthStatusFilter::HEALTHY_OR_ELSE_ALL:
return "HEALTHY_OR_ELSE_ALL";
default:
<API key>* overflowContainer = Aws::<API key>();
if(overflowContainer)
{
return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
}
return {};
}
}
} // namespace <API key>
} // namespace Model
} // namespace ServiceDiscovery
} // namespace Aws
|
package org.vaadin.addon.vol3.interaction;
import org.vaadin.addon.vol3.client.interaction.<API key>;
import org.vaadin.addon.vol3.layer.OLVectorLayer;
/**
* Interaction that allows drawing on the specified vector layer
*/
public class OLDrawInteraction extends OLInteraction {
/** Creates a new instance of draw interaction
*
* @param vectorLayer the layer the interaction operates on
*/
public OLDrawInteraction(OLVectorLayer vectorLayer){
this(vectorLayer, <API key>.DrawingType.POINT);
}
/** Creates a new instance of draw interaction
*
* @param vectorLayer the layer the interaction operates on
* @param drawingType the type of the markers user can create using the interaction
*/
public OLDrawInteraction(OLVectorLayer vectorLayer, <API key>.DrawingType drawingType){
<API key> opts=new <API key>();
opts.setType(drawingType);
init(vectorLayer, opts);
}
/** Creates a new instance of draw interaction
*
* @param vectorLayer the layer the interaction operates on
* @param options the options for the interaction
*/
public OLDrawInteraction(OLVectorLayer vectorLayer, <API key> options){
init(vectorLayer, options);
}
private void init(OLVectorLayer vectorLayer, <API key> options){
if(options!=null){
getState().featureStyles=options.getStyles();
getState().type=<API key>.getTypeAsString(options.getType());
getState().snapTolerance=options.getSnapTolerance();
getState().minPointsPerRing=options.getMinPointsPerRing();
getState().geometryName=options.getGeometryName();
}
getState().layer=vectorLayer;
}
@Override
protected <API key> getState() {
return (<API key>) super.getState();
}
}
|
@charset 'utf-8';
.jqcNotify-element {
width: 24px;
height: 24px;
background-image: url('./images/icon_notify.png');
background-repeat: no-repeat;
background-position: center;
background-size: 24px 24px;
cursor: pointer;
position: relative;
}
.jqcNotify-element:hover,
.jqcNotify-element.active {
background-image: url('./images/icon_notify_active.png');
}
.jqcNotify-container {
position: absolute;
z-index: 999;
box-sizing: border-box;
background: #FFFFFF;
box-shadow: 0 2px 8px 0 rgba(0,0,0,0.20);
border-radius: 4px;
width: 300px;
max-height: 500px;
user-select: none;
}
.jqcNotify-container *{
padding: 0;
margin: 0;
box-sizing: border-box;
}
.jqcNotify-badge{
height: 24px;
min-width: 24px;
background: #C63136;
color: #fff;
border-radius: 12px;
position: absolute;
font-size: 16px;
text-align: center;
line-height: 20px;
box-sizing: border-box;
padding: 0 5px;
transform-origin: 0 0;
transform: scale(0.5, 0.5);
border: 2px solid #fff;
top: -4px;
left: 15px;
}
.jqcNotify-more{
height: 50px;
display: flex;
padding: 0 20px;
align-items: center;
justify-content: space-between;
border-bottom: 1px solid #f2f2f2;
}
.jqcNotfiy-more-left{
font-size: 14px;
color: #222;
}
.<API key>{
width: 10px;
height: 20px;
background: url('./images/icon_arrow.png') no-repeat center;
}
.jqcNotfiy-more-left span{
margin-left: 10px;
color: #999;
}
.jqcNotify-scrollBox{
padding: 0 20px;
font-size: 12px;
max-height: 450px;
position: relative;
overflow: hidden;
}
.jqcNotify-scroller{
position: absolute;
top: 0;
right: 5px;
width: 10px;
height: 100%;
border-radius: 5px;
background: #444;
opacity: .3;
display: none;
/*transition: all .3s;*/
}
.jqcNotify-scroller.hover,
.jqcNotify-scroller:hover{
opacity: .8;
}
.jqcNotify-items{
max-height: 450px;
overflow-y: scroll;
width: 450px;
}
.<API key>{
display: flex;
align-items: center;
justify-content: space-between;
color: #333;
height: 20px;
}
.<API key> span{
color: #999;
min-width: 120px;
margin-left: 10px;
transform-origin: right;
transform: scale(.75);
}
.<API key> p{
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.jqcNotify-items > div{
padding: 9px 0;
border-bottom: 1px solid #f2f2f2;
width: 260px;
}
.jqcNotify-items > div:nth-last-child(1){
border-bottom: none;
}
.jqcNotify-item-body{
color: #666;
line-height: 20px;
word-break: break-all;
}
|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
namespace OpenRiaServices.Controls
{
<summary>
Abstract base class that observes and collates events from
<see cref="<API key>"/> collections of <see cref="<API key>"/>
items.
</summary>
internal abstract class CollectionManager
{
#region Member Fields
private readonly IDictionary<IEnumerable, IList> _localCollections = new Dictionary<IEnumerable, IList>();
private Func<object, <API key>> <API key>;
#endregion
#region Constructors
<summary>
Initializes a new instance of the <see cref="CollectionManager"/> class.
</summary>
protected CollectionManager()
{
this.<API key> = item => (<API key>)item;
}
#endregion
#region Events
<summary>
Raises a generic event any time a managed collection changes.
</summary>
public event EventHandler CollectionChanged;
<summary>
Raises a generic event any time an item in a managed collection changes.
</summary>
public event EventHandler PropertyChanged;
#endregion
#region Properties
<summary>
Gets or sets a cache of expressions. The entry for an item will be cleared if
that item is changed or removed.
</summary>
protected ExpressionCache ExpressionCache { get; set; }
<summary>
Gets or sets the action that is invoked to validate a new or changed item.
</summary>
<remarks>
This can be used to raise programming exceptions. The manager will not attempt
to restore the previous state.
</remarks>
protected Action<object> ValidationAction { get; set; }
<summary>
Gets or sets the function that an <see cref="<API key>"/> implementation
that corresponds to the specified item.
</summary>
<remarks>
In most cases, this is used because the items do not directly implement <see cref="<API key>"/>.
</remarks>
protected Func<object, <API key>> <API key>
{
get
{
return this.<API key>;
}
set
{
if (value == null)
{
throw new <API key>("value");
}
this.<API key> = value;
}
}
#endregion
#region Methods
<summary>
Adds a collection to this manager.
</summary>
<typeparam name="TCollection">The type of the collection</typeparam>
<param name="collection">The collection to manage</param>
<exception cref="<API key>"> is thrown if <paramref name="collection"/> is <c>null</c>.
</exception>
<exception cref="ArgumentException"> is thrown if the collection has already been added to this manager.
</exception>
protected void AddCollection<TCollection>(TCollection collection)
where TCollection : IEnumerable, <API key>
{
if (collection == null)
{
throw new <API key>("collection");
}
if (this._localCollections.ContainsKey(collection))
{
throw new ArgumentException("This collection is already being managed.", "collection");
}
this._localCollections[collection] = new List<object>();
collection.CollectionChanged += this.<API key>;
this.AddAll(collection);
}
<summary>
Removes a collection from this manager.
</summary>
<typeparam name="TCollection">The type of the collection</typeparam>
<param name="collection">The collection to remove</param>
<exception cref="<API key>"> is thrown if <paramref name="collection"/> is <c>null</c>.
</exception>
<exception cref="ArgumentException"> is thrown if the collection has not been added to this manager.
</exception>
protected void RemoveCollection<TCollection>(TCollection collection)
where TCollection : IEnumerable, <API key>
{
if (collection == null)
{
throw new <API key>("collection");
}
if (!this._localCollections.ContainsKey(collection))
{
throw new ArgumentException("This collection is not being managed.", "collection");
}
this.RemoveAll(collection);
collection.CollectionChanged -= this.<API key>;
this._localCollections.Remove(collection);
}
<summary>
Adds each item in the enumeration to this manager.
</summary>
<param name="collection">The collection of items to add</param>
private void AddAll(IEnumerable collection)
{
IList localCollection = this._localCollections[collection];
foreach (object item in collection)
{
this.AddItem(localCollection, item);
}
}
<summary>
Removes each item in the enumeration from this manager.
</summary>
<param name="collection">The collection of items to remove</param>
private void RemoveAll(IEnumerable collection)
{
IList localCollection = this._localCollections[collection];
foreach (object item in localCollection.Cast<object>().ToArray())
{
this.RemoveItem(localCollection, item);
}
}
<summary>
Adds an item to this manager.
</summary>
<param name="localCollection">The local collection instance for tracking the item</param>
<param name="item">The item to add</param>
private void AddItem(IList localCollection, object item)
{
localCollection.Add(item);
this.<API key>(item).PropertyChanged += this.<API key>;
if (this.ValidationAction != null)
{
this.ValidationAction(item);
}
}
<summary>
Removes an item from this manager.
</summary>
<param name="localCollection">The local collection instance for tracking the item</param>
<param name="item">The item to remove</param>
private void RemoveItem(IList localCollection, object item)
{
this.<API key>(item).PropertyChanged -= this.<API key>;
localCollection.Remove(item);
if (this.ExpressionCache != null)
{
this.ExpressionCache.Remove(item);
}
}
<summary>
Handles collection changes by adding or removing the corresponding items and raising a <see cref="CollectionChanged"/> event.
</summary>
<remarks>
Derived classes should call the base implementation when overriding this method.
</remarks>
<param name="sender">The collection that changed</param>
<param name="e">The collection changed event</param>
protected virtual void <API key>(object sender, <API key> e)
{
IEnumerable collection = (IEnumerable)sender;
IList localCollection = this._localCollections[collection];
if (e.Action == <API key>.Reset)
{
this.RemoveAll(collection);
this.AddAll(collection);
}
if ((e.Action == <API key>.Remove) ||
(e.Action == <API key>.Replace))
{
foreach (object item in e.OldItems)
{
this.RemoveItem(localCollection, item);
}
}
if ((e.Action == <API key>.Add) ||
(e.Action == <API key>.Replace))
{
foreach (object item in e.NewItems)
{
this.AddItem(localCollection, item);
}
}
this.OnCollectionChanged();
}
<summary>
Handles item changes and raises a <see cref="PropertyChanged"/> event.
</summary>
<remarks>
Derived classes should call the base implementation when overriding this method.
</remarks>
<param name="sender">The item that changed</param>
<param name="e">The property changed event</param>
protected virtual void <API key>(object sender, <API key> e)
{
if (this.ExpressionCache != null)
{
this.ExpressionCache.Remove(sender);
}
if (this.ValidationAction != null)
{
this.ValidationAction(sender);
}
this.OnPropertyChanged();
}
<summary>
Raises a <see cref="CollectionChanged"/> event.
</summary>
protected virtual void OnCollectionChanged()
{
EventHandler handler = this.CollectionChanged;
if (handler != null)
{
handler(this, new EventArgs());
}
}
<summary>
Raises a <see cref="PropertyChanged"/> event.
</summary>
protected virtual void OnPropertyChanged()
{
EventHandler handler = this.PropertyChanged;
if (handler != null)
{
handler(this, new EventArgs());
}
}
<summary>
Stores the original values for all <see cref="IRestorable"/> items.
</summary>
public void StoreOriginalValues()
{
foreach (IList localCollection in this._localCollections.Values)
{
foreach (IRestorable item in localCollection.OfType<IRestorable>())
{
item.StoreOriginalValue();
}
}
}
<summary>
Restores the original values for all <see cref="IRestorable"/> items.
</summary>
public void <API key>()
{
foreach (IList localCollection in this._localCollections.Values)
{
foreach (IRestorable item in localCollection.OfType<IRestorable>())
{
item.<API key>();
}
}
}
#endregion
}
}
|
// Karma configuration
// Generated on 2014-08-29 using
// generator-karma 0.8.3
module.exports = function(config) {
'use strict';
config.set({
// enable / disable watching file and executing tests whenever any file changes
autoWatch: true,
// base path, that will be used to resolve files and exclude
basePath: '../',
// testing framework to use (jasmine/mocha/qunit/...)
frameworks: ['jasmine'],
// list of files / patterns to load in the browser
files: [
// bower:js
'bower_components/jquery/dist/jquery.js',
'bower_components/es5-shim/es5-shim.js',
'bower_components/angular/angular.js',
'bower_components/json3/lib/json3.js',
'bower_components/bootstrap/dist/js/bootstrap.js',
'bower_components/angular-cookies/angular-cookies.js',
'bower_components/angular-sanitize/angular-sanitize.js',
'bower_components/angular-animate/angular-animate.js',
'bower_components/angular-touch/angular-touch.js',
'bower_components/angular-route/angular-route.js',
'bower_components/angular-resource/angular-resource.js',
'bower_components/angular-bootstrap/ui-bootstrap-tpls.js',
'bower_components/angular-websocket/angular-websocket.min.js',
'bower_components/ace-builds/src-noconflict/ace.js',
'bower_components/ace-builds/src-noconflict/mode-scala.js',
'bower_components/ace-builds/src-noconflict/mode-python.js',
'bower_components/ace-builds/src-noconflict/mode-sql.js',
'bower_components/ace-builds/src-noconflict/mode-markdown.js',
'bower_components/ace-builds/src-noconflict/mode-sh.js',
'bower_components/ace-builds/src-noconflict/mode-r.js',
'bower_components/ace-builds/src-noconflict/keybinding-emacs.js',
'bower_components/ace-builds/src-noconflict/ext-language_tools.js',
'bower_components/ace-builds/src-noconflict/theme-chrome.js',
'bower_components/angular-ui-ace/ui-ace.js',
'bower_components/jquery.scrollTo/jquery.scrollTo.js',
'bower_components/d3/d3.js',
'bower_components/nvd3/build/nv.d3.js',
'bower_components/jquery-ui/jquery-ui.js',
'bower_components/angular-dragdrop/src/angular-dragdrop.js',
'bower_components/perfect-scrollbar/src/perfect-scrollbar.js',
'bower_components/ng-sortable/dist/ng-sortable.js',
'bower_components/angular-elastic/elastic.js',
'bower_components/<API key>/dist/<API key>.min.js',
'bower_components/angular-xeditable/dist/js/xeditable.js',
'bower_components/highlightjs/highlight.pack.js',
'bower_components/lodash/lodash.js',
'bower_components/angular-filter/dist/angular-filter.js',
'bower_components/ngtoast/dist/ngToast.js',
'bower_components/ng-focus-if/focusIf.js',
'bower_components/bootstrap3-dialog/dist/js/bootstrap-dialog.min.js',
'bower_components/zeroclipboard/dist/ZeroClipboard.js',
'bower_components/moment/moment.js',
'bower_components/pikaday/pikaday.js',
'bower_components/handsontable/dist/handsontable.js',
'bower_components/<API key>/lib/<API key>.js',
'bower_components/angular-mocks/angular-mocks.js',
// endbower
'src/app/app.js',
'src/app/app.controller.js',
'src/app*.js',
'src/components*.js',
'test/spec*.js'
],
// list of files / patterns to exclude
exclude: [],
// web server port
port: 9002,
// Start these browsers, currently available:
// - Chrome
// - ChromeCanary
// - Firefox
// - Opera
// - Safari (only Mac)
// - PhantomJS
// - IE (only Windows)
browsers: [
'PhantomJS'
],
reporters: ['coverage','progress'],
preprocessors: {
'src/*/{*.js,!(test)/**/*.js}': 'coverage'
},
coverageReporter: {
type: 'html',
dir: '../reports/<API key>',
subdir: '.'
},
// Which plugins to enable
plugins: [
'<API key>',
'karma-jasmine',
'karma-coverage'
],
// Continuous Integration mode
// if true, it capture browsers, run tests and exit
singleRun: false,
colors: true,
// level of logging
// possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
logLevel: config.LOG_INFO,
// Uncomment the following lines if you are using grunt's server to run the tests
// proxies: {
// URL root prevent conflicts with the site root
// urlRoot: '_karma_'
});
};
|
package com.github.xpenatan.gdx.backends.dragome;
import com.github.xpenatan.gdx.backend.web.<API key>;
/**
* @author xpenatan
*/
public abstract class <API key> extends <API key> {
}
|
#include "Array.h"
#include "mpifftw++.h"
#include "utils.h"
using namespace std;
using namespace utils;
using namespace fftwpp;
using namespace Array;
inline void init(array3<double> f, split3 d)
{
for(unsigned int i=0; i < d.x; ++i) {
unsigned int ii=d.x0+i;
for(unsigned int j=0; j < d.y; j++) {
unsigned int jj=d.y0+j;
for(unsigned int k=0; k < d.Z; k++) {
f(i,j,k)=ii+jj+k+1;
}
}
}
}
int main(int argc, char* argv[])
{
unsigned int outlimit=3000;
#ifndef __SSE2__
fftw::effort |= FFTW_NO_SIMD;
#endif
int retval=0;
// Default number of iterations.
unsigned int N0=10000000;
unsigned int N=0;
int divisor=0; // Test for best block divisor
int alltoall=-1; // Test for best alltoall routine
unsigned int nx=4;
unsigned int ny=0;
unsigned int nz=0;
bool inplace=false;
bool quiet=false;
bool test=false;
bool shift=false;
unsigned int stats=0; // Type of statistics used in timing test.
int provided;
MPI_Init_thread(&argc,&argv,MPI_THREAD_FUNNELED,&provided);
int rank;
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
if(rank != 0) opterr=0;
#ifdef __GNUC__
optind=0;
#endif
for (;;) {
int c = getopt(argc,argv,"S:hti:N:O:T:a:i:m:n:s:x:y:z:q");
if (c == -1) break;
switch (c) {
case 0:
break;
case 'a':
divisor=atoi(optarg);
break;
case 'i':
inplace=atoi(optarg);
break;
case 'N':
N=atoi(optarg);
break;
case 'm':
nx=ny=nz=atoi(optarg);
break;
case 's':
alltoall=atoi(optarg);
break;
case 'x':
nx=atoi(optarg);
break;
case 'y':
ny=atoi(optarg);
break;
case 'z':
nz=atoi(optarg);
break;
case 'n':
N0=atoi(optarg);
break;
case 'O':
shift=atoi(optarg);
break;
case 'S':
stats=atoi(optarg);
break;
case 'T':
fftw::maxthreads=atoi(optarg);
break;
case 'q':
quiet=true;
break;
case 't':
test=true;
break;
case 'h':
default:
if(rank == 0) {
usage(3);
usageTranspose();
usageShift();
}
exit(1);
}
}
if(ny == 0) ny=nx;
if(nz == 0) nz=nx;
if(N == 0) {
N=N0/nx/ny/nz;
if(N < 10) N=10;
}
unsigned int nzp=nz/2+1;
MPIgroup group(MPI_COMM_WORLD,nx,ny);
if(group.size > 1 && provided < MPI_THREAD_FUNNELED)
fftw::maxthreads=1;
defaultmpithreads=fftw::maxthreads;
if(group.rank < group.size) {
bool main=group.rank == 0;
if(!quiet && main) {
cout << "Configuration: "
<< group.size << " nodes X " << fftw::maxthreads
<< " threads/node" << endl;
cout << "Using MPI VERSION " << MPI_VERSION << endl;
cout << "nx=" << nx << ", ny=" << ny << ", nz=" << nz << ", nzp=" << nzp
<< endl;
}
bool showresult = nx*ny < outlimit;
split3 df(nx,ny,nz,group);
split3 dg(nx,ny,nzp,group,true);
unsigned int dfZ=inplace ? 2*dg.Z : df.Z;
split3 dfgather(nx,ny,dfZ,group);
array3<Complex> g(dg.x,dg.y,dg.Z,ComplexAlign(dg.n));
array3<double> f;
if(inplace)
f.Dimension(df.x,df.y,2*dg.Z,(double *) g());
else
f.Dimension(df.x,df.y,df.Z,doubleAlign(df.n));
rcfft3dMPI rcfft(df,dg,f,g,mpiOptions(divisor,alltoall));
if(!quiet && group.rank == 0)
cout << "Initialized after " << seconds() << " seconds." << endl;
if(test) {
init(f,df);
if(!quiet && showresult) {
if(main)
cout << "\nDistributed input:" << endl;
show(f(),dfgather.x,dfgather.y,dfgather.Z,group.active);
}
size_t align=sizeof(Complex);
array3<Complex> ggather(nx,ny,nzp,align);
array3<Complex> glocal(nx,ny,nzp,align);
array3<double> fgather(dfgather.X,dfgather.Y,dfgather.Z,align);
array3<double> flocal;
if(inplace)
flocal.Dimension(nx,ny,2*nzp,(double *) glocal());
else
flocal.Allocate(nx,ny,nz,align);
rcfft3d localForward(nx,ny,nz,flocal,glocal);
crfft3d localBackward(nx,ny,nz,glocal,flocal);
gatherxy(f(), flocal(), dfgather, group.active);
gatherxy(f(), fgather(), dfgather, group.active);
if(main && !quiet)
cout << "Gathered input:\n" << fgather << endl;
if(shift)
rcfft.Forward0(f,g);
else
rcfft.Forward(f,g);
if(main) {
if(shift)
localForward.fft0(flocal,glocal);
else
localForward.fft(flocal,glocal);
cout << endl;
}
if(!quiet && showresult) {
if(main)
cout << "Distributed output:" << endl;
show(g(),dg.X,dg.y,dg.z,group.active);
}
gatheryz(g(),ggather(),dg,group.active);
if(!quiet && main)
cout << "Gathered output:\n" << ggather << endl;
if(!quiet && main)
cout << "Local output:\n" << glocal << endl;
if(main)
retval += checkerror(glocal(),ggather(),dg.X*dg.Y*dg.Z);
if(shift)
rcfft.Backward0(g,f);
else
rcfft.Backward(g,f);
rcfft.Normalize(f);
if(!quiet && showresult) {
if(main)
cout << "Distributed back to input:" << endl;
show(f(),dfgather.x,dfgather.y,dfgather.Z,group.active);
}
gatherxy(f(),fgather(),dfgather,group.active);
if(!quiet && main)
cout << "Gathered back to input:\n" << fgather << endl;
if(main) {
if(shift)
localBackward.fft0Normalized(glocal,flocal);
else
localBackward.fftNormalized(glocal,flocal);
}
if(!quiet && main)
cout << "Local back to input:\n" << flocal << endl;
if(main)
retval += checkerror(flocal(),fgather(),df.Z,df.X*df.Y,dfgather.Z);
if(!quiet && group.rank == 0) {
cout << endl;
if(retval == 0)
cout << "pass" << endl;
else
cout << "FAIL" << endl;
}
} else {
if(main) cout << "N=" << N << endl;
double *T=new double[N];
for(unsigned int i=0; i < N; ++i) {
init(f,df);
if(shift) {
seconds();
rcfft.Forward0(f,g);
rcfft.Backward0(g,f);
T[i]=0.5*seconds();
rcfft.Normalize(f);
} else {
seconds();
rcfft.Forward(f,g);
rcfft.Backward(g,f);
T[i]=0.5*seconds();
rcfft.Normalize(f);
}
}
if(!quiet && showresult)
show(f(),df.x,df.y,dfZ,0,0,0,df.x,df.y,df.Z,group.active);
if(main) timings("FFT timing:",nx,T,N,stats);
delete[] T;
}
deleteAlign(g());
if(!inplace) deleteAlign(f());
}
MPI_Finalize();
return retval;
}
|
using System;
using Akka.Actor;
using Akka.TestKit;
using Akka.Util.Internal;
using FluentAssertions;
using Xunit;
using Xunit.Abstractions;
namespace Akka.Cluster.Tests.Serialization
{
<summary>
https://github.com/akkadotnet/akka.net/issues/3724
Used to validate that `akka.actor.serialize-messages = on` works while
using Akka.Cluster
</summary>
public class BugFix3724Spec : AkkaSpec
{
public BugFix3724Spec(ITestOutputHelper helper)
: base(@"akka.actor.provider = cluster
akka.actor.serialize-messages = on", helper)
{
_cluster = Cluster.Get(Sys);
_selfAddress = Sys.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
}
private readonly Address _selfAddress;
private readonly Cluster _cluster;
[Fact(DisplayName = "Should be able to use 'akka.actor.serialize-messages' while running Akka.Cluster")]
public void <API key>()
{
_cluster.Subscribe(TestActor, ClusterEvent.<API key>.<API key>,
typeof(ClusterEvent.MemberUp));
Within(TimeSpan.FromSeconds(10), () =>
{
EventFilter.Exception<Exception>().Expect(0, () =>
{
// wait for a singleton cluster to fully form and publish a member up event
_cluster.Join(_selfAddress);
var up = ExpectMsg<ClusterEvent.MemberUp>();
up.Member.Address.Should().Be(_selfAddress);
});
});
}
}
}
|
package com.github.mongobee.changeset;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Class containing particular changesets (@{@link ChangeSet})
* @author lstolowski
* @since 27/07/2014
* @see ChangeSet
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ChangeLog {
/**
* Sequence that provide an order for changelog classes.
* If not set, then canonical name of the class is taken and sorted alphabetically, ascending.
* @return order
*/
String order() default "";
}
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CSharpKoans.Core;
using System.Xml.Linq;
using System.IO;
using NUnit.Framework;
namespace CSharpKoans
{
public class AboutLinqToXml :KoanContainer
{
XDocument senatorsDoc = XDocument.Load(Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "senators_cfm.xml"));
XDocument nutritionDoc = XDocument.Load(Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "nutrition.xml"));
const int ___ = int.MaxValue;
string[] FILLMEIN = new string[] { } ;
public class Senator
{
public string LastName { get; set; }
public string Party { get; set; }
public string Website { get; set; }
}
// [Koan]
public void <API key>()
{
var contactInfo = senatorsDoc.Root;
/* contactInfo is the root node */
Assert.AreEqual(___, contactInfo.Name.LocalName);
Assert.AreEqual(___, contactInfo.Parent);
Assert.AreEqual(___, contactInfo.HasElements);
/* Elements() are the direct child nodes of a parent node */
Assert.AreEqual(___, contactInfo.Elements().Count());
/* Descendants are all the children at any level. */
Assert.AreEqual(___, contactInfo.Descendants().Count());
}
// [Koan]
public void <API key>()
{
var contactInfo = senatorsDoc.Root;
var senators = from s in contactInfo.Elements()
select s;
var firstSenator = senators.First();
Assert.AreEqual(___, firstSenator.Name.LocalName);
Assert.AreEqual(___, firstSenator.Parent.Name.LocalName);
Assert.AreEqual(___, firstSenator.HasElements);
/* ancestors are the opposite of descendants */
Assert.AreEqual(___, firstSenator.Ancestors().Count());
/* Elements() are the direct child nodes of a parent node */
Assert.AreEqual(___, firstSenator.Elements().Count());
/* Descendants are all the children at any level. */
Assert.AreEqual(___, firstSenator.Descendants().Count());
/* searching for an child node with a specific name returns all matching child nodes */
var lastNameNodes = firstSenator.Elements("last_name");
Assert.AreEqual(___, lastNameNodes.Count());
var lastName = lastNameNodes.First();
/* Name vs. Value for a node */
Assert.AreEqual(___, lastName.Name.LocalName);
Assert.AreEqual(___, lastName.Value);
}
[Koan]
public void <API key>()
{
var contactInfo = senatorsDoc.Root;
var senators = contactInfo.Elements();
/* OR: from var s contactInfo.Elements select s; */
var firstSenator = senators.First();
/* you could also query the elements using LINQ */
var state = from e in firstSenator.Elements()
where e.Name == "state"
select e.Value;
Assert.AreEqual(___, state.Count());
Assert.AreEqual(___, state.First());
}
[Koan]
public void <API key>()
{
var contactInfo = senatorsDoc.Root;
var nameOfThirdSenator = from s in contactInfo.Elements()
// fill in query here
select s;
/* write a line of code that gets the last_name of the third XElement in the "senators" list */
Assert.AreEqual("Ayotte", nameOfThirdSenator);
}
[Koan]
public void <API key>()
{
var contactInfo = senatorsDoc.Root;
/* write a LINQ query to generate a list of Senator objects from the senator document
hint: select new Senator() */
var senatorObjects = new List<Senator>();
Assert.AreEqual("", senatorObjects.Last().LastName);
/* query the senators (in their object form) to select only the democrats (party = D) */
var democrats = from s in senatorObjects
// add a where clause here
select s;
Assert.AreEqual(50, democrats.Count());
/* write a query to return the names of the republicans in alphabetical order */
var orderedRepubs = from s in senatorObjects
// write the correct query here
select s;
/* don't change this: just make sure it passes */
Assert.IsInstanceOf<IEnumerable<Senator>>(orderedRepubs);
/* Write a query to find the state of the Independent senator. (Party = ID) */
var state = "Replace this string with a LINQ to XML Query";
Assert.AreEqual(state, "CT");
}
public class Food
{
/* you will need to fill this in */
}
[Koan]
public void <API key>()
{
var root = nutritionDoc.Root;
/* Write a query to capture the data in the xml document as an enumerable of type Food.
* You will need to create the Food class first */
// IEnumerable<Food> food = null;
}
}
}
|
package com.tkmtwo.sarapi.mapping;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import com.bmc.arsys.api.Entry;
import com.bmc.arsys.api.Value;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.tkmtwo.sarapi.ArsDataType;
import com.tkmtwo.sarapi.ArsSchemaHelper;
import com.tkmtwo.sarapi.ArsTemplate;
import com.tkmtwo.sarapi.support.EntryUtil;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.convert.ConversionService;
import org.springframework.dao.DataAccessException;
import org.springframework.test.context.<API key>;
import org.springframework.test.context.junit4.<API key>;
public final class PersonFormDao
extends AbstractFormDao<Person> {
MappingQuery<Person> personByFirstName = null;
MappingQuery<String> <API key> = null;
public EntryMapper<Person> newEntryMapper(ArsTemplate at,
ConversionService cs,
ArsSchemaHelper ash,
String fn) {
PersonMapper pm = new PersonMapper();
pm.setTemplate(getTemplate());
pm.<API key>(<API key>());
pm.setSchemaHelper(getSchemaHelper());
pm.setFormName(getFormName());
pm.afterPropertiesSet();
return pm;
}
public void initDao()
throws DataAccessException {
logger.info("PersonFormDao coming up");
personByFirstName = newMappingQuery("'First Name' LIKE ${firstName}");
<API key> = <API key>("'Character Field' = ${charField}",
"SARAPI:TestFields",
"Character Field");
}
public List<String> <API key>(String charField) {
ImmutableMap<String, Value> vs = ImmutableMap.of("charField", ArsDataType.CHAR.getArValue(charField));
return <API key>.getObjects(vs);
}
public List<Person> <API key>(String firstNameLike) {
return personByFirstName.getObjects(ImmutableMap.of("firstName",
ArsDataType.CHAR.getArValue(firstNameLike)));
}
public Person <API key>(String firstNameLike) {
return personByFirstName.getObject(ImmutableMap.of("firstName",
ArsDataType.CHAR.getArValue(firstNameLike)));
}
public Person <API key>(String firstNameLike) {
return personByFirstName.getObjectNullable(ImmutableMap.of("firstName",
ArsDataType.CHAR.getArValue(firstNameLike)));
}
}
|
package goryachev.common.io;
import goryachev.common.util.CList;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
public class CSVReader
implements Closeable
{
public final CSVParser parser;
private BufferedReader rd;
private boolean hasNext = true;
private int skipLineCount;
private boolean linesSkipped;
public CSVReader(Reader rd)
{
this.rd = new BufferedReader(rd);
this.parser = new CSVParser();
}
public CSVReader(String text)
{
this(new StringReader(text));
}
public void setSeparatorChar(char c)
{
parser.setSeparatorChar(c);
}
public void setQuoteChar(char c)
{
parser.setQuoteChar(c);
}
public void setEscapeChar(char c)
{
parser.setEscapeChar(c);
}
public void setStrictQuotes(boolean on)
{
parser.setStrictQuotes(on);
}
public void <API key>(boolean on)
{
parser.<API key>(on);
}
public void setSkipLineCount(int n)
{
skipLineCount = n;
}
public CList<String[]> read() throws Exception
{
CList<String[]> cells = new CList<String[]>();
while(hasNext)
{
String[] nextLineAsTokens = readNext();
if(nextLineAsTokens != null)
{
cells.add(nextLineAsTokens);
}
}
return cells;
}
public String[] readNext() throws Exception
{
String[] result = null;
do
{
String nextLine = getNextLine();
if(!hasNext)
{
return result;
}
String[] r = parser.parseLineMulti(nextLine);
if(r.length > 0)
{
if(result == null)
{
result = r;
}
else
{
String[] t = new String[result.length + r.length];
System.arraycopy(result, 0, t, 0, result.length);
System.arraycopy(r, 0, t, result.length, r.length);
result = t;
}
}
} while(parser.isPending());
return result;
}
protected String getNextLine() throws Exception
{
if(!linesSkipped)
{
for(int i = 0; i < skipLineCount; i++)
{
rd.readLine();
}
linesSkipped = true;
}
String nextLine = rd.readLine();
if(nextLine == null)
{
hasNext = false;
}
return hasNext ? nextLine : null;
}
public void close() throws IOException
{
rd.close();
}
}
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Numerics;
using System.Threading;
using System.Windows.Forms.DataVisualization.Charting; // For plotting graphs
using CMath.PolynomialEquation;
using CMath.PolynomialSolver;
using CMath.Trie;
using CMath.Utils;
namespace CalculatorUI
{
/*
* Search for TODOs using the `TODO` keyword for the upcoming work.
*/
<summary>
Enum that holds the operation to be stored / processed
</summary>
<!--Whatever opeation to be added later should be added here along with another old-like version of it ex:
<!--GCD , OldGCD
public enum OperationTypeEnum
{
Addition,
Subtraction,
Multiplication,
Division,
Modulus,
Gcd,
DerivativeFirst,
DerivativeSecond,
SubstitutionFirst,
SubstitutionSecond,
SolveFirst,
SolveSecond,
IntegralFirst,
IntegralSecond,
<API key>,
<API key>,
PolynomialAccepted,
OldMultiplication,
OldModulus,
OldDivision,
OldAddition,
OldSubtration,
OldGcd,
OldDerivative,
OldSubstitution,
OldSolve,
OldIntegral,
OldDefiniteIntegral
}
public partial class MainForm : Form
{
#region Internal Declrations
internal Polynomial polynomial1, polynomial2, resultPolynomial;
internal Solver _solverInstance;
internal List<Complex> roots;
internal Complex subResult,X1,X2;
internal Thread exitThread, saveThread, loadThread;
//If not found wil be created
internal string tip = "tip : ";
//Definite integral
internal Complex poly1DefIntegralA = 0, poly1DefIntegralB = 0;
internal Complex poly2DefIntegralA = 0, poly2DefIntegralB = 0;
#endregion
public MainForm()
{
InitializeComponent();
exitThread = new Thread(ExitThread);
saveThread = new Thread(() => SaveThread(Program.filePath));
loadThread = new Thread(() => LoadThread(Program.filePath));
//Initialize display,value members for later history viewing
historyListBox.DisplayMember = "DisplayName";
historyListBox.ValueMember = "returnType";
//Load colerd font properties
LoadColorFont(polynomial1Text);
LoadColorFont(polynomial2Text);
LoadColorFont(resPolyText);
}
private void MainForm_Load(object sender, EventArgs e)
{
Program._logItems.Add("Log started " + DateTime.Now.ToShortTimeString());
string[] lines = System.IO.File.ReadAllLines("help.txt");
DateTime start = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
Random rand = new Random((int)(DateTime.Now - start).TotalSeconds);
int n = lines.Length - 1;
while (n < 0 || n > lines.Length - 1 || String.IsNullOrWhiteSpace(lines[n]))
{
n = rand.Next(0, lines.Length - 1);
}
tip = "Tip : " + lines[n];
Polynomial1Chart.Series["Polynomial1"].Color = Properties.Settings.Default.Polynomial1Color;
Polynomial1Chart.Series["Polynomial2"].Color = Properties.Settings.Default.Polynomial2Color;
Polynomial1Chart.Series["Result Polynomial"].Color = Properties.Settings.Default.ResultPolyColor;
}
#region Multithreading
<summary>
A thread to handle exit process
</summary>
internal void ExitThread()
{
Program._saveMan.trySave(Program._historyTrie,Program.filePath);
Application.Exit();
}
<summary>
A thread to handle save operation
</summary>
internal void SaveThread(String File)
{
if(File.EndsWith(".plcl"))
Program._saveMan.trySave(Program._historyTrie, File);
else if(File.EndsWith(".xlsx"))
Program._saveMan.saveExcel(Program._historyTrie,File);
}
<summary>
A thread to handle load operation
</summary>
internal void LoadThread(string File)
{
Program._historyTrie = Program._saveMan.tryLoad(File);
}
#endregion
#region Solve
<summary>
Show roots of polynomial in the roots log panel
</summary>
public void ShowRoots()
{
rootsTextBox.Clear();
StringBuilder result = new StringBuilder();
result.AppendLine("Polynomial roots:");
foreach (var item in roots)
{
result.AppendLine(ComplexUtils.ComplexToString(item));
}
rootsTextBox.Text = result.ToString();
}
<summary>
Instantiate solver with a polynomial, and returns the reults in complex numbers list.
</summary>
<param name="_poly"></param>
<param name="result"></param>
void SolvePolynomial(Polynomial _poly, ref List<Complex> result)
{
_solverInstance = new Solver(_poly);
roots = _solverInstance.solve().ToList();
}
#endregion
#region History
//TODO: use temp file for logging information.
<summary>
Logs an operation into the Log Panel and History
</summary>
<param name="_operation">Operation type to be logged</param>
public void LogOperation(OperationTypeEnum _operation)
{
HistoryLog hL;
switch (_operation)
{
case OperationTypeEnum.Addition:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Added Polynomials.");
Program._historyTrie.insert(polynomial1, '+', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, '+', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.Subtraction:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Subtracted Polynomials.");
Program._historyTrie.insert(polynomial1, '-', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, '-', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.Multiplication:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Multiplied Polynomials.");
Program._historyTrie.insert(polynomial1, '*', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, '*', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.Modulus:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Reminder Polynomial Calculated.");
Program._historyTrie.insert(polynomial1, '%', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, '%', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.Division:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Divided Polynomials.");
Program._historyTrie.insert(polynomial1, '/', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, '/', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.Gcd:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Greatest Common Divisor Polynomial computed.");
Program._historyTrie.insert(polynomial1, 'g', polynomial2, resultPolynomial);
hL = new HistoryLog(polynomial1, polynomial2, 'g', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.SolveFirst:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " First Polynomial Solved.");
Program._historyTrie.insert(polynomial1, 'r', roots);
hL = new HistoryLog(polynomial1, roots, 'r', DateTime.Now.TimeOfDay.ToString());
LogItem(hL);
break;
case OperationTypeEnum.SolveSecond:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Second Polynomial Solved.");
Program._historyTrie.insert(polynomial2, 'r', roots);
hL = new HistoryLog(polynomial2, roots, 'r', DateTime.Now.TimeOfDay.ToString());
LogItem(hL);
break;
case OperationTypeEnum.DerivativeFirst:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " First Polynomial Diffrentiated.");
Program._historyTrie.insert(polynomial1, '^',resultPolynomial);
hL = new HistoryLog(polynomial1,'^', DateTime.Now.TimeOfDay.ToString(),resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.DerivativeSecond:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Second Polynomial Diffrentiated.");
Program._historyTrie.insert(polynomial2, '^',resultPolynomial);
hL = new HistoryLog(polynomial2, '^', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.IntegralFirst:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " First Polynomial Integrated.");
Program._historyTrie.insert(polynomial1, 'I', resultPolynomial);
hL = new HistoryLog(polynomial1, 'I', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.IntegralSecond:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Second Polynomial Integrated.");
Program._historyTrie.insert(polynomial2, 'I', resultPolynomial);
hL = new HistoryLog(polynomial2, 'I', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.SubstitutionFirst:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Substituted in First Polynomial.");
Program._historyTrie.insert(polynomial1, 's', new List<Complex> { X1 }, subResult);
hL = new HistoryLog(polynomial1, new List<KeyValuePair<Char,Complex> >
{ new KeyValuePair<Char,Complex>('X',X1) }
, 's', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.SubstitutionSecond:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Substituted in Second Polynomial.");
Program._historyTrie.insert(polynomial2, 's', new List<Complex> { X2 }, subResult);
hL = new HistoryLog(polynomial2, new List<KeyValuePair<Char,Complex> > {
new KeyValuePair<Char,Complex>('X',X2) }
, 's', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.<API key>:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " First Polynomial Definite Integral Calculated.");
Program._historyTrie.insert(polynomial1, 'd', new List<Complex> { poly1DefIntegralA, poly1DefIntegralB }, subResult);
hL = new HistoryLog(polynomial1, new List<KeyValuePair<Char, Complex>> {
new KeyValuePair<Char, Complex>('A', poly1DefIntegralA),
new KeyValuePair<Char, Complex>('B', poly1DefIntegralB)}
, 'd', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.<API key>:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Second Polynomial Definite Integral Calculated.");
Program._historyTrie.insert(polynomial2, 'd', new List<Complex> { poly2DefIntegralA, poly2DefIntegralB }, subResult);
hL = new HistoryLog(polynomial2, new List<KeyValuePair<Char, Complex>> {
new KeyValuePair<Char, Complex>('A', poly2DefIntegralA),
new KeyValuePair<Char, Complex>('B', poly2DefIntegralB)}
, 'd', DateTime.Now.TimeOfDay.ToString(), resultPolynomial);
LogItem(hL);
break;
case OperationTypeEnum.OldDivision:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Division retrieved.");
break;
case OperationTypeEnum.OldGcd:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Greatest Common Divisor retrieved.");
break;
case OperationTypeEnum.OldModulus:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Reminder Polynomial retrieved.");
break;
case OperationTypeEnum.OldMultiplication:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Multiplication retrieved.");
break;
case OperationTypeEnum.OldSubtration:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Subtraction retrieved.");
break;
case OperationTypeEnum.OldAddition:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Addition retrieved.");
break;
case OperationTypeEnum.OldDerivative:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Derivative retrieved.");
break;
case OperationTypeEnum.OldIntegral:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Integration retrieved.");
break;
case OperationTypeEnum.OldSubstitution:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Substitution retrieved.");
break;
case OperationTypeEnum.OldSolve:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Polynomial root retrieved.");
break;
case OperationTypeEnum.PolynomialAccepted:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Polynomial entered.");
break;
case OperationTypeEnum.OldDefiniteIntegral:
Program._logItems.Add(DateTime.Now.ToShortTimeString() + " Polynomial definite integral retrieved.");
break;
default:
throw new ArgumentException("Unsupported operation");
}
}
<summary>
Adds item to HistoryBox
</summary>
<param name="_log">History Log to insert</param>
internal void LogItem(HistoryLog _log)
{
switch (_log.Operation)
{
case '+':
_log.DisplayName += " Addition";
break;
case '-':
_log.DisplayName += " Subtraction";
break;
case '*':
_log.DisplayName += " Multiplication";
break;
case '/':
_log.DisplayName += " Division";
break;
case '%':
_log.DisplayName += " Modulus";
break;
case 'r':
_log.DisplayName += " Root finding";
break;
case 'g':
_log.DisplayName += " GCD";
break;
case '^':
_log.DisplayName += " Derivative";
break;
case 'I':
_log.DisplayName += " Integral";
break;
case 's':
_log.DisplayName += " Substitution";
break;
case 'd':
_log.DisplayName += " Definite Integral";
break;
}
historyListBox.Items.Add(_log);
}
private void <API key>(object sender, EventArgs e)
{
HistoryLogViewForm hForm = new HistoryLogViewForm(historyListBox.SelectedItem as HistoryLog);
showForm(hForm, this, setClose);
}
#endregion
<summary>
Performs the requested operation from the pressed button
</summary>
<!--Casts the sender as GlassButton then switch over the Tag property then execute operation
private void PerformOperation(object sender, EventArgs e)
{
Polynomial searchResult;
Object dynamicResult;
try
{
rootsTextBox.Clear();
switch ((sender as Glass.GlassButton).Tag as string)
{
case "Add":
if (Program._historyTrie.try_search(polynomial1, '+', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldAddition);
}
else
{
resultPolynomial = polynomial1 + polynomial2;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Addition);
}
break;
case "Subtract":
if (Program._historyTrie.try_search(polynomial1, '-', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldSubtration);
}
else
{
resultPolynomial = polynomial1 - polynomial2;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Subtraction);
}
break;
case "Multiply":
if (Program._historyTrie.try_search(polynomial1, '*', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldMultiplication);
}
else
{
resultPolynomial = polynomial1 * polynomial2;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Multiplication);
}
break;
case "Division":
if (Program._historyTrie.try_search(polynomial1, '/', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldDivision);
}
else
{
resultPolynomial = polynomial1 / polynomial2;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Division);
}
break;
case "Modulus":
if (Program._historyTrie.try_search(polynomial1, '%', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldModulus);
}
else
{
resultPolynomial = polynomial1 % polynomial2;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Modulus);
}
break;
case "GCD":
if (Program._historyTrie.try_search(polynomial1, 'g', polynomial2, out searchResult))
{
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldGcd);
}
else
{
resultPolynomial = Polynomial.__gcd(polynomial1, polynomial2);
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.Gcd);
}
break;
case "Find X1":
if (Program._historyTrie.try_search(polynomial1, 'r', out dynamicResult))
{
roots = dynamicResult as List<Complex>;
LogOperation(OperationTypeEnum.OldSolve);
}
else
{
SolvePolynomial(polynomial1, ref roots);
LogOperation(OperationTypeEnum.SolveFirst);
}
ShowRoots();
break;
case "Find X2":
if (Program._historyTrie.try_search(polynomial2, 'r', out dynamicResult))
{
roots = dynamicResult as List<Complex>;
LogOperation(OperationTypeEnum.OldSolve);
}
else
{
SolvePolynomial(polynomial2, ref roots);
LogOperation(OperationTypeEnum.SolveSecond);
}
ShowRoots();
break;
case "derivative1":
if (Program._historyTrie.try_search(polynomial1, '^', out dynamicResult))
{
searchResult = (Polynomial)dynamicResult;
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldDerivative);
}
else
{
resultPolynomial = polynomial1.derivative;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.DerivativeFirst);
}
break;
case "derivative2":
if (Program._historyTrie.try_search(polynomial2, '^', out dynamicResult))
{
searchResult = (Polynomial)dynamicResult;
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldDerivative);
}
else
{
resultPolynomial = polynomial2.derivative;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.DerivativeSecond);
}
break;
case "int1":
if (Program._historyTrie.try_search(polynomial1, 'I', out dynamicResult))
{
searchResult = (Polynomial)dynamicResult;
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldIntegral);
}
else
{
resultPolynomial = polynomial1.Integral;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.IntegralFirst);
}
break;
case "int2":
if (Program._historyTrie.try_search(polynomial2, 'I', out dynamicResult))
{
searchResult = (Polynomial)dynamicResult;
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldIntegral);
}
else
{
resultPolynomial = polynomial2.Integral;
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.IntegralSecond);
}
break;
case "Sub1":
if (!ComplexUtils.TryParseComplex(textBox1.Text, out X1))
{
MessageBox.Show("Wrong complex format");
return;
}
if (Program._historyTrie.try_search(polynomial1, 's', new List<Complex> {X1}, out subResult))
{
searchResult = new Polynomial();
searchResult.Add(new Term(0,subResult));
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldSubstitution);
}
else
{
subResult = polynomial1.substitute(X1);
resultPolynomial = new Polynomial();
resultPolynomial.Add(new Term(0, subResult));
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.SubstitutionFirst);
}
break;
case "Sub2":
if (!ComplexUtils.TryParseComplex(textBox2.Text, out X2))
{
MessageBox.Show("Wrong complex format");
return;
}
if (Program._historyTrie.try_search(polynomial2, 's', new List<Complex> { X2 }, out subResult))
{
searchResult = new Polynomial();
searchResult.Add(new Term(0,subResult));
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldSubstitution);
}
else
{
subResult = polynomial2.substitute(X2);
resultPolynomial = new Polynomial();
resultPolynomial.Add(new Term(0, subResult));
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.SubstitutionSecond);
}
break;
case "DefInt1":
if (!ComplexUtils.TryParseComplex(textBox3.Text, out poly1DefIntegralA) || !ComplexUtils.TryParseComplex(textBox4.Text, out poly1DefIntegralB))
{
MessageBox.Show("Wrong complex format");
return;
}
if (Program._historyTrie.try_search(polynomial1, 'd', new List<Complex> { poly1DefIntegralA, poly1DefIntegralB }, out subResult))
{
searchResult = new Polynomial();
searchResult.Add(new Term(0, subResult));
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldDefiniteIntegral);
}
else
{
subResult = polynomial1.definite_integral(poly1DefIntegralA,poly1DefIntegralB);
resultPolynomial = new Polynomial();
resultPolynomial.Add(new Term(0, subResult));
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.<API key>);
}
break;
case "DefInt2":
if (!ComplexUtils.TryParseComplex(textBox6.Text, out poly2DefIntegralA) || !ComplexUtils.TryParseComplex(textBox5.Text, out poly2DefIntegralB))
{
MessageBox.Show("Wrong complex format");
return;
}
if (Program._historyTrie.try_search(polynomial2, 'd', new List<Complex> { poly2DefIntegralA, poly2DefIntegralB }, out subResult))
{
searchResult = new Polynomial();
searchResult.Add(new Term(0, subResult));
PolynomialParse(searchResult, resPolyText, true);
LogOperation(OperationTypeEnum.OldDefiniteIntegral);
}
else
{
subResult = polynomial2.definite_integral(poly2DefIntegralA,poly2DefIntegralB);
resultPolynomial = new Polynomial();
resultPolynomial.Add(new Term(0, subResult));
PolynomialParse(resultPolynomial, resPolyText, true);
LogOperation(OperationTypeEnum.<API key>);
}
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (saveThread.IsAlive || loadThread.IsAlive)
{
polynomial1Text.Enabled = false;
polynomial2Text.Enabled = false;
groupBox5.Enabled = false;
}
else
{
polynomial1Text.Enabled = true;
polynomial2Text.Enabled = true;
groupBox5.Enabled = true;
tipLabel.Text = Program._logItems.Count == 0 ? tip : "Log:"+ Program._logItems.Last();
}
if (saveThread.IsAlive)
tipLabel.Text = "Please wait saving...";
else if(loadThread.IsAlive)
tipLabel.Text = "Please wait loading...";
<API key>.Text = DateTime.Now.ToShortDateString() + ' ' + DateTime.Now.ToShortTimeString();
}
#region ToolStripMenuItems
private void <API key>(object sender, EventArgs e)
{
this.Close();
}
private void <API key>(object sender, EventArgs e)
{
saveThread = new Thread(() => SaveThread(Program.filePath));
saveThread.Start();
}
private void <API key>(object sender, EventArgs e)
{
SaveFileDialog newFile = new SaveFileDialog();
newFile.Filter = "History Files (*.plcl)|*.plcl";
if (newFile.ShowDialog() != DialogResult.OK) return;
if(!newFile.FileName.EndsWith(".plcl")) newFile.FileName += ".plcl";
saveThread = new Thread(() => SaveThread(newFile.FileName));
saveThread.Start();
}
private void <API key>(object sender, EventArgs e)
{
OpenFileDialog newFile = new OpenFileDialog();
newFile.Filter = "History Files (*.plcl)|*.plcl";
newFile.FileName = "";
while (!newFile.FileName.EndsWith(".plcl"))
{
if (newFile.ShowDialog() != DialogResult.OK) return;
}
loadThread = new Thread(() => LoadThread(newFile.FileName));
<API key>(null, null);
loadThread.Start();
}
private void <API key>(object sender, EventArgs e)
{
SaveFileDialog newFile = new SaveFileDialog();
newFile.Filter = "Excel file (*.xlsx)|*.xlsx";
if (newFile.ShowDialog() != DialogResult.OK) return;
if (!newFile.FileName.EndsWith(".xlsx")) newFile.FileName += ".xlsx";
saveThread = new Thread(() => SaveThread(newFile.FileName));
saveThread.Start();
}
<summary>
Clears items stored in log, disposes history trie and deletes history log file
reinitiates the log panel, polynomials input text boxes,roots log and history log
reinitiate the colored font settings.
</summary>
private void <API key>(object sender, EventArgs e)
{
if (MessageBox.Show("Are you sure you want to clear all past operations ?\n this action cannot be reverse", "Alert", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == System.Windows.Forms.DialogResult.Yes)
{
System.IO.File.Delete(Program.filePath);
Program._historyTrie.Dispose();
historyListBox.Items.Clear();
Program._logItems.Clear();
Program._logItems.Add("Log started " + DateTime.Now.ToShortTimeString());
polynomial1Text.Text = "Polynomial1";
polynomial2Text.Text = "Polynomial2";
resPolyText.Text = "Result";
rootsTextBox.Clear();
LoadColorFont(polynomial1Text);
LoadColorFont(polynomial2Text);
LoadColorFont(resPolyText);
}
}
#endregion
// Load history logs
private void <API key>(object sender, <API key> e)
{
if (Properties.Settings.Default.AskOnExit)
{
if (MessageBox.Show("Are you sure you want to exit?", " Exit ?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
exitThread.Start();
}
else
{
e.Cancel = true;
}
}
else
{
exitThread.Start();
}
}
#region Form Switch Handlers
<summary>
Close handler of the form, applies settings on close and renables the owner form
</summary>
public void setClose(object sender, FormClosedEventArgs e)
{
this.Enabled = true;
//If customization form
if (((sender as Form).Tag as String) == "cstForm")
{
LoadColorFont(polynomial1Text);
LoadColorFont(polynomial2Text);
LoadColorFont(resPolyText);
Polynomial1Chart.Series["Polynomial1"].Color = Properties.Settings.Default.Polynomial1Color;
Polynomial1Chart.Series["Polynomial2"].Color = Properties.Settings.Default.Polynomial2Color;
Polynomial1Chart.Series["Result Polynomial"].Color = Properties.Settings.Default.ResultPolyColor;
}
tipLabel.BackColor = SystemColors.Control;
}
<summary>
Shows a form and disable the owner form till user closes the on top form
</summary>
<param name="frm">Form to show</param>
<param name="owner">Form to be disabled</param>
<param name="closeHandle">Handler of enable/disable</param>
private void showForm(Form frm, Form owner, <API key> closeHandle)
{
frm.Owner = owner;
frm.Show();
frm.Activate();
owner.Enabled = false;
frm.FormClosed += new <API key>(closeHandle);
}
private void <API key>(object sender, EventArgs e)
{
showForm(new Credits(), this, setClose);
}
private void <API key>(object sender, EventArgs e)
{
showForm(new CustomizeForm(), this, setClose);
}
private void <API key>(object sender, EventArgs e)
{
showForm(new LicenseForm(), this, setClose);
}
#endregion
#region RTF Handling
#region Parsing Algorithms
<summary>
Parse polynomial from rich text box
</summary>
<param name="_rtBox">RichTextBox that contains the data</param>
<returns></returns>
internal Polynomial PolynomialParse(RichTextBox _rtBox)
{
//string _deg = "", _coeff = "";
SortedList<int, Complex> sList = new SortedList<int, Complex>();
string expr = _rtBox.Text;
int delay = 0;
for (int i = 0; i < _rtBox.TextLength; i++)
{
_rtBox.SelectionStart = i;
_rtBox.SelectionLength = 1;
if (_rtBox.SelectionCharOffset > 0)
expr = expr.Insert(i + (delay++), "^");
}
expr = expr.Replace("-X", "-1X");
expr = expr.Replace("-x", "-1x");
expr = expr.Replace("+X", "+1X");
expr = expr.Replace("+x", "+1x");
if (expr.StartsWith("X",true,System.Globalization.CultureInfo.CurrentCulture))
expr = "1" + expr;
string[] terms =expr.Replace("-", "+-").Split(new char[] { '+' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string s in terms)
{
if (s.Contains('x') || s.Contains('X'))
{
if (s.Contains('^'))
{
string[] cofpow = s.Split(new string[] { "x^", "X^" }, StringSplitOptions.RemoveEmptyEntries);
sList.Add(int.Parse(cofpow[1]), new Complex(double.Parse(cofpow[0]), 0)); // N Coeff
}
else
{
string ts = s.Replace("X", "");
ts = ts.Replace("x", "");
if (ts == "")
ts = "1";
sList.Add(1, new Complex(double.Parse(ts), 0)); //Coeff 1
}
}
else
sList.Add(0, new Complex(double.Parse(s), 0)); //Free term
}
return new Polynomial(sList);
}
<summary>
Parse polynomial to RichTextBox with superscript and base considration
</summary>
<param name="_polynomial">Polynomial to be parsed</param>
<param name="_rtBox">RichTextBox to parse to</param>
internal void PolynomialParse(Polynomial _polynomial, RichTextBox _rtBox, bool isResult)
{
if (isResult)
{
_rtBox.Text = "";
}
for (int i = _polynomial.Count - 1; i >= 0; i
{
if (_polynomial[i].Degree == 0)
{
_rtBox.AppendText(ComplexUtils.ComplexToString(_polynomial[i].Coefficient));
if (i != 0)
{
if (_polynomial[i - 1].Coefficient.Real > 0)
_rtBox.AppendText("+");
}
}
else
{
if (_polynomial[i].Coefficient.Real != 1 || _polynomial[i].Coefficient.Imaginary != 0)
_rtBox.AppendText(ComplexUtils.ComplexToString(_polynomial[i].Coefficient));
_rtBox.AppendText("X");
_rtBox.SelectionCharOffset = 7;
if (_polynomial[i].Degree > 1)
_rtBox.AppendText(_polynomial[i].Degree.ToString());
_rtBox.SelectionCharOffset = 0;
if (i != 0)
{
if (_polynomial[i - 1].Coefficient.Real > 0)
_rtBox.AppendText("+");
}
}
}
if (_polynomial.isnull())
{
_rtBox.Text = "0";
}
if (isResult)
{
LoadColorFont(_rtBox);
DrawOnGraph(_polynomial, Polynomial1Chart, "Result Polynomial");
}
}
#endregion
<summary>
Loads color and font settings to polylnomials text boxes
</summary>
<param name="_rbox"></param>
internal void LoadColorFont(RichTextBox _rbox)
{
for (int i = 0; i < _rbox.TextLength; i++)
{
_rbox.SelectionStart = i;
_rbox.SelectionLength = 1;
_rbox.SelectionFont = Properties.Settings.Default.Font;
_rbox.SelectionColor = Properties.Settings.Default.Color;
}
}
<summary>
Enables superscript writing for power
</summary>
<param name="sender"></param>
<param name="e"></param>
private void SuperScriptOnX(object sender, EventArgs e)
{
RichTextBox rtbox = sender as RichTextBox;
if (rtbox.TextLength != 0)
{
char lastChar = rtbox.Text.Last();
if (lastChar == 'X' || lastChar == 'x')
{
rtbox.SelectionCharOffset = 7;
}
}
}
<summary>
Switch to base and parse polynomial on pressing enter
</summary>
<param name="sender">Control sender</param>
<param name="e">KeyPress Param</param>
private void BaseOnEnter(object sender, KeyPressEventArgs e)
{
try
{
RichTextBox rtBox = sender as RichTextBox;
if (e.KeyChar == (char)Keys.Enter)
{
if (rtBox.SelectionCharOffset > 0)
{
rtBox.SelectionCharOffset = 0;
}
else
{
if ((rtBox.Tag as string) == "Poly1")
{
polynomial1 = PolynomialParse(rtBox);
DrawOnGraph(polynomial1, Polynomial1Chart, "Polynomial1");
}
else if ((rtBox.Tag as string) == "Poly2")
{
polynomial2 = PolynomialParse(rtBox);
DrawOnGraph(polynomial2, Polynomial1Chart, "Polynomial2");
}
LogOperation(OperationTypeEnum.PolynomialAccepted);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void DrawOnGraph(Polynomial equation, Chart graph,string name)
{
int minValue = Properties.Settings.Default.MinValue;
int maxValue = Properties.Settings.Default.MaxValue;
this.SuspendLayout();
graph.Series[name].Points.Clear();
for (int i = minValue; i < maxValue; i++)
{
graph.Series[name].Points.AddXY
(i, equation.substitute(i).Real);
graph.Series[name].Points.AddXY
(i,equation.substitute(i).Real);
}
graph.Series[name].ChartType = SeriesChartType.FastLine;
this.ResumeLayout();
graph.Refresh();
}
#endregion
<summary>
Handler of placeholder for text box
</summary>
<param name="sender"></param>
<param name="e"></param>
private void PlaceHolder(object sender,EventArgs e)
{
var txtBox = (sender as TextBox);
if (txtBox.Text == "")
{
switch (txtBox.Tag as string)
{
case "Def1A":
txtBox.Text = "Poly1. a";
break;
case "Def1B":
txtBox.Text = "Poly1. b";
break;
case "Def2A":
txtBox.Text = "Poly2. a";
break;
case "Def2B":
txtBox.Text = "Poly2. b";
break;
case "Poly.1x":
txtBox.Text = "Poly.1 X";
break;
case "Poly.2x":
txtBox.Text = "Poly.2 X";
break;
case "Poly1":
txtBox.Text = "Polynomial1";
break;
case "Poly2":
txtBox.Text = "Polynomial2";
break;
}
txtBox.ForeColor = SystemColors.WindowFrame;
}
}
private void PlaceHolderRemove(object sender,EventArgs e)
{
var txtBox = sender as TextBox;
txtBox.ForeColor = Color.Black;
txtBox.Text = "";
}
private void restorePlaceHolder(object sender, EventArgs e)
{
var current = sender as RichTextBox;
if (current.Text == "")
{
switch (current.Tag as String)
{
case "Poly1":
current.Text = "Polynomial1";
break;
case "Poly2":
current.Text = "Polynomial2";
break;
}
LoadColorFont(current);
}
}
private void <API key>(object sender, EventArgs e)
{
showForm(new LogPanel(Program._logItems), this, setClose);
}
private void tipLabel_MouseHover(object sender, EventArgs e)
{
tipLabel.BackColor = System.Drawing.SystemColors.ActiveCaption;
}
private void tipLabel_MouseLeave(object sender, EventArgs e)
{
tipLabel.BackColor = System.Drawing.SystemColors.Control;
}
}
<summary>
Class that holds the history item, each instance holds one record of operation and two polynomials
The record can hold one operation and its roots.
</summary>
public class HistoryLog
{
public Polynomial firstPolynomial, secondPolynomial, resultPolynomial;
public List<Complex> roots;
public char Operation { get; private set; }
public string _timeStamp { get; private set; }
public string DisplayName { get; set; }
public HistoryLog returnType { get { return this; } }
public List<KeyValuePair<Char, Complex>> parameters { get; private set; }
public HistoryLog(Polynomial polynomial1, Polynomial polynomial2, char operation, string timeStamp, Polynomial res)
{
this.firstPolynomial = polynomial1;
this.secondPolynomial = polynomial2;
this.resultPolynomial = res;
this.Operation = operation;
this._timeStamp = timeStamp;
DisplayName = DateTime.Parse(_timeStamp).ToShortTimeString();
}
public HistoryLog(Polynomial polynomial1, char operation, string timeStamp, Polynomial res)
{
this.firstPolynomial = polynomial1;
this.resultPolynomial = res;
this.Operation = operation;
this._timeStamp = timeStamp;
DisplayName = DateTime.Parse(_timeStamp).ToShortTimeString();
}
public HistoryLog(Polynomial polynomial1, List<Complex> roots, char operation, string timeStamp)
{
this.firstPolynomial = polynomial1;
this.Operation = operation;
this.roots = roots;
this._timeStamp = timeStamp;
DisplayName = DateTime.Parse(_timeStamp).ToShortTimeString();
}
public HistoryLog(Polynomial polynomial, List<KeyValuePair<Char, Complex>> _parameters, char operation, string timeStamp, Polynomial res)
{
this.firstPolynomial = polynomial;
this.resultPolynomial = res;
this.parameters = _parameters;
this.Operation = operation;
this._timeStamp = timeStamp;
DisplayName = DateTime.Parse(_timeStamp).ToShortTimeString();
}
}
}
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="refresh" content="0;URL=constant.O_TEXT.html">
</head>
<body>
<p>Redirecting to <a href="constant.O_TEXT.html">constant.O_TEXT.html</a>...</p>
<script>location.replace("constant.O_TEXT.html" + location.search + location.hash);</script>
</body>
</html>
|
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="refresh" content="0;URL=struct.FutureResult.html">
</head>
<body>
<p>Redirecting to <a href="struct.FutureResult.html">struct.FutureResult.html</a>...</p>
<script>location.replace("struct.FutureResult.html" + location.search + location.hash);</script>
</body>
</html>
|
require 'facter'
pkg = Puppet::Type.type(:package).new(:name => "Symantec NetBackup Client")
v = pkg.retrieve[pkg.property(:ensure)].to_s
Facter.add(:symantec_netbackup) do
confine :osfamily => :windows
setcode do
v
end
end
|
package com.oklab.gitjourney.activities;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceFragment;
import android.preference.PreferenceManager;
import android.preference.RingtonePreference;
import android.support.v4.app.NavUtils;
import android.support.v7.app.ActionBar;
import android.text.TextUtils;
import android.view.MenuItem;
import com.oklab.gitjourney.R;
import java.util.List;
public class SettingsActivity extends <API key> {
/**
* A preference value change listener that updates the preference's summary
* to reflect its new value.
*/
private static Preference.<API key> <API key> = new Preference.<API key>() {
@Override
public boolean onPreferenceChange(Preference preference, Object value) {
String stringValue = value.toString();
if (preference instanceof ListPreference) {
// For list preferences, look up the correct display value in
// the preference's 'entries' list.
ListPreference listPreference = (ListPreference) preference;
int index = listPreference.findIndexOfValue(stringValue);
// Set the summary to reflect the new value.
preference.setSummary(
index >= 0
? listPreference.getEntries()[index]
: null);
} else if (preference instanceof RingtonePreference) {
// For ringtone preferences, look up the correct display value
// using RingtoneManager.
if (TextUtils.isEmpty(stringValue)) {
// Empty values correspond to 'silent' (no ringtone).
preference.setSummary(R.string.<API key>);
} else {
Ringtone ringtone = RingtoneManager.getRingtone(
preference.getContext(), Uri.parse(stringValue));
if (ringtone == null) {
// Clear the summary if there was a lookup error.
preference.setSummary(null);
} else {
// Set the summary to reflect the new ringtone display
// name.
String name = ringtone.getTitle(preference.getContext());
preference.setSummary(name);
}
}
} else {
// For all other preferences, set the summary to the value's
// simple string representation.
preference.setSummary(stringValue);
}
return true;
}
};
/**
* Helper method to determine if the device has an extra-large screen. For
* example, 10" tablets are extra-large.
*/
private static boolean isXLargeTablet(Context context) {
return (context.getResources().getConfiguration().screenLayout
& Configuration.<API key>) >= Configuration.<API key>;
}
/**
* Binds a preference's summary to its value. More specifically, when the
* preference's value is changed, its summary (line of text below the
* preference title) is updated to reflect the value. The summary is also
* immediately updated upon calling this method. The exact display format is
* dependent on the type of preference.
*
* @see #<API key>
*/
private static void <API key>(Preference preference) {
// Set the listener to watch for value changes.
preference.<API key>(<API key>);
// Trigger the listener immediately with the preference's
// current value.
<API key>.onPreferenceChange(preference,
PreferenceManager
.<API key>(preference.getContext())
.getString(preference.getKey(), ""));
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setupActionBar();
}
/**
* Set up the {@link android.app.ActionBar}, if the API is available.
*/
private void setupActionBar() {
ActionBar actionBar = getSupportActionBar();
if (actionBar != null) {
// Show the Up button in the action bar.
actionBar.<API key>(true);
}
}
@Override
public boolean onMenuItemSelected(int featureId, MenuItem item) {
int id = item.getItemId();
if (id == android.R.id.home) {
if (!super.onMenuItemSelected(featureId, item)) {
NavUtils.<API key>(this);
}
return true;
}
return super.onMenuItemSelected(featureId, item);
}
/**
* {@inheritDoc}
*/
@Override
public boolean onIsMultiPane() {
return isXLargeTablet(this);
}
/**
* {@inheritDoc}
*/
@Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public void onBuildHeaders(List<Header> target) {
<API key>(R.xml.pref_headers, target);
}
/**
* This method stops fragment injection in malicious applications.
* Make sure to deny any unknown fragments here.
*/
protected boolean isValidFragment(String fragmentName) {
return PreferenceFragment.class.getName().equals(fragmentName)
|| <API key>.class.getName().equals(fragmentName)
|| <API key>.class.getName().equals(fragmentName);
}
/**
* This fragment shows general preferences only. It is used when the
* activity is showing a two-pane settings UI.
*/
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static class <API key> extends PreferenceFragment {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
<API key>(R.xml.pref_general);
setHasOptionsMenu(true);
// Bind the summaries of EditText/List/Dialog/Ringtone preferences
// to their values. When their values change, their summaries are
// updated to reflect the new value, per the Android Design
// guidelines.
<API key>(findPreference("timezone_list"));
}
@Override
public boolean <API key>(MenuItem item) {
int id = item.getItemId();
if (id == android.R.id.home) {
startActivity(new Intent(getActivity(), SettingsActivity.class));
return true;
}
return super.<API key>(item);
}
}
/**
* This fragment shows data and sync preferences only. It is used when the
* activity is showing a two-pane settings UI.
*/
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static class <API key> extends PreferenceFragment {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
<API key>(R.xml.pref_data_sync);
setHasOptionsMenu(true);
// Bind the summaries of EditText/List/Dialog/Ringtone preferences
// to their values. When their values change, their summaries are
// updated to reflect the new value, per the Android Design
// guidelines.
}
@Override
public boolean <API key>(MenuItem item) {
int id = item.getItemId();
if (id == android.R.id.home) {
startActivity(new Intent(getActivity(), SettingsActivity.class));
return true;
}
return super.<API key>(item);
}
}
}
|
/* $NetBSD: s3c2xx0_intr.h,v 1.15 2014/03/14 21:39:29 matt Exp $ */
/* Derived from i80321_intr.h */
#ifndef _S3C2XX0_INTR_H_
#define _S3C2XX0_INTR_H_
#include <sys/evcnt.h>
#include <arm/cpu.h>
#include <arm/armreg.h>
#include <arm/cpufunc.h>
#include <machine/intr.h>
#include <arm/s3c2xx0/s3c2xx0reg.h>
typedef int (* <API key>)(void *);
extern volatile uint32_t *<API key>;
extern volatile int intr_mask;
extern volatile int global_intr_mask;
#ifdef <API key>
extern volatile int softint_pending;
#endif
extern int s3c2xx0_imask[];
extern int s3c2xx0_ilevel[];
void <API key>( int, int );
static inline void
<API key>(int mask)
{
int save = disable_interrupts(I32_bit);
global_intr_mask &= ~mask;
<API key>();
restore_interrupts(save);
}
static inline void
<API key>(int mask)
{
int save = disable_interrupts(I32_bit);
global_intr_mask |= mask;
<API key>();
restore_interrupts(save);
}
static inline void
s3c2xx0_setipl(int new)
{
set_curcpl(new);
intr_mask = s3c2xx0_imask[curcpl()];
<API key>();
#ifdef <API key>
<API key>();
#endif
}
static inline void
s3c2xx0_splx(int new)
{
int psw;
psw = disable_interrupts(I32_bit);
s3c2xx0_setipl(new);
restore_interrupts(psw);
#ifdef <API key>
cpu_dosoftints();
#endif
}
static inline int
s3c2xx0_splraise(int ipl)
{
int old, psw;
old = curcpl();
if( ipl > old ){
psw = disable_interrupts(I32_bit);
s3c2xx0_setipl(ipl);
restore_interrupts(psw);
}
return (old);
}
static inline int
s3c2xx0_spllower(int ipl)
{
int old = curcpl();
int psw = disable_interrupts(I32_bit);
s3c2xx0_splx(ipl);
restore_interrupts(psw);
return(old);
}
int _splraise(int);
int _spllower(int);
void splx(int);
#if !defined(EVBARM_SPL_NOINLINE)
#define splx(new) s3c2xx0_splx(new)
#define _spllower(ipl) s3c2xx0_spllower(ipl)
#define _splraise(ipl) s3c2xx0_splraise(ipl)
#endif /* !EVBARM_SPL_NOINTR */
/*
* interrupt dispatch table.
*/
#ifdef <API key>
struct intrhand {
TAILQ_ENTRY(intrhand) ih_list; /* link on intrq list */
<API key> ih_func; /* handler */
void *ih_arg; /* arg for handler */
};
#endif
#define IRQNAMESIZE sizeof("s3c2xx0 irq xx")
struct <API key> {
#ifdef <API key>
TAILQ_HEAD(,intrhand) list;
#else
<API key> func;
#endif
void *cookie; /* NULL for stackframe */
int level;
struct evcnt ev;
char name[IRQNAMESIZE];
};
/* used by s3c2{80,40,41}0 interrupt handler */
void s3c2xx0_intr_init(struct <API key> *, int );
/* initialize some variable so that splfoo() doesn't touch ileegal
address during bootstrap */
void <API key>(vaddr_t);
#endif /* _S3C2XX0_INTR_H_ */
|
package net.webservicex;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"getGeoIPResult"
})
@XmlRootElement(name = "GetGeoIPResponse")
public class GetGeoIPResponse {
@XmlElement(name = "GetGeoIPResult")
protected GeoIP getGeoIPResult;
/**
* Obtiene el valor de la propiedad getGeoIPResult.
*
* @return
* possible object is
* {@link GeoIP }
*
*/
public GeoIP getGetGeoIPResult() {
return getGeoIPResult;
}
/**
* Define el valor de la propiedad getGeoIPResult.
*
* @param value
* allowed object is
* {@link GeoIP }
*
*/
public void setGetGeoIPResult(GeoIP value) {
this.getGeoIPResult = value;
}
}
|
#pragma once
#include <aws/imagebuilder/<API key>.h>
#include <aws/imagebuilder/ImagebuilderRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace imagebuilder
{
namespace Model
{
class <API key> <API key> : public ImagebuilderRequest
{
public:
<API key>();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* <API key>() const override { return "ListTagsForResource"; }
Aws::String SerializePayload() const override;
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline const Aws::String& GetResourceArn() const{ return m_resourceArn; }
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline bool <API key>() const { return <API key>; }
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline void SetResourceArn(const Aws::String& value) { <API key> = true; m_resourceArn = value; }
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline void SetResourceArn(Aws::String&& value) { <API key> = true; m_resourceArn = std::move(value); }
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline void SetResourceArn(const char* value) { <API key> = true; m_resourceArn.assign(value); }
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline <API key>& WithResourceArn(const Aws::String& value) { SetResourceArn(value); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline <API key>& WithResourceArn(Aws::String&& value) { SetResourceArn(std::move(value)); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of the resource whose tags you want to
* retrieve.</p>
*/
inline <API key>& WithResourceArn(const char* value) { SetResourceArn(value); return *this;}
private:
Aws::String m_resourceArn;
bool <API key>;
};
} // namespace Model
} // namespace imagebuilder
} // namespace Aws
|
package sbt
package internal
import java.text.DateFormat
import sbt.Def.ScopedKey
import sbt.Keys.{ showSuccess, showTiming, timingFormat }
import sbt.SlashSyntax0._
import sbt.internal.util.complete.Parser
import sbt.internal.util.complete.Parser.{ failure, seq, success }
import sbt.internal.util._
import sbt.std.Transform.DummyTaskMap
import sbt.util.{ Logger, Show }
import scala.annotation.nowarn
sealed trait Aggregation
object Aggregation {
final case class ShowConfig(
settingValues: Boolean,
taskValues: Boolean,
print: String => Unit,
success: Boolean
)
final case class Complete[T](
start: Long,
stop: Long,
results: sbt.Result[Seq[KeyValue[T]]],
state: State
)
final case class KeyValue[+T](key: ScopedKey[_], value: T)
def defaultShow(state: State, showTasks: Boolean): ShowConfig =
ShowConfig(
settingValues = true,
taskValues = showTasks,
s => state.log.info(s),
success = true
)
def printSettings(xs: Seq[KeyValue[_]], print: String => Unit)(
implicit display: Show[ScopedKey[_]]
): Unit =
xs match {
case KeyValue(_, x: Seq[_]) :: Nil => print(x.mkString("* ", "\n* ", ""))
case KeyValue(_, x) :: Nil => print(x.toString)
case _ =>
xs foreach (kv => print(display.show(kv.key) + "\n\t" + kv.value.toString))
}
type Values[T] = Seq[KeyValue[T]]
type AnyKeys = Values[_]
def seqParser[T](ps: Values[Parser[T]]): Parser[Seq[KeyValue[T]]] =
seq(ps.map { case KeyValue(k, p) => p.map(v => KeyValue(k, v)) })
def applyTasks[T](
s: State,
ps: Values[Parser[Task[T]]],
show: ShowConfig
)(implicit display: Show[ScopedKey[_]]): Parser[() => State] =
Command.applyEffect(seqParser(ps))(ts => runTasks(s, ts, DummyTaskMap(Nil), show))
private def showRun[T](complete: Complete[T], show: ShowConfig)(
implicit display: Show[ScopedKey[_]]
): Unit = {
import complete._
val log = state.log
val extracted = Project.extract(state)
val success = results match { case Value(_) => true; case Inc(_) => false }
results.toEither.right.foreach { r =>
if (show.taskValues) printSettings(r, show.print)
}
if (show.success && !state.get(suppressShow).getOrElse(false))
printSuccess(start, stop, extracted, success, log)
}
def timedRun[T](
s: State,
ts: Values[Task[T]],
extra: DummyTaskMap
): Complete[T] = {
import EvaluateTask._
import std.TaskExtra._
val extracted = Project extract s
import extracted.structure
val toRun = ts map { case KeyValue(k, t) => t.map(v => KeyValue(k, v)) } join;
val roots = ts map { case KeyValue(k, _) => k }
val config = extractedTaskConfig(extracted, structure, s)
val start = System.currentTimeMillis
val (newS, result) = withStreams(structure, s) { str =>
val transform = nodeView(s, str, roots, extra)
runTask(toRun, s, str, structure.index.triggers, config)(transform)
}
val stop = System.currentTimeMillis
Complete(start, stop, result, newS)
}
def runTasks[HL <: HList, T](
s: State,
ts: Values[Task[T]],
extra: DummyTaskMap,
show: ShowConfig
)(implicit display: Show[ScopedKey[_]]): State = {
val complete = timedRun[T](s, ts, extra)
showRun(complete, show)
complete.results match {
case Inc(i) => complete.state.handleError(i)
case Value(_) => complete.state
}
}
def printSuccess(
start: Long,
stop: Long,
extracted: Extracted,
success: Boolean,
log: Logger
): Unit = {
import extracted._
def get(key: SettingKey[Boolean]): Boolean =
(currentRef / key).get(structure.data) getOrElse true
if (get(showSuccess)) {
if (get(showTiming)) {
val msg = timingString(start, stop, structure.data, currentRef)
if (success) log.success(msg) else if (Terminal.get.isSuccessEnabled) log.error(msg)
} else if (success)
log.success("")
}
}
private def timingString(
startTime: Long,
endTime: Long,
data: Settings[Scope],
currentRef: ProjectRef,
): String = {
val format = (currentRef / timingFormat).get(data) getOrElse defaultFormat
timing(format, startTime, endTime)
}
def timing(format: java.text.DateFormat, startTime: Long, endTime: Long): String = {
val nowString = format.format(new java.util.Date(endTime))
val total = (endTime - startTime + 500) / 1000
val totalString = s"$total s" +
(if (total <= 60) ""
else {
val maybeHours = total / 3600 match {
case 0 => ""
case h => f"$h%02d:"
}
val mins = f"${total % 3600 / 60}%02d"
val secs = f"${total % 60}%02d"
s" ($maybeHours$mins:$secs)"
})
s"Total time: $totalString, completed $nowString"
}
def defaultFormat: DateFormat = {
import java.text.DateFormat
DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM)
}
def applyDynamicTasks[I](
s: State,
inputs: Values[InputTask[I]],
show: ShowConfig
)(implicit display: Show[ScopedKey[_]]): Parser[() => State] = {
val parsers =
for (KeyValue(k, it) <- inputs)
yield it.parser(s).map(v => KeyValue(k, v))
Command.applyEffect(seq(parsers)) { roots =>
runTasks(s, roots, DummyTaskMap(Nil), show)
}
}
def evaluatingParser(s: State, show: ShowConfig)(keys: Seq[KeyValue[_]])(
implicit display: Show[ScopedKey[_]]
): Parser[() => State] = {
// to make the call sites clearer
def separate[L](in: Seq[KeyValue[_]])(
f: KeyValue[_] => Either[KeyValue[L], KeyValue[_]]
): (Seq[KeyValue[L]], Seq[KeyValue[_]]) =
Util.separate(in)(f)
val kvs = keys.toList
if (kvs.isEmpty)
failure("No such setting/task")
else {
val (inputTasks, other) = separate[InputTask[_]](kvs) {
case KeyValue(k, v: InputTask[_]) => Left(KeyValue(k, v))
case kv => Right(kv)
}
val (tasks, settings) = separate[Task[_]](other) {
case KeyValue(k, v: Task[_]) => Left(KeyValue(k, v))
case kv => Right(kv)
}
// currently, disallow input tasks to be mixed with normal tasks.
// This occurs in `all` or `show`, which support multiple tasks.
// Previously, multiple tasks could be run in one execution, but they were all for the same key, just in different scopes.
// When `all` was added, it allowed different keys and thus opened the possibility for mixing settings,
// tasks, and input tasks in the same call. The code below allows settings and tasks to be mixed, but not input tasks.
// One problem with input tasks in `all` is that many input tasks consume all input and would need syntactic delimiters.
// Once that is addressed, the tasks constructed by the input tasks would need to be combined with the explicit tasks.
if (inputTasks.nonEmpty) {
if (other.nonEmpty) {
val inputStrings = inputTasks.map(_.key).mkString("Input task(s):\n\t", "\n\t", "\n")
val otherStrings = other.map(_.key).mkString("Task(s)/setting(s):\n\t", "\n\t", "\n")
failure(s"Cannot mix input tasks with plain tasks/settings. $inputStrings $otherStrings")
} else
applyDynamicTasks(s, maps(inputTasks)(castToAny), show)
} else {
val base =
if (tasks.isEmpty) success(() => s)
else
applyTasks(s, maps(tasks)(x => success(castToAny(x))), show)
base.map { res => () =>
val newState = res()
if (show.settingValues && settings.nonEmpty) printSettings(settings, show.print)
newState
}
}
}
}
// this is a hack to avoid duplicating method implementations
private[this] def castToAny[T[_]](t: T[_]): T[Any] = t.asInstanceOf[T[Any]]
private[this] def maps[T, S](vs: Values[T])(f: T => S): Values[S] =
vs map { case KeyValue(k, v) => KeyValue(k, f(v)) }
def projectAggregates[Proj](
proj: Option[Reference],
extra: BuildUtil[Proj],
reverse: Boolean
): Seq[ProjectRef] = {
val resRef = proj.map(p => extra.projectRefFor(extra.resolveRef(p)))
resRef.toList.flatMap(
ref => if (reverse) extra.aggregates.reverse(ref) else extra.aggregates.forward(ref)
)
}
def aggregate[T, Proj](
key: ScopedKey[T],
rawMask: ScopeMask,
extra: BuildUtil[Proj],
reverse: Boolean = false
): Seq[ScopedKey[T]] = {
val mask = rawMask.copy(project = true)
Dag.topologicalSort(key) { k =>
if (reverse)
<API key>(k, extra, mask)
else if (aggregationEnabled(k, extra.data))
aggregatedKeys(k, extra, mask)
else
Nil
}
}
def <API key>[T](
key: ScopedKey[T],
extra: BuildUtil[_],
mask: ScopeMask
): Seq[ScopedKey[T]] =
projectAggregates(key.scope.project.toOption, extra, reverse = true) flatMap { ref =>
val toResolve = key.scope.copy(project = Select(ref))
val resolved = Resolve(extra, Zero, key.key, mask)(toResolve)
val skey = ScopedKey(resolved, key.key)
if (aggregationEnabled(skey, extra.data)) skey :: Nil else Nil
}
def aggregatedKeys[T](
key: ScopedKey[T],
extra: BuildUtil[_],
mask: ScopeMask
): Seq[ScopedKey[T]] =
projectAggregates(key.scope.project.toOption, extra, reverse = false) map { ref =>
val toResolve = key.scope.copy(project = Select(ref))
val resolved = Resolve(extra, Zero, key.key, mask)(toResolve)
ScopedKey(resolved, key.key)
}
@nowarn
def aggregationEnabled(key: ScopedKey[_], data: Settings[Scope]): Boolean =
Keys.aggregate in Scope.fillTaskAxis(key.scope, key.key) get data getOrElse true
private[sbt] val suppressShow =
AttributeKey[Boolean]("<API key>", Int.MaxValue)
}
|
# AUTOGENERATED FILE
FROM balenalib/beaglebone-alpine:3.12-run
# Default to UTF-8 file.encoding
ENV LANG C.UTF-8
# add a simple script that can auto-detect the appropriate JAVA_HOME value
# based on whether the JDK or only the JRE is installed
RUN { \
echo '#!/bin/sh'; \
echo 'set -e'; \
echo; \
echo 'dirname "$(dirname "$(readlink -f "$(which javac || which java)")")"'; \
} > /usr/local/bin/docker-java-home \
&& chmod +x /usr/local/bin/docker-java-home
ENV JAVA_HOME /usr/lib/jvm/java-1.8-openjdk
ENV PATH $PATH:/usr/lib/jvm/java-1.8-openjdk/jre/bin:/usr/lib/jvm/java-1.8-openjdk/bin
RUN set -x \
&& apk add --no-cache \
openjdk8-jre \
&& [ "$JAVA_HOME" = "$(docker-java-home)" ]
CMD ["echo","'No CMD command was set in Dockerfile! Details about CMD command could be found in Dockerfile Guide section in our Docs. Here's the link: https://balena.io/docs"]
RUN [ ! -d /.balena/messages ] && mkdir -p /.balena/messages; echo $'Here are a few details about this Docker image (For more information please visit https:
RUN echo $'#!/bin/bash\nbalena-info\nbusybox ln -sf /bin/busybox /bin/sh\n/bin/sh "$@"' > /bin/sh-shim \
&& chmod +x /bin/sh-shim \
&& ln -f /bin/sh /bin/sh.real \
&& ln -f /bin/sh-shim /bin/sh
|
require 'wavefront/cli'
require 'wavefront/metadata'
require 'json'
require 'pp'
# Turn CLI input, from the 'sources' command, into metadata API calls
class Wavefront::Cli::Sources < Wavefront::Cli
attr_accessor :wf, :out_format, :show_hidden, :show_tags, :verbose
def setup_wf
@wf = Wavefront::Metadata.new(options[:token], options[:endpoint],
options[:debug],
{ verbose: options[:verbose],
noop: options[:noop]})
end
def run
setup_wf
@out_format = options[:sourceformat].to_s
@show_hidden = options[:all]
@show_tags = options[:tags]
@verbose = options[:verbose]
begin
if options[:list]
list_source_handler(options[:'<pattern>'], options[:start],
options[:limit])
elsif options[:show]
show_source_handler(options[:'<host>'])
elsif options[:tag] && options[:add]
add_tag_handler(options[:host], options[:'<tag>'])
elsif options[:tag] && options[:delete]
delete_tag_handler(options[:host], options[:'<tag>'])
elsif options[:describe]
describe_handler(options[:host], options[:'<description>'])
elsif options[:undescribe]
describe_handler(options[:'<host>'], '')
elsif options[:untag]
untag_handler(options[:'<host>'])
else
fail 'undefined sources error'
end
rescue Wavefront::Exception::InvalidSource
abort 'ERROR: invalid source name.'
end
end
def list_source_handler(pattern, start = false, limit = false)
limit ||= 100
q = {
desc: false,
limit: limit.to_i,
pattern: pattern
}
q[:lastEntityId] = start if start
res = wf.show_sources(q)
return if noop
display_data(res, 'list_source')
end
def describe_handler(hosts, desc)
hosts = [Socket.gethostname] if hosts.empty?
hosts = [hosts] if hosts.is_a?(String)
hosts.each do |h|
if desc.empty?
puts "clearing description of '
else
puts "setting '#{h}' description to '#{desc}'"
end
begin
wf.set_description(h, desc)
rescue Wavefront::Exception::InvalidString
puts 'ERROR: description contains invalid characters.'
end
end
end
def untag_handler(hosts)
hosts ||= Socket.gethostname
hosts = [hosts] if hosts.is_a?(String)
hosts.each do |h|
puts "Removing all tags from '#{h}'" if verbose
wf.delete_tags(h)
end
end
def add_tag_handler(hosts, tags)
hosts ||= Socket.gethostname
hosts = [hosts] if hosts.is_a?(String)
hosts.each do |h|
tags.each do |t|
puts "Tagging '#{h}' with '#{t}'" if verbose
begin
wf.set_tag(h, t)
rescue Wavefront::Exception::InvalidString
puts 'ERROR: tag contains invalid characters.'
end
end
end
end
def delete_tag_handler(hosts, tags)
hosts ||= Socket.gethostname
hosts = [hosts] if hosts.is_a?(String)
hosts.each do |h|
tags.each do |t|
puts "Removing tag '#{t}' from '#{h}'" if verbose
wf.delete_tag(h, t)
end
end
end
def show_source_handler(sources)
sources.each do |s|
begin
result = wf.show_source(s)
rescue RestClient::ResourceNotFound
puts "Source '#{s}' not found."
next
end
display_data(result, 'show_source')
end
end
def display_data(result, method)
return if noop
if out_format == 'human'
puts public_send('humanize_' + method, result)
elsif out_format == 'json'
puts result.to_json
else
pp result
end
end
def <API key>(result)
hdr = format('%-25s %-30s %s', 'HOSTNAME', 'DESCRIPTION', 'TAGS')
ret = result['sources'].each_with_object([hdr]) do |s, aggr|
if s.include?('userTags') && s['userTags'].include?('hidden') &&
!show_hidden
next
end
if options[:tagged]
skip = false
options[:tagged].each do |t|
unless s.key?('userTags') && s['userTags'].include?(t)
skip = true
break
end
end
next if skip
end
if s['description']
desc = s['description']
desc = desc[0..27] + '...' if desc.length > 30
else
desc = ''
end
tags = s['userTags'] ? s['userTags'].join(', ') : ''
aggr.<< format('%-25s %-30s %s', s['hostname'], desc, tags)
end
if show_tags
ret.<< ['', format('%-25s%s', 'TAG', 'COUNT')]
result['counts'].each do |tag, count|
ret.<< format('%-25s%s', tag, count)
end
end
ret.join("\n")
end
def <API key>(data)
ret = [data['hostname']]
if data['description']
ret.<< format(' %-15s%s', 'description', data['description'])
end
if data['userTags']
ret.<< format(' %-15s%s', 'tags', data['userTags'].shift)
data['userTags'].each { |t| ret.<< format(' %-15s%s', '', t) }
end
ret.join("\n")
end
end
|
package models
import asset.AssetView
import shared.{AddressPool, IpAddressConfig}
import play.api.libs.json._
import util.{IpAddress, IpAddressCalc}
import util.plugins.Callback
import org.squeryl.dsl.ast.LogicalBoolean
case class IpAddresses(
asset_id: Long,
gateway: Long,
address: Long,
netmask: Long,
pool: String,
id: Long = 0) extends IpAddressable
{
import conversions._
override def asJson: String = toJsValue.toString
def toJsValue = Json.toJson(this)
}
object IpAddresses extends IpAddressStorage[IpAddresses] with <API key> {
import org.squeryl.PrimitiveTypeMode._
override protected def createEventName: Option[String] = Some("ipAddresses_create")
override protected def updateEventName: Option[String] = Some("ipAddresses_update")
override protected def deleteEventName: Option[String] = Some("ipAddresses_delete")
val tableDef = table[IpAddresses]("ip_addresses")
lazy val AddressConfig = IpAddressConfig.get()
on(tableDef)(i => declare(
i.id is(autoIncremented,primaryKey),
i.address is(unique),
i.gateway is(indexed),
i.netmask is(indexed),
i.pool is(indexed),
columns(i.asset_id, i.address) are(indexed)
))
def createForAsset(asset: Asset, count: Int, scope: Option[String]): Seq[IpAddresses] = {
(0 until count).map { i =>
createForAsset(asset, scope)
}
}
override def <API key>(overrideStart: Option[String] = None)(implicit scope: Option[String]): Tuple3[Long,Long,Long] = {
throw new <API key>("<API key> not supported")
}
def getNextAddress(iteration: Int)(implicit scope: Option[String]): Tuple3[Long,Long,Long] = {
val network = getNetwork
val startAt = getStartAddress
val calc = IpAddressCalc(network, startAt)
val gateway: Long = getGateway().getOrElse(calc.minAddressAsLong)
val netmask: Long = calc.netmaskAsLong
val currentMax: Option[Long] = iteration match {
case norm if norm == 0 =>
<API key>(scope)
case failed =>
logger.info("Address cache dirty. Failed cache lookup so using DB")
<API key>(scope, true)
<API key>(calc.minAddressAsLong, calc.maxAddressAsLong)
}
val address: Long = calc.nextAvailableAsLong(currentMax)
(gateway, address, netmask)
}
def createForAsset(asset: Asset, scope: Option[String]): IpAddresses = inTransaction {
val assetId = asset.getId
val cfg = getConfig()(scope)
val ipAddresses = createWithRetry(10) { attempt =>
val (gateway, address, netmask) = getNextAddress(attempt)(scope)
logger.debug("trying to use address %s".format(IpAddress.toString(address)))
val ipAddresses = IpAddresses(assetId, gateway, address, netmask, scope.getOrElse(""))
super.create(ipAddresses)
}
ipAddresses
}
def <API key>(asset: Asset, pool: Option[String]): Int = inTransaction {
val rows = tableDef.where(i =>
i.asset_id === asset.id and
i.pool === pool.?
).toList
val res = rows.foldLeft(0) { case(sum, ipInfo) =>
sum + delete(ipInfo)
}
res
}
def findAssetsByAddress(page: PageParams, addys: Seq[String], finder: AssetFinder): Page[AssetView] = {
def whereClause(assetRow: Asset, addressRow: IpAddresses) = {
where(
(assetRow.id === addressRow.asset_id) and
generateFindQuery(addressRow, addys.head) and
finder.asLogicalBoolean(assetRow)
)
}
inTransaction { log {
val results = from(Asset.tableDef, tableDef)((assetRow, addressRow) =>
whereClause(assetRow, addressRow)
select(assetRow)
).page(page.offset, page.size).toList
val totalCount = from(Asset.tableDef, tableDef)((assetRow, addressRow) =>
whereClause(assetRow, addressRow)
compute(count)
)
Page(results, page.page, page.offset, totalCount)
}}
}
def findByAddress(address: String): Option[Asset] = inTransaction { log {
val addressAsLong = try {
IpAddress.toLong(address)
} catch {
case e => return None
}
from(tableDef, Asset.tableDef)((i,a) =>
where(
(i.address === addressAsLong) and
(i.asset_id === a.id)
)
select(a)
).headOption
}}
def findInPool(pool: String): Seq[IpAddresses] = inTransaction { log {
from(tableDef)(i =>
where(i.pool === pool)
select(i)
).toList
}}
override def get(i: IpAddresses) = getOrElseUpdate(getKey.format(i.id)) {
tableDef.lookup(i.id).get
}
def getPoolsInUse(): Set[String] = getOrElseUpdate("getPoolsInUse") {
from(tableDef)(i =>
select(i.pool)
).distinct.toSet
}
override protected def getConfig()(implicit scope: Option[String]): Option[AddressPool] = {
AddressConfig.flatMap(cfg => scope.flatMap(cfg.pool(_)).orElse(cfg.defaultPool))
}
protected def <API key>(opool: Option[String], force: Boolean = false) {
opool.foreach { pool =>
AddressConfig.flatMap(_.pool(pool)).foreach { ap =>
if (!ap.hasAddressCache || force) {
logger.trace("populating address cache for pool %s".format(ap.name))
ap.clearAddresses
findInPool(pool).foreach { address =>
try ap.useAddress(address.address) catch {
case e =>
logger.info("Error using address %s in pool %s: %s".format(address.dottedAddress, pool, e.getMessage))
}
}
}
}
}
}
// NOTE if we find an unused address, and for some reason it is already in the DB, and the insert
// fails, we will recommend the exact same address for use. This happened when the
// ipAddresses_create callback wasn't working correctly. We need a way to detect that we're trying
// to use the same IP address
protected def nextAddressInPool(opool: Option[String]): Option[Long] = {
logger.trace("finding next address in pool %s".format(opool.getOrElse("UNKNOWN")))
opool.flatMap { pool =>
try {
logger.trace("found pool %s, looking for config".format(pool))
AddressConfig.flatMap(_.pool(pool)).map { ap =>
logger.debug("Next address in pool %s in cache is %s".format(ap.name, ap.nextDottedAddress))
ap.nextAddress - 1
}
} catch {
case e =>
logger.warn("Exception getting next address: %s".format(e))
None
}
}
}
protected def <API key>(scope: Option[String]): Option[Long] = {
<API key>(scope)
nextAddressInPool(scope)
}
protected[this] def generateFindQuery(addressRow: IpAddresses, address: String): LogicalBoolean = {
try {
if (address.split('.').size != 4) throw new Exception("Try again later")
(addressRow.address === IpAddress.toLong(address))
} catch {
case e =>
try {
val padded = IpAddress.padRight(address, "0")
val netmask = IpAddress.netmaskFromPad(padded, "0")
val calc = IpAddressCalc(padded, netmask, None)
(addressRow.address gte calc.minAddressAsLong) and
(addressRow.address lte calc.maxAddressAsLong)
} catch {
case ev =>
logger.warn("Totally invalid address: %s".format(address), e)
throw e
}
}
}
}
trait <API key> { self: IpAddressStorage[IpAddresses] =>
// Callbacks to manage populating and managing the address caches
Callback.on("ipAddresses_create") { pce =>
val newAddress = pce.getNewValue.asInstanceOf[IpAddresses]
logger.debug("ipAddress_create pool %s".format(newAddress.pool))
IpAddresses.AddressConfig.flatMap(_.pool(newAddress.pool)).foreach { ap =>
logger.debug("Using address %s in pool %s".format(newAddress.dottedAddress, ap.name))
ap.useAddress(newAddress.address)
}
}
Callback.on("ipAddresses_update") { pce =>
val oldAddress = pce.getOldValue.asInstanceOf[IpAddresses]
val newAddress = pce.getNewValue.asInstanceOf[IpAddresses]
IpAddresses.AddressConfig.flatMap(_.pool(oldAddress.pool)).foreach { ap =>
logger.debug("Purging address %s from pool %s".format(oldAddress.dottedAddress, ap.name))
ap.unuseAddress(oldAddress.address)
}
IpAddresses.AddressConfig.flatMap(_.pool(newAddress.pool)).foreach { ap =>
logger.debug("Using address %s in pool %s".format(newAddress.dottedAddress, ap.name))
ap.useAddress(newAddress.address)
}
}
Callback.on("ipAddresses_delete") { pce =>
val oldAddress = pce.getOldValue.asInstanceOf[IpAddresses]
IpAddresses.AddressConfig.flatMap(_.pool(oldAddress.pool)).foreach { ap =>
logger.debug("Purging address %s from pool %s".format(oldAddress.dottedAddress, ap.name))
try ap.unuseAddress(oldAddress.address) catch {
case e =>
logger.info("Exception unusing old address %s: %s".format(oldAddress.address, e.getMessage))
}
}
}
}
|
package io.subutai.core.security.impl.model;
/**
* KeyRing Data for ManagementHost
*/
public class SecurityKeyData
{
private String secretKeyringPwd;
private String manHostId;
private String peerOwnerId;
public String getSecretKeyringPwd()
{
return secretKeyringPwd;
}
public void setSecretKeyringPwd( final String secretKeyringPwd )
{
this.secretKeyringPwd = secretKeyringPwd;
}
public String getManHostId()
{
return manHostId;
}
public void setManHostId( final String manHostId )
{
this.manHostId = manHostId;
}
public String getPeerOwnerId()
{
return peerOwnerId;
}
public void setPeerOwnerId( final String peerOwnerId )
{
this.peerOwnerId = peerOwnerId;
}
}
|
package com.mesosphere.cosmos.error
import com.mesosphere.universe
import io.circe.Encoder
import io.circe.JsonObject
import io.circe.generic.semiauto.deriveEncoder
final case class VersionNotFound(
packageName: String,
packageVersion: universe.v3.model.Version
) extends CosmosError {
override def data: Option[JsonObject] = CosmosError.deriveData(this)
override def message: String = {
s"Version [$packageVersion] of package [$packageName] not found"
}
}
object VersionNotFound {
implicit val encoder: Encoder[VersionNotFound] = deriveEncoder
}
|
<a class="list-group-item">
<h4 class="<API key>">{{data.title}}</h4>
<p>{{data.description}}</p>
<div class="panel-footer">
<small *ngIf="data.category" class="<API key>">{{data.category}}</small>
<div class="col-sm-3 pull-right">
<div class="btn-group">
<button type="button" class="btn btn-default"
(click)="deleteContents(data, parent)">
<span class="glyphicon glyphicon-trash" aria-hidden="true"></span></button>
</div>
</div>
</div>
</a>
|
{-# LANGUAGE CPP #-}
module Graphics.ImageMagick.MagickWand.PixelWand
( pixelWand
-- , clearPixelWand
-- , cloneWand
-- , cloneWands
, isPixelWandSimilar
-- , isPixelWand
, setColorCount, getColorCount
-- ** Literal names
, setColor
, getColorAsString, <API key>
-- HSL
, getHSL, setHSL
, getMagickColor, setMagickColor
, setColorFromWand
, getQuantumColor, setQuantumColor
-- ** Color parts
-- Index
, getIndex, setIndex
-- Fuzz
, getFuzz, setFuzz
-- Alpha
, getOpacity, getOpacityQuantum, setOpacity, setOpacityQuantum
, getAlpha, getAlphaQuantum, setAlpha, setAlphaQuantum
-- RGB
, getRed, getRedQuantum, setRed, setRedQuantum
, getBlue, getBlueQuantum, setBlue, setBlueQuantum
, getGreen, getGreenQuantum, setGreen, setGreenQuantum
-- CMYK
, getCyan, getCyanQuantum, setCyan, setCyanQuantum
, getMagenta, getMagentaQuantum, setMagenta, setMagentaQuantum
, getYellow, getYellowQuantum, setYellow, setYellowQuantum
, getBlack, getBlackQuantum, setBlack, setBlackQuantum
) where
import Control.Monad (void)
import Control.Monad.IO.Class
import Control.Monad.Trans.Resource
import Data.ByteString (ByteString,
packCString,
useAsCString)
import Foreign hiding (void)
import Foreign.C.Types (CDouble)
import qualified Graphics.ImageMagick.MagickWand.FFI.PixelWand as F
import Graphics.ImageMagick.MagickWand.Types
import Graphics.ImageMagick.MagickWand.Utils
pixelWand :: (MonadResource m) => m PPixelWand
pixelWand = fmap snd (allocate F.newPixelWand destroy)
where destroy = void . F.destroyPixelWand
setColor :: (MonadResource m) => PPixelWand -> ByteString -> m ()
setColor p s = withException_ p $ useAsCString s (F.pixelSetColor p)
getMagickColor :: (MonadResource m) => PPixelWand -> m PMagickPixelPacket
getMagickColor w = liftIO $ do
p <- mallocForeignPtr
withForeignPtr p (F.pixelGetMagickColor w)
return p
setMagickColor :: (MonadResource m) => PPixelWand -> PMagickPixelPacket -> m ()
setMagickColor w p = liftIO $ withForeignPtr p (F.pixelSetMagickColor w)
setColorCount :: (MonadResource m) => PPixelWand -> Int -> m ()
setColorCount w i = liftIO $ F.pixelSetColorCount w (fromIntegral i)
getColorCount :: (MonadResource m) => PPixelWand -> m Int
getColorCount w = liftIO (F.pixelGetColorCount w) >>= return . fromIntegral
getColorAsString :: (MonadResource m) => PPixelWand -> m ByteString
getColorAsString w = liftIO $ F.<API key> w >>= packCString
<API key> :: (MonadResource m) => PPixelWand -> m ByteString
<API key> w = liftIO $ F.<API key> w >>= packCString
getHSL :: (MonadResource m) => PPixelWand -> m (Double, Double, Double)
getHSL w = liftIO $ fmap (map3 realToFrac) (with3 (F.pixelGetHSL w))
setHSL :: (MonadResource m) => PPixelWand -> Double -> Double -> Double -> m ()
setHSL w h s l = liftIO $ F.pixelSetHSL w (realToFrac h) (realToFrac s) (realToFrac l)
setColorFromWand :: (MonadResource m) => PPixelWand -> PPixelWand -> m ()
setColorFromWand = (liftIO .). F.<API key>
getIndex :: (MonadResource m) => PPixelWand -> m IndexPacket
getIndex = liftIO . F.pixelGetIndex
setIndex :: (MonadResource m) => PPixelWand -> IndexPacket -> m ()
setIndex w i = liftIO $ F.pixelSetIndex w i
getQuantumColor :: (MonadResource m) => PPixelWand -> m PPixelPacket
getQuantumColor w = liftIO $ do
p <- mallocForeignPtr
withForeignPtr p (F.<API key> w)
return p
setQuantumColor :: (MonadResource m) => PPixelWand -> PPixelPacket -> m ()
setQuantumColor w p = liftIO $ withForeignPtr p (F.<API key> w)
getFuzz :: (MonadResource m) => PPixelWand -> m Double
getFuzz = liftIO . ((fmap realToFrac) . F.pixelGetFuzz)
setFuzz :: (MonadResource m) => PPixelWand -> Double -> m ()
setFuzz w i = liftIO $ F.pixelSetFuzz w (realToFrac i)
isPixelWandSimilar :: (MonadResource m) => PPixelWand -> PPixelWand -> Double -> m Bool
isPixelWandSimilar pw1 pw2 fuzz = fromMBool $ F.isPixelWandSimilar pw1 pw2 (realToFrac fuzz)
setRedQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setRedQuantum = (liftIO .) . F.pixelSetRedQuantum
getRed :: (MonadResource m) => PPixelWand -> m Double
getRed = (fmap realToFrac) . liftIO . F.pixelGetRed
setRed :: (MonadResource m) => PPixelWand -> Double -> m ()
setRed = (liftIO .) . (. realToFrac) . F.pixelSetRed
getRedQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getRedQuantum = liftIO . F.pixelGetRedQuantum
setGreenQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setGreenQuantum = (liftIO .) . F.<API key>
getGreen :: (MonadResource m) => PPixelWand -> m Double
getGreen = (fmap realToFrac) . liftIO . F.pixelGetGreen
setGreen :: (MonadResource m) => PPixelWand -> Double -> m ()
setGreen = (liftIO .) . (. realToFrac) . F.pixelSetGreen
getGreenQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getGreenQuantum = liftIO . F.<API key>
setBlueQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setBlueQuantum = (liftIO .) . F.pixelSetBlueQuantum
getBlue :: (MonadResource m) => PPixelWand -> m Double
getBlue = (fmap realToFrac) . liftIO . F.pixelGetBlue
setBlue :: (MonadResource m) => PPixelWand -> Double -> m ()
setBlue = (liftIO .) . (. realToFrac) . F.pixelSetBlue
getBlueQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getBlueQuantum = liftIO . F.pixelGetBlueQuantum
setAlphaQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setAlphaQuantum = (liftIO .) . F.<API key>
getAlphaQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getAlphaQuantum = liftIO . F.<API key>
setAlpha :: (MonadResource m) => PPixelWand -> Double -> m ()
setAlpha = (liftIO .) . (. realToFrac) . F.pixelSetAlpha
getAlpha :: (MonadResource m) => PPixelWand -> m Double
getAlpha = (fmap realToFrac) . liftIO . F.pixelGetAlpha
setOpacityQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setOpacityQuantum = (liftIO .) . F.<API key>
getOpacityQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getOpacityQuantum = liftIO . F.<API key>
setOpacity :: (MonadResource m) => PPixelWand -> Double -> m ()
setOpacity = (liftIO .) . (. realToFrac) . F.pixelSetOpacity
getOpacity :: (MonadResource m) => PPixelWand -> m Double
getOpacity = (fmap realToFrac) . liftIO . F.pixelGetOpacity
setBlackQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setBlackQuantum = (liftIO .) . F.<API key>
getBlackQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getBlackQuantum = liftIO . F.<API key>
setBlack :: (MonadResource m) => PPixelWand -> Double -> m ()
setBlack = (liftIO .) . (. realToFrac) . F.pixelSetBlack
getBlack :: (MonadResource m) => PPixelWand -> m Double
getBlack = (fmap realToFrac) . liftIO . F.pixelGetBlack
setCyanQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setCyanQuantum = (liftIO .) . F.pixelSetCyanQuantum
getCyanQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getCyanQuantum = liftIO . F.pixelGetCyanQuantum
setCyan :: (MonadResource m) => PPixelWand -> Double -> m ()
setCyan = (liftIO .) . (. realToFrac) . F.pixelSetCyan
getCyan :: (MonadResource m) => PPixelWand -> m Double
getCyan = (fmap realToFrac) . liftIO . F.pixelGetCyan
setMagentaQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setMagentaQuantum = (liftIO .) . F.<API key>
getMagentaQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getMagentaQuantum = liftIO . F.<API key>
setMagenta :: (MonadResource m) => PPixelWand -> Double -> m ()
setMagenta = (liftIO .) . (. realToFrac) . F.pixelSetMagenta
getMagenta :: (MonadResource m) => PPixelWand -> m Double
getMagenta = (fmap realToFrac) . liftIO . F.pixelGetMagenta
setYellowQuantum :: (MonadResource m) => PPixelWand -> Quantum -> m ()
setYellowQuantum = (liftIO .) . F.<API key>
getYellowQuantum :: (MonadResource m) => PPixelWand -> m Quantum
getYellowQuantum = liftIO . F.<API key>
setYellow :: (MonadResource m) => PPixelWand -> Double -> m ()
setYellow = (liftIO .) . (. realToFrac) . F.pixelSetYellow
getYellow :: (MonadResource m) => PPixelWand -> m Double
getYellow = (fmap realToFrac) . liftIO . F.pixelGetYellow
with3 ::
(Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> IO ())
-> IO (CDouble, CDouble, CDouble)
with3 f = alloca (\x -> alloca (\y -> alloca (\z -> do
_ <- f x y z
x' <- peek x
y' <- peek y
z' <- peek z
return (x',y',z')
)))
map3 :: (a -> b) -> (a, a, a) -> (b, b, b)
map3 f (a,b,c) = (f a, f b, f c)
|
package io.buoyant.linkerd.protocol.h2
import com.twitter.finagle.buoyant.Dst
import com.twitter.finagle.buoyant.h2._
import com.twitter.finagle.http.{Request => H1Request, Response => H1Response}
import com.twitter.finagle.{Dtab, Path, Service}
import com.twitter.io.Buf
import com.twitter.util.Future
import io.buoyant.router.RoutingFactory._
import io.buoyant.test.Awaits
import org.scalatest.FunSuite
class <API key> extends FunSuite with Awaits {
val ingressListResource = Buf.Utf8("""{
"kind":"IngressList",
"apiVersion":"extensions/v1beta",
"items": [{
"kind":"Ingress",
"apiVersion":"extensions/v1beta",
"metadata":{"name":"test-ingress","namespace":"fooNamespace","selfLink":"/apis/extensions/v1beta1/namespaces/srv/ingresses/test-ingress","resourceVersion":"4430527"},
"spec": {
"backend": {
"serviceName": "defaultService",
"servicePort": "defaultPort"
},
"rules": [{
"host": "foo.bar.com",
"http": {
"paths": [{
"path": "/fooPath/.*",
"backend": {
"serviceName": "fooPathService",
"servicePort": "fooPathPort"
}
},
{
"backend": {
"serviceName": "fooHostService",
"servicePort": "fooHostPort"
}
}]
}
}]
}
}]
}""")
val service = Service.mk[H1Request, H1Response] {
case req if req.uri.contains("/apis/extensions/v1beta1/ingresses") =>
val rsp = H1Response()
rsp.content = ingressListResource
Future.value(rsp)
case req if req.uri.contains("/apis/extensions/v1beta1/watch/ingresses") =>
val rsp = H1Response()
rsp.content = ingressListResource
Future.value(rsp)
case req =>
fail(s"unexpected request: $req")
}
test("identifies requests by host, without path") {
val identifier = new IngressIdentifier(Path.Utf8("svc"), () => Dtab.empty, None, service, "linkerd", false)
val req0 = Request("http", Method.Get, "foo.bar.com", "/penguins", Stream.empty())
await(identifier(req0)) match {
case IdentifiedRequest(Dst.Path(name, base, local), req1) =>
assert(name == Path.read("/svc/fooNamespace/fooHostPort/fooHostService"))
case id: UnidentifiedRequest[Request] => fail(s"unexpected identification: ${id.reason}")
}
}
test("identifies requests by host & path") {
val identifier = new IngressIdentifier(Path.Utf8("svc"), () => Dtab.empty, None, service, "linkerd", false)
val req0 = Request("http", Method.Get, "foo.bar.com", "/fooPath/penguins", Stream.empty())
await(identifier(req0)) match {
case IdentifiedRequest(Dst.Path(name, base, local), req1) =>
assert(name == Path.read("/svc/fooNamespace/fooPathPort/fooPathService"))
case id: UnidentifiedRequest[Request] => fail(s"unexpected identification: ${id.reason}")
}
}
test("falls back to the default backend") {
val identifier = new IngressIdentifier(Path.Utf8("svc"), () => Dtab.empty, None, service, "linkerd", false)
val req0 = Request("http", Method.Get, "authority", "/", Stream.empty())
await(identifier(req0)) match {
case IdentifiedRequest(Dst.Path(name, base, local), req1) =>
assert(name == Path.read("/svc/fooNamespace/defaultPort/defaultService"))
case id: UnidentifiedRequest[Request] => fail(s"unexpected identification: ${id.reason}")
}
}
test("<API key> ingress identifies requests by host & path") {
val identifier = new IngressIdentifier(Path.Utf8("svc"), () => Dtab.empty, None, service, "linkerd", true)
val req0 = Request("http", Method.Get, "foo.bar.com", "/fooPath/penguins", Stream.empty())
await(identifier(req0)) match {
case IdentifiedRequest(Dst.Path(name, base, local), req1) =>
assert(name == Path.read("/svc/fooNamespace/fooPathPort/fooPathService"))
case id: UnidentifiedRequest[Request] => fail(s"unexpected identification: ${id.reason}")
}
}
test("<API key> ingress does not fall back to the default backend") {
val identifier = new IngressIdentifier(Path.Utf8("svc"), () => Dtab.empty, None, service, "linkerd", true)
val req0 = Request("http", Method.Get, "authority", "/fooPath/puffins", Stream.empty())
await(identifier(req0)) match {
case IdentifiedRequest(Dst.Path(name, base, local), req1) =>
fail(s"unexpected identification: ${name}")
case id: UnidentifiedRequest[Request] => assert(id.reason == "no ingress rule matches")
}
}
}
|
import {
<API key>,
BLAZAR_SET_API_ROOT,
<API key>,
<API key>,
<API key>,
SET_<API key>
} from '../actions';
const initialState = {
parseAnsi: true,
fetchOverscan: true,
tailIntervalMs: 5000
};
const configReducer = (state = initialState, action) => {
switch (action.type) {
case <API key>:
return {
state,
singularityApiRoot: action.apiRoot
};
case BLAZAR_SET_API_ROOT:
return {
state,
blazarApiRoot: action.apiRoot
};
case <API key>:
return {
state,
parseAnsi: !state.parseAnsi
};
case <API key>:
return {
state,
fetchOverscan: !state.fetchOverscan
};
case <API key>:
return {
state,
tailIntervalMs: action.tailIntervalMs
}
case SET_<API key>:
return {
state,
authorizationHeader: action.authorizationHeader
}
default:
return state;
}
};
export default configReducer;
|
package com.jetbrains.python.lexer;
import com.intellij.lexer.FlexAdapter;
import org.jetbrains.annotations.NotNull;
/**
* @author yole
*/
public class PythonLexer extends FlexAdapter {
public PythonLexer() {
this(PythonLexerKind.REGULAR);
}
public PythonLexer(@NotNull PythonLexerKind kind) {
super(new _PythonLexer(null, kind));
}
@Override
public _PythonLexer getFlex() {
return (_PythonLexer)super.getFlex();
}
}
|
package com.sleepycat.persist.impl;
/**
* Field binding operations implemented via reflection (ReflectionAccessor) or
* bytecode enhancement (EnhancedAccessor).
*
* <p>Normally we read the set of all secondary key fields first and then the
* set of all non-key fields, reading each set in order of field name. But
* when reading an old format record we must account for the following
* class evolution conversions:</p>
* <ul>
* <li>Convert a field: pass value thru converter</li>
* <li>Widen a field type: pass value thru widener</li>
* <li>Add a field: don't read the new field</li>
* <li>Delete a field: skip the deleted field</li>
* <li>Rename a field: read field in a different order</li>
* </ul>
* <p>To support these operations, the methods for reading fields allow reading
* specific ranges of fields as well as all fields. For example, all fields
* up to a deleted field could be read, and then all fields from the following
* field onward.</p>
*
* @author Mark Hayes
*/
interface Accessor {
/**
* A large field value to use instead of Integer.MAX_VALUE, to work around
* Java JIT compiler bug when doing an (X <= Integer.MAX_VALUE) as would be
* done in readXxxKeyFields methods.
*/
final int MAX_FIELD_NUM = Integer.MAX_VALUE - 1;
/**
* Creates a new instance of the target class using its default
* constructor.
*/
Object newInstance();
/**
* Creates a new one dimensional array of the given length, having the
* target class as its component type.
*
* <p>Using a special method for a one dimensional array, which can be
* implemented by bytecode generation, is a compromise. We use reflection
* to create multidimensional arrays. We could in the future generate code
* to create arrays as they are encountered, if there is a need to avoid
* reflection for multidimensional arrays.</p>
*/
Object newArray(int len);
/**
* Returns whether the primary key field is null (for a reference type) or
* zero (for a primitive integer type). Null and zero are used as an
* indication that the key should be assigned from a sequence.
*/
boolean <API key>(Object o);
/**
* Writes the primary key field value to the given EntityOutput.
*
* <p>To write a primary key with a reference type, this method must call
* EntityOutput.writeKeyObject.</p>
*
* @param o is the object whose primary key field is to be written.
*
* @param output the output data to write to.
*/
void writePriKeyField(Object o, EntityOutput output);
/**
* Reads the primary key field value from the given EntityInput.
*
* <p>To read a primary key with a reference type, this method must call
* EntityInput.readKeyObject.</p>
*
* @param o is the object whose primary key field is to be read.
*
* @param input the input data to read from.
*/
void readPriKeyField(Object o, EntityInput input);
/**
* Writes all secondary key field values to the given EntityOutput,
* writing fields in super classes first and in name order within class.
*
* @param o is the object whose secondary key fields are to be written.
*
* <p>If the primary key has a reference type, this method must call
* EntityOutput.<API key> before writing any other fields.</p>
*
* @param output the output data to write to.
*/
void writeSecKeyFields(Object o, EntityOutput output);
/**
* Reads a range of secondary key field values from the given EntityInput,
* reading fields in super classes first and in name order within class.
*
* <p>If the primary key has a reference type, this method must call
* EntityInput.<API key> before reading any other fields.</p>
*
* <p>To read all fields, pass -1 for superLevel, zero for startField and
* MAX_FIELD_NUM for endField. Fields from super classes are read
* first.</p>
*
* <p>To read a specific range of fields, pass a non-negative number for
* superLevel and the specific indices of the field range to be read in the
* class at that level.</p>
*
* @param o is the object whose secondary key fields are to be read.
*
* @param input the input data to read from.
*
* @param startField the starting field index in the range of fields to
* read. To read all fields, the startField should be zero.
*
* @param endField the ending field index in the range of fields to read.
* To read all fields, the endField should be MAX_FIELD_NUM.
*
* @param superLevel is a non-negative number to read the fields of the
* class that is the Nth super instance; or a negative number to read
* fields in all classes.
*/
void readSecKeyFields(Object o,
EntityInput input,
int startField,
int endField,
int superLevel);
/**
* Writes all non-key field values to the given EntityOutput, writing
* fields in super classes first and in name order within class.
*
* @param o is the object whose non-key fields are to be written.
*
* @param output the output data to write to.
*/
void writeNonKeyFields(Object o, EntityOutput output);
/**
* Reads a range of non-key field values from the given EntityInput,
* reading fields in super classes first and in name order within class.
*
* <p>To read all fields, pass -1 for superLevel, zero for startField and
* MAX_FIELD_NUM for endField. Fields from super classes are read
* first.</p>
*
* <p>To read a specific range of fields, pass a non-negative number for
* superLevel and the specific indices of the field range to be read in the
* class at that level.</p>
*
* @param o is the object whose non-key fields are to be read.
*
* @param input the input data to read from.
*
* @param startField the starting field index in the range of fields to
* read. To read all fields, the startField should be zero.
*
* @param endField the ending field index in the range of fields to read.
* To read all fields, the endField should be MAX_FIELD_NUM.
*
* @param superLevel is a non-negative number to read the fields of the
* class that is the Nth super instance; or a negative number to read
* fields in all classes.
*/
void readNonKeyFields(Object o,
EntityInput input,
int startField,
int endField,
int superLevel);
/**
* Writes all composite key field values to the given EntityOutput, writing
* in declared field number order.
*
* @param o the composite key object whose fields are to be written.
*
* @param output the output data to write to.
*/
void <API key>(Object o, EntityOutput output);
/**
* Reads all composite key field values from the given EntityInput,
* reading in declared field number order.
*
* @param o the composite key object whose fields are to be read.
*
* @param input the input data to read from.
*/
void <API key>(Object o, EntityInput input);
/**
* Returns the value of a given field, representing primitives as primitive
* wrapper objects.
*
* @param o is the object containing the key field.
*
* @param field is the field index.
*
* @param superLevel is a positive number to identify the field of the
* class that is the Nth super instance; or zero to identify the field in
* this class.
*
* @param isSecField is true for a secondary key field or false for a
* non-key field.
*
* @return the current field value, or null for a reference type field
* that is null.
*/
Object getField(Object o,
int field,
int superLevel,
boolean isSecField);
/**
* Changes the value of a given field, representing primitives as primitive
* wrapper objects.
*
* @param o is the object containing the key field.
*
* @param field is the field index.
*
* @param superLevel is a positive number to identify the field of the
* class that is the Nth super instance; or zero to identify the field in
* this class.
*
* @param isSecField is true for a secondary key field or false for a
* non-key field.
*
* @param value is the new value of the field, or null to set a reference
* type field to null.
*/
void setField(Object o,
int field,
int superLevel,
boolean isSecField,
Object value);
}
|
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Jasmine Spec Runner v2.3.4</title>
<link rel="shortcut icon" type="image/png" href="libs/jasmine-2.3.4/jasmine_favicon.png">
<link rel="stylesheet" href="libs/jasmine-2.3.4/jasmine.css">
<script src="libs/jasmine-2.3.4/jasmine.js"></script>
<script src="libs/jasmine-2.3.4/jasmine-html.js"></script>
<script src="libs/jasmine-2.3.4/boot.js"></script>
<!-- include source files here... -->
<script src="../libs/jquery-2.1.3.min.js"></script>
<script src="../libs/d3.min.js"></script>
<script src="../src/namespaces.js"></script>
<script src="../src/constants.js"></script>
<script src="../src/tooltip.js"></script>
<script src="../src/legend_control.js"></script>
<script src="../src/bar_chart.js"></script>
<script src="../src/stacked_bar_chart.js"></script>
<script src="../src/bar_chart.js"></script>
<!-- include spec files here... -->
<script type="text/javascript" src="bar_chart_test.js"></script>
</head>
<body></body>
</html>
|
package org.ovirt.engine.core.common.validation;
import junit.framework.Assert;
import org.junit.Test;
public class <API key> {
@Test
public void isValid() {
Assert.assertTrue(new <API key>().isValid("192.168.0.1:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("foo.example.com:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("f0o.example.com:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("storageserver:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("st0rageserver:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("s:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("s.foobar:/tmp/kakukk", null));
Assert.assertTrue(new <API key>().isValid("0s:/tmp/kakukk", null));
Assert.assertFalse(new <API key>().isValid("", null));
Assert.assertFalse(new <API key>().isValid("/tmp/kakukk", null));
Assert.assertFalse(new <API key>().isValid(":/tmp/kakukk", null));
Assert.assertFalse(new <API key>().isValid(".:/tmp/kakukk", null));
Assert.assertFalse(new <API key>().isValid(".example.com:/tmp/kakukk", null));
Assert.assertFalse(new <API key>().isValid("-example.com:/tmp/kakukk", null));
}
}
|
#if !defined(<API key>)
#define <API key>
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/home/support/detail/lexer/generator.hpp>
#include <boost/spirit/home/support/detail/lexer/rules.hpp>
#include <boost/spirit/home/support/detail/lexer/state_machine.hpp>
#include <boost/spirit/home/lex/lexer/lexertl/iterator_tokenizer.hpp>
#include <boost/spirit/home/lex/lexer/lexertl/<API key>.hpp>
#include <boost/spirit/home/lex/lexer/lexertl/wrap_action.hpp>
#include <boost/mpl/bool.hpp>
namespace boost { namespace spirit { namespace lex { namespace lexertl
{
namespace detail
{
template <typename Iterator, typename HasActors, typename HasState
, typename TokenValue>
class data; // no default specialization
// neither supports state, nor actors
template <typename Iterator, typename TokenValue>
class data<Iterator, mpl::false_, mpl::false_, TokenValue>
{
protected:
typedef typename
boost::detail::iterator_traits<Iterator>::value_type
char_type;
public:
typedef Iterator base_iterator_type;
typedef iterator_range<Iterator> token_value_type;
typedef token_value_type get_value_type;
typedef std::size_t state_type;
typedef char_type const* state_name_type;
typedef unused_type <API key>;
typedef detail::wrap_action<unused_type, Iterator, data, std::size_t>
wrap_action_type;
typedef unused_type next_token_functor;
typedef unused_type get_state_name_type;
// initialize the shared data
template <typename IterData>
data (IterData const& data_, Iterator& first, Iterator const& last)
: first_(first), last_(last)
, state_machine_(data_.state_machine_)
, rules_(data_.rules_)
, bol_(data_.state_machine_.data()._seen_BOL_assertion) {}
// The following functions are used by the implementation of the
// placeholder '_state'.
template <typename Char>
void set_state_name (Char const*)
{
// some (random) versions of gcc instantiate this function even if it's not
// needed leading to false static asserts
#if !defined(__GNUC__)
// If you see a compile time assertion below you're probably
// using a token type not supporting lexer states (the 3rd
// template parameter of the token is mpl::false_), but your
// code uses state changes anyways.
BOOST_STATIC_ASSERT(false);
#endif
}
char_type const* get_state_name() const { return rules_.initial(); }
std::size_t get_state_id (char_type const*) const
{
return 0;
}
// The function get_eoi() is used by the implementation of the
// placeholder '_eoi'.
Iterator const& get_eoi() const { return last_; }
// The function less() is used by the implementation of the support
// function lex::less(). Its functionality is equivalent to flex'
// function yyless(): it returns an iterator positioned to the
// nth input character beyond the current start iterator (i.e. by
// assigning the return value to the placeholder '_end' it is
// possible to return all but the first n characters of the current
// token back to the input stream.
// This function does nothing as long as no semantic actions are
// used.
Iterator const& less(Iterator const& it, int n)
{
// The following assertion fires most likely because you are
// using lexer semantic actions without using the actor_lexer
// as the base class for your token definition class.
BOOST_ASSERT(false &&
"Are you using lexer semantic actions without using the "
"actor_lexer base?");
return it;
}
// The function more() is used by the implementation of the support
// function lex::more(). Its functionality is equivalent to flex'
// function yymore(): it tells the lexer that the next time it
// matches a rule, the corresponding token should be appended onto
// the current token value rather than replacing it.
// These functions do nothing as long as no semantic actions are
// used.
void more()
{
// The following assertion fires most likely because you are
// using lexer semantic actions without using the actor_lexer
// as the base class for your token definition class.
BOOST_ASSERT(false &&
"Are you using lexer semantic actions without using the "
"actor_lexer base?");
}
bool adjust_start() { return false; }
void revert_adjust_start() {}
// The function lookahead() is used by the implementation of the
// support function lex::lookahead. It can be used to implement
// lookahead for lexer engines not supporting constructs like flex'
// a/b (match a, but only when followed by b):
// This function does nothing as long as no semantic actions are
// used.
bool lookahead(std::size_t id, std::size_t state = std::size_t(~0))
{
// The following assertion fires most likely because you are
// using lexer semantic actions without using the actor_lexer
// as the base class for your token definition class.
BOOST_ASSERT(false &&
"Are you using lexer semantic actions without using the "
"actor_lexer base?");
return false;
}
// the functions next, invoke_actions, and get_state are used by
// the functor implementation below
// The function next() tries to match the next token from the
// underlying input sequence.
std::size_t next(Iterator& end, std::size_t& unique_id, bool& prev_bol)
{
prev_bol = bol_;
typedef <API key><Iterator> tokenizer;
return tokenizer::next(state_machine_, bol_, end, last_
, unique_id);
}
// nothing to invoke, so this is empty
BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t
, std::size_t, std::size_t, Iterator const&)
{
return pass_flags::pass_normal; // always accept
}
std::size_t get_state() const { return 0; }
void set_state(std::size_t) {}
Iterator& get_first() { return first_; }
Iterator const& get_first() const { return first_; }
Iterator const& get_last() const { return last_; }
iterator_range<Iterator> get_value() const
{
return iterator_range<Iterator>(first_, last_);
}
bool has_value() const { return false; }
void reset_value() {}
void reset_bol(bool bol) { bol_ = bol; }
protected:
Iterator& first_;
Iterator last_;
boost::lexer::basic_state_machine<char_type> const& state_machine_;
boost::lexer::basic_rules<char_type> const& rules_;
bool bol_; // helper storing whether last character was \n
private:
// silence MSVC warning C4512: assignment operator could not be generated
data& operator= (data const&);
};
// doesn't support lexer semantic actions, but supports state
template <typename Iterator, typename TokenValue>
class data<Iterator, mpl::false_, mpl::true_, TokenValue>
: public data<Iterator, mpl::false_, mpl::false_, TokenValue>
{
protected:
typedef data<Iterator, mpl::false_, mpl::false_, TokenValue> base_type;
typedef typename base_type::char_type char_type;
public:
typedef Iterator base_iterator_type;
typedef iterator_range<Iterator> token_value_type;
typedef token_value_type get_value_type;
typedef typename base_type::state_type state_type;
typedef typename base_type::state_name_type state_name_type;
typedef typename base_type::<API key>
<API key>;
// initialize the shared data
template <typename IterData>
data (IterData const& data_, Iterator& first, Iterator const& last)
: base_type(data_, first, last)
, state_(0) {}
// The following functions are used by the implementation of the
// placeholder '_state'.
void set_state_name (char_type const* new_state)
{
std::size_t state_id = this->rules_.state(new_state);
// If the following assertion fires you've probably been using
// a lexer state name which was not defined in your token
// definition.
BOOST_ASSERT(state_id != boost::lexer::npos);
if (state_id != boost::lexer::npos)
state_ = state_id;
}
char_type const* get_state_name() const
{
return this->rules_.state(state_);
}
std::size_t get_state_id (char_type const* state) const
{
return this->rules_.state(state);
}
// the functions next() and get_state() are used by the functor
// implementation below
// The function next() tries to match the next token from the
// underlying input sequence.
std::size_t next(Iterator& end, std::size_t& unique_id, bool& prev_bol)
{
prev_bol = this->bol_;
typedef <API key><Iterator> tokenizer;
return tokenizer::next(this->state_machine_, state_,
this->bol_, end, this->get_eoi(), unique_id);
}
std::size_t& get_state() { return state_; }
void set_state(std::size_t state) { state_ = state; }
protected:
std::size_t state_;
private:
// silence MSVC warning C4512: assignment operator could not be generated
data& operator= (data const&);
};
// does support lexer semantic actions, may support state
template <typename Iterator, typename HasState, typename TokenValue>
class data<Iterator, mpl::true_, HasState, TokenValue>
: public data<Iterator, mpl::false_, HasState, TokenValue>
{
public:
typedef semantic_actions<Iterator, HasState, data>
<API key>;
protected:
typedef data<Iterator, mpl::false_, HasState, TokenValue> base_type;
typedef typename base_type::char_type char_type;
typedef typename <API key>::<API key>
<API key>;
public:
typedef Iterator base_iterator_type;
typedef TokenValue token_value_type;
typedef TokenValue const& get_value_type;
typedef typename base_type::state_type state_type;
typedef typename base_type::state_name_type state_name_type;
typedef detail::wrap_action<<API key>
, Iterator, data, std::size_t> wrap_action_type;
template <typename IterData>
data (IterData const& data_, Iterator& first, Iterator const& last)
: base_type(data_, first, last)
, actions_(data_.actions_), hold_()
, value_(iterator_range<Iterator>(first, last))
, has_value_(false), has_hold_(false) {}
// invoke attached semantic actions, if defined
BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t state
, std::size_t& id, std::size_t unique_id, Iterator& end)
{
return actions_.invoke_actions(state, id, unique_id, end, *this);
}
// The function less() is used by the implementation of the support
// function lex::less(). Its functionality is equivalent to flex'
// function yyless(): it returns an iterator positioned to the
// nth input character beyond the current start iterator (i.e. by
// assigning the return value to the placeholder '_end' it is
// possible to return all but the first n characters of the current
// token back to the input stream).
Iterator const& less(Iterator& it, int n)
{
it = this->get_first();
std::advance(it, n);
return it;
}
// The function more() is used by the implementation of the support
// function lex::more(). Its functionality is equivalent to flex'
// function yymore(): it tells the lexer that the next time it
// matches a rule, the corresponding token should be appended onto
// the current token value rather than replacing it.
void more()
{
hold_ = this->get_first();
has_hold_ = true;
}
// The function lookahead() is used by the implementation of the
// support function lex::lookahead. It can be used to implement
// lookahead for lexer engines not supporting constructs like flex'
// a/b (match a, but only when followed by b)
bool lookahead(std::size_t id, std::size_t state = std::size_t(~0))
{
Iterator end = end_;
std::size_t unique_id = boost::lexer::npos;
bool bol = this->bol_;
if (std::size_t(~0) == state)
state = this->state_;
typedef <API key><Iterator> tokenizer;
return id == tokenizer::next(this->state_machine_, state,
bol, end, this->get_eoi(), unique_id);
}
// The adjust_start() and revert_adjust_start() are helper
// functions needed to implement the functionality required for
// lex::more(). It is called from the functor body below.
bool adjust_start()
{
if (!has_hold_)
return false;
std::swap(this->get_first(), hold_);
has_hold_ = false;
return true;
}
void revert_adjust_start()
{
// this will be called only if adjust_start above returned true
std::swap(this->get_first(), hold_);
has_hold_ = true;
}
TokenValue const& get_value() const
{
if (!has_value_) {
value_ = iterator_range<Iterator>(this->get_first(), end_);
has_value_ = true;
}
return value_;
}
template <typename Value>
void set_value(Value const& val)
{
value_ = val;
has_value_ = true;
}
void set_end(Iterator const& it)
{
end_ = it;
}
bool has_value() const { return has_value_; }
void reset_value() { has_value_ = false; }
protected:
<API key> const& actions_;
Iterator hold_; // iterator needed to support lex::more()
Iterator end_; // iterator pointing to end of matched token
mutable TokenValue value_; // token value to use
mutable bool has_value_; // 'true' if value_ is valid
bool has_hold_; // 'true' if hold_ is valid
private:
// silence MSVC warning C4512: assignment operator could not be generated
data& operator= (data const&);
};
}
}}}}
#endif
|
// WARNING: before doing any changes to this file
// check comments at the head of BinSerializer.cpp
#include "<API key>.h"
using namespace NxParameterized;
#ifndef <API key>
Reloc::Reloc(RelocType type_, physx::PxU32 ptrPos_, const <API key> &parent)
: type(type_),
ptrPos(ptrPos_),
traits(parent.mTraits)
{
ptrData = reinterpret_cast<<API key> *>(traits->alloc(sizeof(<API key>)));
PX_PLACEMENT_NEW(ptrData, <API key>)(parent.mTargetParams, parent.mTraits, parent.dict);
}
Reloc::Reloc(const Reloc &cinfo): type(cinfo.type), ptrPos(cinfo.ptrPos), traits(cinfo.traits)
{
Reloc &info = (Reloc &)cinfo;
//Take ownership of stream to avoid slow recursive copies (especially when reallocating array elements)
ptrData = info.ptrData;
info.ptrData = 0;
}
Reloc::~Reloc()
{
if( ptrData )
{
ptrData->~<API key>();
traits->free(ptrData);
}
}
<API key>::<API key>(const PlatformABI &targetParams, Traits *traits, Dictionary &dict_)
: PlatformStream(targetParams, traits),
data(traits),
mRelocs(Traits::Allocator(traits)),
mStrings(Traits::Allocator(traits)),
mMerges(Traits::Allocator(traits)),
dict(dict_),
mTotalAlign(1)
{}
<API key>::<API key>(const <API key> &s)
: PlatformStream(s),
data(s.data),
mRelocs(Traits::Allocator(s.mTraits)),
mStrings(Traits::Allocator(s.mTraits)),
mMerges(Traits::Allocator(s.mTraits)),
dict(s.dict),
mTotalAlign(1)
{
mRelocs.reserve(s.mRelocs.size());
for(physx::PxU32 i = 0; i < s.mRelocs.size(); ++i)
mRelocs.pushBack(s.mRelocs[i]);
mStrings.reserve(s.mStrings.size());
for(physx::PxU32 i = 0; i < s.mStrings.size(); ++i)
mStrings.pushBack(s.mStrings[i]);
mMerges.reserve(s.mMerges.size());
for(physx::PxU32 i = 0; i < s.mMerges.size(); ++i)
mMerges.pushBack(s.mMerges[i]);
}
#ifndef NDEBUG
void <API key>::dump() const
{
PlatformStream::dump();
dumpBytes(data, size());
fflush(stdout);
for(physx::PxU32 i = 0; i < mRelocs.size(); ++i)
{
printf("Relocation %d at %x:\n", (int)i, mRelocs[i].ptrPos);
mRelocs[i].ptrData->dump();
}
fflush(stdout);
}
#endif
void <API key>::storeU32At(physx::PxU32 x, physx::PxU32 i)
{
if( mCurParams.endian != mTargetParams.endian )
SwapBytes(reinterpret_cast<char *>(&x), 4U, TYPE_U32);
*reinterpret_cast<physx::PxU32 *>(&data[i]) = x;
}
physx::PxU32 <API key>::storeString(const char *s)
{
physx::PxU32 off = storeSimple((physx::PxU8)*s);
while( *s++ )
storeSimple((physx::PxU8)*s);
return off;
}
physx::PxU32 <API key>::storeBytes(const char *s, physx::PxU32 n)
{
if( !n )
return size();
physx::PxU32 off = storeSimple((physx::PxU8)s[0]);
for(physx::PxU32 i = 1; i < n; ++i)
storeSimple((physx::PxU8)s[i]);
return off;
}
physx::PxU32 <API key>::beginStruct(physx::PxU32 align_, physx::PxU32 pad_)
{
physx::PxU32 off = size();
mStack.pushBack(Agregate(Agregate::STRUCT, pad_));
align(align_); // Align _after_ we push struct to avoid ignored align() when inside array
return off;
}
physx::PxU32 <API key>::beginStruct(physx::PxU32 align_)
{
return beginStruct(align_, align_);
}
physx::PxU32 <API key>::beginStruct(const Definition *pd)
{
return beginStruct(getTargetAlignment(pd), getTargetPadding(pd));
}
void <API key>::closeStruct()
{
PX_ASSERT(mStack.size() > 0);
//Tail padding
align(mStack.back().align);// Align _before_ we pop struct to avoid ignored align() when inside array
mStack.popBack();
}
physx::PxU32 <API key>::beginString()
{
return beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));
}
void <API key>::closeString()
{
closeStruct();
}
physx::PxU32 <API key>::beginArray(const Definition *pd)
{
return beginArray(getTargetAlignment(pd));
}
physx::PxU32 <API key>::beginArray(physx::PxU32 align_)
{
align(align_); // Align _before_ we push array because otherwise align() would be ignored
physx::PxU32 off = size();
mStack.pushBack(Agregate(Agregate::ARRAY, align_));
return off;
}
void <API key>::closeArray()
{
// No tail padding when in array
mStack.popBack();
}
void <API key>::skipBytes(physx::PxU32 nbytes)
{
data.skipBytes(nbytes);
}
void <API key>::align(physx::PxU32 border)
{
bool isAligned;
physx::PxU32 newSize = getAlign(size(), border, isAligned);
if( isAligned )
mTotalAlign = physx::PxMax(mTotalAlign, border);
data.skipBytes(newSize - size());
}
void <API key>::mergeDict()
{
for(physx::PxU32 i = 0; i < dict.size(); ++i)
{
const char *s = dict.get(i);
physx::PxU32 off = storeString(s);
dict.setOffset(s, off);
}
}
physx::PxU32 <API key>::storeNullPtr()
{
//Do not align on PxU32 or PxU64 boundary (already aligned at pointer boundary)
align(mTargetParams.aligns.pointer);
physx::PxU32 off = size();
if( 4 == mTargetParams.sizes.pointer )
data.skipBytes(4);
else
{
PX_ASSERT( 8 == mTargetParams.sizes.pointer );
data.skipBytes(8);
}
return off;
}
Reloc &<API key>::storePtr(RelocType type, physx::PxU32 align)
{
physx::PxU32 off = storeNullPtr();
mRelocs.pushBack(Reloc(type, off, *this));
mRelocs.back().ptrData->setAlignment(align);
return mRelocs.back();
}
Reloc &<API key>::storePtr(RelocType type, const Definition *pd)
{
return storePtr(type, getTargetAlignment(pd));
}
void <API key>::storeStringPtr(const char *s)
{
physx::PxU32 off = storeNullPtr();
if( s )
{
mStrings.pushBack(StringReloc(off, s));
dict.put(s);
}
}
physx::PxU32 <API key>::<API key>(Handle &handle)
{
physx::PxI32 n;
handle.getArraySize(n);
const NxParameterized::Definition *pdStruct = handle.parameterDefinition()->child(0);
physx::PxI32 nfields = pdStruct->numChildren();
physx::PxU32 align_ = getTargetAlignment(pdStruct),
size_ = getTargetSize(pdStruct),
pad_ = getTargetPadding(pdStruct);
align(align_);
physx::PxU32 off = size();
data.reserve(size() + n * physx::PxMax(align_, size_));
char *p = data;
p += data.size();
for(physx::PxI32 i = 0; i < n; ++i)
{
beginStruct(align_, pad_);
handle.set(i);
for(physx::PxI32 j = 0; j < nfields; ++j)
{
handle.set(j);
const Definition *pdField = pdStruct->child(j);
if( pdField->alignment() )
align( pdField->alignment() );
if( pdField->hint("DONOTSERIALIZE") )
{
//Simply skip bytes
align(getTargetAlignment(pdField));
skipBytes(getTargetSize(pdField));
}
else
{
//No need to align structs because of tail padding
switch( pdField->type() )
{
case TYPE_MAT34:
{
physx::PxMat44 val;
handle.getParamMat34(val);
storeSimple(physx::PxMat34Legacy(val));
break;
}
# define <API key>
# define <API key>
# define <API key>
# define <API key>(type_name, enum_name, c_type) \
case TYPE_##enum_name: \
{ \
c_type val; \
handle.getParam##type_name(val); \
storeSimple<c_type>(val); \
break; \
}
# include "<API key>.h"
default:
DEBUG_ASSERT( 0 && "Unexpected type" );
return PX_MAX_U32;
}
}
handle.popIndex();
}
handle.popIndex();
closeStruct();
}
return off;
}
physx::PxU32 <API key>::storeObjHeader(const NxParameterized::Interface &obj, bool isIncluded)
{
physx::PxU32 align_ = PxMax3(mTargetParams.aligns.Bool, mTargetParams.aligns.i32, mTargetParams.aligns.pointer);
physx::PxU32 off = beginStruct(align_);
physx::PxU32 hdrOff = data.size();
PX_ASSERT( hdrOff % sizeof(physx::PxU32) == 0 );
storeSimple(physx::PxU32(0)); //Data offset
//className
storeStringPtr(obj.className());
//name
storeStringPtr(obj.name());
//isIncluded
storeSimple(isIncluded);
//version
storeSimple<physx::PxU32>(obj.version());
//checksum size
physx::PxU32 bits = (physx::PxU32)-1;
const physx::PxU32 *checksum = obj.checksum(bits);
PX_ASSERT( bits % 32 == 0 ); //32 bits in physx::PxU32
physx::PxU32 i32s = bits / 32;
storeSimple(i32s);
//checksum pointer
Reloc &reloc = storePtr(RELOC_ABS_RAW, mTargetParams.aligns.i32);
for(physx::PxU32 i = 0; i < i32s; ++i)
reloc.ptrData->storeSimple(checksum[i]);
closeStruct();
//We force alignment to calculate dataOffset
//(when object is inserted no additional padding will be inserted)
const Definition *pd = obj.<API key>();
physx::PxU32 customAlign = pd ? getTargetAlignment(pd) : 1;
align(physx::PxMax(16U, customAlign)); //16 for safety
storeU32At(data.size() - hdrOff, hdrOff); //Now we know object data offset
return off;
}
physx::PxU32 <API key>::beginObject(const NxParameterized::Interface &obj, bool /*isRoot*/, const Definition *pd)
{
//NxParameterized objects is derived from NxParameters so we need to store its fields as well.
//WARN: this implementation _heavily_ depends on implementation of NxParameters
//Alignment of NxParameters
physx::PxU32 parentAlign = physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool),
childAlign = pd ? getTargetAlignment(pd) : 1,
totalAlign = physx::PxMax(parentAlign, childAlign);
physx::PxU32 off = beginStruct(totalAlign);
//NxParameters fields
for(physx::PxU32 i = 0; i < 6; storeNullPtr(), ++i); //vtable and other fields
storeStringPtr(obj.name()); //mName
storeStringPtr(obj.className()); //mClassName
storeSimple(true); //mDoDeallocateSelf (all objects are responsible for memory deallocation)
storeSimple(false); //mDoDeallocateName
storeSimple(false); //<API key>
//Some general theory of alignment handling
//Imagine that we have class:
//class A: A1, A2, ... An
// T1 f1;
// T2 f2;
//Then all Ai/fi are aligned on natural boundary. Whether or not padding bytes for Ai are inserted
//and whether or not Ai+1 or fi may reuse those bytes depends on compiler;
//we store this info in PlatformABI's doReusePadding flag.
//doReusePadding == false means that padding bytes are always there.
//doReusePadding == true means that padding bytes are _not_ inserted for non-POD Ai but are inserted for POD Ai.
//(I have yet to see compiler that does not insert padding bytes for POD base class!).
//Compilers may handle derived classes in two different ways.
//Say we have
// class B {int x; char y; };
// class A: public B {char z; };
//Then in pure C code this may look like either as
// struct A { struct { int x; char y; } b; char z; };
//or as
// struct A { int x; char y; char z; };
//(the latter is usual if B is not POD).
//Take care of that here (NxParameters is not POD!).
if( !mTargetParams.<API key> )
align(parentAlign); //Insert tail padding for NxParameters
//ParametersStruct is aligned on natural boundary
align(childAlign);
return off;
}
physx::PxU32 <API key>::merge(const <API key> &mergee)
{
//All structs should be closed
PX_ASSERT( !mergee.mStack.size() );
align(mergee.alignment());
physx::PxU32 base = data.size();
data.appendBytes(mergee.data, mergee.data.size());
//Update relocations
mRelocs.reserve(mRelocs.size() + mergee.mRelocs.size());
for(physx::PxU32 i = 0; i < mergee.mRelocs.size(); ++i)
{
mRelocs.pushBack(mergee.mRelocs[i]);
mRelocs.back().ptrPos += base;
}
mStrings.reserve(mStrings.size() + mergee.mStrings.size());
for(physx::PxU32 i = 0; i < mergee.mStrings.size(); ++i)
{
mStrings.pushBack(mergee.mStrings[i]);
mStrings.back().ptrPos += base;
}
mMerges.reserve(mMerges.size() + mergee.mMerges.size());
for(physx::PxU32 i = 0; i < mergee.mMerges.size(); ++i)
{
mMerges.pushBack(mergee.mMerges[i]);
mMerges.back().ptrPos += base;
if( !mergee.mMerges[i].isExtern )
mMerges.back().targetPos += base;
}
return base;
}
void <API key>::flatten()
{
//It's very important that data for child objects is stored
//after current object to allow safe initialization
//Generic pointers
for(physx::PxU32 i = 0; i < mRelocs.size(); ++i)
{
Reloc &reloc = mRelocs[i];
//Recursively add data which is pointed-to
align( reloc.ptrData->alignment() );
MergedReloc m = { reloc.ptrPos, data.size(), reloc.type, false };
mMerges.pushBack(m);
merge(*reloc.ptrData); //Internal pointers are recursively added here
}
//String pointers
for(physx::PxU32 i = 0; i < mStrings.size(); ++i)
{
//String pointers are external and absolute
MergedReloc m = { mStrings[i].ptrPos, dict.getOffset(mStrings[i].s), RELOC_ABS_RAW, true };
mMerges.pushBack(m);
}
mRelocs.clear();
mStrings.clear();
}
physx::PxU32 <API key>::writeRelocs()
{
physx::PxU32 ptrOff = storeSimple<physx::PxU32>(mMerges.size()); //Offset of relocation table
data.reserve(mMerges.size() * 2 * physx::PxMax(4U, mTargetParams.aligns.i32));
for(physx::PxU32 i = 0; i < mMerges.size(); ++i)
{
char *ptr = &data[mMerges[i].ptrPos];
if( 4 == mTargetParams.sizes.pointer )
{
physx::PxU32 *ptrAsInt = reinterpret_cast<physx::PxU32 *>(ptr);
*ptrAsInt = mMerges[i].targetPos;
if( mTargetParams.endian != mCurParams.endian )
SwapBytes(ptr, 4U, TYPE_U32);
}
else
{
PX_ASSERT(8 == mTargetParams.sizes.pointer);
physx::PxU64 *ptrAsInt = reinterpret_cast<physx::PxU64 *>(ptr);
*ptrAsInt = mMerges[i].targetPos;
if( mTargetParams.endian != mCurParams.endian )
SwapBytes(ptr, 8U, TYPE_U64);
}
//BinaryReloc struct
beginStruct(mTargetParams.aligns.i32);
storeSimple<physx::PxU32>(static_cast<physx::PxU32>(mMerges[i].type));
storeSimple<physx::PxU32>(mMerges[i].ptrPos);
closeStruct();
}
mMerges.clear();
return ptrOff;
}
#endif
|
package v1alpha1
import (
"fmt"
"net/url"
"path/filepath"
"strconv"
"strings"
"time"
rbac "k8s.io/api/rbac/v1"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// KoliPrefixValue is used for creating annotations and labels
const (
KoliPrefixValue = "kolihub.io"
ReleaseExpireAfter = 20
)
// IsValid validates if the user is valid verifying the email, customer and organization
func (u User) IsValid() bool {
return len(u.Customer) > 0 && len(u.Organization) > 0 && len(u.Email) > 0
}
// <API key> contains all the cluster roles provisioned on the platform
var <API key> []PlatformRole
// <API key> contains all the resources allowed for a user to configure
// in resource quotas: http://kubernetes.io/docs/admin/resourcequota/#Object-Count-Quota
var <API key> *ResourceList
// GetRoleBinding retrieves a role binding for this role
func (r PlatformRole) GetRoleBinding(subjects []rbac.Subject) *rbac.RoleBinding {
return &rbac.RoleBinding{
ObjectMeta: metav1.ObjectMeta{Name: string(r)},
Subjects: subjects,
RoleRef: rbac.RoleRef{
Kind: "ClusterRole",
Name: string(r), // must match role name
},
}
}
// IsRegisteredRole check if the role matches with the registered roles.
func (r PlatformRole) IsRegisteredRole() bool {
for _, role := range <API key> {
if r == role {
return true
}
}
return false
}
// Exists verifies if the slice contains the role
func (r PlatformRole) Exists(roles []PlatformRole) bool {
for _, role := range roles {
if r == role {
return true
}
}
return false
}
// NewPlatformRoles converts a string of comma separated roles to registered []PlatformRoles
func NewPlatformRoles(roles string) []PlatformRole {
platformRoles := []PlatformRole{}
for _, r := range strings.Split(roles, ",") {
role := PlatformRole(r)
if !role.IsRegisteredRole() {
continue
}
platformRoles = append(platformRoles, role)
}
return platformRoles
}
// <API key> removes resources which are not registered on the platform
func (r *ResourceList) <API key>() {
for resourceName := range *r {
_, hasKey := (*<API key>)[resourceName]
if !hasKey {
delete(*r, resourceName)
}
}
}
// Expired verifies if the creation time of the resource is expired.
func (r *Release) Expired() bool {
expireAfter := r.Spec.ExpireAfter
if expireAfter == 0 {
expireAfter = ReleaseExpireAfter
}
createdAt := r.CreationTimestamp.Add(time.Duration(expireAfter) * time.Minute)
if createdAt.Before(time.Now().UTC()) {
return true
}
return false
}
// BuildRevision returns the revision as int, if the conversion fails returns 0
func (r *Release) BuildRevision() int {
buildRev, _ := strconv.Atoi(r.Spec.BuildRevision)
return buildRev
}
// IsGitHubSource check if the source of the build is from github
func (r *Release) IsGitHubSource() bool {
return r.Spec.Source == GitHubSource
}
// GitCloneURL constructs the remote clone URL for the given release
func (r *Release) GitCloneURL() (string, error) {
u, err := url.Parse(r.Spec.GitRemote)
if err != nil {
return "", fmt.Errorf("failed parsing url: %s", err)
}
gitRemoteURL := fmt.Sprintf("%s://jwt:%s@%s/%s", u.Scheme, r.Spec.AuthToken, u.Host, r.Spec.GitRepository)
return gitRemoteURL + ".git", nil
}
// GitReleaseURL constructs the URL where the release must be stored
func (r *Release) GitReleaseURL(host string) string {
// urlPath := filepath.Join("releases", r.Namespace, r.Spec.DeployName, r.Spec.HeadCommit.ID)
// ref := r.Spec.HeadCommit.ID
// if len(ref) == 0 {
// ref = base64.StdEncoding.EncodeToString([]byte(r.Spec.GitBranch))
urlPath := filepath.Join("releases", "v1beta1", r.Namespace, r.Spec.DeployName, "objects")
return fmt.Sprintf("%s/%s", host, urlPath)
}
func (d *Domain) HasFinalizer(finalizer string) bool {
for _, f := range d.GetFinalizers() {
if f == finalizer {
return true
}
}
return false
}
// IsPrimary validates if it's a primary domain
func (d *Domain) IsPrimary() bool {
return len(d.Spec.Sub) == 0
}
// IsValidSharedDomain verifies if the shared domain it's a subdomain from the primary
func (d *Domain) IsValidSharedDomain() bool {
return !d.IsPrimary() && d.IsValidDomain()
}
func (d *Domain) IsValidDomain() bool {
if len(strings.Split(d.Spec.Sub, ".")) > 1 || len(strings.Split(d.Spec.PrimaryDomain, ".")) < 2 {
return false
}
return true
}
func (d *Domain) GetDomain() string {
if d.IsPrimary() {
return d.GetPrimaryDomain()
}
return d.Spec.Sub + "." + d.Spec.PrimaryDomain
}
// GetDomainType returns the type of the resource: 'primary' or 'shared'
func (d *Domain) GetDomainType() string {
if d.IsPrimary() {
return "primary"
}
return "shared"
}
// GetPrimaryDomain returns the primary domain of the resource
func (d *Domain) GetPrimaryDomain() string {
return d.Spec.PrimaryDomain
}
// HasDelegate verifies if the the resource has the target namespace in the delegates attribute
func (d *Domain) HasDelegate(namespace string) bool {
for _, delegateNS := range d.Spec.Delegates {
if delegateNS == namespace || delegateNS == "*" {
return true
}
}
return false
}
// IsOK verifies if the resource is in the OK state
func (d *Domain) IsOK() bool {
if d.Status.Phase == DomainStatusOK {
return true
}
return false
}
// CPU return the CPU from limits and requests respectively
func (p *Plan) CPU() (*resource.Quantity, *resource.Quantity) {
return p.Spec.Resources.Limits.Cpu(),
p.Spec.Resources.Requests.Cpu()
}
// Memory returns the memory from limits and requests respectively
func (p *Plan) Memory() (*resource.Quantity, *resource.Quantity) {
return p.Spec.Resources.Limits.Memory(),
p.Spec.Resources.Requests.Memory()
}
// Storage returns the storage ammount from the spec
func (p *Plan) Storage() *resource.Quantity {
return &p.Spec.Storage
}
// IsDefaultType validate if the plan is PlanTypeDefault
func (p *Plan) IsDefaultType() bool {
return p.Spec.Type == PlanTypeDefault
}
// IsStorageType validate if the plan is PlanTypeStorage
func (p *Plan) IsStorageType() bool {
return p.Spec.Type == PlanTypeStorage
}
// AddFile add filename with size in the map
func (i *GitInfo) AddFile(filename string, size int64) {
if i.Files == nil {
i.Files = make(map[string]int64)
}
i.Files[filename] = size
}
// GetCommitSha returns a SHA struct, nil if the commit is invalid
func (i *GitInfo) GetCommitSha() *SHA {
commitSha, _ := NewSha(i.HeadCommit.ID)
return commitSha
}
|
#pragma once
#include <aws/chime-sdk-identity/<API key>.h>
#include <aws/chime-sdk-identity/<API key>.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace ChimeSDKIdentity
{
namespace Model
{
class <API key> <API key> : public <API key>
{
public:
<API key>();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* <API key>() const override { return "<API key>"; }
Aws::String SerializePayload() const override;
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline const Aws::String& <API key>() const{ return <API key>; }
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline bool <API key>() const { return <API key>; }
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline void <API key>(const Aws::String& value) { <API key> = true; <API key> = value; }
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline void <API key>(Aws::String&& value) { <API key> = true; <API key> = std::move(value); }
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline void <API key>(const char* value) { <API key> = true; <API key>.assign(value); }
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline <API key>& <API key>(const Aws::String& value) { <API key>(value); return *this;}
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline <API key>& <API key>(Aws::String&& value) { <API key>(std::move(value)); return *this;}
/**
* <p>The ARN of the <code>AppInstanceAdmin</code>.</p>
*/
inline <API key>& <API key>(const char* value) { <API key>(value); return *this;}
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline const Aws::String& GetAppInstanceArn() const{ return m_appInstanceArn; }
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline bool <API key>() const { return <API key>; }
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline void SetAppInstanceArn(const Aws::String& value) { <API key> = true; m_appInstanceArn = value; }
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline void SetAppInstanceArn(Aws::String&& value) { <API key> = true; m_appInstanceArn = std::move(value); }
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline void SetAppInstanceArn(const char* value) { <API key> = true; m_appInstanceArn.assign(value); }
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline <API key>& WithAppInstanceArn(const Aws::String& value) { SetAppInstanceArn(value); return *this;}
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline <API key>& WithAppInstanceArn(Aws::String&& value) { SetAppInstanceArn(std::move(value)); return *this;}
/**
* <p>The ARN of the <code>AppInstance</code>.</p>
*/
inline <API key>& WithAppInstanceArn(const char* value) { SetAppInstanceArn(value); return *this;}
private:
Aws::String <API key>;
bool <API key>;
Aws::String m_appInstanceArn;
bool <API key>;
};
} // namespace Model
} // namespace ChimeSDKIdentity
} // namespace Aws
|
<!DOCTYPE HTML PUBLIC "-
<!--NewPage
<HTML>
<HEAD>
<!-- Generated by javadoc (build 1.6.0_20) on Tue Jun 01 14:31:51 BST 2010 -->
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<TITLE>
<API key> (Jena Framework)
</TITLE>
<META NAME="date" CONTENT="2010-06-01">
<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../stylesheet.css" TITLE="Style">
<SCRIPT type="text/javascript">
function windowTitle()
{
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="<API key> (Jena Framework)";
}
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>
</HEAD>
<BODY BGCOLOR="white" onload="windowTitle();">
<HR>
<A NAME="navbar_top"></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="class-use/<API key>.html"><FONT CLASS="NavBarFont1"><B>Use</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../com/hp/hpl/jena/reasoner/FinderUtil.html" title="class in com.hp.hpl.jena.reasoner"><B>PREV CLASS</B></A>
<A HREF="../../../../../com/hp/hpl/jena/reasoner/InfGraph.html" title="interface in com.hp.hpl.jena.reasoner"><B>NEXT CLASS</B></A></FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../index.html?com/hp/hpl/jena/reasoner/<API key>.html" target="_top"><B>FRAMES</B></A>
<A HREF="<API key>.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!
if(window==top) {
document.writeln('<A HREF="../../../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
<TR>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
SUMMARY: NESTED | FIELD | <A HREF="#constructor_summary">CONSTR</A> | <A HREF="#<API key>.lang.Throwable">METHOD</A></FONT></TD>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
DETAIL: FIELD | <A HREF="#constructor_detail">CONSTR</A> | METHOD</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<HR>
<H2>
<FONT SIZE="-1">
com.hp.hpl.jena.reasoner</FONT>
<BR>
Class <API key></H2>
<PRE>
java.lang.Object
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by ">java.lang.Throwable
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by ">java.lang.Exception
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by ">java.lang.RuntimeException
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by "><A HREF="../../../../../com/hp/hpl/jena/shared/JenaException.html" title="class in com.hp.hpl.jena.shared">com.hp.hpl.jena.shared.JenaException</A>
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by "><A HREF="../../../../../com/hp/hpl/jena/reasoner/ReasonerException.html" title="class in com.hp.hpl.jena.reasoner">com.hp.hpl.jena.reasoner.ReasonerException</A>
<IMG SRC="../../../../../resources/inherit.gif" ALT="extended by "><B>com.hp.hpl.jena.reasoner.<API key></B>
</PRE>
<DL>
<DT><B>All Implemented Interfaces:</B> <DD>java.io.Serializable</DD>
</DL>
<HR>
<DL>
<DT><PRE>public class <B><API key></B><DT>extends <A HREF="../../../../../com/hp/hpl/jena/reasoner/ReasonerException.html" title="class in com.hp.hpl.jena.reasoner">ReasonerException</A></DL>
</PRE>
<P>
Exception used to to signal that a configuration parameter was used
(typically in a setParameter call) that was not understood - either
because it was not a recognized parameter URI or its value range was incorrect.
<P>
<P>
<DL>
<DT><B>Version:</B></DT>
<DD>$Revision: 1.1 $ on $Date: 2009/06/29 08:55:50 $</DD>
<DT><B>Author:</B></DT>
<DD><a href="mailto:der@hplb.hpl.hp.com">Dave Reynolds</a></DD>
<DT><B>See Also:</B><DD><A HREF="../../../../../serialized-form.html#com.hp.hpl.jena.reasoner.<API key>">Serialized Form</A></DL>
<HR>
<P>
<A NAME="constructor_summary"></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
<B>Constructor Summary</B></FONT></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD><CODE><B><A HREF="../../../../../com/hp/hpl/jena/reasoner/<API key>.html#<API key>(java.lang.String)"><API key></A></B>(java.lang.String message)</CODE>
<BR>
Constructor.</TD>
</TR>
</TABLE>
<A NAME="method_summary"></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
<B>Method Summary</B></FONT></TH>
</TR>
</TABLE>
<A NAME="<API key>.lang.Throwable"></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#EEEEFF" CLASS="<API key>">
<TH ALIGN="left"><B>Methods inherited from class java.lang.Throwable</B></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD><CODE>fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString</CODE></TD>
</TR>
</TABLE>
<A NAME="<API key>.lang.Object"></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#EEEEFF" CLASS="<API key>">
<TH ALIGN="left"><B>Methods inherited from class java.lang.Object</B></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD><CODE>equals, getClass, hashCode, notify, notifyAll, wait, wait, wait</CODE></TD>
</TR>
</TABLE>
<P>
<A NAME="constructor_detail"></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="1"><FONT SIZE="+2">
<B>Constructor Detail</B></FONT></TH>
</TR>
</TABLE>
<A NAME="<API key>(java.lang.String)"></A><H3>
<API key></H3>
<PRE>
public <B><API key></B>(java.lang.String message)</PRE>
<DL>
<DD>Constructor.
<P>
</DL>
<HR>
<A NAME="navbar_bottom"></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="<API key>"></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="class-use/<API key>.html"><FONT CLASS="NavBarFont1"><B>Use</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../com/hp/hpl/jena/reasoner/FinderUtil.html" title="class in com.hp.hpl.jena.reasoner"><B>PREV CLASS</B></A>
<A HREF="../../../../../com/hp/hpl/jena/reasoner/InfGraph.html" title="interface in com.hp.hpl.jena.reasoner"><B>NEXT CLASS</B></A></FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../index.html?com/hp/hpl/jena/reasoner/<API key>.html" target="_top"><B>FRAMES</B></A>
<A HREF="<API key>.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!
if(window==top) {
document.writeln('<A HREF="../../../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
<TR>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
SUMMARY: NESTED | FIELD | <A HREF="#constructor_summary">CONSTR</A> | <A HREF="#<API key>.lang.Throwable">METHOD</A></FONT></TD>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
DETAIL: FIELD | <A HREF="#constructor_detail">CONSTR</A> | METHOD</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<HR>
Copyright © 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Hewlett-Packard Development Company, LP
</BODY>
</HTML>
|
<html>
<head>
<meta charset="UTF-8">
<title>ex02</title>
</head>
<body>
<?php
for ($i = 0; $i < 101; $i+=3) {
echo "Valor de i: $i<br>";
}
?>
</body>
</html>
|
/*body, div, dl, dt, dd, ul, ol, li, h1, h2, h3, h4, h5, h6, pre, code, form, fieldset, legend, input, textarea, p, blockquote { margin: 0pt; padding: 0pt; font: Arial, Helvetica, sans-serif}
body {background: none repeat scroll 0% 0% rgb(255, 255, 255); color: rgb(75, 75, 75); }
fieldset, img { border: 0pt none; }
address, caption, cite, code, dfn, em, strong, th, var { font-style: normal; font-weight: normal; }
ul,li { list-style: none outside none; }
input, textarea, select { font-family: inherit; font-size: inherit; font-weight: inherit; }
input.text,textarea.textarea,select.select {border: 1px solid #CCC;}*/
span.button{font:12px Verdana, Arial, Helvetica, sans-serif;vertical-align:middle;}
table{border-collapse: collapse;}
.ui-widget { font-family: Verdana,Arial,sans-serif; font-size: 12px; }
.ui-widget .ui-widget { font-size: 12px; }
.ui-widget input, .ui-widget select, .ui-widget textarea, .ui-widget button { font-family: Verdana,Arial,sans-serif; font-size: 12px;}
.dataTables_wrapper {position: relative;min-height: 102px;clear: both;_height: 302px;zoom: 1;padding:10px;/* Feeling sorry for IE */}
.<API key> {position: absolute;top: 50%;left: 50%;width: 340px;height: 40px;margin-left: -170px;margin-top: -15px;padding: 10px 10px 10px 10px;border: 1px solid #ddd;text-align: left;color: #999;font-size: 14px;background-color: white;line-height:20px;}
table.display { margin: 0pt auto; clear: both; width: 100%;border:1px solid #CCC;border-radius:5px;}
table.display thead th { padding: 3px 10px 3px 10px; border: 1px solid #D2D2D2;font-weight: bold; cursor: pointer;}
table.display tfoot th { padding: 3px 10px 3px 10px; border-top: 1px solid black; font-weight: bold;text-align:left}
table.display td { padding: 3px 5px 3px 5px;}
table.display tr.odd{background:#F6F6F6}
table.display tr.foot td{padding: 3px 5px 3px 5px;border-top: 1px solid black;}
table.display tr.sub{background:#F4E7FF}
table.display tr.even:hover,table.display tr.even td.highlighted{background-color: #ECFFB3;}
table.display tr.odd:hover,table.display tr.odd td.highlighted{background-color: #E6FF99;}
table.display tr.row_selected{background-color: #FFF4DD;}
table.tb_list {margin:0 auto;}
table.tb_list th{border: 1px solid #EEE;text-align: center;line-height:1.5;font-size:110%;font-weight:bold;color:#666666}
table.tb_list td{line-height:1.5}
table.tb_list td.c{text-align:center}
table.tb_list td.opt{text-align:center}
.<API key> table{border-bottom:0px;border-radius:5px 0 0 0;}
.<API key> table{border:0 5px 0 5px;border-radius:0;}
.<API key> table{border-top:0px;border-radius:0 0 5px 0;}
table.DTCR_clonedTable {background-color: white;z-index: 202;}
div.DTCR_pointer {width: 1px;background-color: #0259C4;z-index: 201;}
body.alt div.DTCR_pointer {margin-top: -15px;margin-left: -9px;width: 18px;background: url('../../image/default/insert.png') no-repeat top left;}
.pager {font-size: 80%;vertical-align:middle;float:right}
.pager a {text-decoration: none;border: solid 1px #AAE;color: #15B;background:#FFF}
.pager a, .pager span {display: block;float: left;padding: 0.3em 0.5em;margin-right:5px;}
.pager .current {background: #26B;color: #fff;border: solid 1px #AAE;}
.pager .current.prev, .pagination .current.next{color:#999;border-color:#999;background:#fff;}
.pager .status {background:#FFF;border: solid 1px #AAE;}
.pager input,.pager select {float:left;display:block;height:20px;margin-right:0.5em}
.pager select{height:22px}
.dialog { font-size: 100%; }
.dialog label,.dialog input { display:block; }
.dialog input.text { margin-bottom:12px; width:95%; padding: .4em; }
.dialog fieldset { padding:0; border:0; margin-top:25px; }
.dialog h1 { font-size: 1.2em; margin: .6em 0; }
.dialog div#users-contain { width: 350px; margin: 20px 0; }
.dialog div#users-contain table { margin: 1em 0; border-collapse: collapse; width: 100%; }
.dialog div#users-contain table td, .dialog div#users-contain table th { border: 1px solid #eee; padding: .6em 10px; text-align: left; }
.dialog .ui-dialog .ui-state-error { padding: .3em; }
.dialog .validateTips { border: 1px solid transparent; padding: 0.3em; }
label.error{color:red;padding-left:10px}
.bg1 {background-color:#eee;color:#35608C;}
.checkbox{vertical-align:middle;}
ul.opt_icons{float: left;}
ul.opt_icons li { border-right: 0px solid #DDD; padding-right: 3px; margin-right: 3px;float: left;}
ul.opt_icons li.last{border-right: 0px;}
.material-preview{padding-bottom:10px;padding-right:50px}
.ui-table-row{border-bottom: 1px solid #ddd;padding:10px;}
.preview-wrapper{display: block;height:35px;line-height:35px;width: 200px;vertical-align:middle;text-align:center;}
.<API key> {background-color: #FFFFFF;border: 1px dashed #CCCCCC;}
.<API key> {background-color: #F8F6F7;border: 1px dashed #CCCCCC;}
.sorting_asc {background: url("../../image/default/sort_asc.png") no-repeat scroll right center transparent;}
.sorting_desc {background: url("../../image/default/sort_desc.png") no-repeat scroll right center transparent;}
.sorting {background: url("../../image/default/sort_both.png") no-repeat scroll right center transparent;}
.<API key> {background: url("../../image/default/sort_asc_disabled.png") no-repeat scroll right center transparent;}
.<API key> {background: url("../../image/default/sort_desc_disabled.png") no-repeat scroll right center transparent;}
ul.orient-wrapper{width:100%;padding-bottom:10px;padding-right:10px;}
ul.orient-wrapper li {float:left;clear:both;width:870px;background: none repeat scroll 0 0 #F5FAFE;border: 1px solid #D0DCE8;margin-left:90px;position: relative;word-wrap: break-word;margin-top:5px;}
span.<API key> {background: url("../../image/default/BlockSprites.png") repeat scroll -180px -240px transparent;cursor: pointer;height: 11px;display:block;overflow: hidden;position: absolute;right: 5px;top: 5px;width: 11px;}
.tips { margin: 10px; }
.tips_t, .tips_b { height: 3px; background: none; font-size: 0px; overflow: hidden; }
.tips_c{border:1px solid #F8E3B4;padding:10px;background-color:#FFFFE3;border-radius:3px;}
button.ui-button::-moz-focus-inner { border: 0pt none; padding: 0pt; }
#btnSubmit{width:150px;}
.common_bg { background: url('../../image/default/sprite_common.gif') no-repeat scroll 0% 0% transparent; }
.option_menu { float: right; width: 300px; padding-top: 10px; text-align: right; padding-right: 10px; }
.option_menu p { padding: 2px 0px; }
.option_menu span { float: right; display: block; height: 25px; line-height: 25px; padding-left: 23px; text-align: left; }
.option_menu span a { line-height: 25px; }
.option_menu span.op01 { width: 35px; background-position: -559px -152px; }
.option_menu span.op02 { width: 35px; background-position: -559px -187px; }
.option_menu span.op03 { width: 35px; background-position: -559px -213px; }
.option_menu span.op04 { width: 35px; background-position: -559px -239px; }
.option_menu span.op05 { width: 35px; background-position: left 4px; background-image: url(../../image/default/icon-comments.jpg) }
/* UI Search*/
.list-links, .list-position, .list-table-headcntr, .<API key>, .list-table-foot { }
.list-links:after, .list-position:after, .list-table-headcntr:after, .<API key>:after, .list-table-foot:after { content: " "; display: block; height: 0px; visibility: hidden; clear: both; }
.list-table-head { height: 28px; color: rgb(53, 96, 140); background: none repeat scroll 0px 0px rgb(199, 222, 237); border-top: 1px solid rgb(163, 205, 233); }
.list-table-headcntr { border-top: 1px solid rgb(216, 232, 242); height: 27px; line-height: 27px; }
.table-search .ui-text { margin-right: 5px;border:1px solid #7E9DB9;height:18px;line-height:18px}
.table-search div.ui-button { margin-top: 0px; }
.table-search { height:21px; width: 223px; margin:0;}
.table-filter div.ui-combobox { float: left; margin-right: 25px; }
.table-filter-title { padding-top: 1px; height: 19px; line-height: 19px; float: left; }
.list-table-head .table-filter { float: left; display: inline; margin: 3px 15px 0px 10px; }
.<API key> {float: left;padding-right: 5px;}
/* UI Form Element*/
.crumb, .menu, .form-row, .form-line, .form-single-line, .form-value, .form-value-mini, .edit-submit { }
.menu:after, .crumb:after, .form-row:after, .form-line:after, .form-single-line:after, .form-value:after, .form-value-mini:after, .edit-submit:after { content: " "; display: block; height: 0px; visibility: hidden; clear: both; }
.edit-submit {padding-top:10px; }
.form-row { padding: 2px 0px; }
.form-row .ui-button {margin-right: 5px;}
.form-line, .form-single-line, .form-key, .form-key-mini, .form-value-mini, .form-value { float: left; display: inline; line-height: 24px; }
.form-line, .form-value { width: 550px; }
.ui-dialog-body .form-value { width: auto; min-width: 200px; height:auto}
.form-key, .form-key-mini { float: left; padding: 1px 0px 3px 36px; width: 120px; }
.ui-dialog-body .form-key, .ui-dialog-body .form-single-line { padding-left: 10px; text-align:right;}
.form-value { padding: 2px;}
.form-row .ui-text { margin-right: 5px; }
.form-row .ui-combobox, .form-row .ui-button, .form-row .ui-text, .form-row .ui-textarea, .form-row .ui-buttonmenu { margin-top: 2px; }
/* UI Form Button*/
div.ui-button, div.ui-button-label { background-image: url('../../image/default/BlockSprites.png?v=5155'); display: inline; float: left; }
div.ui-button { text-align: center; cursor: pointer; background: none repeat scroll 0% 0% transparent; }
div.ui-button-bg-left { background-image: url('../../image/default/BlockSprites.png?v=5155'); width: 5px; float: left; height: 20px; }
div.ui-button-label { line-height: 21px; overflow: hidden; padding: 0px 10px 0px 5px; background-position: right 0px; font-size: 12px; font-weight: 700; font-family: STHeiti,SimSun; color:#666666; height: 20px;cursor: pointer;}
div.ui-button-hover div.ui-button-bg-left { background-position: left -20px; }
div.ui-button-hover div.ui-button-label { background-position: right -20px; }
div.ui-button-press div.ui-button-bg-left { background-position: left -40px;}
div.ui-button-press div.ui-button-label { background-position: right -40px;}
.ui-textarea, .ui-text { float: left; font-family: STHeiti,SimSun; }
/* UI Form Submit */
div.skin-btnsubmit div.ui-button-bg-left { height: 30px; background-position: left -120px; }
div.<API key> { height: 30px; line-height: 30px; background-position: right -120px; padding: 0px 30px 0px 25px; }
div.skin-btnsubmit div.ui-button-bg-left { height: 30px; background-position: left -120px; }
div.<API key> { height: 30px; line-height: 30px; background-position: right -120px; padding: 0px 30px 0px 25px; }
div.<API key> div.ui-button-bg-left { background-position: left -150px; }
div.<API key> div.<API key> { background-position: right -150px; }
div.<API key> div.ui-button-bg-left { background-position: left -180px; }
div.<API key> div.<API key> { background-position: right -180px; }
/* UI Form Back Button */
div.skin-btnback div.ui-button-bg-left, div.skin-btnback-small div.ui-button-bg-left { background: none repeat scroll 0% 0% transparent; }
div.skin-btnback { margin-left: 30px; }
div.skin-btnback .ui-button-bg-left { display: none; }
div.skin-btnback-label { height: 30px; line-height: 30px; color: rgb(51, 119, 170); background: none repeat scroll 0% 0% transparent; text-decoration: underline; padding: 0px; }
/* UI Form Combobox*/
.form-row .ui-combobox { float: left; margin-right: 5px; }
.form-row .ui-combobox, .form-row .ui-button, .form-row .ui-text, .form-row .ui-textarea, .form-row .ui-buttonmenu { margin-top: 2px; }
.ui-combobox { padding: 1px; font-size: 12px; background: none repeat scroll 0% 0% rgb(255, 255, 255); border: 1px solid rgb(126, 157, 185); font-family: STHeiti,SimSun; }
.ui-combobox-cur { padding: 0px 0px 0px 2px; text-align: left; background: none repeat scroll 0% 0% rgb(255, 255, 255); line-height: 16px; height: 16px; color: rgb(51, 51, 51); cursor: pointer; overflow: hidden; float: left; }
.ui-combobox-btn { float: right; width: 16px; height: 16px; background: url('../../image/default/BlockSprites.png?v=5155.png') no-repeat scroll 0px -316px rgb(126, 157, 185); cursor: pointer; }
.ui-combobox-active, .ui-combobox-hover { border: 1px solid rgb(237, 187, 114); }
.ui-combobox-hover .ui-combobox-btn { background-position: -16px -316px; }
.ui-richsel { float: left; }
.ui-richsel-tip { height: 15px; width: 15px; background: url('../../image/default/BlockSprites.png?v=5155.png') no-repeat scroll -155px -315px transparent; margin: 4px 10px 0px 5px; display: inline; float: left; cursor: pointer; }
/*UI Buttons*/
.ka_button, .ka_button:hover { text-decoration: none; border: 0px none; display: inline-block; letter-spacing: 1.2px; text-transform: uppercase; color: rgb(221, 221, 221) ! important; }
.ka_button span { display: block; }
.guide_button .ka_button {margin-right:20px}
.large_button { margin: 5px 10px 5px 0px; padding: 0px 34px 0px 0px; font-size: 1.5em;font-weight:bold; background: url('../../image/default/bg-buttons-sprite.png') no-repeat scroll 100% -261px transparent; color: rgb(244, 244, 242); border: 0px none; outline: medium none; cursor: pointer; }
.large_button span { margin: 0px; padding: 28px 0px 33px 33px; line-height: 16px; background: url('../../image/default/bg-buttons-sprite.png') no-repeat scroll 0px -186px transparent; border: 0px none; outline: medium none; cursor: pointer; }
.small_coolblue, .small_coolblue span, .medium_coolblue, .medium_coolblue span, .large_coolblue, .large_coolblue span { background-image: url('../../image/default/<API key>.png') ! important; }
.guide_button{width:664px}
.Icon .Container{z-index:-10000}
/*UI Tab */
.custom-tab { display: block; float: left; font-style: normal; height: 30px; line-height: 20px; margin-right: 20px; padding-top: 10px; font-size: 14px; }
.custom-tab em { font-style: normal; padding-bottom: 10px; display: inline-block; height: 20px; }
.custom-tab-active { background: url('../../image/default/arrowtab.png') no-repeat scroll center bottom transparent; font-weight: 700; }
.edit-profile { padding: 0px 11px; }
.edit-profile .tab-wrapper { border-bottom: 1px solid rgb(158, 202, 232); margin-bottom: 15px; padding-left: 10px; }
.edit-profile .custom-tab { font-size: 12px; height: auto; }
.edit-profile .custom-tab em { padding: 0px 10px 7px 0px; }
/*UI Dialog */
.ui-dialog { position: absolute; z-index: 1001; width: 800px; background: none repeat scroll 0% 0% rgb(255, 255, 255); border: 1px solid rgb(158, 201, 233); }
.ui-dialog-close { position: absolute; top: 5px; right: 16px; cursor: pointer; border: 4px solid rgb(199, 222, 236); height: 11px; width: 11px; overflow: hidden; background: url('../../image/default/BlockSprites.png?v=5155.png') no-repeat scroll -180px -240px rgb(199, 222, 236); }
.ui-dialog-head { background: none repeat scroll 0% 0% rgb(199, 222, 236); border-top: 1px solid rgb(220, 234, 243); border-bottom: 1px solid rgb(158, 201, 233); height: 30px;overflow:hidden; }
div.ui-dialog-title { color: rgb(51, 102, 153); font-size: 12px; font-weight: 700; line-height: 27px; padding-left: 12px; }
.ui-dialog-foot { border-top: 1px solid rgb(197, 223, 240); background: none repeat scroll 0% 0% rgb(230, 243, 251); padding: 10px; }
.ui-dialog-foot .ui-button { margin-right: 5px; }
.ui-dialog-body { padding: 10px; position: relative; }
.ui-dialog-foot:after { content: " "; display: block; height: 0px; visibility: hidden; clear: both; }
.ui-link { color: rgb(51, 119, 170); cursor: pointer; }
.ui-textarea, .ui-text { float: left; display: inline; padding: 1px 2px; font-size: 12px; background: none repeat scroll 0% 0% rgb(255, 255, 255); text-align: left; border: 1px solid rgb(126, 157, 185); font-family: STHeiti,SimSun; }
.ui-text { height: 16px; line-height: 14px; }
.ui-dialog { background: none repeat scroll 0px 0px rgb(255, 255, 255); border: 1px solid #256EB1; color: rgb(51, 51, 51); }
.ui-dialog-close { background: url('../../image/default/ui-colorpicker.png') repeat-x scroll -120px -200px transparent; cursor: pointer; height: 19px; position: absolute; right: 8px; width: 19px; top: 3px; }
/*UI Fix*/
.pwd-tip { color: rgb(153, 153, 153); }
.clearfix:after { content: "."; display: block; height: 0px; clear: both; visibility: hidden; }
.clearfix { display: inline-block; }
.clearfix { display: block; }
/* Color Picker */
.color_widget{position:relative;height: 36px;cursor: pointer;}
.colorpicker_holder{top: 32px;left: 0;width: 356px;height: 0;overflow: hidden;position: absolute;z-index:9999}
.colorpicker_holder .colorpicker_hue div {background-image: url(../../image/default/custom_indic.gif);}
.colorpicker_holder .colorpicker_hex {background-image: url(../../image/default/custom_hex.png);}
.colorpicker_holder .colorpicker_rgb_r {background-image: url(../../image/default/custom_rgb_r.png);}
.colorpicker_holder .colorpicker_rgb_g {background-image: url(../../image/default/custom_rgb_g.png);}
.colorpicker_holder .colorpicker_rgb_b {background-image: url(../../image/default/custom_rgb_b.png);}
.colorpicker_holder .colorpicker_hsb_s {background-image: url(../../image/default/custom_hsb_s.png);display: none;}
.colorpicker_holder .colorpicker_hsb_h {background-image: url(../../image/default/custom_hsb_h.png);display: none;}
.colorpicker_holder .colorpicker_hsb_b {background-image: url(../../image/default/custom_hsb_b.png);display: none;}
.colorpicker_holder .colorpicker_submit {background-image: url(../../image/default/custom_submit.png);}
.colorpicker_holder .colorpicker input {color: #778398;}
.colorpicker_holder .colorpicker {width: 356px;height: 176px;overflow: hidden;position: absolute;bottom: 1px;left: -1px;background: url(../../image/default/custom_background.png);font-family: Arial, Helvetica, sans-serif;display: none;}
.colorpicker_color {width: 150px;height: 150px;left: 14px;top: 13px;position: absolute;background: #f00;overflow: hidden;cursor: crosshair;}
.colorpicker_color div {position: absolute;top: 0;left: 0;width: 150px;height: 150px;background: url(../../image/default/colorpicker_overlay.png);}
.colorpicker_color div div {position: absolute;top: 0;left: 0;width: 11px;height: 11px;overflow: hidden;background: url(../../image/default/colorpicker_select.gif);margin: -5px 0 0 -5px;}
.colorpicker_hue {position: absolute;top: 13px;left: 171px;width: 35px;height: 150px;cursor: n-resize;}
.colorpicker_hue div {position: absolute;width: 35px;height: 9px;overflow: hidden;background: url(../../image/default/colorpicker_indic.gif) left top;margin: -4px 0 0 0;left: 0px;}
.<API key> {position: absolute;width: 60px;height: 30px;left: 213px;top: 13px;background: #f00;}
.<API key> {position: absolute;width: 60px;height: 30px;left: 283px;top: 13px;background: #f00;}
.colorpicker input {background-color: transparent;border: 1px solid transparent;position: absolute;font-size: 10px;font-family: Arial, Helvetica, sans-serif;color: #898989;top: 4px;right: 11px;text-align: right;margin: 0;padding: 0;height: 11px;}
.colorpicker_hex {position: absolute;width: 72px;height: 22px;background: url(../../image/default/colorpicker_hex.png) top;left: 212px;top: 142px;}
.colorpicker_hex input {right: 6px;}
.colorpicker_field {height: 22px;width: 62px;background-position: top;position: absolute;}
.colorpicker_field span {position: absolute;width: 12px;height: 22px;overflow: hidden;top: 0;right: 0;cursor: n-resize;}
.colorpicker_rgb_r {background-image: url(../../image/default/colorpicker_rgb_r.png);top: 52px;left: 212px;}
.colorpicker_rgb_g {background-image: url(../../image/default/colorpicker_rgb_g.png);top: 82px;left: 212px;}
.colorpicker_rgb_b {background-image: url(../../image/default/colorpicker_rgb_b.png);top: 112px;left: 212px;}
.colorpicker_hsb_h {background-image: url(../../image/default/colorpicker_hsb_h.png);top: 52px;left: 282px;}
.colorpicker_hsb_s {background-image: url(../../image/default/colorpicker_hsb_s.png);top: 82px;left: 282px;}
.colorpicker_hsb_b {background-image: url(../../image/default/colorpicker_hsb_b.png);top: 112px;left: 282px;}
.colorpicker_submit {position: absolute;width: 22px;height: 22px;background: url(../../image/default/colorpicker_submit.png) top;left: 322px;top: 142px;overflow: hidden;}
.colorpicker_focus {background-position: center;}
.colorpicker_hex.colorpicker_focus {background-position: bottom;}
.colorpicker_submit.colorpicker_focus {background-position: bottom;}
.colorpicker_slider {background-position: bottom;}
.color_selector {position: absolute;top: 0;left: 0;width: 36px;height: 36px;background: url(../../image/default/select2.png);}
.color_selector div {position: absolute;top: 4px;left: 4px;width: 28px;height: 28px;background: url(../../image/default/select2.png) center;}
#param_list.orient-wrapper li{width:350px}
span.form_tips{height:20px;line-height:20px;color:#CCC;margin-top:2px;display:inline-block;vertical-align:middle;margin-left:10px;}
.ui-tooltip-layer { position: relative; top: -25px; left: 20px; width: 300px; border: 1px solid #BEA06E; background: none repeat scroll 0% 0% #FFF7DB; padding: 5px; line-height: 19px; text-align: left; color: rgb(51, 51, 51); z-index: 2001; }
.ui-tooltip-layer dt { padding: 3px 0px; font-size: 14px; border-bottom: 1px dashed #CCC; }
.ui-tooltip-layer dd { font-size: 12px; padding: 3px 0px 0px; }
.jb_info{background-color:#F8FCFD}
.recycle a{text-decoration:underline}
.opacity_bg {background-color:#000;height:1666px;width:2888px;filter:alpha(opacity=50);opacity:0.5;position: absolute;top:0;left:0;z-index: 200;}
/*default*/
.additionform_top
{
background: none repeat scroll 0 0 #F0F6FA;
border: 1px solid #C5DEF0;
cursor: pointer;
height: 28px;
line-height: 28px;
margin: 1px 10px 0px;
position: relative;
}
.additionform_top h3
{
font-size: 12px;
padding-left: 53px;
}
.additionform_button{
height: 11px;
left: 36px;
overflow: hidden;
position: absolute;
top: 8px;
width: 11px;
}
.<API key>
{
background: url("../../image/default/BlockSprites.png") repeat scroll -61px -305px transparent;
}
.<API key>
{
background: url("../../image/default/BlockSprites.png") repeat scroll -50px -305px transparent;
}
|
This folder contains some static web file, mainly used for landing pages.
|
/* arch/sandpoint/include/bootinfo.h has served as base for this file */
#ifndef <API key>
#define <API key>
#include <machine/bootconfig.h>
#define BOOTINFO_MAGIC 0xb007babe
#define BOOTINFO_MAXSIZE 4096
struct btinfo_common {
int next;
int type;
};
#define BTINFO_MAGIC 1
#define BTINFO_SYMTAB 2
#define BTINFO_BOOTSTRING 3
#define BTINFO_BOOTPATH 4
#define BTINFO_ROOTDEVICE 5
#define BTINFO_NET 6
struct btinfo_magic {
struct btinfo_common common;
unsigned int magic;
};
struct btinfo_symtab {
struct btinfo_common common;
int nsym;
void *ssym;
void *esym;
};
struct btinfo_bootstring {
struct btinfo_common common;
char bootstring[MAX_BOOT_STRING];
};
struct btinfo_bootpath {
struct btinfo_common common;
char bootpath[80];
};
struct btinfo_rootdevice {
struct btinfo_common common;
char devname[16];
unsigned int cookie;
unsigned int partition;
};
struct btinfo_net {
struct btinfo_common common;
char devname[16];
unsigned cookie;
uint8_t mac_address[6];
};
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.