text:
#include "tensorflow/lite/experimental/acceleration/mini_benchmark/mini_benchmark.h"

#include <unistd.h>

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include <gtest/gtest.h>
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "flatbuffers/flatbuffers.h"  // from @flatbuffers
#include "tensorflow/lite/experimental/acceleration/configuration/configuration.pb.h"
#include "tensorflow/lite/experimental/acceleration/configuration/configuration_generated.h"
#include "tensorflow/lite/experimental/acceleration/configuration/proto_to_flatbuffer.h"
#include "tensorflow/lite/experimental/acceleration/mini_benchmark/embedded_mobilenet_float_validation_model.h"
#include "tensorflow/lite/experimental/acceleration/mini_benchmark/mini_benchmark_test_helper.h"
#include "tensorflow/lite/experimental/acceleration/mini_benchmark/status_codes.h"

namespace tflite {
namespace acceleration {
namespace {

TEST(BasicMiniBenchmarkTest, EmptySettings) {
  proto::MinibenchmarkSettings settings_proto;
  flatbuffers::FlatBufferBuilder empty_settings_buffer_;
  const MinibenchmarkSettings* empty_settings =
      ConvertFromProto(settings_proto, &empty_settings_buffer_);
  std::unique_ptr<MiniBenchmark> mb(
      CreateMiniBenchmark(*empty_settings, "ns", "id"));
  mb->TriggerMiniBenchmark();
  const ComputeSettingsT acceleration = mb->GetBestAcceleration();
  EXPECT_EQ(nullptr, acceleration.tflite_settings);
  EXPECT_TRUE(mb->MarkAndGetEventsToLog().empty());
  EXPECT_EQ(-1, mb->NumRemainingAccelerationTests());
}

class MiniBenchmarkTest : public ::testing::Test {
 protected:
  void SetUp() override {
    MiniBenchmarkTestHelper helper;
    should_perform_test_ = helper.should_perform_test();

    if (should_perform_test_) {
      mobilenet_model_path_ = MiniBenchmarkTestHelper::DumpToTempFile(
          "mobilenet_float_with_validation.tflite",
          g_tflite_acceleration_embedded_mobilenet_float_validation_model,
          g_tflite_acceleration_embedded_mobilenet_float_validation_model_len);
    }
  }

  void SetupBenchmark(proto::Delegate delegate, const std::string& model_path,
                      bool reset_storage = true) {
    proto::MinibenchmarkSettings settings;
    proto::TFLiteSettings* tflite_settings = settings.add_settings_to_test();
    tflite_settings->set_delegate(delegate);
    proto::ModelFile* file = settings.mutable_model_file();
    file->set_filename(model_path);
    proto::BenchmarkStoragePaths* paths = settings.mutable_storage_paths();
    paths->set_storage_file_path(::testing::TempDir() + "/storage.fb");
    if (reset_storage) {
      (void)unlink(paths->storage_file_path().c_str());
      // The suffix needs to be same as the one used in
      // MiniBenchmarkImpl::LocalEventStorageFileName
      (void)unlink((paths->storage_file_path() + ".extra.fb").c_str());
    }
    paths->set_data_directory_path(::testing::TempDir());
    settings_ = ConvertFromProto(settings, &settings_buffer_);

    mb_ = CreateMiniBenchmark(*settings_, ns_, model_id_);
  }

  void TriggerBenchmark(proto::Delegate delegate, const std::string& model_path,
                        bool reset_storage = true) {
    SetupBenchmark(delegate, model_path, reset_storage);
    mb_->TriggerMiniBenchmark();
  }

  void WaitForValidationCompletion(
      absl::Duration timeout = absl::Seconds(300)) {
    absl::Time deadline = absl::Now() + timeout;
    while (absl::Now() < deadline) {
      if (mb_->NumRemainingAccelerationTests() == 0) return;
      absl::SleepFor(absl::Milliseconds(200));
    }

    // We reach here only when the timeout has been reached w/o validation
    // completing.
    ASSERT_NE(0, mb_->NumRemainingAccelerationTests());
  }

  const std::string ns_ = "org.tensorflow.lite.mini_benchmark.test";
  const std::string model_id_ = "test_minibenchmark_model";

  bool should_perform_test_ = true;

  std::unique_ptr<MiniBenchmark> mb_;
  std::string mobilenet_model_path_;

  flatbuffers::FlatBufferBuilder settings_buffer_;
  // Simply a reference to settings_buffer_ for convenience.
  const MinibenchmarkSettings* settings_;
};

TEST_F(MiniBenchmarkTest, OnlyCPUSettings) {
  if (!should_perform_test_) return;
  SetupBenchmark(proto::Delegate::NONE, mobilenet_model_path_);
  EXPECT_EQ(-1, mb_->NumRemainingAccelerationTests());
  // We haven't triggered the benchmark yet, so a default ComputeSettingsT is
  // expected.
  ComputeSettingsT acceleration = mb_->GetBestAcceleration();
  EXPECT_EQ(nullptr, acceleration.tflite_settings);
  EXPECT_EQ(1, mb_->NumRemainingAccelerationTests());

  mb_->TriggerMiniBenchmark();
  // We just have 1 acceleration test to complete as the default CPU execution.
  WaitForValidationCompletion();
  acceleration = mb_->GetBestAcceleration();
  // As the best is the default CPU execution, the returned acceleration above
  // is still a default ComputeSettingsT.
  EXPECT_EQ(nullptr, acceleration.tflite_settings);
}

TEST_F(MiniBenchmarkTest, RunSuccessfully) {
  if (!should_perform_test_) return;

  TriggerBenchmark(proto::Delegate::XNNPACK, mobilenet_model_path_);

  // We have 2 acceleration tests to complete: one for the default CPU execution
  // and the other for XNNPACK delegate execution.
  WaitForValidationCompletion();
  // Mark existing events to be logged to simplify the logic of checking the
  // best decision event later.
  mb_->MarkAndGetEventsToLog();

  const ComputeSettingsT acceleration1 = mb_->GetBestAcceleration();
  EXPECT_NE(nullptr, acceleration1.tflite_settings);

  // The 2nd call should return the same acceleration settings.
  const ComputeSettingsT acceleration2 = mb_->GetBestAcceleration();
  EXPECT_EQ(acceleration1, acceleration2);
  // As we choose mobilenet-v1 float model, XNNPACK delegate should be the best
  // on CPU.
  EXPECT_EQ(tflite::Delegate_XNNPACK, acceleration1.tflite_settings->delegate);

  EXPECT_EQ(model_id_, acceleration1.model_identifier_for_statistics);
  EXPECT_EQ(ns_, acceleration1.model_namespace_for_statistics);

  // As the best decision event has not been marked as to-be-logged, we should
  // get one best decision event after the call.
  auto events = mb_->MarkAndGetEventsToLog();
  EXPECT_EQ(1, events.size());
  const auto& decision = events.front().best_acceleration_decision;
  EXPECT_NE(nullptr, decision);
  EXPECT_EQ(tflite::Delegate_XNNPACK,
            decision->min_latency_event->tflite_settings->delegate);
}

TEST_F(MiniBenchmarkTest, BestAccelerationEventIsMarkedLoggedAfterRestart) {
  if (!should_perform_test_) return;

  TriggerBenchmark(proto::Delegate::XNNPACK, mobilenet_model_path_);
  // We have 2 acceleration tests to complete: one for the default CPU execution
  // and the other for XNNPACK delegate execution.
  WaitForValidationCompletion();
  // Mark existing events to be logged to simplify the logic of checking the
  // best decision event later.
  mb_->MarkAndGetEventsToLog();
  mb_->GetBestAcceleration();

  // The best acceleration decision event was already persisted to the storage
  // above. So, we could retrieve the best acceleration immediately.
  TriggerBenchmark(proto::Delegate::XNNPACK, mobilenet_model_path_,
                   /*reset_storage=*/false);
  // As all acceleration tests have completed before, we expect no remaining
  // tests to be performed.
  EXPECT_EQ(0, mb_->NumRemainingAccelerationTests());
  const ComputeSettingsT acceleration = mb_->GetBestAcceleration();
  // As we choose mobilenet-v1 float model, XNNPACK delegate should be the best
  // on CPU.
  EXPECT_EQ(tflite::Delegate_XNNPACK, acceleration.tflite_settings->delegate);
  EXPECT_EQ(model_id_, acceleration.model_identifier_for_statistics);
  EXPECT_EQ(ns_, acceleration.model_namespace_for_statistics);

  // Similar to "RunSuccessfully' test above, the best decision event has not
  // been marked as to-be-logged, we should get one best decision event after
  // the call.
  auto events = mb_->MarkAndGetEventsToLog();
  EXPECT_EQ(1, events.size());
}

TEST_F(MiniBenchmarkTest,
       BestAccelerationEventIsNotReMarkedLoggedAfterRestart) {
  if (!should_perform_test_) return;

  TriggerBenchmark(proto::Delegate::XNNPACK, mobilenet_model_path_);
  // We have 2 acceleration tests to complete: one for the default CPU execution
  // and the other for XNNPACK delegate execution.
  WaitForValidationCompletion();
  mb_->GetBestAcceleration();

  // As the GetBestAcceleration above generates events synchronously, the event
  // will be persisted to the storage after the call, thus no waiting is needed
  // here.
  mb_->MarkAndGetEventsToLog();

  // The best acceleration decision event was already collected above. So, we
  // could retrieve the best acceleration immediately.
  TriggerBenchmark(proto::Delegate::XNNPACK, mobilenet_model_path_,
                   /*reset_storage=*/false);
  mb_->GetBestAcceleration();

  // As we have marked mini-benchmark events to be logged, we will expect
  // empty to-log events.
  EXPECT_TRUE(mb_->MarkAndGetEventsToLog().empty());
}

TEST_F(MiniBenchmarkTest, DelegatePluginNotSupported) {
  if (!should_perform_test_) return;

  // As Hexagon delegate plugin isn't supported in mini-benchmark, we will
  // expect a delegate plugin not-supported error.
  // Also, note that if a supported delegate plugin isn't linked to the this
  // test itself or the ":validator_runner_so_for_tests" target on Android,
  // one will expect a delegate plugin not-found error.
  TriggerBenchmark(proto::Delegate::HEXAGON, mobilenet_model_path_);

  // We have 2 acceleration tests to complete: one for the default CPU execution
  // and the other for HEXAGON delegate not supported.
  WaitForValidationCompletion();

  const ComputeSettingsT acceleration = mb_->GetBestAcceleration();
  // As the best performance is achieved on the default CPU, there's no
  // acceleration settings.
  EXPECT_EQ(nullptr, acceleration.tflite_settings);
  EXPECT_EQ(model_id_, acceleration.model_identifier_for_statistics);
  EXPECT_EQ(ns_, acceleration.model_namespace_for_statistics);

  // Check there is a Hexagon-delegate-not-supported event.
  const auto events = mb_->MarkAndGetEventsToLog();
  bool is_found = false;
  for (const auto& event : events) {
    const auto& t = event.benchmark_event;
    if (t == nullptr) continue;
    if (t->event_type == tflite::BenchmarkEventType_ERROR &&
        t->error->exit_code ==
            tflite::acceleration::kMinibenchmarkDelegateNotSupported) {
      is_found = true;
      break;
    }
  }
  EXPECT_TRUE(is_found);
}

}  // namespace
}  // namespace acceleration
}  // namespace tflite


text:
namespace BrightstarDB.EntityFramework
{
    /// <summary>
    /// Exception raised when an attempt is made to add an entity to a context without first setting its key properties.
    /// </summary>
    /// <remarks>This type of exception will also be raised if the parameterless Create() method is called on the context entity set for
    /// an entity type that has key proeprties.</remarks>
    public sealed class EntityKeyRequiredException : EntityFrameworkException
    {
        internal EntityKeyRequiredException() : base(Strings.EntityFramework_KeyRequired){}
    }
}

redpajama_set_name: RedPajamaGithub


text:
////////////////////////////////////////////////////
/// \file tf_publisher.hpp
/// \brief Declare ahl_robot::TfPublisher class
/// \author Daichi Yoshikawa
////////////////////////////////////////////////////

#ifndef __AHL_ROBOT_TF_PUBLISHER_HPP
#define __AHL_ROBOT_TF_PUBLISHER_HPP

#include <memory>
#include <geometry_msgs/TransformStamped.h>
#include <tf2/LinearMath/Quaternion.h>
#include <tf2_ros/transform_broadcaster.h>
#include "ahl_robot/robot/robot.hpp"

namespace ahl_robot
{

  /// Publish tf depending on the state of ahl_robot::Robot
  class TfPublisher
  {
  public:
    /// Constructor
    explicit TfPublisher();

    /// Publish tf
    /// \param robot Shared pointer of robot of which you'd like to see the frames
    /// \param publish_com If true, it publishes frames attached to center of mass of each link
    void publish(const RobotPtr& robot, bool publish_com = true);
  private:
    /// Publish tf
    /// \param mnp Shared pointer of manipulator of which you'd like to see the frames
    /// \param current Current time
    /// \publish_com If true, it publishes frames attached to center of mass of each link
    void publish(const ManipulatorPtr& mnp, const ros::Time& current, bool publish_com);

    //! Singleton of transform broadcaster
    tf2_ros::TransformBroadcaster& transformBroadcaster();
  };

  using TfPublisherPtr = std::shared_ptr<TfPublisher>;

} // namespace ahl_robot

#endif // __AHL_ROBOT_TF_PUBLISHER_HPP


text:
class InvalidLangException(Exception):
    """
    Base invalid language exception
    """

    def __init__(self, lang):
        self.lang = lang.encode('utf-8')

    def __str__(self):
        return repr(self.lang)

class InvalidFormException(Exception):
    """
    Raised when form is invalid
    """

    def __init__(self, form):
        self.form = form

    def __str__(self):
        return repr(self.form)

class InvalidSrcException(InvalidLangException):
    """
    Raised when src is not in available langs
    """

class InvalidTrgException(InvalidLangException):
    """
    Raised when trg is not in available langs
    """


text:
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using Shuffler;
using System.Diagnostics;

namespace UnitTestProject {
    [TestClass]
    public class UnitTestShuffler {
        private List<int> GenerateTestList(int count) {
            List<int> list = new List<int>();

            for (int i = 0; i < count; i++) {
                list.Add(i);
            }
            return list;
        }

        [TestMethod]
        public void TestShuffle3Items() {
            List<int> original = new List<int>() { 0, 1, 2 };

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            List<int> shuffled = original.Shuffle();

            stopwatch.Stop();
            Console.WriteLine(string.Format("Shuffling 3 items took {0} milliseconds or {1} ticks", stopwatch.ElapsedMilliseconds, stopwatch.ElapsedTicks));

            CollectionAssert.AllItemsAreUnique(shuffled);
            for (int index = 0; index < shuffled.Count; index++) {
                Assert.AreNotEqual(original[index], shuffled[index]);
            }
        }

        [TestMethod]
        public void TestShuffle10000Items() {
            List<int> original = GenerateTestList(10000);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            List<int> shuffled = original.Shuffle();

            stopwatch.Stop();
            Console.WriteLine(string.Format("Shuffling 10,000 items took {0} milliseconds or {1} ticks", stopwatch.ElapsedMilliseconds, stopwatch.ElapsedTicks));

            CollectionAssert.AllItemsAreUnique(shuffled);
            for (int index = 0; index < shuffled.Count; index++) {
                Assert.AreNotEqual(original[index], shuffled[index]);
            }
        }

        [TestMethod]
        public void TestShuffle100000Items() {
            List<int> original = GenerateTestList(100000);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            List<int> shuffled = original.Shuffle();

            stopwatch.Stop();
            Console.WriteLine(string.Format("Shuffling 100,000 items took {0} milliseconds or {1} ticks", stopwatch.ElapsedMilliseconds, stopwatch.ElapsedTicks));

            CollectionAssert.AllItemsAreUnique(shuffled);
            for (int index = 0; index < shuffled.Count; index++) {
                Assert.AreNotEqual(original[index], shuffled[index]);
            }
        }

        [TestMethod]
        public void TestShuffle10000000Items() {
            List<int> original = GenerateTestList(10000000);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            List<int> shuffled = original.Shuffle();

            stopwatch.Stop();
            Console.WriteLine(string.Format("Shuffling 10,000,000 items took {0} milliseconds or {1} ticks", stopwatch.ElapsedMilliseconds, stopwatch.ElapsedTicks));

            CollectionAssert.AllItemsAreUnique(shuffled);
            for (int index = 0; index < shuffled.Count; index++) {
                Assert.AreNotEqual(original[index], shuffled[index]);
            }
        }
    }
}


text:
package iso20022

// Characteristics shared by all individual items included in the currency control message.
type CurrencyControlHeader2 struct {

	// Point to point reference, as assigned by the instructing party, and sent to the next party in the chain to unambiguously identify the message.
	// Usage: The instructing party has to make sure that MessageIdentification is unique per instructed party for a pre-agreed period.
	MessageIdentification *Max35Text `xml:"MsgId"`

	// Date and time at which the message was created.
	CreationDateTime *ISODateTime `xml:"CreDtTm"`

	// Number of individual items contained in the message.
	NumberOfItems *Max15NumericText `xml:"NbOfItms"`

	// Party that receives the message.
	ReceivingParty *PartyIdentification77 `xml:"RcvgPty"`

	// Agent which sends the message.
	RegistrationAgent *BranchAndFinancialInstitutionIdentification5 `xml:"RegnAgt"`
}

func (c *CurrencyControlHeader2) SetMessageIdentification(value string) {
	c.MessageIdentification = (*Max35Text)(&value)
}

func (c *CurrencyControlHeader2) SetCreationDateTime(value string) {
	c.CreationDateTime = (*ISODateTime)(&value)
}

func (c *CurrencyControlHeader2) SetNumberOfItems(value string) {
	c.NumberOfItems = (*Max15NumericText)(&value)
}

func (c *CurrencyControlHeader2) AddReceivingParty() *PartyIdentification77 {
	c.ReceivingParty = new(PartyIdentification77)
	return c.ReceivingParty
}

func (c *CurrencyControlHeader2) AddRegistrationAgent() *BranchAndFinancialInstitutionIdentification5 {
	c.RegistrationAgent = new(BranchAndFinancialInstitutionIdentification5)
	return c.RegistrationAgent
}


text:
package org.rabix.bindings.draft3.expression.javascript;

import java.io.Reader;
import java.io.StringReader;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.NativeJSON;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
import org.mozilla.javascript.Undefined;
import org.rabix.bindings.draft3.expression.Draft3ExpressionException;
import org.rabix.common.helper.JSONHelper;
import org.rabix.common.json.BeanSerializer;

import com.fasterxml.jackson.databind.JsonNode;

public class Draft3ExpressionJavascriptResolver {

  public final static int TIMEOUT_IN_SECONDS = 5;

  public final static String EXPR_CONTEXT_NAME = "inputs";
  public final static String EXPR_SELF_NAME = "self";

  public final static int OPTIMIZATION_LEVEL = -1;
  public final static int MAX_STACK_DEPTH = 10;

  /**
   * Evaluate JS script (function or statement)
   */
  public static Object evaluate(Object context, Object self, String expr, List<String> engineConfigs) throws Draft3ExpressionException {
    String trimmedExpr = StringUtils.trim(expr);
    if (trimmedExpr.startsWith("$")) {
      trimmedExpr = trimmedExpr.substring(1);
    }

    String function = trimmedExpr;
    if (trimmedExpr.startsWith("{")) {
      function = "(function()%expr)()";
      function = function.replace("%expr", trimmedExpr);
    }

    Context cx = Context.enter();
    cx.setOptimizationLevel(OPTIMIZATION_LEVEL);
    cx.setMaximumInterpreterStackDepth(MAX_STACK_DEPTH);
    cx.setClassShutter(new Draft3ExpressionDenyAllClassShutter());

    try {
      Scriptable globalScope = cx.initStandardObjects();

      if (engineConfigs != null) {
        for (int i = 0; i < engineConfigs.size(); i++) {
          Reader engineConfigReader = new StringReader(engineConfigs.get(i));
          cx.evaluateReader(globalScope, engineConfigReader, "engineConfig_" + i + ".js", 1, null);
        }
      }

      putToScope(EXPR_CONTEXT_NAME, context, cx, globalScope);
      putToScope(EXPR_SELF_NAME, self, cx, globalScope);

      Scriptable resultScope = cx.newObject(globalScope);
      resultScope.setPrototype(globalScope);
      resultScope.setParentScope(globalScope);

      Object result = cx.evaluateString(resultScope, function, "script", 1, null);
      if (result == null || result instanceof Undefined) {
        return null;
      }

      Object wrappedResult = Context.javaToJS(result, globalScope);
      putToScope("$result", wrappedResult, cx, globalScope);
      ScriptableObject.putProperty(globalScope, "$result", wrappedResult);

      String finalFunction = "(function() { " + "           var result = $result;"
          + "           var type = result instanceof Array? \"array\" : typeof result;"
          + "           return JSON.stringify({ \"result\" : result, \"type\" : type }); " + "     })()";

      Scriptable wrapScope = cx.newObject(globalScope);
      wrapScope.setPrototype(globalScope);
      wrapScope.setParentScope(globalScope);
      result = cx.evaluateString(wrapScope, finalFunction, "script", 1, null);
      return castResult(result);
    } catch (Exception e) {
      String msg = String.format("Failed evaluating expression %s.", expr);
      throw new Draft3ExpressionException(msg, e);
    } finally {
      Context.exit();
    }
  }

  /**
   * Add object to execution scope
   */
  private static void putToScope(String name, Object value, Context cx, Scriptable scope) {
    if (value != null) {
      String selfJson = BeanSerializer.serializePartial(value);

      Object json = NativeJSON.parse(cx, scope, selfJson, new org.mozilla.javascript.Callable() {
        @Override
        public Object call(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
          return args[1];
        }
      });
      ScriptableObject.putProperty(scope, name, json);
    } else {
      ScriptableObject.putProperty(scope, name, null);
    }
  }

  /**
   * Cast result to proper Java object
   */
  private static Object castResult(Object result) {
    if (result == null) {
      return null;
    }
    JsonNode node = JSONHelper.readJsonNode(result.toString());
    return JSONHelper.transformPreserveNull(node.get("result"));

  }

}


text:
title:  Dos épocas, un mismo mensaje
date:   10/04/2021
---

**inTro**

### Cuando algo no encaja

En el debate respecto al antiguo pacto y al nuevo, los teólogos generalmente creen que las referencias bíblicas y las alusiones al antiguo pacto se aplican solo al antiguo pacto histórico, es decir, al pacto que Dios hizo con su pueblo en el Sinaí y a la ley, que incluía el sábado. También creen que las características negativas del antiguo pacto que podemos leer en el Nuevo Testamento se aplican al pacto del Sinaí.

En la «Introducción» de este folleto (ver p. 5) hablábamos del antiguo pacto y de la ley de Dios {identificados por la mayoría de los teólogos como el pacto y la ley del Sinaí) en los siguientes términos:

- decíamos que se presenta bajo la figura de un tutor o guía que ya no es necesario una vez que acudimos a Cristo (Gál. 3: 24-25);

- que es un pacto «según la carne» y no según el espíritu (Gál. 4: 23, 30, NBLA);

- que impide a la gente del pacto «compartir la herencia [eterna]» (Gál. 4: 30) al estar sometidos «al yugo de la esclavitud» (Gál. 5: 1);

- que «condena a muerte» (2 Cor. 3: 6, NVI);

- que es un «ministerio que causaba muerte» (2 Cor. 3: 7, 9, NVI), una alianza que mantenía a la gente «bajo la ley» y no «bajo la gracia» (Rom. 6: 14, NVI);

- algo a lo que debemos morir con el fin de desposarnos con Cristo y recibir la salvación (Rom. 7: 1-4);

- decíamos que se volvió obsoleto con la llegada del nuevo pacto (Heb. 8: 13).

Estas descripciones del pacto del Sinaí y de sus leyes están muy lejos de las promesas y garantías que marcan la identidad del nuevo pacto, por eso no es de extrañar que Dios necesitara un nuevo pacto. iPero espera un momento! En su prefacio al nuevo pacto, al presentar las razones por las que necesitaba formular uno nuevo, Dios no mencionó ninguna de las cosas que acabamos de mencionar. Lo que dijo es que se necesitaba un nuevo pacto porque el pueblo del pacto había sido infiel al pacto del Sinaí. iQué interesante!

En la lección de esta semana haremos una comparativa más profunda del pacto del Sinaí y del nuevo pacto, en niveles fundamentales que deberían cambiar la ecuación respecto a la forma en que ambos se relacionan con el evangelio.

Escribelo aqui

- Copia Deuteronomio 5: l-6: 9 de tu versión favorita de la Biblia.

- Si no dispones de demasiado tiempo, copia únicamente Deuteronomio 6: 4-9.

- También puedes parafrasear el pasaje, resumirlo o hacer un bosquejo del mismo.


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Romanschulzia mexicana H.H. Iltis & Al-Shehbaz

### Remarks
null


text:
<!DOCTYPE HTML>

<title>Uses of Class com.mxgraph.util.mxEventObject (mxGraph 4.2.2 API Specification)</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<meta name="dc.created" content="2020-10-28">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery/jquery-ui.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

mxGraph 4.2.2

All Classes

SEARCH:
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">

JavaScript is disabled on your browser.

Uses of Class
com.mxgraph.util.mxEventObject

Packages that use mxEventObject

Package
Description

com.mxgraph.util

This package provides utility classes such as mxConstants, mxUtils, mxPoint
  and mxRectangle as well as all classes for custom events and the undo
  history.

Uses of mxEventObject in com.mxgraph.util

Methods in com.mxgraph.util with parameters of type mxEventObject

Modifier and Type
Method
Description

void
mxEventSource.fireEvent(mxEventObject evt)

Dispatches the given event name with this object as the event source.

void
mxEventSource.fireEvent(mxEventObject evt,
         java.lang.Object sender)

Dispatches the given event name, passing all arguments after the given
 name to the registered listeners for the event.

void
mxEventSource.mxIEventListener.invoke(java.lang.Object sender,
      mxEventObject evt)

Called when the graph model has changed.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

mxGraph 4.2.2

All Classes

JavaScript is disabled on your browser.

Copyright (c) 2010-2017 Gaudenz Alder, JGraph Ltd. All rights reserved.


text:
package com.logginghub.logging.modules;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import com.logginghub.logging.DefaultLogEvent;
import com.logginghub.logging.LogEvent;
import com.logginghub.logging.LogEventBuilder;
import com.logginghub.logging.exceptions.LoggingMessageSenderException;
import com.logginghub.logging.modules.configuration.ExternalFileMonitorConfiguration;
import com.logginghub.utils.Asynchronous;
import com.logginghub.utils.Destination;
import com.logginghub.utils.ExceptionHandler;
import com.logginghub.utils.FileUtils;
import com.logginghub.utils.Multiplexer;
import com.logginghub.utils.SystemErrExceptionHandler;
import com.logginghub.utils.ThreadUtils;
import com.logginghub.utils.WorkerThread;
import com.logginghub.utils.logging.Logger;
import com.logginghub.utils.module.Module;
import com.logginghub.utils.module.ServiceDiscovery;

public class ExternalFileMonitorModule implements Module<ExternalFileMonitorConfiguration>, Asynchronous {

    private Logger logger = Logger.getLoggerFor(ExternalFileMonitorModule.class);
    private ExternalFileMonitorConfiguration configuration;
    private WorkerThread thread;
    private ExceptionHandler exceptionHandler = new SystemErrExceptionHandler();
    private int level;

    private Multiplexer<LogEvent> logEventMultiplexer = new Multiplexer<LogEvent>();

    @Override public void configure(ExternalFileMonitorConfiguration configuration, ServiceDiscovery discovery) {
        this.configuration = configuration;
        level = Logger.parseLevel(configuration.getLevel());

        @SuppressWarnings("unchecked") Destination<LogEvent> eventDestination = discovery.findService(Destination.class,
                                                                                LogEvent.class,
                                                                                configuration.getDestination());
        logEventMultiplexer.addDestination(eventDestination);
    }

    @Override public void start() {

        final File file = new File(configuration.getPath());
        thread = WorkerThread.executeOngoing("FileReader", new Runnable() {
            @Override public void run() {
                if (file.exists()) {
                    try {
                        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
                        String line = null;

                        // TODO : might be nice to have a feature to play since
                        // a last captured time stamp?

                        // TODO : need to deal with rotations, truncations etc

                        // If we aren't grabbing lines, skip straight to the end
                        if (!configuration.isReplayAll()) {
                            bufferedReader.skip(file.length());
                        }

                        while (thread.isRunning()) {
                            line = bufferedReader.readLine();
                            if (line == null) {
                                ThreadUtils.sleep(100);
                            }
                            else {
                                processLine(line);
                            }
                        }

                        FileUtils.closeQuietly(bufferedReader);
                    }
                    catch (IOException e) {
                        exceptionHandler.handleException("Opening file", e);
                    }
                    catch (LoggingMessageSenderException e) {
                        exceptionHandler.handleException("Sending event", e);
                    }
                }
            }
        });

        thread.setIterationDelay(1000);
    }

    protected void processLine(String line) throws LoggingMessageSenderException {
        DefaultLogEvent event = LogEventBuilder.start()
                                               .setMessage(configuration.getPrefix() + line + configuration.getPostfix())
                                               .setLevel(level)
                                               .setChannel(configuration.getChannel())
                                               .toLogEvent();

        logEventMultiplexer.send(event);
    }

    public Multiplexer<LogEvent> getLogEventMultiplexer() {
        return logEventMultiplexer;
    }

    @Override public void stop() {
        thread.stop();
    }

}


text:
\documentclass[]{article}   % list options between brackets
\usepackage{amsmath}        % list packages between braces
\usepackage[utf8]{inputenc}
\usepackage{graphicx}
\usepackage{lmodern}

%Page
\addtolength{\oddsidemargin}{-.875in}
\addtolength{\evensidemargin}{-.875in}
\addtolength{\textwidth}{1.75in}
\addtolength{\topmargin}{-.875in}
\addtolength{\textheight}{1.75in}
%Page

% type user-defined commands here
\begin{document}

\title{Études et expérimentation de la reconnaissance des chiffres}   % type title between braces
\author{NGUYEN Van Tho - NGUYEN Quoc Khai}         % type author(s) between braces
\date{22 Décembre, 2013}    % type date between braces
\maketitle

\section{Introduction}
Dans ce TP, nous visons à développer un programme qui peut reconnaître des chiffres. Pour
il existe plein de recherches qui donnent les résultats efficaces
tels que K-plus proches voisins, Décision stumps, Classification non linéaire, SVMs,
Réseaux neuraux et Réseaux de convolution\cite{c1}. Il existe aussi des méthode moins
efficace comme Classification linéaire, la classification bayésienne. Pour
trouver des bonnes méthodes, nous examinons quelques algorithmes qui rendent des
résultats acceptables et qui sont faisables. Après ces études, nous avons choisit 2
méthodes, K-plus proches voisins et SVM. Nous expérimentons plusieurs paramètres de ces
deux méthodes pour trouver la meilleure configuration.\\

\section{Descriptions des méthodes utilisées}
Dans ce TP, nous avons utilisé 2 méthodes, K-plus proches voisins et SVM
\subsection{K-plus proches voisins Euclide}
Cette méthode est réalisé dans des étapes suivantes.
\subsubsection{Détection des blocks}
Chaque image est divisée en N blocks de même taille. On vous signale que le choix du nombre de block est si important, cela influence beaucoup au résultat de reconnaissance. Après avoir testé des paramètres, on a choisi de mettre $N = 14x14 = 196$.
\subsubsection{Calcul du descripteur}
Un descripteur contient $N$ éléments et une valeur d'un élément $e$ est la somme des pixels d'un block qu'on a détecté dans la dernière étape.
\subsubsection{Calcul de la distance d'Euclide entre deux descripteurs}
\begin{equation}
D = \sqrt{\sum_{\substack{
   	(1<=i<=N)}} (e_{1i} - e_{2i})^2}
\end{equation}
\subsubsection{K-plus proches voisins (K-Nearest Neighbors)}
Quand on entre une image de test, le programme calcule la distance $D$ entre cette image avec toutes les images d'apprentissage, ils donnes $K$ images ayant les distances les plus courtes. Choix du type le plus populaire pour le type de l'image de test. Ici, K est un paramètre d'entré. En observant le résultat des tests, nous trouvons que $K = 4$ donne le meilleur résultat.
\subsection{Méthode SVM}
Nous avons aussi implémenté un programme utilisé la méthode SVM. Cette méthode utilise la
même structure que la méthode K-plus proches voisins. Autrement dit, l'image est divisée
en N bloques. Le vecteur caractéristique est un vecteur de taille N, chaque élément de
vecteur est la somme des valeurs de niveau de gris d'un bloc.

Dans ce travail, nous avons utilisé l'implémentation de SVM de OpenCV.

\begin{center}
 \includegraphics{./images/svm.png}
\end{center}

Le kernel gaussien utilisé dans notre programme:
\begin{center}
$K(x_{i}, x_{j}) = exp(-\gamma(x_{i}- x_{j})^2)$
\end{center}

\section{Présentation du programme}
Ce programme contient 4 classes divisées en 8 fichiers : \textit{channel.h channel.cpp IO.h IO.cpp training.h training.cpp control.h et control.cpp} et un fichier de la fonction \textit{main}, \textit{main.cpp}. Un \textit{makefile} sert à faciliter de compiler le programme.

Ce programme a les fonctionnalités suivantes :
\begin{enumerate}
\item Création des descripteurs pour les images d'apprentissage ou de test et les enregistre dans un fichier.
\item A partir de deux fichiers de descripteur de test et d'apprentissage, le programme catégorise les images vers la catégorie correspondante.
\end{enumerate}

Dans ce programme, aucun algorithme est réutilisé. Par contre, nous avons utilisé la librairie OpenCV pour le traitement de base.
\section{Expérimentation}
\subsection{Évaluation}
Pour évaluer le programme, nous avons utilisés deux critères: le taux de précision et le
temps de calcul. Une configuration des paramètres est considérée meilleure si elle rend
un résultat avec un grand taux de précision et avec un petit temps de calcul.

\subsection{SVM}
Une des difficultés de l'algorithme SVM est comment choisir les bonnes paramètres.
Un mauvais choix de paramètres peut rendre un résultat très mauvais. Avec un kernel
gaussien, on a deux paramètres à optimiser: la constance C et le gamma. Donc, pour
trouver les valeurs optimales de ces paramètres, nous utilisons la méthode Grid search
proposé par Chih-Wei Hsu, Chih-Chung Chang et Chih-Jen Lin \cite{c2}.En effet, nous avons
expérimenté les valeurs de C de $2^{-5}$ à $2^{15}$ et gamma de $2^{-19}$ à $2^3$. De
plus, pour trouver le nombre optimal de blocs, nous expérimenté plusieurs nombre de bloc:
de 7 à 16.

Les bonnes valeurs de C reçues sont de 2 à 8. Les bonnes valeurs de gamma sont de 0.0001
à 0.008. Nous avons fait la deuxième série d'expérimentation avec ces valeurs de C et
gamma.

\subsection{Méthode KNN}
Avec cette méthode, pour obtenir le bon résultat, il faut bien choisir des paramètres
comme le nombre de block, le K plus proches voisins.
\begin{enumerate}
\item Nombre de block, ce paramètre est important. Quand le nombre de block est petit, le
résultat n'est pas exact. Par contre, quand on le met très grand, la méthode peut se
tromper aussi à cause des bruits dans les images.
\item K plus proches voisins, cette paramètre est aussi importante mais c'est plus facile
de fixer cette paramètre. Par rapport des testes, nous trouvons que le bon est d'entre 1
et 5.
\end{enumerate}
\section{Analyse des résultats obtenus}
\subsection{Méthode KNN}

\begin{figure}[!htb]
\minipage{0.55\textwidth}
  \includegraphics[width=\linewidth]{images/graphique.png}
  \caption{Taux de correct}\label{fig:awesome_image2}
\endminipage\hfill
\minipage{0.55\textwidth}
  \includegraphics[width=\linewidth]{images/graphique1.png}
  \caption{Temps de calcul}\label{fig:awesome_image3}
\endminipage\hfill
\end{figure}

\subsection{Méthode SVM}
Comme nous avons discuté dans la section expérimentation, le point crucial de cette
méthode est de bien choisir la configuration de C et gamma. Voir les figures de
résultats, on constate qu'il y a un petit compromis entre le taux de précision et le
temps de calcul. En fait, quand le résultat est crucial, on peut utiliser la
configuration avec C = 3, gamma = 0.002 et le nombre de blocs est 14x14. Cette
configuration rend le taux de précision de
94.8\% et le temps de calcul est 4 seconds.
Par contre,quand le temps de calcul est plus crucial, la configuration avec C = 8, gamma =
0.0004 le nombre de blocs est 7x7. Cette configuration rend le taux de précision de
92.1\% et le temps de calcul est 0.8 seconds.

\pagebreak
\begin{figure}[!htb]
\minipage{0.55\textwidth}
  \includegraphics[width=\linewidth]{images/graphique2.png}
  \caption{Taux de correct, blocs = 7x7}\label{fig:awesome_image2}
\endminipage\hfill
\minipage{0.55\textwidth}
  \includegraphics[width=\linewidth]{images/graphique3.png}
  \caption{Temps de calcul, blocs = 7x7}\label{fig:awesome_image3}
\endminipage\hfill
\end{figure}

\begin{figure}[!htb]
\minipage{0.5\textwidth}
  \includegraphics[width=\linewidth]{images/graphique4.png}
  \caption{Taux de correct, blocs = 14x14}\label{fig:awesome_image2}
\endminipage\hfill
\minipage{0.5\textwidth}
  \includegraphics[width=\linewidth]{images/graphique5.png}
  \caption{Temps de calcul, blocs = 14x14}\label{fig:awesome_image3}
\endminipage\hfill
\end{figure}

\subsection{Comparaison entre KNN et SVM}
Nous constatons que la méthode SVM peut donner des résultats beaucoup plus vite que la
méthode KNN. De plus, la précision de résultat rendu par SVM est un peu importante par
rapport à celui rendu par la méthode KNN.

\section{Conclusion}
Dans ce projet, nous avons implémenté deux algorithmes pour la reconnaissance de chiffres
manuscrit. Nous avons aussi expérimenté plusieurs configurations des paramètres pour
trouver la meilleure configuration.

En général, la méthode SVM est meilleure que la méthode KNN en toutes les termes
d'évaluation. Cependant, pour trouver les bonnes paramètres, on doit faire plus
d'expérimentation.

\clearpage
\begin{thebibliography}{9}
\bibitem{c1}
  David Lowe
  \emph{THE MNIST DATABASE of handwritten digits}.
  Yann LeCun, Courant Institute, NYU,
  Corinna Cortes, Google Labs, New York,
  Christopher J.C. Burges, Microsoft Research, Redmond,
  \emph{http://www.cs.ubc.ca/~lowe/keypoints/}

\bibitem{c2}
  Chih-Wei Hsu, Chih-Chung Chang, and Chih-Jen Lin
  \emph{A Practical Guide to Support Vector Classification}.
  Department of Computer Science
National Taiwan University, Taipei 106, Taiwan
  \emph{http://www.csie.ntu.edu.tw/~cjlin}

\end{thebibliography}

\end{document}


text:
// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

using System.Collections.Immutable;
using System.Linq;
using System.Reflection;
using System.Threading;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.Host.Mef
{
    public static class DesktopMefHostServices
    {
        private static MefHostServices s_defaultServices;
        public static MefHostServices DefaultServices
        {
            get
            {
                if (s_defaultServices == null)
                {
                    Interlocked.CompareExchange(ref s_defaultServices, MefHostServices.Create(DefaultAssemblies), null);
                }

                return s_defaultServices;
            }
        }

        private static ImmutableArray<Assembly> s_defaultAssemblies;
        private static ImmutableArray<Assembly> DefaultAssemblies
        {
            get
            {
                if (s_defaultAssemblies == null)
                {
                    ImmutableInterlocked.InterlockedCompareExchange(ref s_defaultAssemblies, CreateDefaultAssemblies(), default(ImmutableArray<Assembly>));
                }

                return s_defaultAssemblies;
            }
        }

        private static ImmutableArray<Assembly> CreateDefaultAssemblies()
        {
            var assemblyNames = new string[]
            {
                "Microsoft.CodeAnalysis.Workspaces.Desktop",
            };

            return MefHostServices.DefaultAssemblies.Concat(MefHostServices.LoadNearbyAssemblies(assemblyNames));
        }
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<channel><item><title><![CDATA[Sidebar]]></title><slug>sidebar</slug><value><![CDATA[
website Features

XML based data storage

Best-in-Class User Interface

\'Undo\' protection &amp; backups

Easy to theme

Great documentation

Growing community

This is your sidebar text. Please change me in Theme -> Edit Components

Download the Latest Website
]]></value></item><item><title><![CDATA[Tagline]]></title><slug>tagline</slug><value><![CDATA[Just Another Website]]></value></item></channel>


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/cloud/compute/v1/compute.proto

namespace Google\Cloud\Compute\V1;

use Google\Protobuf\Internal\GPBType;
use Google\Protobuf\Internal\RepeatedField;
use Google\Protobuf\Internal\GPBUtil;

/**
 * Message containing Cloud CDN configuration for a backend service.
 *
 * Generated from protobuf message google.cloud.compute.v1.BackendServiceCdnPolicy
 */
class BackendServiceCdnPolicy extends \Google\Protobuf\Internal\Message
{
    /**
     * Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyBypassCacheOnRequestHeader bypass_cache_on_request_headers = 486203082;
     */
    private $bypass_cache_on_request_headers;
    /**
     * The CacheKeyPolicy for this CdnPolicy.
     *
     * Generated from protobuf field optional .google.cloud.compute.v1.CacheKeyPolicy cache_key_policy = 159263727;
     */
    private $cache_key_policy = null;
    /**
     * Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
     * Check the CacheMode enum for the list of possible values.
     *
     * Generated from protobuf field optional string cache_mode = 28877888;
     */
    private $cache_mode = null;
    /**
     * Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
     *
     * Generated from protobuf field optional int32 client_ttl = 29034360;
     */
    private $client_ttl = null;
    /**
     * Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 default_ttl = 100253422;
     */
    private $default_ttl = null;
    /**
     * Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 max_ttl = 307578001;
     */
    private $max_ttl = null;
    /**
     * Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
     *
     * Generated from protobuf field optional bool negative_caching = 336110005;
     */
    private $negative_caching = null;
    /**
     * Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyNegativeCachingPolicy negative_caching_policy = 155359996;
     */
    private $negative_caching_policy;
    /**
     * If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
     *
     * Generated from protobuf field optional bool request_coalescing = 532808276;
     */
    private $request_coalescing = null;
    /**
     * Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
     *
     * Generated from protobuf field optional int32 serve_while_stale = 236682203;
     */
    private $serve_while_stale = null;
    /**
     * Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
     *
     * Generated from protobuf field optional int64 signed_url_cache_max_age_sec = 269374534;
     */
    private $signed_url_cache_max_age_sec = null;
    /**
     * [Output Only] Names of the keys for signing request URLs.
     *
     * Generated from protobuf field repeated string signed_url_key_names = 371848885;
     */
    private $signed_url_key_names;

    /**
     * Constructor.
     *
     * @param array $data {
     *     Optional. Data for populating the Message object.
     *
     *     @type array<\Google\Cloud\Compute\V1\BackendServiceCdnPolicyBypassCacheOnRequestHeader>|\Google\Protobuf\Internal\RepeatedField $bypass_cache_on_request_headers
     *           Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
     *     @type \Google\Cloud\Compute\V1\CacheKeyPolicy $cache_key_policy
     *           The CacheKeyPolicy for this CdnPolicy.
     *     @type string $cache_mode
     *           Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
     *           Check the CacheMode enum for the list of possible values.
     *     @type int $client_ttl
     *           Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
     *     @type int $default_ttl
     *           Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *     @type int $max_ttl
     *           Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *     @type bool $negative_caching
     *           Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
     *     @type array<\Google\Cloud\Compute\V1\BackendServiceCdnPolicyNegativeCachingPolicy>|\Google\Protobuf\Internal\RepeatedField $negative_caching_policy
     *           Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
     *     @type bool $request_coalescing
     *           If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
     *     @type int $serve_while_stale
     *           Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
     *     @type int|string $signed_url_cache_max_age_sec
     *           Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
     *     @type array<string>|\Google\Protobuf\Internal\RepeatedField $signed_url_key_names
     *           [Output Only] Names of the keys for signing request URLs.
     * }
     */
    public function __construct($data = NULL) {
        \GPBMetadata\Google\Cloud\Compute\V1\Compute::initOnce();
        parent::__construct($data);
    }

    /**
     * Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyBypassCacheOnRequestHeader bypass_cache_on_request_headers = 486203082;
     * @return \Google\Protobuf\Internal\RepeatedField
     */
    public function getBypassCacheOnRequestHeaders()
    {
        return $this->bypass_cache_on_request_headers;
    }

    /**
     * Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyBypassCacheOnRequestHeader bypass_cache_on_request_headers = 486203082;
     * @param array<\Google\Cloud\Compute\V1\BackendServiceCdnPolicyBypassCacheOnRequestHeader>|\Google\Protobuf\Internal\RepeatedField $var
     * @return $this
     */
    public function setBypassCacheOnRequestHeaders($var)
    {
        $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Cloud\Compute\V1\BackendServiceCdnPolicyBypassCacheOnRequestHeader::class);
        $this->bypass_cache_on_request_headers = $arr;

        return $this;
    }

    /**
     * The CacheKeyPolicy for this CdnPolicy.
     *
     * Generated from protobuf field optional .google.cloud.compute.v1.CacheKeyPolicy cache_key_policy = 159263727;
     * @return \Google\Cloud\Compute\V1\CacheKeyPolicy|null
     */
    public function getCacheKeyPolicy()
    {
        return $this->cache_key_policy;
    }

    public function hasCacheKeyPolicy()
    {
        return isset($this->cache_key_policy);
    }

    public function clearCacheKeyPolicy()
    {
        unset($this->cache_key_policy);
    }

    /**
     * The CacheKeyPolicy for this CdnPolicy.
     *
     * Generated from protobuf field optional .google.cloud.compute.v1.CacheKeyPolicy cache_key_policy = 159263727;
     * @param \Google\Cloud\Compute\V1\CacheKeyPolicy $var
     * @return $this
     */
    public function setCacheKeyPolicy($var)
    {
        GPBUtil::checkMessage($var, \Google\Cloud\Compute\V1\CacheKeyPolicy::class);
        $this->cache_key_policy = $var;

        return $this;
    }

    /**
     * Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
     * Check the CacheMode enum for the list of possible values.
     *
     * Generated from protobuf field optional string cache_mode = 28877888;
     * @return string
     */
    public function getCacheMode()
    {
        return isset($this->cache_mode) ? $this->cache_mode : '';
    }

    public function hasCacheMode()
    {
        return isset($this->cache_mode);
    }

    public function clearCacheMode()
    {
        unset($this->cache_mode);
    }

    /**
     * Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
     * Check the CacheMode enum for the list of possible values.
     *
     * Generated from protobuf field optional string cache_mode = 28877888;
     * @param string $var
     * @return $this
     */
    public function setCacheMode($var)
    {
        GPBUtil::checkString($var, True);
        $this->cache_mode = $var;

        return $this;
    }

    /**
     * Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
     *
     * Generated from protobuf field optional int32 client_ttl = 29034360;
     * @return int
     */
    public function getClientTtl()
    {
        return isset($this->client_ttl) ? $this->client_ttl : 0;
    }

    public function hasClientTtl()
    {
        return isset($this->client_ttl);
    }

    public function clearClientTtl()
    {
        unset($this->client_ttl);
    }

    /**
     * Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
     *
     * Generated from protobuf field optional int32 client_ttl = 29034360;
     * @param int $var
     * @return $this
     */
    public function setClientTtl($var)
    {
        GPBUtil::checkInt32($var);
        $this->client_ttl = $var;

        return $this;
    }

    /**
     * Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 default_ttl = 100253422;
     * @return int
     */
    public function getDefaultTtl()
    {
        return isset($this->default_ttl) ? $this->default_ttl : 0;
    }

    public function hasDefaultTtl()
    {
        return isset($this->default_ttl);
    }

    public function clearDefaultTtl()
    {
        unset($this->default_ttl);
    }

    /**
     * Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 default_ttl = 100253422;
     * @param int $var
     * @return $this
     */
    public function setDefaultTtl($var)
    {
        GPBUtil::checkInt32($var);
        $this->default_ttl = $var;

        return $this;
    }

    /**
     * Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 max_ttl = 307578001;
     * @return int
     */
    public function getMaxTtl()
    {
        return isset($this->max_ttl) ? $this->max_ttl : 0;
    }

    public function hasMaxTtl()
    {
        return isset($this->max_ttl);
    }

    public function clearMaxTtl()
    {
        unset($this->max_ttl);
    }

    /**
     * Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
     *
     * Generated from protobuf field optional int32 max_ttl = 307578001;
     * @param int $var
     * @return $this
     */
    public function setMaxTtl($var)
    {
        GPBUtil::checkInt32($var);
        $this->max_ttl = $var;

        return $this;
    }

    /**
     * Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
     *
     * Generated from protobuf field optional bool negative_caching = 336110005;
     * @return bool
     */
    public function getNegativeCaching()
    {
        return isset($this->negative_caching) ? $this->negative_caching : false;
    }

    public function hasNegativeCaching()
    {
        return isset($this->negative_caching);
    }

    public function clearNegativeCaching()
    {
        unset($this->negative_caching);
    }

    /**
     * Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. When the cache mode is set to CACHE_ALL_STATIC or USE_ORIGIN_HEADERS, negative caching applies to responses with the specified response code that lack any Cache-Control, Expires, or Pragma: no-cache directives. When the cache mode is set to FORCE_CACHE_ALL, negative caching applies to all responses with the specified response code, and override any caching headers. By default, Cloud CDN will apply the following default TTLs to these status codes: HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s HTTP 405 (Method Not Found), 421 (Misdirected Request), 501 (Not Implemented): 60s. These defaults can be overridden in negative_caching_policy.
     *
     * Generated from protobuf field optional bool negative_caching = 336110005;
     * @param bool $var
     * @return $this
     */
    public function setNegativeCaching($var)
    {
        GPBUtil::checkBool($var);
        $this->negative_caching = $var;

        return $this;
    }

    /**
     * Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyNegativeCachingPolicy negative_caching_policy = 155359996;
     * @return \Google\Protobuf\Internal\RepeatedField
     */
    public function getNegativeCachingPolicy()
    {
        return $this->negative_caching_policy;
    }

    /**
     * Sets a cache TTL for the specified HTTP status code. negative_caching must be enabled to configure negative_caching_policy. Omitting the policy and leaving negative_caching enabled will use Cloud CDN's default cache TTLs. Note that when specifying an explicit negative_caching_policy, you should take care to specify a cache TTL for all response codes that you wish to cache. Cloud CDN will not apply any default negative caching when a policy exists.
     *
     * Generated from protobuf field repeated .google.cloud.compute.v1.BackendServiceCdnPolicyNegativeCachingPolicy negative_caching_policy = 155359996;
     * @param array<\Google\Cloud\Compute\V1\BackendServiceCdnPolicyNegativeCachingPolicy>|\Google\Protobuf\Internal\RepeatedField $var
     * @return $this
     */
    public function setNegativeCachingPolicy($var)
    {
        $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Cloud\Compute\V1\BackendServiceCdnPolicyNegativeCachingPolicy::class);
        $this->negative_caching_policy = $arr;

        return $this;
    }

    /**
     * If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
     *
     * Generated from protobuf field optional bool request_coalescing = 532808276;
     * @return bool
     */
    public function getRequestCoalescing()
    {
        return isset($this->request_coalescing) ? $this->request_coalescing : false;
    }

    public function hasRequestCoalescing()
    {
        return isset($this->request_coalescing);
    }

    public function clearRequestCoalescing()
    {
        unset($this->request_coalescing);
    }

    /**
     * If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests to the origin.
     *
     * Generated from protobuf field optional bool request_coalescing = 532808276;
     * @param bool $var
     * @return $this
     */
    public function setRequestCoalescing($var)
    {
        GPBUtil::checkBool($var);
        $this->request_coalescing = $var;

        return $this;
    }

    /**
     * Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
     *
     * Generated from protobuf field optional int32 serve_while_stale = 236682203;
     * @return int
     */
    public function getServeWhileStale()
    {
        return isset($this->serve_while_stale) ? $this->serve_while_stale : 0;
    }

    public function hasServeWhileStale()
    {
        return isset($this->serve_while_stale);
    }

    public function clearServeWhileStale()
    {
        unset($this->serve_while_stale);
    }

    /**
     * Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache. This setting defines the default "max-stale" duration for any cached responses that do not specify a max-stale directive. Stale responses that exceed the TTL configured here will not be served. The default limit (max-stale) is 86400s (1 day), which will allow stale content to be served up to this limit beyond the max-age (or s-max-age) of a cached response. The maximum allowed value is 604800 (1 week). Set this to zero (0) to disable serve-while-stale.
     *
     * Generated from protobuf field optional int32 serve_while_stale = 236682203;
     * @param int $var
     * @return $this
     */
    public function setServeWhileStale($var)
    {
        GPBUtil::checkInt32($var);
        $this->serve_while_stale = $var;

        return $this;
    }

    /**
     * Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
     *
     * Generated from protobuf field optional int64 signed_url_cache_max_age_sec = 269374534;
     * @return int|string
     */
    public function getSignedUrlCacheMaxAgeSec()
    {
        return isset($this->signed_url_cache_max_age_sec) ? $this->signed_url_cache_max_age_sec : 0;
    }

    public function hasSignedUrlCacheMaxAgeSec()
    {
        return isset($this->signed_url_cache_max_age_sec);
    }

    public function clearSignedUrlCacheMaxAgeSec()
    {
        unset($this->signed_url_cache_max_age_sec);
    }

    /**
     * Maximum number of seconds the response to a signed URL request will be considered fresh. After this time period, the response will be revalidated before being served. Defaults to 1hr (3600s). When serving responses to signed URL requests, Cloud CDN will internally behave as though all responses from this backend had a "Cache-Control: public, max-age=[TTL]" header, regardless of any existing Cache-Control header. The actual headers served in responses will not be altered.
     *
     * Generated from protobuf field optional int64 signed_url_cache_max_age_sec = 269374534;
     * @param int|string $var
     * @return $this
     */
    public function setSignedUrlCacheMaxAgeSec($var)
    {
        GPBUtil::checkInt64($var);
        $this->signed_url_cache_max_age_sec = $var;

        return $this;
    }

    /**
     * [Output Only] Names of the keys for signing request URLs.
     *
     * Generated from protobuf field repeated string signed_url_key_names = 371848885;
     * @return \Google\Protobuf\Internal\RepeatedField
     */
    public function getSignedUrlKeyNames()
    {
        return $this->signed_url_key_names;
    }

    /**
     * [Output Only] Names of the keys for signing request URLs.
     *
     * Generated from protobuf field repeated string signed_url_key_names = 371848885;
     * @param array<string>|\Google\Protobuf\Internal\RepeatedField $var
     * @return $this
     */
    public function setSignedUrlKeyNames($var)
    {
        $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::STRING);
        $this->signed_url_key_names = $arr;

        return $this;
    }

}