text:
module Azure::HybridCompute::Mgmt::V2019_12_12
  module Models
    #
    # Describes the Machine Extensions List Result.
    #
    class MachineExtensionsListResult

      include MsRestAzure

      include MsRest::JSONable
      # @return [Array<MachineExtension>] The list of extensions
      attr_accessor :value

      # @return [String] The uri to fetch the next page of machine extensions.
      # Call ListNext() with this to fetch the next page of extensions.
      attr_accessor :next_link

      # return [Proc] with next page method call.
      attr_accessor :next_method

      #
      # Gets the rest of the items for the request, enabling auto-pagination.
      #
      # @return [Array<MachineExtension>] operation results.
      #
      def get_all_items
        items = @value
        page = self
        while page.next_link != nil && !page.next_link.strip.empty? do
          page = page.get_next_page
          items.concat(page.value)
        end
        items
      end

      #
      # Gets the next page of results.
      #
      # @return [MachineExtensionsListResult] with next page content.
      #
      def get_next_page
        response = @next_method.call(@next_link).value! unless @next_method.nil?
        unless response.nil?
          @next_link = response.body.next_link
          @value = response.body.value
          self
        end
      end

      #
      # Mapper for MachineExtensionsListResult class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'MachineExtensionsListResult',
          type: {
            name: 'Composite',
            class_name: 'MachineExtensionsListResult',
            model_properties: {
              value: {
                client_side_validation: true,
                required: false,
                serialized_name: 'value',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'MachineExtensionElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'MachineExtension'
                      }
                  }
                }
              },
              next_link: {
                client_side_validation: true,
                required: false,
                serialized_name: 'nextLink',
                type: {
                  name: 'String'
                }
              }
            }
          }
        }
      end
    end
  end
end


text:
package im.actor.model.droidkit.bser;

public interface BserCreator<T> {
    T createInstance();
}

redpajama_set_name: RedPajamaGithub


text:
#ifndef _SYSC_RESOURCE_ACCESS_IF_H_
#define _SYSC_RESOURCE_ACCESS_IF_H_

#include <cstddef>
#include <cstdint>
#include <sysc/kernel/sc_time.h>

namespace scc {
/**
 * @class resource_access_if
 * @brief interface defining access to a resource e.g. a register
 *
 */
class resource_access_if {
public:
    virtual ~resource_access_if() = default;
    /**
     * @fn std::size_t size()const =0
     * @brief return the size of the resource
     *
     * @return the size
     */
    virtual std::size_t size() const = 0;
    /**
     * @fn void reset()=0
     * @brief reset the resource
     *
     */
    virtual void reset() = 0;
    /**
     * @fn bool write(const uint8_t*, std::size_t, uint64_t=0, sc_core::sc_time=sc_core::SC_ZERO_TIME)=0
     * @brief write to the resource
     *
     * @param data  to write
     * @param length  of data to write
     * @param offset  of the data to write
     * @param d the annotated delay
     * @return true it the access is successful
     */
    virtual bool write(const uint8_t* data, std::size_t length, uint64_t offset = 0,
                       sc_core::sc_time d = sc_core::SC_ZERO_TIME) = 0;
    /**
     * @fn bool read(uint8_t*, std::size_t, uint64_t=0, sc_core::sc_time=sc_core::SC_ZERO_TIME)const =0
     * @brief read the data from the resource
     *
     * @param data buffer to read the data into
     * @param length  of data to read
     * @param offset  of the data to read
     * @param d the annotated delay
     * @return true it the access is successful
     */
    virtual bool read(uint8_t* data, std::size_t length, uint64_t offset = 0,
                      sc_core::sc_time d = sc_core::SC_ZERO_TIME) const = 0;
    /**
     * @fn bool write_dbg(const uint8_t*, std::size_t, uint64_t=0)=0
     * @brief debug write to the resource
     *
     * @param data to write
     * @param length of data to write
     * @param offset of the data to write
     * @return true it the access is successful
     */
    virtual bool write_dbg(const uint8_t* data, std::size_t length, uint64_t offset = 0) = 0;
    /**
     * @fn bool read_dbg(uint8_t*, std::size_t, uint64_t=0)const =0
     * @brief debug read the data from the resource
     *
     * @param data buffer to read the data into
     * @param length length of data to read
     * @param offset offset of the data to read
     * @return true it the access is successful
     */
    virtual bool read_dbg(uint8_t* data, std::size_t length, uint64_t offset = 0) const = 0;
};
/**
 * @class indexed_resource_access_if
 * @brief interface defining access to an indexed resource e.g. register file
 *
 */
class indexed_resource_access_if {
public:
    using value_type = resource_access_if;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using reference = value_type&;
    using const_reference = const value_type&;
    using iterator = resource_access_if*;
    using const_iterator = const resource_access_if*;

    virtual ~indexed_resource_access_if() = default;
    /**
     * @fn std::size_t size()=0
     * @brief get the size of the resource
     *
     * @return size of the resource in bytes
     */
    virtual std::size_t size() = 0;
    /**
     * @fn reference operator [](std::size_t)=0
     * @brief get value at index
     *
     * @param idx the index
     * @return the value
     */
    virtual reference operator[](std::size_t idx) noexcept = 0;
    /**
     * @fn const_reference operator [](std::size_t)const =0
     * @brief get value at index
     *
     * @param idx the index
     * @return the value
     */
    virtual const_reference operator[](std::size_t idx) const noexcept = 0;
    /**
     * @fn reference operator [](std::size_t)=0
     * @brief get value at index with range checking
     *
     * @param idx the index
     * @return the value
     */
    virtual reference at(std::size_t idx) = 0;
    /**
     * @fn const_reference operator [](std::size_t)const =0
     * @brief get value at index with range checking
     *
     * @param idx the index
     * @return the value
     */
    virtual const_reference at(std::size_t idx) const = 0;
};
} // namespace scc
#endif /* _SYSC_RESOURCE_ACCESS_IF_H_ */


text:
  Labosse est
       un village
       situé dans le département de l'Oise en Picardie. On dénombrait 438 habitants en 2008.

Le parc d'habitations, à Labosse, se décomposait en 2011 en un appartements et 229 maisons soit
 un marché plutôt équilibré.

Si vous pensez emmenager à Labosse, vous pourrez facilement trouver une maison à acheter.

À coté de Labosse sont positionnées géographiquement les communes de
Lalandelle située à 6 km, 461 habitants,
Boutencourt localisée à 4 km, 246 habitants,
Énencourt-Léage située à 6 km, 115 habitants,
Jaméricourt localisée à 5 km, 240 habitants,
Villers-Saint-Barthélemy localisée à 6 km, 467 habitants,
Énencourt-le-Sec située à 5 km, 200 habitants,
 entre autres. De plus, Labosse est située à seulement 15 km de Beauvais.


text:
#include <stdint.h>
#include <set>
#include <string>

#include "mobile/change_registration_request.h"

#include "application_manager/commands/command_request_test.h"
#include "application_manager/event_engine/event.h"
#include "application_manager/mock_application.h"
#include "application_manager/mock_application_manager.h"
#include "application_manager/mock_hmi_capabilities.h"
#include "application_manager/mock_hmi_interface.h"
#include "application_manager/mock_message_helper.h"
#include "application_manager/policies/mock_policy_handler_interface.h"
#include "application_manager/smart_object_keys.h"
#include "gtest/gtest.h"
#include "policy/policy_regular/policy/usage_statistics/mock_statistics_manager.h"
#include "smart_objects/smart_object.h"
#include "utils/custom_string.h"
#include "utils/helpers.h"

namespace test {
namespace components {
namespace commands_test {
namespace mobile_commands_test {
namespace change_registration_request {

namespace am = application_manager;
using am::ApplicationManager;
using am::ApplicationSharedPtr;
using am::MockMessageHelper;
using am::commands::CommandImpl;
using am::commands::MessageSharedPtr;
using policy_test::MockPolicyHandlerInterface;
using sdl_rpc_plugin::commands::ChangeRegistrationRequest;
using ::test::components::application_manager_test::MockApplication;
using ::testing::_;
using ::testing::Return;
using ::testing::ReturnRef;
using ::testing::SetArgPointee;

namespace custom_str = utils::custom_string;
namespace strings = ::application_manager::strings;
namespace hmi_response = ::application_manager::hmi_response;

namespace {
const uint32_t kAppId = 1u;
const uint32_t kCmdId = 1u;
const uint32_t kConnectionKey = 2u;
}  // namespace

class ChangeRegistrationRequestTest
    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
 public:
  ChangeRegistrationRequestTest()
      : app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>())
      , mock_app_(CreateMockApp())
      , supported_languages_(CreateMessage(smart_objects::SmartType_Array)) {}

  MessageSharedPtr CreateMsgFromMobile() {
    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
    (*msg)[strings::params][strings::connection_key] = kConnectionKey;
    smart_objects::SmartObject msg_params =
        smart_objects::SmartObject(smart_objects::SmartType_Map);
    msg_params[strings::hmi_display_language] = mobile_apis::Language::EN_US;
    msg_params[strings::language] = mobile_apis::Language::EN_US;
    (*msg)[strings::msg_params] = msg_params;
    return msg;
  }
  void PrepareExpectationBeforeRun() {
    (*supported_languages_)[0] =
        static_cast<int32_t>(mobile_apis::Language::EN_US);
    EXPECT_CALL(mock_hmi_capabilities_, ui_supported_languages())
        .WillOnce(Return(supported_languages_));
    EXPECT_CALL(mock_hmi_capabilities_, vr_supported_languages())
        .WillOnce(Return(supported_languages_));
    EXPECT_CALL(mock_hmi_capabilities_, tts_supported_languages())
        .WillOnce(Return(supported_languages_));

    EXPECT_CALL(app_mngr_, hmi_interfaces())
        .WillRepeatedly(ReturnRef(mock_hmi_interfaces_));
    EXPECT_CALL(
        mock_hmi_interfaces_,
        GetInterfaceFromFunction(hmi_apis::FunctionID::UI_ChangeRegistration))
        .WillRepeatedly(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
    EXPECT_CALL(mock_hmi_interfaces_,
                GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
        .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));

    EXPECT_CALL(
        mock_hmi_interfaces_,
        GetInterfaceFromFunction(hmi_apis::FunctionID::VR_ChangeRegistration))
        .WillRepeatedly(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
    EXPECT_CALL(mock_hmi_interfaces_,
                GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
        .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));

    EXPECT_CALL(
        mock_hmi_interfaces_,
        GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_ChangeRegistration))
        .WillRepeatedly(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
    EXPECT_CALL(mock_hmi_interfaces_,
                GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
        .WillRepeatedly(Return(am::HmiInterfaces::STATE_AVAILABLE));
  }

  void CheckExpectations(const hmi_apis::Common_Result::eType hmi_response,
                         const mobile_apis::Result::eType mobile_response,
                         const am::HmiInterfaces::InterfaceState state,
                         const bool success,
                         const hmi_apis::Common_Result::eType ui_hmi_response =
                             hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                         const hmi_apis::Common_Result::eType vr_hmi_response =
                             hmi_apis::Common_Result::UNSUPPORTED_RESOURCE) {
    MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();

    std::shared_ptr<ChangeRegistrationRequest> command =
        CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);
    MockAppPtr mock_app = CreateMockApp();
    ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
    ON_CALL(*mock_app, app_id()).WillByDefault(Return(1));
    am::ApplicationSet application_set;
    const utils::custom_string::CustomString name("name");
    MockAppPtr app = CreateMockApp();
    app->set_name(name);

    DataAccessor<am::ApplicationSet> accessor(application_set,
                                              app_set_lock_ptr_);

    application_set.insert(app);

    EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
    EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));
    PrepareExpectationBeforeRun();
    EXPECT_CALL(mock_hmi_interfaces_, GetInterfaceState(_))
        .WillRepeatedly(Return(state));
    command->Run();

    MessageSharedPtr ui_response = CreateMessage(smart_objects::SmartType_Map);
    MessageSharedPtr vr_response = CreateMessage(smart_objects::SmartType_Map);
    MessageSharedPtr tts_response = CreateMessage(smart_objects::SmartType_Map);
    CreateResponseFromHMI(ui_response, ui_hmi_response, "ui_info");
    CreateResponseFromHMI(vr_response, vr_hmi_response, "unsupported_resource");

    (*tts_response)[strings::params][hmi_response::code] = hmi_response;
    (*tts_response)[strings::msg_params] = 0;

    am::event_engine::Event event_ui(
        hmi_apis::FunctionID::UI_ChangeRegistration);
    event_ui.set_smart_object(*ui_response);
    am::event_engine::Event event_vr(
        hmi_apis::FunctionID::VR_ChangeRegistration);
    event_vr.set_smart_object(*vr_response);
    am::event_engine::Event event_tts(
        hmi_apis::FunctionID::TTS_ChangeRegistration);
    event_tts.set_smart_object(*tts_response);

    MessageSharedPtr response_to_mobile;

    EXPECT_CALL(mock_rpc_service_,
                ManageMobileCommand(
                    _, am::commands::Command::CommandSource::SOURCE_SDL))
        .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));

    command->on_event(event_ui);
    command->on_event(event_vr);
    command->on_event(event_tts);

    EXPECT_EQ(
        (*response_to_mobile)[strings::msg_params][strings::success].asBool(),
        success);
    EXPECT_EQ((*response_to_mobile)[strings::msg_params][strings::result_code]
                  .asInt(),
              static_cast<int32_t>(mobile_response));
  }

  void CreateResponseFromHMI(MessageSharedPtr msg,
                             hmi_apis::Common_Result::eType result,
                             const std::string& info) {
    (*msg)[strings::params][hmi_response::code] = static_cast<int32_t>(result);
    (*msg)[strings::msg_params][strings::info] = info;
  }

  MessageSharedPtr CreateFullParamsUISO() {
    MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
    (*msg)[am::strings::params][am::strings::connection_key] = kConnectionKey;
    smart_objects::SmartObject menu_params =
        smart_objects::SmartObject(smart_objects::SmartType_Map);
    menu_params[am::strings::position] = 10;
    menu_params[am::strings::menu_name] = "LG";

    smart_objects::SmartObject msg_params =
        smart_objects::SmartObject(smart_objects::SmartType_Map);
    msg_params[am::strings::cmd_id] = kCmdId;
    msg_params[am::strings::menu_params] = menu_params;
    msg_params[am::strings::app_id] = kAppId;
    msg_params[am::strings::cmd_icon] = 1;
    msg_params[am::strings::cmd_icon][am::strings::value] = "10";
    (*msg)[am::strings::msg_params] = msg_params;

    return msg;
  }

  void SetUp() OVERRIDE {
    ON_CALL(app_mngr_, application(kConnectionKey))
        .WillByDefault(Return(mock_app_));
    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kConnectionKey));
  }

  void ExpectationsHmiCapabilities(
      smart_objects::SmartObjectSPtr supported_languages) {
    EXPECT_CALL(mock_hmi_capabilities_, ui_supported_languages())
        .WillOnce(Return(supported_languages));
    EXPECT_CALL(mock_hmi_capabilities_, vr_supported_languages())
        .WillOnce(Return(supported_languages));
    EXPECT_CALL(mock_hmi_capabilities_, tts_supported_languages())
        .WillOnce(Return(supported_languages));
  }

  void ResultCommandExpectations(MessageSharedPtr msg,
                                 const std::string& info) {
    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::success].asBool(),
              true);
    EXPECT_EQ(
        (*msg)[am::strings::msg_params][am::strings::result_code].asInt(),
        static_cast<int32_t>(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE));
    EXPECT_EQ((*msg)[am::strings::msg_params][am::strings::info].asString(),
              info);
  }

  typedef TypeIf<kMocksAreNice,
                 NiceMock<application_manager_test::MockHMICapabilities>,
                 application_manager_test::MockHMICapabilities>::Result
      MockHMICapabilities;
  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
  MockHMICapabilities hmi_capabilities_;
  MockAppPtr mock_app_;
  MessageSharedPtr supported_languages_;
  MockPolicyHandlerInterface mock_policy_handler_;
};

typedef ChangeRegistrationRequestTest::MockHMICapabilities MockHMICapabilities;

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_VRHmiSendSuccess_UNSUPPORTED_RESOURCE) {
  MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();
  std::shared_ptr<ChangeRegistrationRequest> command =
      CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);

  am::ApplicationSet application_set;
  const utils::custom_string::CustomString name("name");
  MockAppPtr app = CreateMockApp();
  app->set_name(name);

  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);

  application_set.insert(app);

  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
  EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));

  smart_objects::SmartObjectSPtr supported_languages(
      CreateMessage(smart_objects::SmartType_Array));
  (*supported_languages)[0] =
      static_cast<int32_t>(mobile_apis::Language::EN_US);

  ExpectationsHmiCapabilities(supported_languages);

  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceFromFunction(hmi_apis::FunctionID::UI_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));

  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceFromFunction(hmi_apis::FunctionID::VR_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
      .WillByDefault(Return(am::HmiInterfaces::STATE_NOT_RESPONSE));

  ON_CALL(
      mock_hmi_interfaces_,
      GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
  command->Run();

  MessageSharedPtr ui_response = CreateMessage(smart_objects::SmartType_Map);
  MessageSharedPtr vr_response = CreateMessage(smart_objects::SmartType_Map);
  MessageSharedPtr tts_response = CreateMessage(smart_objects::SmartType_Map);
  CreateResponseFromHMI(
      ui_response, hmi_apis::Common_Result::WARNINGS, "ui_info");
  CreateResponseFromHMI(vr_response,
                        hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                        "VR is not supported by system");
  CreateResponseFromHMI(
      tts_response, hmi_apis::Common_Result::SUCCESS, "tts_info");
  (*ui_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
  (*vr_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
  (*tts_response)[am::strings::msg_params][am::strings::app_id] =
      kConnectionKey;
  am::event_engine::Event event_ui(hmi_apis::FunctionID::UI_ChangeRegistration);
  event_ui.set_smart_object(*ui_response);
  am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_ChangeRegistration);
  event_vr.set_smart_object(*vr_response);
  am::event_engine::Event event_tts(
      hmi_apis::FunctionID::TTS_ChangeRegistration);
  event_tts.set_smart_object(*tts_response);

  EXPECT_CALL(mock_hmi_interfaces_, GetInterfaceState(_))
      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));

  MessageSharedPtr response_to_mobile;

  EXPECT_CALL(
      mock_rpc_service_,
      ManageMobileCommand(_, am::commands::Command::CommandSource::SOURCE_SDL))
      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));

  command->on_event(event_ui);
  command->on_event(event_tts);
  command->on_event(event_vr);

  ResultCommandExpectations(response_to_mobile,
                            "ui_info, VR is not supported by system, tts_info");
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_UNSUPPORTED_RESOURCE_STATE_NOT_AVAILABLE_Expect_false) {
  MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();
  std::shared_ptr<ChangeRegistrationRequest> command =
      CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);
  MockAppPtr mock_app = CreateMockApp();
  ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app));
  ON_CALL(*mock_app, app_id()).WillByDefault(Return(1));
  am::ApplicationSet application_set;
  const utils::custom_string::CustomString name("name");
  MockAppPtr app = CreateMockApp();
  app->set_name(name);
  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);
  application_set.insert(app);
  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
  EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));

  (*supported_languages_)[0] =
      static_cast<int32_t>(mobile_apis::Language::EN_US);
  EXPECT_CALL(mock_hmi_capabilities_, ui_supported_languages())
      .WillOnce(Return(supported_languages_));
  EXPECT_CALL(mock_hmi_capabilities_, vr_supported_languages())
      .WillOnce(Return(supported_languages_));
  EXPECT_CALL(mock_hmi_capabilities_, tts_supported_languages())
      .WillOnce(Return(supported_languages_));

  EXPECT_CALL(app_mngr_, hmi_interfaces())
      .WillRepeatedly(ReturnRef(mock_hmi_interfaces_));

  EXPECT_CALL(mock_hmi_interfaces_, GetInterfaceState(_))
      .WillRepeatedly(Return(am::HmiInterfaces::STATE_NOT_AVAILABLE));

  MessageSharedPtr response_to_mobile;

  EXPECT_CALL(
      mock_rpc_service_,
      ManageMobileCommand(_, am::commands::Command::CommandSource::SOURCE_SDL))
      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));
  command->Run();

  EXPECT_EQ(
      (*response_to_mobile)[strings::msg_params][strings::success].asBool(),
      false);
  EXPECT_EQ(
      (*response_to_mobile)[strings::msg_params][strings::result_code].asInt(),
      static_cast<int32_t>(mobile_apis::Result::UNSUPPORTED_RESOURCE));
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_UNSUPPORTED_RESOURCE_STATE_NOT_RESPONSE_Expect_false) {
  CheckExpectations(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                    mobile_apis::Result::UNSUPPORTED_RESOURCE,
                    am::HmiInterfaces::STATE_NOT_RESPONSE,
                    false);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_UNSUPPORTED_RESOURCE_STATE_AVAILABLE_Expect_false) {
  CheckExpectations(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                    mobile_apis::Result::UNSUPPORTED_RESOURCE,
                    am::HmiInterfaces::STATE_AVAILABLE,
                    false);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_UNSUPPORTED_RESOURCE_SUCCESS_STATE_AVAILABLE_Expect_true) {
  CheckExpectations(hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                    mobile_apis::Result::UNSUPPORTED_RESOURCE,
                    am::HmiInterfaces::STATE_AVAILABLE,
                    true,
                    hmi_apis::Common_Result::SUCCESS,
                    hmi_apis::Common_Result::SUCCESS);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_SUCCESS_STATE_AVAILABLE_Expect_true) {
  CheckExpectations(hmi_apis::Common_Result::SUCCESS,
                    mobile_apis::Result::SUCCESS,
                    am::HmiInterfaces::STATE_AVAILABLE,
                    true,
                    hmi_apis::Common_Result::SUCCESS,
                    hmi_apis::Common_Result::SUCCESS);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_WRONG_LANGUAGE_STATE_AVAILABLE_Expect_true) {
  CheckExpectations(hmi_apis::Common_Result::WRONG_LANGUAGE,
                    mobile_apis::Result::WRONG_LANGUAGE,
                    am::HmiInterfaces::STATE_AVAILABLE,
                    true,
                    hmi_apis::Common_Result::SUCCESS,
                    hmi_apis::Common_Result::SUCCESS);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_TTS_INVALID_DATA_STATE_AVAILABLE_Expect_false) {
  CheckExpectations(hmi_apis::Common_Result::INVALID_DATA,
                    mobile_apis::Result::INVALID_DATA,
                    am::HmiInterfaces::STATE_AVAILABLE,
                    false,
                    hmi_apis::Common_Result::SUCCESS,
                    hmi_apis::Common_Result::SUCCESS);
}

TEST_F(ChangeRegistrationRequestTest,
       OnEvent_UIHmiSendSuccess_UNSUPPORTED_RESOURCE) {
  MessageSharedPtr msg_from_mobile = CreateMsgFromMobile();

  std::shared_ptr<ChangeRegistrationRequest> command =
      CreateCommand<ChangeRegistrationRequest>(msg_from_mobile);

  am::ApplicationSet application_set;
  const utils::custom_string::CustomString name("name");
  MockAppPtr app = CreateMockApp();
  app->set_name(name);

  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);

  application_set.insert(app);

  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
  EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));

  smart_objects::SmartObjectSPtr supported_languages(
      CreateMessage(smart_objects::SmartType_Array));
  (*supported_languages)[0] =
      static_cast<int32_t>(mobile_apis::Language::EN_US);

  ExpectationsHmiCapabilities(supported_languages);

  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceFromFunction(hmi_apis::FunctionID::UI_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));

  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceFromFunction(hmi_apis::FunctionID::VR_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_VR));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_VR))
      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));

  ON_CALL(
      mock_hmi_interfaces_,
      GetInterfaceFromFunction(hmi_apis::FunctionID::TTS_ChangeRegistration))
      .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_TTS));
  ON_CALL(mock_hmi_interfaces_,
          GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
      .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));

  command->Run();

  MessageSharedPtr ui_response = CreateMessage(smart_objects::SmartType_Map);
  MessageSharedPtr vr_response = CreateMessage(smart_objects::SmartType_Map);
  MessageSharedPtr tts_response = CreateMessage(smart_objects::SmartType_Map);
  CreateResponseFromHMI(ui_response,
                        hmi_apis::Common_Result::UNSUPPORTED_RESOURCE,
                        "unsupported_resource");
  CreateResponseFromHMI(
      vr_response, hmi_apis::Common_Result::WARNINGS, "vr_info");
  CreateResponseFromHMI(
      tts_response, hmi_apis::Common_Result::SUCCESS, "tts_info");
  (*ui_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
  (*vr_response)[am::strings::msg_params][am::strings::app_id] = kConnectionKey;
  (*tts_response)[am::strings::msg_params][am::strings::app_id] =
      kConnectionKey;
  am::event_engine::Event event_ui(hmi_apis::FunctionID::UI_ChangeRegistration);
  event_ui.set_smart_object(*ui_response);
  am::event_engine::Event event_vr(hmi_apis::FunctionID::VR_ChangeRegistration);
  event_vr.set_smart_object(*vr_response);
  am::event_engine::Event event_tts(
      hmi_apis::FunctionID::TTS_ChangeRegistration);
  event_tts.set_smart_object(*tts_response);

  MessageSharedPtr response_to_mobile;

  EXPECT_CALL(
      mock_rpc_service_,
      ManageMobileCommand(_, am::commands::Command::CommandSource::SOURCE_SDL))
      .WillOnce(DoAll(SaveArg<0>(&response_to_mobile), Return(true)));

  command->on_event(event_vr);
  command->on_event(event_tts);
  command->on_event(event_ui);

  ResultCommandExpectations(response_to_mobile,
                            "unsupported_resource, vr_info, tts_info");
}

}  // namespace change_registration_request
}  // namespace mobile_commands_test
}  // namespace commands_test
}  // namespace components
}  // namespace test


text:
<?php

namespace CawaKharkov\LaravelBalance\Providers;

use  \Illuminate\Support\ServiceProvider;

class TransactionsProvider  extends ServiceProvider
{
    /**
     * Register bindings in the container.
     *
     * @return void
     */
    public function boot()
    {

        view()->composer(
            config('laravel_balance.compose'),\CawaKharkov\LaravelBalance\ViewComposers\TransactionViewComposer::class
        );

    }

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}


text:
<?php

/* @Framework/Form/button_widget.html.php */
class __TwigTemplate_151db908f5a55f62d162330b2506cccb73917370035ce77dc636f59f0f0ba7b4 extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = false;

        $this->blocks = array(
        );
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        // line 1
        echo "<?php if (!\$label) { \$label = isset(\$label_format)
    ? strtr(\$label_format, array('%name%' => \$name, '%id%' => \$id))
    : \$view['form']->humanize(\$name); } ?>
<button type=\"<?php echo isset(\$type) ? \$view->escape(\$type) : 'button' ?>\" <?php echo \$view['form']->block(\$form, 'button_attributes') ?>><?php echo \$view->escape(false !== \$translation_domain ? \$view['translator']->trans(\$label, array(), \$translation_domain) : \$label) ?></button>
";
    }

    public function getTemplateName()
    {
        return "@Framework/Form/button_widget.html.php";
    }

    public function getDebugInfo()
    {
        return array (  19 => 1,);
    }

    /** @deprecated since 1.27 (to be removed in 2.0). Use getSourceContext() instead */
    public function getSource()
    {
        @trigger_error('The '.__METHOD__.' method is deprecated since version 1.27 and will be removed in 2.0. Use getSourceContext() instead.', E_USER_DEPRECATED);

        return $this->getSourceContext()->getCode();
    }

    public function getSourceContext()
    {
        return new Twig_Source("", "@Framework/Form/button_widget.html.php", "C:\\College\\College\\Third year\\Second Semester\\WFDassignment\\NURLmanager\\vendor\\symfony\\symfony\\src\\Symfony\\Bundle\\FrameworkBundle\\Resources\\views\\Form\\button_widget.html.php");
    }
}


text:
#ifndef _BOSS_1_CENTRAL_SCRIPT__
#define _BOSS_1_CENTRAL_SCRIPT__

#include "Engine/GameObject.hpp"
#include "Engine/SceneManager.hpp"
#include "Engine/CameraSystem.hpp"
#include "Engine/InputSystem.hpp"

#include "Components/Script.hpp"
#include "Components/Animator.hpp"
#include "Math/Vector.hpp"

#include <string>

class FirstBossCentralEffectScript : public Script {
public:
    FirstBossCentralEffectScript(GameObject *owner);

    // Get the component name and replace it by returning its string name.
    std::string GetComponentName() override {
        return "FirstBossCentralEffectScript";
    };
    void FixedComponentUpdate() override;
    void Start() override;

private:
    void CreateAnimations();

    // Pointer to game controls
    InputSystem *m_input = nullptr;

    // Pointer to animator game.
    Animator *m_animator = nullptr;

    // Poiter to position of gamer.
    Vector *m_position = nullptr;

    // Poiter to object boss.
    GameObject *m_boss = nullptr;

protected:
    void ComponentUpdate() override;

};
#endif


text:
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.Azure.WebJobs.Script.Description;

namespace Microsoft.Azure.WebJobs.Script.Binding
{
    public class BindingContext
    {
        /// <summary>
        /// Gets or sets the collection of Attributes to bind.
        /// </summary>
        public Attribute[] Attributes { get; set; }

        /// <summary>
        /// Gets or sets the binder to use to perform the bind.
        /// </summary>
        public Binder Binder { get; set; }

        /// <summary>
        /// Gets or sets the trigger value that caused the current invocation.
        /// </summary>
        public object TriggerValue { get; set; }

        /// <summary>
        /// Gets or sets the data type hint for the binding.
        /// </summary>
        public DataType DataType { get; set; }

        /// <summary>
        /// Gets or sets the cardinality hint for the binding.
        /// </summary>
        public Cardinality Cardinality { get; set; }

        /// <summary>
        /// Gets or sets the target value the binding is binding to.
        /// </summary>
        public object Value { get; set; }

        /// <summary>
        /// Gets or sets the collection of binding data for this invocation.
        /// </summary>
        public IReadOnlyDictionary<string, object> BindingData { get; set; }
    }
}


text:
<?php

namespace Symfony\Component\Validator\Tests\Constraints;

use Symfony\Component\Validator\Constraints\DateTime;
use Symfony\Component\Validator\Constraints\DateTimeValidator;

class DateTimeValidatorTest extends AbstractConstraintValidatorTest
{
    protected function createValidator()
    {
        return new DateTimeValidator();
    }

    public function testNullIsValid()
    {
        $this->validator->validate(null, new DateTime());

        $this->assertNoViolation();
    }

    public function testEmptyStringIsValid()
    {
        $this->validator->validate('', new DateTime());

        $this->assertNoViolation();
    }

    public function testDateTimeClassIsValid()
    {
        $this->validator->validate(new \DateTime(), new DateTime());

        $this->assertNoViolation();
    }

    /**
     * @expectedException \Symfony\Component\Validator\Exception\UnexpectedTypeException
     */
    public function testExpectsStringCompatibleType()
    {
        $this->validator->validate(new \stdClass(), new DateTime());
    }

    public function testDateTimeWithDefaultFormat()
    {
        $this->validator->validate('1995-05-10 19:33:00', new DateTime());

        $this->assertNoViolation();

        $this->validator->validate('1995-03-24', new DateTime());

        $this->buildViolation('This value is not a valid datetime.')
            ->setParameter('{{ value }}', '"1995-03-24"')
            ->setCode(DateTime::INVALID_FORMAT_ERROR)
            ->assertRaised();
    }

    /**
     * @dataProvider getValidDateTimes
     */
    public function testValidDateTimes($format, $dateTime)
    {
        $constraint = new DateTime(array(
            'format' => $format,
        ));

        $this->validator->validate($dateTime, $constraint);

        $this->assertNoViolation();
    }

    public function getValidDateTimes()
    {
        return array(
            array('Y-m-d H:i:s e', '1995-03-24 00:00:00 UTC'),
            array('Y-m-d H:i:s', '2010-01-01 01:02:03'),
            array('Y/m/d H:i', '2010/01/01 01:02'),
            array('F d, Y', 'December 31, 1999'),
            array('d-m-Y', '10-05-1995'),
        );
    }

    /**
     * @dataProvider getInvalidDateTimes
     */
    public function testInvalidDateTimes($format, $dateTime, $code)
    {
        $constraint = new DateTime(array(
            'message' => 'myMessage',
            'format' => $format,
        ));

        $this->validator->validate($dateTime, $constraint);

        $this->buildViolation('myMessage')
            ->setParameter('{{ value }}', '"'.$dateTime.'"')
            ->setCode($code)
            ->assertRaised();
    }

    public function getInvalidDateTimes()
    {
        return array(
            array('Y-m-d', 'foobar', DateTime::INVALID_FORMAT_ERROR),
            array('H:i', '00:00:00', DateTime::INVALID_FORMAT_ERROR),
            array('Y-m-d', '2010-01-01 00:00', DateTime::INVALID_FORMAT_ERROR),
            array('Y-m-d e', '2010-01-01 TCU', DateTime::INVALID_FORMAT_ERROR),
            array('Y-m-d H:i:s', '2010-13-01 00:00:00', DateTime::INVALID_DATE_ERROR),
            array('Y-m-d H:i:s', '2010-04-32 00:00:00', DateTime::INVALID_DATE_ERROR),
            array('Y-m-d H:i:s', '2010-02-29 00:00:00', DateTime::INVALID_DATE_ERROR),
            array('Y-m-d H:i:s', '2010-01-01 24:00:00', DateTime::INVALID_TIME_ERROR),
            array('Y-m-d H:i:s', '2010-01-01 00:60:00', DateTime::INVALID_TIME_ERROR),
            array('Y-m-d H:i:s', '2010-01-01 00:00:60', DateTime::INVALID_TIME_ERROR),
        );
    }
}


text:
package api

import (
	"github.com/castaneai/kirara/resource"
	"github.com/labstack/echo"
	"net/http"
)

func GetPosts(c echo.Context) error {
	keyword := c.Param("keyword")
	res := resource.Tiqav{} // TODO: other resources
	posts, err := res.SearchByKeyword(keyword, 1)
	if err != nil {
		return echo.NewHTTPError(http.StatusInternalServerError)
	}
	return c.JSON(http.StatusOK, posts)
}


text:
require 'traffic_source_parser/channels/types/base_type'

module TrafficSourceParser
  module Channels
    module Types
      module OtherAdvertising
        extend self

          OTHER_ADVERTISING_REGEX = /^(cpv|cpa|cpp|content-text)$/

          def channel_name
            'Other Advertising'
          end

          # Sessions that are tagged with a medium of "cpc", "ppc", "cpm", "cpv", "cpa", "cpp", "content-text", "affiliate" (excluding Paid Search).
          def match_source?(traffic_source)
            traffic_source[:medium] =~ OTHER_ADVERTISING_REGEX
          end

      end
    end
  end
end


text:
// Copyright (c) 2018 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package krico

import (
	"github.com/intelsdi-x/snap/scheduler/wmap"
	"github.com/intelsdi-x/swan/pkg/conf"
	"github.com/intelsdi-x/swan/pkg/executor"
	"github.com/intelsdi-x/swan/pkg/snap"
	"github.com/intelsdi-x/swan/pkg/snap/publishers"
	"time"
)

// DefaultConfig returns default configuration for KRICO session.
func DefaultConfig(cgroup string, domain string) snap.SessionConfig {

	pub := publishers.Publisher{
		PluginName: snap.CassandraPublisher,
		Publisher:  wmap.NewPublishNode("cassandra", snap.PluginAnyVersion),
	}
	pub.Publisher.AddConfigItem("server", conf.CassandraAddress.Value())
	pub.Publisher.AddConfigItem("keyspaceName", conf.CassandraKeyspaceName.Value())

	return snap.SessionConfig{
		SnapteldAddress: snap.SnapteldAddress.Value(),
		Interval:        1 * time.Second,
		Publisher:       pub.Publisher,
		Plugins: []string{
			pub.PluginName,
			"snap-plugin-collector-perfevents",
			"snap-plugin-collector-libvirt",
		},
		TaskName: "swan-krico-session",
		Metrics: []string{
			"/intel/libvirt/" + domain + "/cpu/cputime",                 // cpu:time ( 1.0 == 1 logic CPU )
			"/intel/libvirt/" + domain + "/memory/rss",                  // ram:used [GB]
			"/intel/linux/perfevents/cgroup/cache-references/" + cgroup, // cpu:cache:references ( L3 memory [1/s] )
			"/intel/linux/perfevents/cgroup/cache-misses/" + cgroup,     // cpu:cache:misses ( L3 memory [1/s] )
			"/intel/libvirt/" + domain + "/disk/*/wrbytes",              // disk:bandwidth:read [MiB/s]
			"/intel/libvirt/" + domain + "/disk/*/rdbytes",              // disk:bandwidth:write [MiB/s]
			"/intel/libvirt/" + domain + "/disk/*/wrreq",                // disk:operations:read [1/s]
			"/intel/libvirt/" + domain + "/disk/*/rdreq",                // disk:operations:write [1/s]
			"/intel/libvirt/" + domain + "/network/*/txbytes",           // network:bandwidth:send [MiB/s]
			"/intel/libvirt/" + domain + "/network/*/rxbytes",           // network:bandwidth:receive [MiB/s]
			"/intel/libvirt/" + domain + "/network/*/txpackets",         // network:packets:send [1/s]
			"/intel/libvirt/" + domain + "/network/*/rxpackets",         // network:packets:receive [1/s]
		},
	}
}

// Session configures & launches snap workflow for KRICO.
type Session struct {
	session *snap.Session
}

// NewSessionLauncher creates KRICO session.
func NewSessionLauncher(config snap.SessionConfig) (*Session, error) {

	session, err := snap.NewSessionLauncher(config)

	if err != nil {
		return nil, err
	}

	return &Session{
		session: session,
	}, nil
}

// Launch starts Snap Collection session and returns handle to that session.
func (s *Session) Launch() (executor.TaskHandle, error) {
	return s.session.Launch()
}

// String returns human readable name for job.
func (s *Session) String() string {
	return "Snap KRICO Collection"
}


text:
from numpy import pi

import mbuild as mb

from mbuild.lib.moieties import Silane
from mbuild.lib.moieties import CH3
from mbuild.examples.pmpc.mpc import MPC
from mbuild.examples.pmpc.initiator import Initiator

class Brush(mb.Compound):
    """ """
    def __init__(self, chain_length=4, alpha=pi/4):
        super(Brush, self).__init__()

        # Add parts
        self.add(Silane(), label='silane')
        self.add(Initiator(), label='initiator')
        self.add(mb.Polymer(MPC(alpha=alpha), n=chain_length,
                            port_labels=('up', 'down')), label='pmpc')
        self.add(CH3(), label='methyl')

        mb.force_overlap(self['initiator'], self['initiator']['down'], self['silane']['up'])
        mb.force_overlap(self['pmpc'], self['pmpc']['down'], self['initiator']['up'])
        mb.force_overlap(self['methyl'], self['methyl']['up'], self['pmpc']['up'])

        # Make self.port point to silane.bottom_port
        self.add(self['silane']['down'], label='down', containment=False)

if __name__ == "__main__":
    #pmpc = Brush(chain_length=1, alpha=pi/4)
    pmpc = Brush()
    print(pmpc)


text:
"""
The entrypoints module.
"""

import click
from jasper.runner import Runner
from jasper.display import Display

@click.command()
@click.argument('test_directory', type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True))
@click.option('--ansi', is_flag=True, default=False, help="Flag to force display to use ansi escape sequences for coloring.")
@click.option('-v', type=click.IntRange(0, 2), default=0, help="Verbosity level from 0 to 2. default is 0.")
def jasper(test_directory, ansi, v):
    """
    The entrypoint of the application.

    Runs Jasper tests within a given directory and displays the results.

    :param test_directory: The directory containing feature files to run.
    :param ansi: A flag for whether or not to force ansi escape sequences in the display for coloring purposes.
    :param v: A verbosity level for the display. Ranges from 0 to 2.
    """
    runner = Runner(test_directory)
    completed_suite = runner.run()
    display = Display(force_ansi=ansi, verbosity_level=v)
    display.prepare_suite(completed_suite)
    display.display()

if __name__ == '__main__':
    jasper()


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
	<context id="mysqlTables" targetRuntime="MyBatis3">
		<commentGenerator>

			<property name="suppressDate" value="true" />

			<property name="suppressAllComments" value="true" />
		</commentGenerator>
		<jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://127.0.0.1:3306/mall_schema" userId="root" password="young" />

		<javaTypeResolver>

			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver>

		<javaModelGenerator targetPackage="cc.congyi.model" targetProject="${targetProject}">

      		<property name="enableSubPackages" value="true" />

      		<property name="trimStrings" value="true" />
		</javaModelGenerator>

		<sqlMapGenerator targetPackage="cc.congyi.persistence.mybatis" targetProject="${targetProject}">
			<property name="enableSubPackages" value="true" />
		</sqlMapGenerator>

		<javaClientGenerator type="XMLMAPPER" targetPackage="cc.congyi.persistence.mybatis" targetProject="${targetProject}">
			<property name="enableSubPackages" value="true" />
		</javaClientGenerator>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

		    <property name="useActualColumnNames" value="false"/>
		    <generatedKey column="ID" sqlStatement="MySql" identity="true"/>

	</context>
</generatorConfiguration>


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package leaptest.view;

import com.jme3.math.FastMath;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Quad;

/**
 *
 * @author silvandeleemput
 */
public class Floor extends Geometry {

    public Floor(int scale)
    {
        super("Floor", new Quad(scale,scale));
        setLocalTranslation(-scale/2, -0.1f , scale/2);
        rotate(-FastMath.PI*0.5f, 0f, 0f);
        setMaterial(MaterialManager.floor);
        setShadowMode(ShadowMode.Receive);
    }

}


text:
package org.kuali.rice.krad.bo;

import org.junit.Test;
import org.reflections.Reflections;

import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;
import java.lang.reflect.Method;
import java.util.Set;

import static org.junit.Assert.fail;

/**
 * This test verifies that all of the JPA objects in this module are statically weaved.
 *
 *
If one executes this test from within an IDE environment, it very well may not pass if one of the JPA objects
 * under examination was modified and then recompiled by the IDE. The static weaving process is handled by Maven,
 * so without executing the appropriate Maven lifecycle phase, the class will not get weaved. Regardless, this test
 * should *always* pass when executed from the command line.

 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 */
public class StaticWeavingTest {

    @Test
    public void testStaticWeaving() {
        // first, scan for all files on the classpath with an @Entity or @MappedSuperClass annotation
        Reflections reflections = new Reflections("org.kuali.rice.krad");
        Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Entity.class);
        Set<Class<?>> superTypes = reflections.getTypesAnnotatedWith(MappedSuperclass.class);
        Set<Class<?>> embeddableTypes = reflections.getTypesAnnotatedWith(Embeddable.class);

        // next, let's assert that they have been statically weaved
        assertStaticWeaved(entityTypes, superTypes, embeddableTypes);
    }

    private void assertStaticWeaved(Set<Class<?>>... types) {
        for (Set<Class<?>> typeSet : types) {
            for (Class<?> type : typeSet) {
                boolean foundWeaved = false;
                Method[] methods = type.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.getName().startsWith("_persistence")) {
                        foundWeaved = true;
                        break;
                    }
                }
                if (!foundWeaved) {
                    fail("(NOTE: it is expected this test may fail if executed from the IDE instead of command line "
                            + "since the IDE will not execute the static weaving automatically). Found a class which is "
                            + "not bytecode weaved (contains no methods starting with '_persistence'): " + type + " "
                            + "In order to resolve this, please ensure that this type is included in "
                            + "META-INF/persistence-weaving.xml");
                }
            }
        }
    }

}


text:
package schip8

object Opcodes {
  /* 1nnn - Jump to location nnn */
  def onennn(o: Operands, vmState: VMState): VMState = vmState.copy(pc= o.nnn)

  /* 3xkk - Skip next instruction if Vx = kk */
  def threexkk(o: Operands, vmState: VMState): VMState =
    if (vmState.V(o.x) == o.kk) vmState.copy(pc = vmState.pc + 2) else vmState

  /* 6xkk - Set Vx = kk */
  def sixxkk(o: Operands, vmState: VMState): VMState = {
    val VV = vmState.V
    VV(o.x) = o.kk
    vmState.copy(V=VV)
  }

  /* 7xkk - Set Vx = Vx + kk */
  def sevenxkk(o: Operands, vmState: VMState): VMState = {
    val VV = vmState.V
    VV(o.x) = (VV(o.x) + o.kk).toByte
    vmState.copy(V=VV)
  }

  /* Annn - Set I = nnn */
  def annn(o: Operands, vmState: VMState): VMState = vmState.copy(I=o.nnn)

  /* Cxkk - Set Vx = random byte AND kk. */
  def cxkk(o: Operands, vmState: VMState): VMState = {
    val randomByte = new Array[Byte](1)
    scala.util.Random.nextBytes(randomByte)
    val VV = vmState.V
    VV(o.x) = (randomByte(0) & o.kk).toByte
    vmState.copy(V=VV)
  }

  /* Dxyn - Display n-byte sprite starting at memory location I at (Vx, Vy).
     Set VF = collision */
  def dxyn(o: Operands, vmState: VMState): VMState = {
    val collision = VM.drawSprite(vmState.V(o.x), vmState.V(o.y), vmState.I, o.n, vmState)
    val VV = vmState.V
    if (collision) VV(0xF) = 1 else VV(0xF) = 0
    vmState.copy(V=VV)
  }

  /* opcodes execution */
  def execute(vmState: VMState): VMState = {
    /* a chip-8 instruction is 16-bit */
    val instruction = (
      (vmState.memory.locations(vmState.pc) << 8) /* Get first byte and shift it << 8 */
      + vmState.memory.locations(vmState.pc + 1)  /* concatenate with second byte     */
    )

    val opcode    = (instruction & 0xF000)
    val operands  = Operands(instruction)
    println("Executing Instruction..." + instruction.toHexString)

    opcode match {
      case 0x1000 =>
        /* 1nnn - Jump to location nnn */
        Opcodes.onennn(operands, vmState)
      case 0x3000 =>
        /* 3xkk - Skip next instruction if Vx = kk */
        Opcodes.threexkk(operands, vmState)
      case 0x6000 =>
        /* 6xkk - Set Vx = kk */
        Opcodes.sixxkk(operands, vmState)
      case 0x7000 =>
        /* 7xkk - Set Vx = Vx + kk */
        Opcodes.sevenxkk(operands, vmState)
      case 0xA000 =>
        /* Annn - Set I = nnn */
        Opcodes.annn(operands, vmState)

      case 0xC000 =>
        /* Cxkk - Set Vx = random byte AND kk. */
        Opcodes.cxkk(operands, vmState)

      case 0xD000 =>
        /* Dxyn - Display n-byte sprite starting at memory location I at (Vx, Vy).
           Set VF = collision */
        Opcodes.dxyn(operands, vmState)
      case _ =>
        vmState
    }
  }
}

/* Extract operands from instruction */
case class Operands(instruction: Int) {
  def nnn       = (instruction & 0x0FFF).toShort
  def x         = ((instruction & 0x0F00) >> 8).toByte
  def y         = ((instruction & 0x00F0) >> 4).toByte
  def n         = ((instruction & 0x000F)).toByte
  def kk        = (instruction & 0x00FF).toByte
}

object Instructions {
  def executeNext(vmState: VMState): VMState = {
    /* Execute instruction at pc and get new VM state */
    val newVmState = Opcodes.execute(vmState)

    /* Update program counter.
       Instructions in chip-8 are 2 bytes long */
    newVmState.copy(pc = newVmState.pc + 2)
  }
}


text:
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**id** | **String** | [read-only] Subscription identifier  | [optional]
**type** | **String** | [required] Type of subscription (email, webhook)  | [optional]
**topic** | [**Topic**](Topic.md) | [required]  | [optional]
**params** | [**Params**](Params.md) | [required]  | [optional]


text:
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Profile extends Model {

    /**
     * The database table used by the model.
     *
     * @var string
     */
    protected $table = 'profiles';

    /**
     * The attributes that are not mass assignable.
     *
     * @var array
     */
    protected $guarded = [
    	'id'
    ];

	/**
	 * Fillable fields for a Profile
	 *
	 * @var array
	 */
	protected $fillable = [
		'theme_id',
        'location',
		'bio',
		'twitter_username',
		'github_username'
	];

    protected $casts = [
        'theme_id' => 'integer',
    ];

	/**
	 * A profile belongs to a user
	 *
	 * @return mixed
	 */
	public function user()
	{
		return $this->belongsTo('App\Models\User');
	}

    /**
     * Profile Theme Relationships
     *
     * @var array
     */
    public function theme()
    {
        return $this->hasOne('App\Models\Theme');
    }

}


text:
body {
  background-color: #f5f5f5;
}
form {
  display: inline;
}

/* Undo MDL typography module styles.
When we decide to use their typography rules, we may be able to remove some of
these rules.
 */

html, body, table, td, th, p {
  font-family: arial,sans-serif;
  font-size: 13px;
}
html, body {
  font-weight: inherit;
  line-height: inherit;
}
body, h3 {
  margin: 0px;
  padding: 0px;
}
ul,ol {
  font-weight: inherit;
  letter-spacing: inherit;
  font-size: inherit;
  line-height: inherit;
}
h1,h2,h3,h4,h5 {
  font-size: inherit;
  line-height: inherit;
  font-weight: bold;
}
h3 {
  font-size: 1.17em;;
}
h2 {
  font-size: 1.5em;
}
a {
  color: rgb(0, 0, 238);
}
iframe {
  border: 2px inset;
}
fieldset {
  padding: 0.35em 0.75em 0.625em 0.75em;
}

/* end MDL overrides */

table {
  width: 100%;
  border-width: 1px;
  border-spacing: 2px;
  border-style: outset;
  border-color: gray;
  border-collapse: collapse;
}
table th {
  border-width: 1px;
  padding: 4px;
  background-color: #f5f5f5;
  border-style: inset;
  border-color: gray;
  text-align: center;
}
table td {
  border-width: 1px;
  padding: 8px;
  border-style: inset;
  border-color: gray;
}

div#gcb-main-area {
  text-align: center;
  padding-top: 12px;
  position: relative;
}
div#gcb-section {
  padding-bottom: 4px;
}
div#gcb-main-content {
  padding: 32px;
  text-align: left;
}
div#gcb-main-content li {
  margin: 1px 0px;
}
div#gcb-footer {
  text-align: center;
  font-size: smaller;
  padding: 4px;
  border-top: solid 1px #607D8B;
  background-color: #f5f5f5;
}
h2 {
  margin-left: 32px;
}
.section + .section {
  margin-top: 40px;
}
h3 {
  color: #37474F;
}
p.page-description {
  margin: 0;
  padding: 0.4em 0 0 1em;
  width: 40em;
  text-align: left;
}
p.page-description, p.description {
  font-size: 80%;
  color: #666;
}
div#formContainer {
  margin: 0;
}
.gcb-button {
  display: inline-block;
  margin: 0;
  padding: 4px 12px;
  background-color: #37474F;
  color: #fff;
  text-decoration: none;
  border: none;
  border-radius: 3px;
  font-size: 12px;
  font-weight: normal;
  cursor: default;
}
.gcb-button-toolbar {
  margin-top: 5px;
  margin-bottom: 5px;
}
.gcb-icon-button {
  padding-top:0;
  padding-bottom:0;
  padding-left: 8px;
  line-height: 20px;
}
.gcb-icon-button .icon {
  color: inherit;
  padding:0;
  background-color: transparent;
  cursor: inherit;
}
.gcb-icon-button span {
  vertical-align: middle;
}

.gcb-pull-right {
  float: right;
}
#gcb-section pre {
  padding: 0px;
  margin: 0px;
}
span.draft-label {
  color: #999;
}
.strong {
  font-weight: bold;
}

/* CSS for lists of items in the Course settings editor. */

div.settings-list {
  width: 500px;
  float: left;
}
div.new-form-layout div.settings-list.wide {
  width: inherit;
  float: none;
  margin-left: 90px;
  min-width: 700px;
}
div.new-form-layout div.settings-list.wide > span:first-child {
  display: none;
}
div.settings-list > div.inputEx-ListField-childContainer > div {
  margin-top: 15px;
}
div.settings-list a.inputEx-List-link {
  color: #000;
  background-color: #f2f2f2;
  border: solid #808080 1px;
  padding: 3px;
  font-weight: bold;
  font-size: 10px;
  margin-left: 0px;
}
div.new-form-layout div.settings-list a.inputEx-List-link {
  color: #fff;
  background-color: #666;
  font-weight: normal;
  border-radius: 3px;
  padding: 3px 10px;
}
div.settings-list a:hover {
  text-decoration: none;
}
div.settings-list-item {
  margin-left: 0px;
  width: 100%;
}
div.settings-list-item + a {
  float: right;
  margin-top: -10px;
  margin-right: 7px;
}
div.new-form-layout div.settings-list-item > fieldset > div.inputEx-fieldWrapper {
  padding: 15px 0 0 0;
}
div.settings-list-item > fieldset > div > div.inputEx-Field {
  width: auto;
  min-width: 325px;
}
div.settings-list-item select {
  max-width: 220px;
}
div.settings-list-item input[type="text"] {
  width: 300px;
  border-left: solid 1px #999;
}
div.settings-list-item div.inputEx-description {
  width: 250px;
}
div.settings-list > div.inputEx-description {
  margin-top: 10px;
}
div#formContainer div.settings-list-item fieldset {
  border: solid #999 1px;
  margin-left: 0px;
}
div#formContainer div.new-form-layout div.settings-list-item fieldset {
  border: solid #ddd 1px;
  border-radius: 3px;
}
div#formContainer div.settings-list-item fieldset legend span {
  font-weight: normal;
}
.icon {
  display: inline-block;
  border: none;
  vertical-align: middle;
  font-size: 16px;
  margin: 0;
  padding: 0 4px;
  color: #555;
  background-color: inherit;
  text-decoration: none;
  cursor: pointer;
}
.icon.inactive {
  cursor: auto;
}
.assets-table-container {
  max-height: 400px;
  overflow: auto;
  overflow-y: scroll;
  margin: 0px 0px 20px 0px;
  border: solid 1px;
}
.assets-table {
  border-style: hidden;
  border-right-style: solid;
}
.assets-table td {
  padding: 4px 10px;
  vertical-align: top;
}
.assets-table th {
  padding: 5px 15px;
  cursor: pointer;
  background-repeat: no-repeat;
}
.assets-table li {
  margin: 0px;
}
.assets-table .md-arrow-drop-up,
.assets-table .md-arrow-drop-down {
  display: none;
}
.assets-table .sort-asc .md-arrow-drop-up,
.assets-table .sort-desc .md-arrow-drop-down {
  display: inline;
  font-size: 18px;
  vertical-align: middle;
}
.assets-table ul {
  margin: 0px;
  padding: 0px;
  list-style-type: none;
}
.assets-table span.count {
  font-style: italic;
}
#modal-window {
  display: none;
}
#modal-background {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background-color: #000;
  opacity: 0.5;
  filter: alpha(opacity=50);
  z-index: 1000;
}
#modal-container {
  border: 2px inset;
  border-radius: 10px;
  position: fixed;
  top: 50%;
  margin-top: -250px;
  left: 50%;
  width: 780px;
  margin-left: -410px;
  z-index: 1010;
  background-color: #fff;
  padding: 20px;
}
.close-button {
  position: absolute;
  top: 0px;
  right: 0px;
  color: #888;
  font-weight: bold;
  font-size: 13px;
  cursor: pointer;
  border: none;
  background: none;
  outline: none;
  padding: 5px;
}
#modal-container > div > iframe {
  width: 100%;
  border: none;
}
.filter-container {
  position: relative;
  overlfow: auto;
}
#add-to-group form div {
  display: inline-block;
  text-align: left;
}
.filter-popup {
  display: none;
  position: absolute;
  right: 0;
  top: 26px;
  width: 470px;
  background-color: #fff;
  border: 1px solid #ccc;
  border: 1px solid rgba(0,0,0,0.2);
  padding: 10px;
  -mozkit-box-shadow: 2px 2px 4px rgba(0,0,0,0.2);
  -webkit-box-shadow: 2px 2px 4px rgba(0,0,0,0.2);
  box-shadow: 2px 2px 4px rgba(0,0,0,0.2);
}
.form-popup label span {
  display: inline-block;
  width  : 120px;
  text-align: right;
  margin-right: 5px;
  vertical-align: middle;
}
.form-popup input[type="text"] {
  width: 216px;
  margin: 0px;
}
.form-popup input[type="checkbox"] {
  margin: 3px 0px;
}
.form-popup select, .form-popup label span.uneditable-field {
  text-align: left;
  width: 220px;
  margin: 0px;
}
.form-popup .buttons {
  margin-left: 121px;
}
.form-popup .buttons .gcb-button {
  display: inline-block;
}
.form-popup > fieldset {
  border:none;
  border-top: solid 1px #999999;
}
.form-popup legend {
  color: #505050;
  font-weight: bold;
  text-align: left;
}
li.activity-item {
  list-style-type: square;
}
span.course-title {
  display: inline-block;
  font-weight: bold;
  max-width: 250px;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}
span.down-arrow {
  margin: 0 0 3px 5px;
  width: 10px;
  height: 5px;
  display: inline-block;
  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAFCAYAAAB8ZH1oAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3wEIEgAQ1X1ifwAAABl0RVh0Q29tbWVudABDcmVhdGVkIHdpdGggR0lNUFeBDhcAAABgSURBVAjXdcqxDYNAEAXRWRBEdEEJlOAOXIBLwh3RADUQk5Fdhm5IzoCQPNJu8l/knKuI6IAaEKiABohyO7CRUmrV0f99uae+1eUGVvVTtvIuPKiTOquvHzrNA/dqz6MD5qlhajDm5qkAAAAASUVORK5CYII=);
}
div.current-course {
  color: #666;
  background-color: white;
  padding: 9px 11px;
}
/* Styles for role editor */
div.permission-module {
  display: inline-block;
}
div.permission-item.inputEx-ListField-subFieldEl {
  margin: 0;
  margin-bottom: 8px;
}
div.permission-item input {
  margin: 1px 5px 0px 0px;
}
div.permission-item .inputEx-label,
div.permission-item label,
div.permission-item .inputEx-Group-legend,
div.permission-module .inputEx-List-link {
  display: none;
}
div.permission-item .inputEx-fieldWrapper {
  display: inline-block;
  vertical-align: text-top;
  margin: 0;
}
.permission-label {
  display: inline;
}
.permission-name {
  display: none;
}
div#formContainer fieldset .permission-item fieldset {
  margin: 0;
  border: 0;
  padding: 0;
}
.settings-section {
  width: 700px;
  margin: auto;
}
.settings-section-title {
  font-weight: bold;
  padding-left: 1em;
  background-color: #eee;
  color: #555;
}
.settings-section-content {
  margin-left: 2em;
}
.settings-property {
  margin: 8px;
}
.settings-property-label {
  float: left;
  padding-right: 1em;
  width: 130px;
  text-align: right;
  color: #555;
}
.settings-property-box {
  float: left;
  width: 500px;
}
.settings-property-value {
  border-left: 1px solid #999;
  color: #555;
  background: #EEE;
  padding: 3px;
  min-height: 1em;
}
.settings-property-descr {
  font-size: 75%;
  color: #555;
}
.settings-property-clear {
  clear: both;
}

div.codemirror-container-readonly {
    padding-bottom: 1.5em;
}

div.codemirror-container-readonly div.CodeMirror {
    height: auto!important;
}
.title-text {
  vertical-align: middle;
}
label.settings.togglebutton {
  vertical-align: sub;
}
.gcb-message {
  margin-left: 40px;
  margin-right: 40px;
  margin-top: 1em;
  margin-bottom: 1em;
}

/* Collapse component

Use this to build "zippy" menus.  Some JavaScript in view.js is required to
calculate element heights on startup.  Re-run updateCollapse to recalculate it
any time you create or modify some collapsible content.

.gcb-collapse: Container
.gcb-collapse--opened: Makes the contents visible
.gcb-collapse__content: The contents that can be hidden
.gcb-collapse__content-wrapper: Wraps and hides the contents
.gcb-collapse__icon: An icon that will rotate on open and close
.gcb-collapse__button: The clickable element
.gcb-accordion: Wrap multiple collapses in this and they'll collapse their
  neighbors when you open them.

Minimal Example:

    expand_more
    Click me to see the content

      This is the content

*/

.gcb-collapse--opened {
  border-top: 1px solid #e0e0e0;
  border-bottom: 1px solid #e0e0e0;
  margin-top: -1px;
}

.gcb-collapse--opened + .gcb-collapse--opened {
  border-top: none;
  margin-top: 0;
}

.gcb-collapse__content-wrapper {
  overflow: hidden;
}

.gcb-collapse__content {
  transition-property: margin-top;
  transition-duration: 0.2s;
}

.gcb-collapse__button {
  font-weight: bold;
}

.gcb-collapse__icon {
  transition-property: transform;
  transition-duration: 0.2s;
  color: rgba(0,0,0,0.3);

  /* TODO(nretallack): Some day, MDL should provide some facility for
  positioning icons inside list items so we don't have to do this */
  position: absolute;
  right: 6px;
  margin-top: -3px;
}

.gcb-collapse--opened .gcb-collapse__icon {
  transform: rotate(-180deg);
}

.gcb-collapse--opened .gcb-collapse__content {
  /* Overrides the inline style calculated by the JavaScript on startup */
  margin-top: 0 !important;
}

/* end of collapse component */

.mdl-layout__content {
  overflow: auto;
  background: #fff;
}

/* Drawer menu adjustments */
.mdl-layout__drawer .mdl-navigation.gcb-menu .mdl-navigation__link {
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 30px;
  padding-right: 30px;
  cursor: pointer;
  position: relative;
  font-size: 15px;
  color: inherit;
}

.mdl-layout__drawer .mdl-navigation .mdl-navigation__link:hover {
  background-color: rgba(0, 0, 0, 0.05);
}

/* current page indication */
.mdl-layout__drawer .mdl-navigation.gcb-menu .mdl-navigation__link.gcb-active,
.mdl-layout__drawer .mdl-navigation.gcb-menu .mdl-navigation__link.gcb-active:hover {
  background: rgba(0, 0, 0, 0.08);
}

.mdl-navigation.gcb-menu .gcb-active-group .gcb-collapse__button {
  color: rgb(0, 150, 136);
}

/* adjustments for the header */
.mdl-layout__header .mdl-navigation .mdl-navigation__link,
.mdl-layout__header a {
  color: inherit;
}

.mdl-layout__content {
  z-index: auto;
}

@media screen and (min-width: 851px) {
  .mdl-layout__drawer-button {
    display: none;
  }
  .mdl-layout__header-row {
    padding-left: 40px;
  }
}

.mdl-layout__header {
  position: relative;
}

.mdl-layout__drawer .mdl-layout-title {
  padding-left: 30px;
  border-bottom: 1px solid #e0e0e0;
  margin: 0;
  padding-top: 22px;
  padding-bottom: 22px;
}

@media screen and (max-width: 850px) {
  .mdl-layout__drawer .mdl-layout-title {
    padding-top: 18px;
    padding-bottom: 18px;
  }
}

.gcb-drawer-header {
  background:  white;
  border-bottom: 1px solid #e0e0e0;
}

/* indent sub-menus */
.mdl-layout__drawer .mdl-navigation.gcb-menu .gcb-menu .mdl-navigation__link {
  padding-left: 45px;
}

/* Course Picker stuff */
.gcb-course-picker.mdl-navigation.gcb-menu {
  padding-top: 0;
}

.gcb-course-picker.gcb-collapse.gcb-collapse--opened {
  border-bottom: none;
  border-top: none;
  margin-top: 0;
}

/* eliminate extra borders in the menu */

#nav-menu .gcb-collapse:first-of-type {
  border-top: 0;
  margin-top: 0;
}

#nav-menu .gcb-collapse:last-of-type {
  border-bottom: 0;
}

/* Call out the Site Admin menu */

.gcb-page--dashboard #menu-group__admin {
  margin-top: 15px;
  padding-top: 15px;
  border-top: 1px solid #e0e0e0;
}

.gcb-page--dashboard #menu-group__help {
  border-bottom: 0;
}

/* Stuff on the site-admin page */

.gcb-page--admin .mdl-layout__header {
  background-color: rgb(103, 58, 183);
}

.gcb-page--admin .mdl-navigation.gcb-menu .gcb-active-group .gcb-collapse__button {
  color: rgb(103, 58, 183);
}


text:
/**
 * @file: Practica_10_2.java
 *
 * @utor: Moisés Alcocer, 2016
 */

package practicas;

//imports
import java.sql.*;

/**
 * This class solve practice 10.2 - CallableStatement
 *
 * Programa que ejecuta el procedimiento "subida_sal" ya creado en MySQL:
 * el procedimiento "subida_sal" permite subir el salario a los profesores de un dept.
 *
 */
public class Practica_10_2 {

    /**********************************/
    /*** Properties declaration *******/

        private Connection con;
        private CallableStatement cs;

    /**********************************/
    /*** Methods declaration **********/

        /**
         * Construct
         *
         * @param salary_increment
         * @param dept_name
         */
        public Practica_10_2( int salary_increment, String dept_name ) {
            System.out.println( "Practica_10_2 / Construct()" );

            //Abrir conexión
            con = universal.GetConnection.get( "mysql", mysql.DbConstants.DB_NAME );

            try {
                String sentence = "CALL subida_sal( ?, ? )";
                cs = con.prepareCall( sentence );

                System.out.println( "Cargando parámetros..." );
                cs.setInt(   1, salary_increment );
                cs.setString( 2, dept_name );

                System.out.println( "Ejecutando llamada al procedimiento..." );
                cs.executeUpdate();

                System.out.println( "Actualización completada. \n" );

            } catch( SQLException e ) {

                System.out.println( "Error con el CallableStatement..." );
                System.out.println( "---> " + e.toString( ));
            }

            //Free resources
            try {
                System.out.println( "Cerrando CallableStatement..." );
                cs.close();

                System.out.println( "Cerrando Connection..." );
                con.close();

            } catch( SQLException e ) {

                System.out.println( "Error librerando recursos..." );
                System.out.println( "---> " + e.toString( ));
            }
        }

} //class


text:
#include "SDL_config.h"

void SDL_EnumUnixAudioDevices(int flags, int classic, int (*test) (int fd),
                              char ***devs, int *count);
void SDL_FreeUnixAudioDevices(char ***devices, int *devCount);

/* vi: set ts=4 sw=4 expandtab: */


text: The current model can be ordered from an outsourced PCB manufacturer (OSHPark):


text:
/**
 * Onshape REST API
 * The Onshape REST API consumed by all clients.
 *
 * OpenAPI spec version: 1.93
 * Contact: api-support@onshape.zendesk.com
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

import localVarRequest = require('request');
import http = require('http');
import Promise = require('bluebird');

/* tslint:disable:no-unused-locals */
import { BTListResponseBTPurchaseInfo } from '../model/bTListResponseBTPurchaseInfo';
import { BTPurchaseInfo } from '../model/bTPurchaseInfo';
import { BTPurchaseUserParams } from '../model/bTPurchaseUserParams';

import { ObjectSerializer, Authentication, HttpBasicAuth, ApiKeyAuth, OAuth, VoidAuth } from '../model/models';

let defaultBasePath = 'http://localhost';

// ===============================================
// This file is autogenerated - Please do not edit
// ===============================================

export enum AccountsApiApiKeys {
}

export class AccountsApi {
    protected _basePath = defaultBasePath;
    protected defaultHeaders : any = {};
    protected _useQuerystring : boolean = false;

    protected authentications = {
        'default': <Authentication>new VoidAuth(),
        'OAuth2': new OAuth(),
    }

    constructor(basePath?: string);
    constructor(basePathOrUsername: string, password?: string, basePath?: string) {
        if (password) {
            if (basePath) {
                this.basePath = basePath;
            }
        } else {
            if (basePathOrUsername) {
                this.basePath = basePathOrUsername
            }
        }
    }

    set useQuerystring(value: boolean) {
        this._useQuerystring = value;
    }

    set basePath(basePath: string) {
        this._basePath = basePath;
    }

    get basePath() {
        return this._basePath;
    }

    public setDefaultAuthentication(auth: Authentication) {
        this.authentications.default = auth;
    }

    public setApiKey(key: AccountsApiApiKeys, value: string) {
        (this.authentications as any)[AccountsApiApiKeys[key]].apiKey = value;
    }

    set accessToken(token: string) {
        this.authentications.OAuth2.accessToken = token;
    }

    /**
     *
     * @summary Cancel Recurring Subscription
     * @param aid
     * @param pid
     * @param cancelImmediately
     */
    public cancelPurchaseNew (aid: string, pid: string, cancelImmediately?: boolean) : Promise<{ response: http.ClientResponse; body?: any;  }> {
        const localVarPath = this.basePath + '/api/accounts/{aid}/purchases/{pid}'
            .replace('{' + 'aid' + '}', encodeURIComponent(String(aid)))
            .replace('{' + 'pid' + '}', encodeURIComponent(String(pid)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};

        // verify required parameter 'aid' is not null or undefined
        if (aid === null || aid === undefined) {
            throw new Error('Required parameter aid was null or undefined when calling cancelPurchaseNew.');
        }

        // verify required parameter 'pid' is not null or undefined
        if (pid === null || pid === undefined) {
            throw new Error('Required parameter pid was null or undefined when calling cancelPurchaseNew.');
        }

        if (cancelImmediately !== undefined) {
            localVarQueryParameters['cancelImmediately'] = ObjectSerializer.serialize(cancelImmediately, "boolean");
        }

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'DELETE',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        this.authentications.OAuth2.applyToRequest(localVarRequestOptions);

        this.authentications.default.applyToRequest(localVarRequestOptions);

        if (Object.keys(localVarFormParams).length) {
            if (localVarUseFormData) {
                (<any>localVarRequestOptions).formData = localVarFormParams;
            } else {
                localVarRequestOptions.form = localVarFormParams;
            }
        }
        return new Promise<{ response: http.ClientResponse; body?: any;  }>((resolve, reject) => {
            localVarRequest(localVarRequestOptions, (error, response, body) => {
                if (error) {
                    reject(error);
                } else {
                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                        resolve({ response: response, body: body });
                    } else {
                        reject({ response: response, body: body });
                    }
                }
            });
        });
    }
    /**
     *
     * @summary Mark Purchase Consumed For User
     * @param pid
     * @param bTPurchaseUserParams
     */
    public consumePurchase (pid: string, bTPurchaseUserParams?: BTPurchaseUserParams) : Promise<{ response: http.ClientResponse; body: BTPurchaseInfo;  }> {
        const localVarPath = this.basePath + '/api/accounts/purchases/{pid}/consume'
            .replace('{' + 'pid' + '}', encodeURIComponent(String(pid)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};

        // verify required parameter 'pid' is not null or undefined
        if (pid === null || pid === undefined) {
            throw new Error('Required parameter pid was null or undefined when calling consumePurchase.');
        }

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'POST',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
            body: ObjectSerializer.serialize(bTPurchaseUserParams, "BTPurchaseUserParams")
        };

        this.authentications.OAuth2.applyToRequest(localVarRequestOptions);

        this.authentications.default.applyToRequest(localVarRequestOptions);

        if (Object.keys(localVarFormParams).length) {
            if (localVarUseFormData) {
                (<any>localVarRequestOptions).formData = localVarFormParams;
            } else {
                localVarRequestOptions.form = localVarFormParams;
            }
        }
        return new Promise<{ response: http.ClientResponse; body: BTPurchaseInfo;  }>((resolve, reject) => {
            localVarRequest(localVarRequestOptions, (error, response, body) => {
                if (error) {
                    reject(error);
                } else {
                    body = ObjectSerializer.deserialize(body, "BTPurchaseInfo");
                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                        resolve({ response: response, body: body });
                    } else {
                        reject({ response: response, body: body });
                    }
                }
            });
        });
    }
    /**
     *
     * @summary Get Plan Purchases
     * @param planId
     * @param offset
     * @param limit
     */
    public getPlanPurchases (planId: string, offset?: number, limit?: number) : Promise<{ response: http.ClientResponse; body: BTListResponseBTPurchaseInfo;  }> {
        const localVarPath = this.basePath + '/api/accounts/plans/{planId}/purchases'
            .replace('{' + 'planId' + '}', encodeURIComponent(String(planId)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};

        // verify required parameter 'planId' is not null or undefined
        if (planId === null || planId === undefined) {
            throw new Error('Required parameter planId was null or undefined when calling getPlanPurchases.');
        }

        if (offset !== undefined) {
            localVarQueryParameters['offset'] = ObjectSerializer.serialize(offset, "number");
        }

        if (limit !== undefined) {
            localVarQueryParameters['limit'] = ObjectSerializer.serialize(limit, "number");
        }

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'GET',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        this.authentications.default.applyToRequest(localVarRequestOptions);

        if (Object.keys(localVarFormParams).length) {
            if (localVarUseFormData) {
                (<any>localVarRequestOptions).formData = localVarFormParams;
            } else {
                localVarRequestOptions.form = localVarFormParams;
            }
        }
        return new Promise<{ response: http.ClientResponse; body: BTListResponseBTPurchaseInfo;  }>((resolve, reject) => {
            localVarRequest(localVarRequestOptions, (error, response, body) => {
                if (error) {
                    reject(error);
                } else {
                    body = ObjectSerializer.deserialize(body, "BTListResponseBTPurchaseInfo");
                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                        resolve({ response: response, body: body });
                    } else {
                        reject({ response: response, body: body });
                    }
                }
            });
        });
    }
    /**
     *
     * @summary Get User's Appstore Purchases.
     * @param all
     * @param ownPurchaseOnly
     */
    public getPurchases (all?: boolean, ownPurchaseOnly?: boolean) : Promise<{ response: http.ClientResponse; body: Array<BTPurchaseInfo>;  }> {
        const localVarPath = this.basePath + '/api/accounts/purchases';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};

        if (all !== undefined) {
            localVarQueryParameters['all'] = ObjectSerializer.serialize(all, "boolean");
        }

        if (ownPurchaseOnly !== undefined) {
            localVarQueryParameters['ownPurchaseOnly'] = ObjectSerializer.serialize(ownPurchaseOnly, "boolean");
        }

        let localVarUseFormData = false;

        let localVarRequestOptions: localVarRequest.Options = {
            method: 'GET',
            qs: localVarQueryParameters,
            headers: localVarHeaderParams,
            uri: localVarPath,
            useQuerystring: this._useQuerystring,
            json: true,
        };

        this.authentications.default.applyToRequest(localVarRequestOptions);

        if (Object.keys(localVarFormParams).length) {
            if (localVarUseFormData) {
                (<any>localVarRequestOptions).formData = localVarFormParams;
            } else {
                localVarRequestOptions.form = localVarFormParams;
            }
        }
        return new Promise<{ response: http.ClientResponse; body: Array<BTPurchaseInfo>;  }>((resolve, reject) => {
            localVarRequest(localVarRequestOptions, (error, response, body) => {
                if (error) {
                    reject(error);
                } else {
                    body = ObjectSerializer.deserialize(body, "Array<BTPurchaseInfo>");
                    if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
                        resolve({ response: response, body: body });
                    } else {
                        reject({ response: response, body: body });
                    }
                }
            });
        });
    }
}


text:
#if NETSTANDARD2_0
//-----------------------------------------------------------------------
// <copyright file="ApplicationContextManager.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Application context manager that uses HttpContextAccessor</summary>
//-----------------------------------------------------------------------
using Csla.Core;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Text;

namespace Csla.Web
{
  /// <summary>
  /// Application context manager that uses HttpContextAccessor when
  /// resolving HttpContext to store context values.
  /// </summary>
  public class ApplicationContextManager : IContextManager
  {

    private const string _localContextName = "Csla.LocalContext";
    private const string _clientContextName = "Csla.ClientContext";
    private const string _globalContextName = "Csla.GlobalContext";

    private readonly IServiceProvider _serviceProvider;

    /// <summary>
    /// Creates an instance of the object, initializing it
    /// with the required IServiceProvider.
    /// </summary>
    /// <param name="serviceProvider">ASP.NET Core IServiceProvider</param>
    public ApplicationContextManager(IServiceProvider serviceProvider)
    {
      _serviceProvider = serviceProvider;
    }

    /// <summary>
    /// Gets the current HttpContext instance.
    /// </summary>
    protected virtual HttpContext HttpContext
    {
      get
      {
        HttpContext result = null;
        var httpContextAccessor = (IHttpContextAccessor)_serviceProvider.GetService(typeof(IHttpContextAccessor));
        if (httpContextAccessor != null)
        {
          result = httpContextAccessor.HttpContext;
        }
        return result;
      }
    }

    /// <summary>
    /// Gets a value indicating whether this
    /// context manager is valid for use in
    /// the current environment.
    /// </summary>
    public bool IsValid
    {
      get { return HttpContext != null; }
    }

    /// <summary>
    /// Gets the current principal.
    /// </summary>
    public System.Security.Principal.IPrincipal GetUser()
    {
      var result = HttpContext?.User;
      if (result == null)
      {
        result = new Csla.Security.CslaClaimsPrincipal();
        SetUser(result);
      }
      return result;
    }

    /// <summary>
    /// Sets the current principal.
    /// </summary>
    /// <param name="principal">Principal object.</param>
    public void SetUser(System.Security.Principal.IPrincipal principal)
    {
      HttpContext.User = (ClaimsPrincipal)principal;
    }

    /// <summary>
    /// Gets the local context.
    /// </summary>
    public ContextDictionary GetLocalContext()
    {
      return (ContextDictionary)HttpContext?.Items[_localContextName];
    }

    /// <summary>
    /// Sets the local context.
    /// </summary>
    /// <param name="localContext">Local context.</param>
    public void SetLocalContext(ContextDictionary localContext)
    {
      HttpContext.Items[_localContextName] = localContext;
    }

    /// <summary>
    /// Gets the client context.
    /// </summary>
    public ContextDictionary GetClientContext()
    {
      return (ContextDictionary)HttpContext?.Items[_clientContextName];
    }

    /// <summary>
    /// Sets the client context.
    /// </summary>
    /// <param name="clientContext">Client context.</param>
    public void SetClientContext(ContextDictionary clientContext)
    {
      HttpContext.Items[_clientContextName] = clientContext;
    }

    /// <summary>
    /// Gets the global context.
    /// </summary>
    public ContextDictionary GetGlobalContext()
    {
      return (ContextDictionary)HttpContext?.Items[_globalContextName];
    }

    /// <summary>
    /// Sets the global context.
    /// </summary>
    /// <param name="globalContext">Global context.</param>
    public void SetGlobalContext(ContextDictionary globalContext)
    {
      HttpContext.Items[_globalContextName] = globalContext;
    }
  }
}
#endif


text:
<?php

class CreateAction {

}


text:
import { LetterEe16 } from "../../";

export = LetterEe16;


text:
#if UNITY_EDITOR

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.Linq;

namespace NodeCanvas.Editor{

	//Shows a GUI within a popup. The delegate includes the gui calls
	public class QuickPopup : PopupWindowContent {

		private System.Action Call;
		private Rect myRect = new Rect(0,0,200,10);

		public static void Show(System.Action Call, Vector2 pos = default(Vector2)){
			var e = Event.current;
			pos = pos == default(Vector2)? new Vector2(e.mousePosition.x, e.mousePosition.y) : pos;
			var rect = new Rect(pos.x, pos.y, 0, 0);
			PopupWindow.Show(rect, new QuickPopup(Call) );
		}

		public QuickPopup(System.Action Call){ this.Call = Call; }
		public override Vector2 GetWindowSize(){ return new Vector2(myRect.xMin + myRect.xMax, myRect.yMin + myRect.yMax); }
		public override void OnGUI(Rect rect){
			GUILayout.BeginVertical("box");
			Call();
			GUILayout.EndVertical();
			if (Event.current.type == EventType.Repaint){
				myRect = GUILayoutUtility.GetLastRect();
			}
		}
	}
}

#endif


text:
=================
Available proxies
=================

.. automodule:: wsgiproxy.proxies

.. autoclass:: Proxy

.. autoclass:: TransparentProxy

.. autoclass:: HostProxy


text:
require 'geo_ruby/simple_features/point'
require 'geo_ruby/simple_features/line_string'
require 'geo_ruby/simple_features/linear_ring'
require 'geo_ruby/simple_features/polygon'
require 'geo_ruby/simple_features/multi_point'
require 'geo_ruby/simple_features/multi_line_string'
require 'geo_ruby/simple_features/multi_polygon'
require 'geo_ruby/simple_features/geometry_collection'

module GeoRuby
  module SimpleFeatures

    #Raised when an error in the EWKB string is detected
    class EWKBFormatError < StandardError
    end

    #Parses EWKB strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
    #
    #=Example
    # factory = GeometryFactory::new
    # ewkb_parser = EWKBParser::new(factory)
    # ewkb_parser.parse(<EWKB String>)
    # geometry = @factory.geometry
    #
    #You can also use directly the static method Geometry.from_ewkb
    class EWKBParser

      def initialize(factory)
        @factory = factory
        @parse_options ={
          1 => method(:parse_point),
          2 => method(:parse_line_string),
          3 => method(:parse_polygon),
          4 => method(:parse_multi_point),
          5 => method(:parse_multi_line_string),
          6 => method(:parse_multi_polygon),
          7 => method(:parse_geometry_collection)
        }
      end

      #Parses the ewkb string passed as argument and notifies the factory of events
      def parse(ewkb)
        @factory.reset
        @unpack_structure=UnpackStructure::new(ewkb)
        @with_z = false
        @with_m = false
        parse_geometry
        @unpack_structure.done
        @srid=nil
      end

      private
      def parse_geometry
        @unpack_structure.endianness=@unpack_structure.read_byte
        @geometry_type = @unpack_structure.read_uint

        if (@geometry_type & Z_MASK) != 0
          @with_z=true
          @geometry_type = @geometry_type & ~Z_MASK
        end
        if (@geometry_type & M_MASK) != 0
          @with_m=true
          @geometry_type = @geometry_type & ~M_MASK
        end
        if (@geometry_type & SRID_MASK) != 0
          @srid = @unpack_structure.read_uint
          @geometry_type = @geometry_type & ~SRID_MASK
        else
          #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
          @srid= @srid || DEFAULT_SRID
        end

        if @parse_options.has_key? @geometry_type
          @parse_options[@geometry_type].call
        else
          raise EWKBFormatError::new("Unknown geometry type")
        end
      end

      def parse_geometry_collection
        parse_multi_geometries(GeometryCollection)
      end

      def parse_multi_polygon
        parse_multi_geometries(MultiPolygon)
      end

      def parse_multi_line_string
        parse_multi_geometries(MultiLineString)
      end

      def parse_multi_point
        parse_multi_geometries(MultiPoint)
      end

      def parse_multi_geometries(geometry_type)
        @factory.begin_geometry(geometry_type,@srid)
        num_geometries = @unpack_structure.read_uint
        1.upto(num_geometries) { parse_geometry }
        @factory.end_geometry(@with_z,@with_m)
      end

      def parse_polygon
        @factory.begin_geometry(Polygon,@srid)
        num_linear_rings = @unpack_structure.read_uint
        1.upto(num_linear_rings) {parse_linear_ring}
        @factory.end_geometry(@with_z,@with_m)
      end

      def parse_linear_ring
        parse_point_list(LinearRing)
      end

      def parse_line_string
        parse_point_list(LineString)
      end

      #used to parse line_strings and linear_rings
      def parse_point_list(geometry_type)
        @factory.begin_geometry(geometry_type,@srid)
        num_points = @unpack_structure.read_uint
        1.upto(num_points) {parse_point}
        @factory.end_geometry(@with_z,@with_m)
      end

      def parse_point
        @factory.begin_geometry(Point,@srid)
        x = @unpack_structure.read_double
        y = @unpack_structure.read_double
        if ! (@with_z or @with_m) #most common case probably
          @factory.add_point_x_y(x,y)
        elsif @with_m and @with_z
          z = @unpack_structure.read_double
          m = @unpack_structure.read_double
          @factory.add_point_x_y_z_m(x,y,z,m)
        elsif @with_z
          z = @unpack_structure.read_double
          @factory.add_point_x_y_z(x,y,z)
        else
          m = @unpack_structure.read_double
          @factory.add_point_x_y_m(x,y,m)
        end

        @factory.end_geometry(@with_z,@with_m)
      end
    end

    #Parses HexEWKB strings. In reality, it just transforms the HexEWKB string into the equivalent EWKB string and lets the EWKBParser do the actual parsing.
    class HexEWKBParser < EWKBParser
      def initialize(factory)
        super(factory)
      end
      #parses an HexEWKB string
      def parse(hexewkb)
        super(decode_hex(hexewkb))
      end
      #transforms a HexEWKB string into an EWKB string
      def decode_hex(hexewkb)
        result=""
        num_bytes = (hexewkb.size + 1) / 2
        0.upto(num_bytes-1) do |i|
          result << hexewkb[i*2,2].hex
        end
        result
      end
    end

    class HexEWKBParser < EWKBParser
     #transforms a HexEWKB string into an EWKB string
     # Patched for speedup

   end

    class UnpackStructure #:nodoc:
      NDR=1
      XDR=0
      def initialize(ewkb)
        @position=0
        @ewkb=ewkb
      end
      def done
        raise EWKBFormatError::new("Trailing data") if @position != @ewkb.length
      end
      def read_double
        i=@position
        @position += 8
        packed_double = @ewkb[i...@position]
        raise EWKBFormatError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
        packed_double.unpack(@double_mark)[0]
      end
      def read_uint
        i=@position
        @position += 4
        packed_uint = @ewkb[i...@position]
        raise EWKBFormatError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
        packed_uint.unpack(@uint_mark)[0]
      end
      def read_byte
        i = @position
        @position += 1
        packed_byte = @ewkb[i...@position]
        raise EWKBFormatError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
        packed_byte.unpack("C")[0]
      end
      def endianness=(byte_order)
        if(byte_order == NDR)
          @uint_mark="V"
          @double_mark="E"
        elsif(byte_order == XDR)
          @uint_mark="N"
          @double_mark="G"
        end
      end
    end
  end
end


text:
import { memo } from 'react'
import { BasicTooltip } from '@nivo/tooltip'
import { ArcTooltipComponentProps } from './types'

export const ChordArcTooltip = memo(({ arc }: ArcTooltipComponentProps) => (
    <BasicTooltip id={arc.label} value={arc.formattedValue} color={arc.color} enableChip={true} />
))