text:
package fr.acinq.eclair.channel.states.b

import akka.actor.Status
import akka.testkit.{TestFSMRef, TestProbe}
import fr.acinq.bitcoin.scalacompat.{Btc, ByteVector32, ByteVector64, SatoshiLong}
import fr.acinq.eclair.TestConstants.{Alice, Bob}
import fr.acinq.eclair.blockchain.DummyOnChainWallet
import fr.acinq.eclair.blockchain.bitcoind.ZmqWatcher._
import fr.acinq.eclair.channel._
import fr.acinq.eclair.channel.fsm.Channel
import fr.acinq.eclair.channel.fsm.Channel.TickChannelOpenTimeout
import fr.acinq.eclair.channel.publish.TxPublisher
import fr.acinq.eclair.channel.states.{ChannelStateTestsBase, ChannelStateTestsTags}
import fr.acinq.eclair.wire.protocol.{AcceptChannel, Error, FundingCreated, FundingSigned, Init, OpenChannel}
import fr.acinq.eclair.{TestConstants, TestKitBaseClass}
import org.scalatest.funsuite.FixtureAnyFunSuiteLike
import org.scalatest.{Outcome, Tag}

import scala.concurrent.duration._

/**
 * Created by PM on 05/07/2016.
 */

class WaitForFundingSignedStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with ChannelStateTestsBase {

  case class FixtureParam(alice: TestFSMRef[ChannelState, ChannelData, Channel], aliceOrigin: TestProbe, alice2bob: TestProbe, bob2alice: TestProbe, alice2blockchain: TestProbe)

  override def withFixture(test: OneArgTest): Outcome = {
    import com.softwaremill.quicklens._
    val aliceNodeParams = Alice.nodeParams
      .modify(_.channelConf.maxFundingSatoshis).setToIf(test.tags.contains(ChannelStateTestsTags.Wumbo))(Btc(100))
    val bobNodeParams = Bob.nodeParams
      .modify(_.channelConf.maxFundingSatoshis).setToIf(test.tags.contains(ChannelStateTestsTags.Wumbo))(Btc(100))

    val (fundingSatoshis, pushMsat) = if (test.tags.contains(ChannelStateTestsTags.Wumbo)) {
      (Btc(5).toSatoshi, TestConstants.initiatorPushAmount)
    } else {
      (TestConstants.fundingSatoshis, TestConstants.initiatorPushAmount)
    }

    val setup = init(aliceNodeParams, bobNodeParams, tags = test.tags)

    import setup._
    val channelConfig = ChannelConfig.standard
    val channelFlags = ChannelFlags.Private
    val (aliceParams, bobParams, channelType) = computeFeatures(setup, test.tags, channelFlags)
    val aliceInit = Init(aliceParams.initFeatures)
    val bobInit = Init(bobParams.initFeatures)
    within(30 seconds) {
      alice ! INPUT_INIT_CHANNEL_INITIATOR(ByteVector32.Zeroes, fundingSatoshis, dualFunded = false, TestConstants.feeratePerKw, TestConstants.feeratePerKw, Some(pushMsat), requireConfirmedInputs = false, aliceParams, alice2bob.ref, bobInit, channelFlags, channelConfig, channelType)
      alice2blockchain.expectMsgType[TxPublisher.SetChannelId]
      bob ! INPUT_INIT_CHANNEL_NON_INITIATOR(ByteVector32.Zeroes, None, dualFunded = false, None, bobParams, bob2alice.ref, aliceInit, channelConfig, channelType)
      bob2blockchain.expectMsgType[TxPublisher.SetChannelId]
      alice2bob.expectMsgType[OpenChannel]
      alice2bob.forward(bob)
      bob2alice.expectMsgType[AcceptChannel]
      bob2alice.forward(alice)
      alice2bob.expectMsgType[FundingCreated]
      alice2bob.forward(bob)
      alice2blockchain.expectMsgType[TxPublisher.SetChannelId]
      awaitCond(alice.stateName == WAIT_FOR_FUNDING_SIGNED)
      withFixture(test.toNoArgTest(FixtureParam(alice, aliceOrigin, alice2bob, bob2alice, alice2blockchain)))
    }
  }

  test("recv FundingSigned with valid signature") { f =>
    import f._
    val listener = TestProbe()
    alice.underlying.system.eventStream.subscribe(listener.ref, classOf[TransactionPublished])
    bob2alice.expectMsgType[FundingSigned]
    bob2alice.forward(alice)
    awaitCond(alice.stateName == WAIT_FOR_FUNDING_CONFIRMED)
    val fundingTxId = alice2blockchain.expectMsgType[WatchFundingSpent].txId
    val txPublished = listener.expectMsgType[TransactionPublished]
    assert(txPublished.tx.txid == fundingTxId)
    assert(txPublished.miningFee > 0.sat)
    val watchConfirmed = alice2blockchain.expectMsgType[WatchFundingConfirmed]
    assert(watchConfirmed.minDepth == 1) // when funder we trust ourselves so we never wait more than 1 block
    aliceOrigin.expectMsgType[ChannelOpenResponse.ChannelOpened]
  }

  test("recv FundingSigned with valid signature (zero-conf)", Tag(ChannelStateTestsTags.AnchorOutputsZeroFeeHtlcTxs), Tag(ChannelStateTestsTags.ZeroConf)) { f =>
    import f._
    bob2alice.expectMsgType[FundingSigned]
    bob2alice.forward(alice)
    awaitCond(alice.stateName == WAIT_FOR_CHANNEL_READY)
    // alice doesn't watch for the funding tx to confirm
    alice2blockchain.expectMsgType[WatchFundingSpent]
    alice2blockchain.expectMsgType[WatchFundingLost]
    alice2blockchain.expectNoMessage(100 millis)
    aliceOrigin.expectMsgType[ChannelOpenResponse.ChannelOpened]
  }

  test("recv FundingSigned with valid signature (wumbo)", Tag(ChannelStateTestsTags.Wumbo)) { f =>
    import f._
    bob2alice.expectMsgType[FundingSigned]
    bob2alice.forward(alice)
    awaitCond(alice.stateName == WAIT_FOR_FUNDING_CONFIRMED)
    alice2blockchain.expectMsgType[WatchFundingSpent]
    val watchConfirmed = alice2blockchain.expectMsgType[WatchFundingConfirmed]
    assert(watchConfirmed.minDepth == 1) // when funder we trust ourselves so we never wait more than 1 block
    aliceOrigin.expectMsgType[ChannelOpenResponse.ChannelOpened]
  }

  test("recv FundingSigned with invalid signature") { f =>
    import f._
    // sending an invalid sig
    alice ! FundingSigned(ByteVector32.Zeroes, ByteVector64.Zeroes)
    awaitCond(alice.stateName == CLOSED)
    alice2bob.expectMsgType[Error]
    aliceOrigin.expectMsgType[Status.Failure]
  }

  test("recv CMD_CLOSE") { f =>
    import f._
    val sender = TestProbe()
    val c = CMD_CLOSE(sender.ref, None, None)
    alice ! c
    sender.expectMsg(RES_SUCCESS(c, alice.stateData.asInstanceOf[DATA_WAIT_FOR_FUNDING_SIGNED].channelId))
    awaitCond(alice.stateName == CLOSED)
    aliceOrigin.expectMsgType[ChannelOpenResponse.ChannelClosed]
  }

  test("recv CMD_FORCECLOSE") { f =>
    import f._
    val sender = TestProbe()
    alice ! CMD_FORCECLOSE(sender.ref)
    awaitCond(alice.stateName == CLOSED)
    aliceOrigin.expectMsgType[ChannelOpenResponse.ChannelClosed]
  }

  test("recv INPUT_DISCONNECTED") { f =>
    import f._
    val fundingTx = alice.stateData.asInstanceOf[DATA_WAIT_FOR_FUNDING_SIGNED].fundingTx
    assert(alice.underlyingActor.wallet.asInstanceOf[DummyOnChainWallet].rolledback.isEmpty)
    alice ! INPUT_DISCONNECTED
    awaitCond(alice.stateName == CLOSED)
    assert(alice.underlyingActor.wallet.asInstanceOf[DummyOnChainWallet].rolledback.contains(fundingTx))
    aliceOrigin.expectMsgType[Status.Failure]
  }

  test("recv TickChannelOpenTimeout") { f =>
    import f._
    alice ! TickChannelOpenTimeout
    awaitCond(alice.stateName == CLOSED)
    aliceOrigin.expectMsgType[Status.Failure]
  }

}


text:
<?php include (TEMPLATEPATH . '/library/navigation-sidebar.php'); ?>

<div class="generalwrapping">

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Sluggable\Fixture\Inheritance;

use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;

/**
 * @ORM\Entity
 * @ORM\InheritanceType("SINGLE_TABLE")
 * @ORM\DiscriminatorColumn(name="discriminator", type="string")
 * @ORM\DiscriminatorMap({
 *      "vehicle" = "Vehicle",
 *      "car" = "Car"
 * })
 */
class Vehicle
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @Gedmo\Sluggable
     * @ORM\Column(length=128)
     */
    private $title;

    /**
     * @Gedmo\Slug
     * @ORM\Column(length=128, unique=true)
     */
    private $slug;

    public function getId()
    {
        return $this->id;
    }

    public function setTitle($title)
    {
        $this->title = $title;
    }

    public function getTitle()
    {
        return $this->title;
    }

    public function getSlug()
    {
        return $this->slug;
    }
}


text:
/**
 * @file
 *
 * This file wraps the generated autoconf header to provide define
 * blocks to prevent issue when included more than once.
 *
 * @warning Only include this in source files.
 *
 * @author Brian Rectanus <brectanus@qualys.com>
 */

#ifndef _HTP_CONFIG_AUTO_H
#define _HTP_CONFIG_AUTO_H

#ifdef HAVE_CONFIG_H
#include "htp_config_auto_gen.h"
#endif

#endif /* _HTP_CONFIG_AUTO_H */


text:
package awqatty.b.CustomEventListeners;

abstract public class SwitchedEventListenerBase {

	protected boolean state;

	static public class ListenerSwitch {
		private SwitchedEventListenerBase listener;
		public ListenerSwitch(SwitchedEventListenerBase l) {
			listener = l;
		}
		public void enableListener() {listener.state = true;}
		public void disableListener() {listener.state = false;}
	}

	public SwitchedEventListenerBase() {
		state = true;
	}

	public ListenerSwitch getSwitch() {
		return new ListenerSwitch(this);
	}
}


text:
import React, { Component, PropTypes } from 'react'
import connectToStore from '../HOC/connectToStore'
import { Link } from 'react-router'
import { loadArticleById, deleteArticle } from '../AC/articles'
import { loadArticleComments } from '../AC/comments'
import Article from '../components/Article'

class ArticleContainer extends Component {
    static propTypes = {
        id: PropTypes.string.isRequired,
        article: PropTypes.object,
        comments: PropTypes.array
    };

    render() {
        const { article } = this.props
        const { comments } = this.props
        if (!article || article.loading) return
Loading...

        return

    }
}

function getState(stores, props) {
    const { id } = props
    const article = stores.articles.getById(id)
    const comments = stores.comments.getByArticleId(id)

    if (!article || !article.text && !article.loading) loadArticleById({ id })

    return { article, comments }
}

export default connectToStore(['articles','comments'], getState)(ArticleContainer)


text:
from distutils.core import setup
setup(name='yamli',version='0.2',py_modules=['yamli'],
author='val314159',author_email='jmward@gmail.com',
install_requires='pyaml',url='https://github.com/val314159/yamli')


text:
namespace doris {
namespace segment_v2 {

// when page is read into memory, we use this to store it
// This class should delete memory
class PageHandle {
public:
    static PageHandle create_from_slice(const Slice& slice) {
        return PageHandle(slice);
    }

    PageHandle() : _data((const uint8_t*)nullptr, 0) { }

    // Move constructor
    PageHandle(PageHandle&& other) noexcept : _data(other._data) {
        other._data = Slice();
    }

    PageHandle& operator=(PageHandle&& other) noexcept {
        std::swap(_data, other._data);
        return *this;
    }

    ~PageHandle() {
        delete[] _data.data;
        _data = Slice();
    }

    Slice data() const {
        return _data;
    }

private:
    PageHandle(const Slice& data) : _data(data) {
    }

    Slice _data;

    // cause we
    DISALLOW_COPY_AND_ASSIGN(PageHandle);
};

}
}


text:
import { expect } from 'chai';
import * as actions from '../../src/bookmark/bookmark-list-actions';
import { selectedTag } from '../../src/app/reducers';

describe('reducer', () => {
  describe('selectedTag', () => {
    it('should reduce to the selected tag with uninitialized state', () => {
      const tag = 'foobar';
      const state = undefined;
      const newState = selectedTag(state, actions.selectTag(tag));
      expect(newState).to.equal(tag);
    });

    it('should reduce to the selected tag with initialized state', () => {
      const tag = 'foobar';
      const state = 'baz';
      const newState = selectedTag(state, actions.selectTag(tag));
      expect(newState).to.equal(tag);
    });

    it('should return the original state for unrecognized actions', () => {
      const tag = 'foobar';
      const state = 'buz';
      const newState = selectedTag(state, actions.invalidateTag(tag));
      expect(newState).to.equal(state);
    });
  });
});


text:
using System;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Discord;
using XenoBot2.Data;
using XenoBot2.Shared;
using static XenoBot2.Utilities;

namespace XenoBot2.Commands
{
	/// <summary>
	///		Core bot commands. This group cannot be disabled.
	/// </summary>
	internal static class Base
	{
		internal static async Task Help(CommandInfo info, Message msg)
		{
			Func<string, Task> send = async s =>
			{
				if (msg.User.PrivateChannel == null)
					await msg.User.CreatePMChannel();
				await msg.User.PrivateChannel.SendMessage(s);
				Thread.Sleep(100);
			};
			if (!msg.Channel.IsPrivate)
				await msg.Channel.SendMessage($"{msg.User.NicknameMention}: Sending you a PM!");

			if (!info.HasArguments)
			{
				WriteLog(msg.User, "requested help index.");

				await send(Messages.HelpTextHeader);
				// show list of commands + shorthelp

				var iter = 0;

				var helpLines = from item in Program.BotInstance.Commands
								where item.Value != null
								let channelPermitted = Permitted(item.Value.Permission, msg.User, msg.Channel)
								let globalPermitted = Permitted(item.Value.Permission, msg.User)
								where !item.Value.Flags.HasFlag(CommandFlag.Hidden) && channelPermitted
								let num = iter++
								group GenerateHelpEntry(item.Value, item.Key, channelPermitted, globalPermitted) by num / 10 into items
								select items;

				var builder = new StringBuilder();

				foreach (var i in helpLines)
				{
					builder.Clear();
					i.Aggregate(builder, (b, s) => b.AppendLine(s));
					await send(builder.ToString());
				}

			}
			else
			{
				if (!Program.BotInstance.Commands.Contains(info.Arguments[0])) return;
				var cmd = Program.BotInstance.Commands[info.Arguments[0]].ResolveCommand();

				WriteLog(msg.User, $"requested help page '{info.Arguments[0]}'");
				var builder = new StringBuilder();
				builder.AppendLine("```");
				builder.AppendLine($"Help - {info.Arguments[0]}");
				builder.AppendLine("---");
				builder.AppendLine($"Category: {cmd.HelpCategory}");
				builder.AppendLine($"Authorization: {cmd.Permission}");
				builder.AppendLine(GeneratePermissionLine(cmd, msg.User, msg.Channel));
				builder.Append("Arguments: ");
				builder.AppendLine(string.IsNullOrWhiteSpace(cmd.Arguments) ? "{none}" : cmd.Arguments);
				if (!string.IsNullOrWhiteSpace(cmd.HelpText))
				{
					builder.AppendLine("Short Description:");
					builder.AppendLine($"\t{cmd.HelpText}");
				}
				if (!string.IsNullOrWhiteSpace(cmd.LongHelpText))
				{
					builder.AppendLine("\nDescription: ");
					builder.AppendLine("\t" + cmd.LongHelpText.Replace("\n", "\n\t").TrimEnd());
				}
					builder.AppendLine("```");
				await send(builder.ToString());

			}
		}

		private static string GeneratePermissionLine(Command cmd, User user, Channel channel)
		{
			var globalPermitted = Permitted(cmd.Permission, user);
			var channelPermitted = Permitted(cmd.Permission, user, channel);

			if (globalPermitted) return "You are globally permitted to use this command.";
			return channelPermitted ? $"You are permitted to use this command in channel '{channel.Name}'." : "You are not permitted to use this command.";
		}

		private static string GenerateHelpEntry(Command cmd, string cmdname, bool channelPermitted = false, bool globalPermitted = false)
		{
			var builder = new StringBuilder();

			var helptext = cmd.HelpText;
			if (cmd.AliasFor != null)
				helptext = cmd.ResolveCommand().HelpText;

			builder.Append($"{cmdname} - {cmd.HelpCategory}");

			if (cmd.AliasFor != null)
				builder.AppendLine($"(Alias For {cmd.AliasFor})");
			else
				builder.AppendLine();

			builder.AppendLine($"Required Permissions: {cmd.Permission}");

			if (string.IsNullOrWhiteSpace(helptext)) return builder.ToString();
			builder.Append(" -> ");
			builder.AppendLine(helptext);

			return builder.ToString();
		}

		internal static async Task Version(CommandInfo info, Message msg)
		{
			WriteLog(msg.User, "requested bot version.");
			await msg.Channel.SendMessage($"`XenoBot2 v{GetVersion()} {Program.BuildType}`");
		}
	}
}


text:
import { GPGPUProgram } from './gpgpu_math';
export declare class UnpackProgram implements GPGPUProgram {
    variableNames: string[];
    packedInputs: boolean;
    packedOutput: boolean;
    outputShape: number[];
    userCode: string;
    constructor(outputShape: number[]);
}


text:
package com.google.template.autoesc;

enum LogDetailLevel {
  NONE,
  HIGH_LEVEL,
  MODERATE,
  DETAILED,
  ALL,
  ;

  /** {@code logLevel.meetsThreshhold(threshold)}. */
  boolean shouldLogEventAtLevel(LogDetailLevel eventLevel) {
    return this.compareTo(eventLevel) >= 0;
  }
}


text:
{{ event.name.text | appCleanDates }}

 {{event.start.local | amDateFormat:'ddd, MMM D'}}

            Learn more

      No matches for "{{search}}"

  <app-pagination (pageChange)="config.currentPage = $event" [config]="config"></app-pagination>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http;
using Newtonsoft.Json.Serialization;

namespace http_users_endpoint
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "Home",
                routeTemplate: "",
                defaults: new { controller = "Home" }
            );

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }
}


text: package org.scalafmt.config


text:
import {
  RelayNetworkLayer,
  urlMiddleware
} from 'react-relay-network-modern/node8'
import RelaySSR from 'react-relay-network-modern-ssr/node8/server'
import { Network, Environment, RecordSource, Store } from 'relay-runtime'

export default {
  initEnvironment: () => {
    const source = new RecordSource()
    const store = new Store(source)
    const relaySSR = new RelaySSR()

    return {
      relaySSR,
      environment: new Environment({
        store,
        network: new RelayNetworkLayer([
          urlMiddleware({
            url: req => process.env.RELAY_ENDPOINT
          }),
          relaySSR.getMiddleware()
        ])
      })
    }
  },
  createEnvironment: (relayData, key) => {
    const source = new RecordSource()
    const store = new Store(source)

    return new Environment({
      store,
      network: Network.create(
        () => relayData.find(([dataKey]) => dataKey === key)[1]
      )
    })
  }
}


text:
typedef enum
{
    //! @brief Error event
    TWR_TAG_VOC_LP_EVENT_ERROR = TWR_SGPC3_EVENT_ERROR,

    //! @brief Update event
    TWR_TAG_VOC_LP_EVENT_UPDATE = TWR_SGPC3_EVENT_UPDATE

} twr_tag_voc_lp_event_t;

//! @brief HARDWARIO VOC-LP Module instance

typedef twr_sgpc3_t twr_tag_voc_lp_t;

//! @brief Initialize HARDWARIO VOC-LP Module
//! @param[in] self Instance
//! @param[in] i2c_channel I2C channel

void twr_tag_voc_lp_init(twr_tag_voc_lp_t *self, twr_i2c_channel_t i2c_channel);

//! @brief Set callback function
//! @param[in] self Instance
//! @param[in] event_handler Function address
//! @param[in] event_param Optional event parameter (can be NULL)

void twr_tag_voc_lp_set_event_handler(twr_tag_voc_lp_t *self, void (*event_handler)(twr_tag_voc_lp_t *, twr_tag_voc_lp_event_t, void *), void *event_param);

//! @brief Set measurement interval
//! @param[in] self Instance
//! @param[in] interval Measurement interval

void twr_tag_voc_lp_set_update_interval(twr_tag_voc_lp_t *self, twr_tick_t interval);

//! @brief Start measurement manually
//! @param[in] self Instance
//! @return true On success
//! @return false When other measurement is in progress

bool twr_tag_voc_lp_measure(twr_tag_voc_lp_t *self);

//! @brief Get measured TVOC in ppb (parts per billion)
//! @param[in] self Instance
//! @param[out] ppb Pointer to variable where result will be stored
//! @return true When value is valid
//! @return false When value is invalid

bool twr_tag_voc_lp_get_tvoc_ppb(twr_tag_voc_lp_t *self, uint16_t *ppb);

//! @brief Set sensor compensation (absolute humidity is calculated from temperature and relative humidity)
//! @param[in] self Instance
//! @param[in] t_celsius Pointer to variable holding temperature in degrees of celsius (must be NULL if not available)
//! @param[in] rh_percentage Pointer to variable holding relative humidity in percentage (must be NULL if not available)
//! @return Absolute humidity in grams per cubic meter

float twr_tag_voc_lp_set_compensation(twr_tag_voc_lp_t *self, float *t_celsius, float *rh_percentage);

//! @}

#endif // _TWR_TAG_VOC_LP_H


text:
module Mongoid #:nodoc:
  module Extensions #:nodoc:
    module Date #:nodoc:
      module Conversions #:nodoc:
        def get(value)
          return nil if value.blank?
          if Mongoid::Config.instance.use_utc?
            value.to_date
          else
            ::Date.new(value.year, value.month, value.day)
          end
        end

        protected

        def convert_to_time(value)
          value = ::Date.parse(value) if value.is_a?(::String)
          ::Time.utc(value.year, value.month, value.day)
        end
      end
    end
  end
end


text:
import { arrayContentsMatch } from 'utils/array';
import { getKeypath } from 'shared/keypaths';
import { isEqual } from 'utils/is';

export default function Ractive$updateModel ( keypath, cascade ) {
	var values, key, bindings;

	if ( typeof keypath === 'string' && !cascade ) {
		bindings = this._twowayBindings[ keypath ];
	} else {
		bindings = [];

		for ( key in this._twowayBindings ) {
			if ( !keypath || getKeypath( key ).equalsOrStartsWith( keypath ) ) { // TODO is this right?
				bindings.push.apply( bindings, this._twowayBindings[ key ]);
			}
		}
	}

	values = consolidate( this, bindings );
	return this.set( values );
}

function consolidate ( ractive, bindings ) {
	var values = {}, checkboxGroups = [];

	bindings.forEach( b => {
		var oldValue, newValue;

		// special case - radio name bindings
		if ( b.radioName && !b.element.node.checked ) {
			return;
		}

		// special case - checkbox name bindings come in groups, so
		// we want to get the value once at most
		if ( b.checkboxName ) {
			if ( !checkboxGroups[ b.keypath.str ] && !b.changed() ) {
				checkboxGroups.push( b.keypath );
				checkboxGroups[ b.keypath.str ] = b;
			}

			return;
		}

		oldValue = b.attribute.value;
		newValue = b.getValue();

		if ( arrayContentsMatch( oldValue, newValue ) ) {
			return;
		}

		if ( !isEqual( oldValue, newValue ) ) {
			values[ b.keypath.str ] = newValue;
		}
	});

	// Handle groups of `<input type='checkbox' name='{{foo}}' ...>`
	if ( checkboxGroups.length ) {
		checkboxGroups.forEach( keypath => {
			var binding, oldValue, newValue;

			binding = checkboxGroups[ keypath.str ]; // one to represent the entire group
			oldValue = binding.attribute.value;
			newValue = binding.getValue();

			if ( !arrayContentsMatch( oldValue, newValue ) ) {
				values[ keypath.str ] = newValue;
			}
		});
	}

	return values;
}


text:
All URIs are relative to *https://video.twilio.com*

Method | HTTP request | Description
------------- | ------------- | -------------
[**FetchRoomParticipantPublishedTrack**](RoomsParticipantsPublishedTracksApi.md#FetchRoomParticipantPublishedTrack) | **Get** /v1/Rooms/{RoomSid}/Participants/{ParticipantSid}/PublishedTracks/{Sid} |
[**ListRoomParticipantPublishedTrack**](RoomsParticipantsPublishedTracksApi.md#ListRoomParticipantPublishedTrack) | **Get** /v1/Rooms/{RoomSid}/Participants/{ParticipantSid}/PublishedTracks |

## FetchRoomParticipantPublishedTrack

> VideoV1RoomParticipantPublishedTrack FetchRoomParticipantPublishedTrack(ctx, RoomSidParticipantSidSid)

Returns a single Track resource represented by TrackName or SID.

### Path Parameters

Name | Type | Description
------------- | ------------- | -------------
**ctx** | **context.Context** | context for authentication, logging, cancellation, deadlines, tracing, etc.
**RoomSid** | **string** | The SID of the Room resource where the Track resource to fetch is published.
**ParticipantSid** | **string** | The SID of the Participant resource with the published track to fetch.
**Sid** | **string** | The SID of the RoomParticipantPublishedTrack resource to fetch.

### Other Parameters

Other parameters are passed through a pointer to a FetchRoomParticipantPublishedTrackParams struct

Name | Type | Description
------------- | ------------- | -------------

### Return type

[**VideoV1RoomParticipantPublishedTrack**](VideoV1RoomParticipantPublishedTrack.md)

### Authorization

[accountSid_authToken](../README.md#accountSid_authToken)

### HTTP request headers

- **Content-Type**: Not defined
- **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
[[Back to Model list]](../README.md#documentation-for-models)
[[Back to README]](../README.md)

## ListRoomParticipantPublishedTrack

> []VideoV1RoomParticipantPublishedTrack ListRoomParticipantPublishedTrack(ctx, RoomSidParticipantSidoptional)

Returns a list of tracks associated with a given Participant. Only `currently` Published Tracks are in the list resource.

### Path Parameters

Name | Type | Description
------------- | ------------- | -------------
**ctx** | **context.Context** | context for authentication, logging, cancellation, deadlines, tracing, etc.
**RoomSid** | **string** | The SID of the Room resource where the Track resources to read are published.
**ParticipantSid** | **string** | The SID of the Participant resource with the published tracks to read.

### Other Parameters

Other parameters are passed through a pointer to a ListRoomParticipantPublishedTrackParams struct

Name | Type | Description
------------- | ------------- | -------------
**PageSize** | **int** | How many resources to return in each list page. The default is 50, and the maximum is 1000.
**Limit** | **int** | Max number of records to return.

### Return type

[**[]VideoV1RoomParticipantPublishedTrack**](VideoV1RoomParticipantPublishedTrack.md)

### Authorization

[accountSid_authToken](../README.md#accountSid_authToken)

### HTTP request headers

- **Content-Type**: Not defined
- **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints)
[[Back to Model list]](../README.md#documentation-for-models)
[[Back to README]](../README.md)


text:
package io.quarkus.it.rest.client.wronghost;

import javax.ws.rs.GET;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import org.eclipse.microprofile.faulttolerance.Retry;
import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

@RegisterRestClient(baseUri = "https://wrong.host.badssl.com/", configKey = "wrong-host")
public interface WrongHostClient {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Retry(delay = 1000)
    Response invoke();
}


text:
package org.apache.sis.filter;

import com.esri.core.geometry.Geometry;
import org.junit.Ignore;
import org.junit.Test;

/**
 * Tests {@link BinarySpatialFilter} implementations using ESRI library.
 *
 * @author  Johann Sorel (Geomatys)
 * @author  Martin Desruisseaux (Geomatys)
 * @version 1.3
 * @since   1.1
 * @module
 */
public final strictfp class BinarySpatialFilterUsingESRI_Test extends BinarySpatialFilterTestCase<Geometry> {
    /**
     * Creates a new test.
     */
    public BinarySpatialFilterUsingESRI_Test() {
        super(Geometry.class);
    }

    /**
     * Test ignored for now (not yet mapped to an ESRI operation).
     */
    @Test
    @Override
    @Ignore("Not yet mapped to an ESRI operation.")
    public void testDWithin() {
    }

    /**
     * Test ignored for now (not yet mapped to an ESRI operation).
     */
    @Test
    @Override
    @Ignore("Not yet mapped to an ESRI operation.")
    public void testBeyond() {
    }

    /**
     * Test ignored for now (not yet mapped to an ESRI operation).
     */
    @Test
    @Override
    @Ignore("Not yet mapped to an ESRI operation.")
    public void testWithReprojection() {
    }

    /**
     * Test ignored for now (not yet mapped to an ESRI operation).
     */
    @Test
    @Override
    @Ignore("Requires geometry reprojection.")
    public void testSpatialContextDoesNotDegenerateEnvelope() {
    }
}


text:
package org.elasticsearch.xpack.eql.execution.payload;

import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.DocValueFormat;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchSortValues;
import org.elasticsearch.xpack.eql.session.Results.Type;

import java.util.Arrays;
import java.util.List;

public class SearchResponsePayload extends AbstractPayload {

    private final List<SearchHit> hits;

    public SearchResponsePayload(SearchResponse response) {
        super(response.isTimedOut(), response.getTook());
        hits = Arrays.asList(response.getHits().getHits());
        // clean hits
        SearchSortValues sortValues = new SearchSortValues(new Object[0], new DocValueFormat[0]);
        for (SearchHit hit : hits) {
            hit.sortValues(sortValues);
        }
    }

    @Override
    public Type resultType() {
        return Type.SEARCH_HIT;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <V> List<V> values() {
        return (List<V>) hits;
    }
}


text:
ACCEPTED

#### According to
World Register of Marine Species

#### Published in
Harwati, T. U. , Kasai, Y. , Kodama, Y. , Susilaningsih, D. , and Watanabe, K. 2009. Tropicibacter naphthalenivorans gen. nov. , sp. nov. , a polycyclic aromatic hydrocarbon-degrading bacterium isolated from Semarang Port in Indonesia. Int. J. Syst. Evol. Microbiol. 59:392-396.

#### Original name
null

### Remarks
null


text:
cask 'yourkit-java-profiler' do
  version '2019.8-b123'
  sha256 'd49b62ffde035c3d7a6eba517bf71ed2fe9256ff09951185628d3b707e3c4e1d'

  url "https://www.yourkit.com/download/YourKit-JavaProfiler-#{version}.dmg"
  appcast 'https://www.yourkit.com/download/'
  name 'YourKit Java Profiler'
  homepage 'https://www.yourkit.com/features/'

  auto_updates true

  app "YourKit-Java-Profiler-#{version.major_minor}.app"
end


text:
package com.example.reference;

import arez.annotations.ArezComponent;
import arez.annotations.LinkType;
import arez.annotations.Reference;
import arez.annotations.ReferenceId;
import javax.annotation.Nullable;

@ArezComponent
abstract class NullableLazyLoadReferenceModel
{
  @Reference( load = LinkType.LAZY )
  abstract MyEntity getMyEntity();

  @ReferenceId
  @Nullable
  Integer getMyEntityId()
  {
    return 0;
  }

  static class MyEntity
  {
  }
}


text:
from django.contrib.auth import get_user_model
from django.core.urlresolvers import reverse
from django.test import TestCase, Client
from mixer.backend.django import mixer
from organisation.models import DepartmentUser
from .models import Approval

User = get_user_model()

class ApprovalViewsTestCase(TestCase):
    client = Client()

    def setUp(self):
        # Create User and linked DepartmentUser objects.
        self.du1 = mixer.blend(DepartmentUser, username=mixer.RANDOM, photo=None)
        self.user1 = User.objects.create_user(
            username=self.du1.username, email=self.du1.email)
        self.user1.set_password('pass')
        self.user1.save()
        # Log in user1 by default.
        self.client.login(username=self.user1.username, password='pass')
        self.du2 = mixer.blend(DepartmentUser, username=mixer.RANDOM, photo=None)
        self.user2 = User.objects.create_user(
            username=self.du2.username, email=self.du2.email)
        self.user2.set_password('pass')
        self.user2.save()

    def test_approval_create_get(self):
        """Test the approval_create GET response
        """
        url = reverse('approval_create')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_approval_create_post(self):
        """Test the approval_create POST response
        """
        url = reverse('approval_create')
        self.assertEqual(Approval.objects.count(), 0)
        response = self.client.post(url, {
            'approver': self.du2.pk,
            'proposal_desc': 'Test approval request',
        })
        self.assertEqual(response.status_code, 302)
        self.assertEqual(Approval.objects.count(), 1)

    def test_approval_detail(self):
        """Test the approval_detail view
        """
        app = mixer.blend(Approval, approver=self.du2)
        url = reverse('approval_detail', kwargs={'pk': app.pk})
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_approval_confirm(self):
        """Test the approval_confirm view
        """
        app = mixer.blend(Approval, approver=self.du2)
        self.assertFalse(app.confirmed_date)
        # Log in user2.
        self.client.logout()
        self.client.login(username=self.user2.username, password='pass')
        url = reverse('approval_confirm', kwargs={'guid': app.guid})
        response = self.client.get(url)
        self.assertEqual(response.status_code, 302)
        app = Approval.objects.get(pk=app.pk)  # Refresh from db.
        self.assertTrue(app.confirmed_date)


text:
from typing import TYPE_CHECKING

from msrest import Serializer

from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import HttpResponse
from azure.core.polling import LROPoller, NoPolling, PollingMethod
from azure.core.rest import HttpRequest
from azure.core.tracing.decorator import distributed_trace
from azure.mgmt.core.exceptions import ARMErrorFormat
from azure.mgmt.core.polling.arm_polling import ARMPolling

from .. import models as _models
from .._vendor import _convert_request, _format_url_section

if TYPE_CHECKING:
    # pylint: disable=unused-import,ungrouped-imports
    from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, Union
    T = TypeVar('T')
    ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]

_SERIALIZER = Serializer()
_SERIALIZER.client_side_validation = False
# fmt: off

def build_get_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_name,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments/{experimentName}")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentName": _SERIALIZER.url("experiment_name", experiment_name, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="GET",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

def build_create_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_name,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments/{experimentName}")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentName": _SERIALIZER.url("experiment_name", experiment_name, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="POST",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

def build_get_by_id_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_id,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentId": _SERIALIZER.url("experiment_id", experiment_id, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="GET",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

def build_update_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_id,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    content_type = kwargs.pop('content_type', None)  # type: Optional[str]

    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentId": _SERIALIZER.url("experiment_id", experiment_id, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    if content_type is not None:
        _header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="PATCH",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

def build_delete_request_initial(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_id,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentId": _SERIALIZER.url("experiment_id", experiment_id, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="DELETE",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

def build_get_by_query_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    content_type = kwargs.pop('content_type', None)  # type: Optional[str]
    url_safe_experiment_names_only = kwargs.pop('url_safe_experiment_names_only', True)  # type: Optional[bool]

    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments:query")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct parameters
    _query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
    if url_safe_experiment_names_only is not None:
        _query_parameters['urlSafeExperimentNamesOnly'] = _SERIALIZER.query("url_safe_experiment_names_only", url_safe_experiment_names_only, 'bool')

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    if content_type is not None:
        _header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="POST",
        url=_url,
        params=_query_parameters,
        headers=_header_parameters,
        **kwargs
    )

def build_delete_tags_request(
    subscription_id,  # type: str
    resource_group_name,  # type: str
    workspace_name,  # type: str
    experiment_id,  # type: str
    **kwargs  # type: Any
):
    # type: (...) -> HttpRequest
    content_type = kwargs.pop('content_type', None)  # type: Optional[str]

    accept = "application/json"
    # Construct URL
    _url = kwargs.pop("template_url", "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}/tags:delete")  # pylint: disable=line-too-long
    path_format_arguments = {
        "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
        "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
        "workspaceName": _SERIALIZER.url("workspace_name", workspace_name, 'str'),
        "experimentId": _SERIALIZER.url("experiment_id", experiment_id, 'str'),
    }

    _url = _format_url_section(_url, **path_format_arguments)

    # Construct headers
    _header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
    if content_type is not None:
        _header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
    _header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')

    return HttpRequest(
        method="POST",
        url=_url,
        headers=_header_parameters,
        **kwargs
    )

# fmt: on
class ExperimentsOperations(object):
    """ExperimentsOperations operations.

    You should not instantiate this class directly. Instead, you should create a Client instance that
    instantiates it for you and attaches it as an attribute.

    :ivar models: Alias to model classes used in this operation group.
    :type models: ~azure.mgmt.machinelearningservices.models
    :param client: Client for service requests.
    :param config: Configuration of service client.
    :param serializer: An object model serializer.
    :param deserializer: An object model deserializer.
    """

    models = _models

    def __init__(self, client, config, serializer, deserializer):
        self._client = client
        self._serialize = serializer
        self._deserialize = deserializer
        self._config = config

    @distributed_trace
    def get(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_name,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> "_models.Experiment"
        """Get details of an Experiment.

        Get details of an Experiment with specific Experiment name.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_name: The experiment name.
        :type experiment_name: str
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: Experiment, or the result of cls(response)
        :rtype: ~azure.mgmt.machinelearningservices.models.Experiment
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        cls = kwargs.pop('cls', None)  # type: ClsType["_models.Experiment"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        request = build_get_request(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_name=experiment_name,
            template_url=self.get.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

        deserialized = self._deserialize('Experiment', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    get.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments/{experimentName}"}  # type: ignore

    @distributed_trace
    def create(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_name,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> "_models.Experiment"
        """Create an Experiment.

        Create a new Experiment.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_name: The experiment name.
        :type experiment_name: str
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: Experiment, or the result of cls(response)
        :rtype: ~azure.mgmt.machinelearningservices.models.Experiment
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        cls = kwargs.pop('cls', None)  # type: ClsType["_models.Experiment"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        request = build_create_request(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_name=experiment_name,
            template_url=self.create.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

        deserialized = self._deserialize('Experiment', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    create.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments/{experimentName}"}  # type: ignore

    @distributed_trace
    def get_by_id(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_id,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> "_models.Experiment"
        """Get details of an Experiment.

        Get details of an Experiment with specific Experiment Id.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_id: The identifier of the experiment.
        :type experiment_id: str
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: Experiment, or the result of cls(response)
        :rtype: ~azure.mgmt.machinelearningservices.models.Experiment
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        cls = kwargs.pop('cls', None)  # type: ClsType["_models.Experiment"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        request = build_get_by_id_request(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_id=experiment_id,
            template_url=self.get_by_id.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

        deserialized = self._deserialize('Experiment', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    get_by_id.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}"}  # type: ignore

    @distributed_trace
    def update(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_id,  # type: str
        body=None,  # type: Optional["_models.ModifyExperiment"]
        **kwargs  # type: Any
    ):
        # type: (...) -> "_models.Experiment"
        """Update details of an Experiment.

        Update details of an Experiment with specific Experiment Id.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_id: The identifier of the experiment.
        :type experiment_id: str
        :param body: Experiment details which needs to be updated.
        :type body: ~azure.mgmt.machinelearningservices.models.ModifyExperiment
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: Experiment, or the result of cls(response)
        :rtype: ~azure.mgmt.machinelearningservices.models.Experiment
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        cls = kwargs.pop('cls', None)  # type: ClsType["_models.Experiment"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]

        if body is not None:
            _json = self._serialize.body(body, 'ModifyExperiment')
        else:
            _json = None

        request = build_update_request(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_id=experiment_id,
            content_type=content_type,
            json=_json,
            template_url=self.update.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

        deserialized = self._deserialize('Experiment', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    update.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}"}  # type: ignore

    def _delete_initial(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_id,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> Any
        cls = kwargs.pop('cls', None)  # type: ClsType[Any]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        request = build_delete_request_initial(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_id=experiment_id,
            template_url=self._delete_initial.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            raise HttpResponseError(response=response, error_format=ARMErrorFormat)

        deserialized = self._deserialize('object', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    _delete_initial.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}"}  # type: ignore

    @distributed_trace
    def begin_delete(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_id,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> LROPoller[Any]
        """Delete an Experiment.

        Delete an existing Empty Experiment.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_id: The identifier of the experiment.
        :type experiment_id: str
        :keyword callable cls: A custom type or function that will be passed the direct response
        :keyword str continuation_token: A continuation token to restart a poller from a saved state.
        :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this
         operation to not poll, or pass in your own initialized polling object for a personal polling
         strategy.
        :paramtype polling: bool or ~azure.core.polling.PollingMethod
        :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
         Retry-After header is present.
        :return: An instance of LROPoller that returns either any or the result of cls(response)
        :rtype: ~azure.core.polling.LROPoller[any]
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
        cls = kwargs.pop('cls', None)  # type: ClsType[Any]
        lro_delay = kwargs.pop(
            'polling_interval',
            self._config.polling_interval
        )
        cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
        if cont_token is None:
            raw_result = self._delete_initial(
                subscription_id=subscription_id,
                resource_group_name=resource_group_name,
                workspace_name=workspace_name,
                experiment_id=experiment_id,
                cls=lambda x,y,z: x,
                **kwargs
            )
        kwargs.pop('error_map', None)

        def get_long_running_output(pipeline_response):
            response = pipeline_response.http_response
            deserialized = self._deserialize('object', pipeline_response)
            if cls:
                return cls(pipeline_response, deserialized, {})
            return deserialized

        if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
        elif polling is False: polling_method = NoPolling()
        else: polling_method = polling
        if cont_token:
            return LROPoller.from_continuation_token(
                polling_method=polling_method,
                continuation_token=cont_token,
                client=self._client,
                deserialization_callback=get_long_running_output
            )
        return LROPoller(self._client, raw_result, get_long_running_output, polling_method)

    begin_delete.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}"}  # type: ignore

    @distributed_trace
    def get_by_query(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        url_safe_experiment_names_only=True,  # type: Optional[bool]
        body=None,  # type: Optional["_models.ExperimentQueryParams"]
        **kwargs  # type: Any
    ):
        # type: (...) -> Iterable["_models.PaginatedExperimentList"]
        """Get all Experiments in a specific workspace.

        Get all experiments in a specific workspace with the specified query filters.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param url_safe_experiment_names_only:
        :type url_safe_experiment_names_only: bool
        :param body: Query parameters for data sorting and filtering.
        :type body: ~azure.mgmt.machinelearningservices.models.ExperimentQueryParams
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: An iterator like instance of either PaginatedExperimentList or the result of
         cls(response)
        :rtype:
         ~azure.core.paging.ItemPaged[~azure.mgmt.machinelearningservices.models.PaginatedExperimentList]
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]

        cls = kwargs.pop('cls', None)  # type: ClsType["_models.PaginatedExperimentList"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))
        def prepare_request(next_link=None):
            if not next_link:
                if body is not None:
                    _json = self._serialize.body(body, 'ExperimentQueryParams')
                else:
                    _json = None

                request = build_get_by_query_request(
                    subscription_id=subscription_id,
                    resource_group_name=resource_group_name,
                    workspace_name=workspace_name,
                    content_type=content_type,
                    json=_json,
                    url_safe_experiment_names_only=url_safe_experiment_names_only,
                    template_url=self.get_by_query.metadata['url'],
                )
                request = _convert_request(request)
                request.url = self._client.format_url(request.url)

            else:
                if body is not None:
                    _json = self._serialize.body(body, 'ExperimentQueryParams')
                else:
                    _json = None

                request = build_get_by_query_request(
                    subscription_id=subscription_id,
                    resource_group_name=resource_group_name,
                    workspace_name=workspace_name,
                    content_type=content_type,
                    json=_json,
                    url_safe_experiment_names_only=url_safe_experiment_names_only,
                    template_url=next_link,
                )
                request = _convert_request(request)
                request.url = self._client.format_url(request.url)
                request.method = "GET"
            return request

        def extract_data(pipeline_response):
            deserialized = self._deserialize("PaginatedExperimentList", pipeline_response)
            list_of_elem = deserialized.value
            if cls:
                list_of_elem = cls(list_of_elem)
            return deserialized.next_link or None, iter(list_of_elem)

        def get_next(next_link=None):
            request = prepare_request(next_link)

            pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
                request,
                stream=False,
                **kwargs
            )
            response = pipeline_response.http_response

            if response.status_code not in [200]:
                map_error(status_code=response.status_code, response=response, error_map=error_map)
                error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
                raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

            return pipeline_response

        return ItemPaged(
            get_next, extract_data
        )
    get_by_query.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experiments:query"}  # type: ignore

    @distributed_trace
    def delete_tags(
        self,
        subscription_id,  # type: str
        resource_group_name,  # type: str
        workspace_name,  # type: str
        experiment_id,  # type: str
        body=None,  # type: Optional["_models.DeleteTagsCommand"]
        **kwargs  # type: Any
    ):
        # type: (...) -> "_models.DeleteExperimentTagsResult"
        """Delete list of Tags in an Experiment.

        Delete list of Tags from a specific Experiment Id.

        :param subscription_id: The Azure Subscription ID.
        :type subscription_id: str
        :param resource_group_name: The Name of the resource group in which the workspace is located.
        :type resource_group_name: str
        :param workspace_name: The name of the workspace.
        :type workspace_name: str
        :param experiment_id: The identifier of the experiment.
        :type experiment_id: str
        :param body: The requested tags list to be deleted.
        :type body: ~azure.mgmt.machinelearningservices.models.DeleteTagsCommand
        :keyword callable cls: A custom type or function that will be passed the direct response
        :return: DeleteExperimentTagsResult, or the result of cls(response)
        :rtype: ~azure.mgmt.machinelearningservices.models.DeleteExperimentTagsResult
        :raises: ~azure.core.exceptions.HttpResponseError
        """
        cls = kwargs.pop('cls', None)  # type: ClsType["_models.DeleteExperimentTagsResult"]
        error_map = {
            401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
        }
        error_map.update(kwargs.pop('error_map', {}))

        content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]

        if body is not None:
            _json = self._serialize.body(body, 'DeleteTagsCommand')
        else:
            _json = None

        request = build_delete_tags_request(
            subscription_id=subscription_id,
            resource_group_name=resource_group_name,
            workspace_name=workspace_name,
            experiment_id=experiment_id,
            content_type=content_type,
            json=_json,
            template_url=self.delete_tags.metadata['url'],
        )
        request = _convert_request(request)
        request.url = self._client.format_url(request.url)

        pipeline_response = self._client._pipeline.run(  # pylint: disable=protected-access
            request,
            stream=False,
            **kwargs
        )
        response = pipeline_response.http_response

        if response.status_code not in [200]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)

        deserialized = self._deserialize('DeleteExperimentTagsResult', pipeline_response)

        if cls:
            return cls(pipeline_response, deserialized, {})

        return deserialized

    delete_tags.metadata = {'url': "/history/v1.0/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/experimentids/{experimentId}/tags:delete"}  # type: ignore


text:
.class Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter$CustomViewHolder;
.super Ljava/lang/Object;
.source "LocaleDragAndDropAdapter.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "CustomViewHolder"
.end annotation

# instance fields
.field private final mLocaleDragCell:Lcom/samsung/android/settings/localepicker/LocaleDragCell;

.field final synthetic this$0:Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter;

# direct methods
.method public constructor <init>(Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter;Landroid/view/View;)V
    .locals 0

    iput-object p1, p0, Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter$CustomViewHolder;->this$0:Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter;

    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    check-cast p2, Lcom/samsung/android/settings/localepicker/LocaleDragCell;

    iput-object p2, p0, Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter$CustomViewHolder;->mLocaleDragCell:Lcom/samsung/android/settings/localepicker/LocaleDragCell;

    return-void
.end method

# virtual methods
.method public getLocaleDragCell()Lcom/samsung/android/settings/localepicker/LocaleDragCell;
    .locals 1

    iget-object v0, p0, Lcom/samsung/android/settings/localepicker/LocaleDragAndDropAdapter$CustomViewHolder;->mLocaleDragCell:Lcom/samsung/android/settings/localepicker/LocaleDragCell;

    return-object v0
.end method


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30"/>
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.USE_CREDENTIALS"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WAKE_LOCK"/>

    <uses-feature
        android:name="android.hardware.location.gps"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.sensor.barometer"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.sensor.accelerometer"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.sensor.compass"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.sensor.gyroscope"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.bluetooth"
        android:required="false"/>
    <uses-feature
        android:name="android.hardware.screen.landscape"
        android:required="false"/>

    <application
        android:name=".BaseApplication"
        android:allowBackup="true"
        android:fullBackupContent="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name_long"
        android:requestLegacyExternalStorage="true"
        android:theme="@style/AppTheme">

        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="@string/google_maps_key"/>

        <activity
            android:name=".views.MainActivity"
            android:label="@string/app_name"
            android:launchMode="singleTask"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.CATEGORY_OPENABLE" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:scheme="content" />
                <data android:scheme="file" />
                <data android:host="*" />
                <data android:mimeType="text/comma-separated-values" />
                <data android:mimeType="text/csv" />
            </intent-filter>
        </activity>
        <activity
            android:name=".views.altimeter.AltimeterActivity"
            android:label="@string/action_altimeter"/>
        <activity
            android:name=".views.map.MapActivity"
            android:label="@string/title_activity_map"/>
        <activity
            android:name=".views.tracks.TrackListActivity"
            android:label="@string/app_name"
            android:windowSoftInputMode="stateHidden"/>
        <activity
            android:name=".views.tracks.TrackLocalActivity"
            android:label="@string/app_name"/>
        <activity
            android:name=".views.tracks.TrackRemoteActivity"
            android:label="@string/app_name"/>
        <activity
            android:name=".views.SettingsActivity"
            android:label="@string/title_activity_settings"/>
        <activity
            android:name=".views.AudibleSettingsActivity"
            android:label="@string/title_activity_audible_settings"/>
        <activity
            android:name=".views.bluetooth.BluetoothActivity"
            android:label="@string/title_activity_bluetooth"/>
        <activity
            android:name=".views.SensorActivity"
            android:label="@string/app_name"/>
        <activity
            android:name=".views.laser.LaserActivity"/>

        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="com.platypii.baseline.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/file_provider_paths"/>
        </provider>

        <service
            android:name=".ForegroundService"
            android:foregroundServiceType="location"/>

    </application>

</manifest>


text:
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using gov.va.medora.mdo;

namespace gov.va.medora.mdws.dto
{
    public class TaggedIcdRptArrays : AbstractArrayTO
    {
        public TaggedIcdRptArray[] arrays;

        public TaggedIcdRptArrays() { }

        public TaggedIcdRptArrays(IndexedHashtable t)
        {
            if (t.Count == 0)
            {
                return;
            }
            arrays = new TaggedIcdRptArray[t.Count];
            for (int i = 0; i < t.Count; i++)
            {
                if (t.GetValue(i) == null)
                {
                    arrays[i] = new TaggedIcdRptArray((string)t.GetKey(i));
                }
                else if (MdwsUtils.isException(t.GetValue(i)))
                {
                    arrays[i] = new TaggedIcdRptArray((string)t.GetKey(i), (Exception)t.GetValue(i));
                }
                else if (t.GetValue(i).GetType().IsArray)
                {
                    arrays[i] = new TaggedIcdRptArray((string)t.GetKey(i), (IcdReport[])t.GetValue(i));
                }
                else
                {
                    arrays[i] = new TaggedIcdRptArray((string)t.GetKey(i), (IcdReport)t.GetValue(i));
                }
            }
            count = t.Count;
        }
    }
}


text:
cd ..
mkdir build_vs_test
cd build_vs_test
cmake ../test/ -G "Visual Studio 15 2017"


text:
package org.oep.ssomgt.service.base;

import org.oep.ssomgt.service.AppRoleLocalServiceUtil;

import java.util.Arrays;

/**
 * @author trungdk
 * @generated
 */
public class AppRoleLocalServiceClpInvoker {
	public AppRoleLocalServiceClpInvoker() {
		_methodName0 = "addAppRole";

		_methodParameterTypes0 = new String[] { "org.oep.ssomgt.model.AppRole" };

		_methodName1 = "createAppRole";

		_methodParameterTypes1 = new String[] { "long" };

		_methodName2 = "deleteAppRole";

		_methodParameterTypes2 = new String[] { "long" };

		_methodName3 = "deleteAppRole";

		_methodParameterTypes3 = new String[] { "org.oep.ssomgt.model.AppRole" };

		_methodName4 = "dynamicQuery";

		_methodParameterTypes4 = new String[] {  };

		_methodName5 = "dynamicQuery";

		_methodParameterTypes5 = new String[] {
				"com.liferay.portal.kernel.dao.orm.DynamicQuery"
			};

		_methodName6 = "dynamicQuery";

		_methodParameterTypes6 = new String[] {
				"com.liferay.portal.kernel.dao.orm.DynamicQuery", "int", "int"
			};

		_methodName7 = "dynamicQuery";

		_methodParameterTypes7 = new String[] {
				"com.liferay.portal.kernel.dao.orm.DynamicQuery", "int", "int",
				"com.liferay.portal.kernel.util.OrderByComparator"
			};

		_methodName8 = "dynamicQueryCount";

		_methodParameterTypes8 = new String[] {
				"com.liferay.portal.kernel.dao.orm.DynamicQuery"
			};

		_methodName9 = "dynamicQueryCount";

		_methodParameterTypes9 = new String[] {
				"com.liferay.portal.kernel.dao.orm.DynamicQuery",
				"com.liferay.portal.kernel.dao.orm.Projection"
			};

		_methodName10 = "fetchAppRole";

		_methodParameterTypes10 = new String[] { "long" };

		_methodName11 = "getAppRole";

		_methodParameterTypes11 = new String[] { "long" };

		_methodName12 = "getPersistedModel";

		_methodParameterTypes12 = new String[] { "java.io.Serializable" };

		_methodName13 = "getAppRoles";

		_methodParameterTypes13 = new String[] { "int", "int" };

		_methodName14 = "getAppRolesCount";

		_methodParameterTypes14 = new String[] {  };

		_methodName15 = "updateAppRole";

		_methodParameterTypes15 = new String[] { "org.oep.ssomgt.model.AppRole" };

		_methodName74 = "getBeanIdentifier";

		_methodParameterTypes74 = new String[] {  };

		_methodName75 = "setBeanIdentifier";

		_methodParameterTypes75 = new String[] { "java.lang.String" };

		_methodName80 = "addAppRole";

		_methodParameterTypes80 = new String[] {
				"long", "java.lang.String", "java.lang.String",
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName81 = "updateAppRole";

		_methodParameterTypes81 = new String[] {
				"long", "long", "java.lang.String", "java.lang.String",
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName82 = "updateAppRole";

		_methodParameterTypes82 = new String[] {
				"org.oep.ssomgt.model.AppRole",
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName84 = "removeAppRole";

		_methodParameterTypes84 = new String[] { "org.oep.ssomgt.model.AppRole" };

		_methodName85 = "removeAppRole";

		_methodParameterTypes85 = new String[] { "long" };

		_methodName86 = "getAppRole";

		_methodParameterTypes86 = new String[] { "long" };

		_methodName90 = "countByCompany";

		_methodParameterTypes90 = new String[] { "long" };

		_methodName91 = "findByCompany";

		_methodParameterTypes91 = new String[] { "long" };

		_methodName92 = "findByCompany";

		_methodParameterTypes92 = new String[] { "long", "int", "int" };

		_methodName93 = "countByCompany";

		_methodParameterTypes93 = new String[] {
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName94 = "findByCompany";

		_methodParameterTypes94 = new String[] {
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName95 = "findByCompany";

		_methodParameterTypes95 = new String[] {
				"int", "int", "com.liferay.portal.service.ServiceContext"
			};

		_methodName96 = "countByCompanyGroup";

		_methodParameterTypes96 = new String[] { "long", "long" };

		_methodName97 = "findByCompanyGroup";

		_methodParameterTypes97 = new String[] { "long", "long" };

		_methodName98 = "findByCompanyGroup";

		_methodParameterTypes98 = new String[] { "long", "long", "int", "int" };

		_methodName99 = "countByCompanyGroup";

		_methodParameterTypes99 = new String[] {
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName100 = "findByCompanyGroup";

		_methodParameterTypes100 = new String[] {
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName101 = "findByCompanyGroup";

		_methodParameterTypes101 = new String[] {
				"int", "int", "com.liferay.portal.service.ServiceContext"
			};

		_methodName102 = "countByCompanyGroupApplication";

		_methodParameterTypes102 = new String[] { "long", "long", "long" };

		_methodName103 = "countByCompanyGroupApplication";

		_methodParameterTypes103 = new String[] {
				"long", "com.liferay.portal.service.ServiceContext"
			};

		_methodName104 = "findByCompanyGroupApplication";

		_methodParameterTypes104 = new String[] { "long", "long", "long" };

		_methodName105 = "findByCompanyGroupApplication";

		_methodParameterTypes105 = new String[] {
				"long", "com.liferay.portal.service.ServiceContext"
			};

		_methodName106 = "findByCompanyGroupApplication";

		_methodParameterTypes106 = new String[] {
				"long", "long", "long", "int", "int"
			};

		_methodName107 = "findByCompanyGroupApplication";

		_methodParameterTypes107 = new String[] {
				"long", "int", "int",
				"com.liferay.portal.service.ServiceContext"
			};

		_methodName108 = "validate";

		_methodParameterTypes108 = new String[] {
				"long", "java.lang.String", "java.lang.String"
			};
	}

	public Object invokeMethod(String name, String[] parameterTypes,
		Object[] arguments) throws Throwable {
		if (_methodName0.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes0, parameterTypes)) {
			return AppRoleLocalServiceUtil.addAppRole((org.oep.ssomgt.model.AppRole)arguments[0]);
		}

		if (_methodName1.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes1, parameterTypes)) {
			return AppRoleLocalServiceUtil.createAppRole(((Long)arguments[0]).longValue());
		}

		if (_methodName2.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes2, parameterTypes)) {
			return AppRoleLocalServiceUtil.deleteAppRole(((Long)arguments[0]).longValue());
		}

		if (_methodName3.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes3, parameterTypes)) {
			return AppRoleLocalServiceUtil.deleteAppRole((org.oep.ssomgt.model.AppRole)arguments[0]);
		}

		if (_methodName4.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes4, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQuery();
		}

		if (_methodName5.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes5, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQuery((com.liferay.portal.kernel.dao.orm.DynamicQuery)arguments[0]);
		}

		if (_methodName6.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes6, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQuery((com.liferay.portal.kernel.dao.orm.DynamicQuery)arguments[0],
				((Integer)arguments[1]).intValue(),
				((Integer)arguments[2]).intValue());
		}

		if (_methodName7.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes7, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQuery((com.liferay.portal.kernel.dao.orm.DynamicQuery)arguments[0],
				((Integer)arguments[1]).intValue(),
				((Integer)arguments[2]).intValue(),
				(com.liferay.portal.kernel.util.OrderByComparator)arguments[3]);
		}

		if (_methodName8.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes8, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQueryCount((com.liferay.portal.kernel.dao.orm.DynamicQuery)arguments[0]);
		}

		if (_methodName9.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes9, parameterTypes)) {
			return AppRoleLocalServiceUtil.dynamicQueryCount((com.liferay.portal.kernel.dao.orm.DynamicQuery)arguments[0],
				(com.liferay.portal.kernel.dao.orm.Projection)arguments[1]);
		}

		if (_methodName10.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes10, parameterTypes)) {
			return AppRoleLocalServiceUtil.fetchAppRole(((Long)arguments[0]).longValue());
		}

		if (_methodName11.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes11, parameterTypes)) {
			return AppRoleLocalServiceUtil.getAppRole(((Long)arguments[0]).longValue());
		}

		if (_methodName12.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes12, parameterTypes)) {
			return AppRoleLocalServiceUtil.getPersistedModel((java.io.Serializable)arguments[0]);
		}

		if (_methodName13.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes13, parameterTypes)) {
			return AppRoleLocalServiceUtil.getAppRoles(((Integer)arguments[0]).intValue(),
				((Integer)arguments[1]).intValue());
		}

		if (_methodName14.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes14, parameterTypes)) {
			return AppRoleLocalServiceUtil.getAppRolesCount();
		}

		if (_methodName15.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes15, parameterTypes)) {
			return AppRoleLocalServiceUtil.updateAppRole((org.oep.ssomgt.model.AppRole)arguments[0]);
		}

		if (_methodName74.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes74, parameterTypes)) {
			return AppRoleLocalServiceUtil.getBeanIdentifier();
		}

		if (_methodName75.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes75, parameterTypes)) {
			AppRoleLocalServiceUtil.setBeanIdentifier((java.lang.String)arguments[0]);

			return null;
		}

		if (_methodName80.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes80, parameterTypes)) {
			return AppRoleLocalServiceUtil.addAppRole(((Long)arguments[0]).longValue(),
				(java.lang.String)arguments[1], (java.lang.String)arguments[2],
				(com.liferay.portal.service.ServiceContext)arguments[3]);
		}

		if (_methodName81.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes81, parameterTypes)) {
			return AppRoleLocalServiceUtil.updateAppRole(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue(),
				(java.lang.String)arguments[2], (java.lang.String)arguments[3],
				(com.liferay.portal.service.ServiceContext)arguments[4]);
		}

		if (_methodName82.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes82, parameterTypes)) {
			return AppRoleLocalServiceUtil.updateAppRole((org.oep.ssomgt.model.AppRole)arguments[0],
				(com.liferay.portal.service.ServiceContext)arguments[1]);
		}

		if (_methodName84.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes84, parameterTypes)) {
			AppRoleLocalServiceUtil.removeAppRole((org.oep.ssomgt.model.AppRole)arguments[0]);

			return null;
		}

		if (_methodName85.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes85, parameterTypes)) {
			AppRoleLocalServiceUtil.removeAppRole(((Long)arguments[0]).longValue());

			return null;
		}

		if (_methodName86.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes86, parameterTypes)) {
			return AppRoleLocalServiceUtil.getAppRole(((Long)arguments[0]).longValue());
		}

		if (_methodName90.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes90, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompany(((Long)arguments[0]).longValue());
		}

		if (_methodName91.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes91, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompany(((Long)arguments[0]).longValue());
		}

		if (_methodName92.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes92, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompany(((Long)arguments[0]).longValue(),
				((Integer)arguments[1]).intValue(),
				((Integer)arguments[2]).intValue());
		}

		if (_methodName93.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes93, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompany((com.liferay.portal.service.ServiceContext)arguments[0]);
		}

		if (_methodName94.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes94, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompany((com.liferay.portal.service.ServiceContext)arguments[0]);
		}

		if (_methodName95.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes95, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompany(((Integer)arguments[0]).intValue(),
				((Integer)arguments[1]).intValue(),
				(com.liferay.portal.service.ServiceContext)arguments[2]);
		}

		if (_methodName96.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes96, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompanyGroup(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue());
		}

		if (_methodName97.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes97, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroup(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue());
		}

		if (_methodName98.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes98, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroup(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue(),
				((Integer)arguments[2]).intValue(),
				((Integer)arguments[3]).intValue());
		}

		if (_methodName99.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes99, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompanyGroup((com.liferay.portal.service.ServiceContext)arguments[0]);
		}

		if (_methodName100.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes100, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroup((com.liferay.portal.service.ServiceContext)arguments[0]);
		}

		if (_methodName101.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes101, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroup(((Integer)arguments[0]).intValue(),
				((Integer)arguments[1]).intValue(),
				(com.liferay.portal.service.ServiceContext)arguments[2]);
		}

		if (_methodName102.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes102, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue(),
				((Long)arguments[2]).longValue());
		}

		if (_methodName103.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes103, parameterTypes)) {
			return AppRoleLocalServiceUtil.countByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				(com.liferay.portal.service.ServiceContext)arguments[1]);
		}

		if (_methodName104.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes104, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue(),
				((Long)arguments[2]).longValue());
		}

		if (_methodName105.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes105, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				(com.liferay.portal.service.ServiceContext)arguments[1]);
		}

		if (_methodName106.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes106, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				((Long)arguments[1]).longValue(),
				((Long)arguments[2]).longValue(),
				((Integer)arguments[3]).intValue(),
				((Integer)arguments[4]).intValue());
		}

		if (_methodName107.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes107, parameterTypes)) {
			return AppRoleLocalServiceUtil.findByCompanyGroupApplication(((Long)arguments[0]).longValue(),
				((Integer)arguments[1]).intValue(),
				((Integer)arguments[2]).intValue(),
				(com.liferay.portal.service.ServiceContext)arguments[3]);
		}

		if (_methodName108.equals(name) &&
				Arrays.deepEquals(_methodParameterTypes108, parameterTypes)) {
			AppRoleLocalServiceUtil.validate(((Long)arguments[0]).longValue(),
				(java.lang.String)arguments[1], (java.lang.String)arguments[2]);

			return null;
		}

		throw new UnsupportedOperationException();
	}

	private String _methodName0;
	private String[] _methodParameterTypes0;
	private String _methodName1;
	private String[] _methodParameterTypes1;
	private String _methodName2;
	private String[] _methodParameterTypes2;
	private String _methodName3;
	private String[] _methodParameterTypes3;
	private String _methodName4;
	private String[] _methodParameterTypes4;
	private String _methodName5;
	private String[] _methodParameterTypes5;
	private String _methodName6;
	private String[] _methodParameterTypes6;
	private String _methodName7;
	private String[] _methodParameterTypes7;
	private String _methodName8;
	private String[] _methodParameterTypes8;
	private String _methodName9;
	private String[] _methodParameterTypes9;
	private String _methodName10;
	private String[] _methodParameterTypes10;
	private String _methodName11;
	private String[] _methodParameterTypes11;
	private String _methodName12;
	private String[] _methodParameterTypes12;
	private String _methodName13;
	private String[] _methodParameterTypes13;
	private String _methodName14;
	private String[] _methodParameterTypes14;
	private String _methodName15;
	private String[] _methodParameterTypes15;
	private String _methodName74;
	private String[] _methodParameterTypes74;
	private String _methodName75;
	private String[] _methodParameterTypes75;
	private String _methodName80;
	private String[] _methodParameterTypes80;
	private String _methodName81;
	private String[] _methodParameterTypes81;
	private String _methodName82;
	private String[] _methodParameterTypes82;
	private String _methodName84;
	private String[] _methodParameterTypes84;
	private String _methodName85;
	private String[] _methodParameterTypes85;
	private String _methodName86;
	private String[] _methodParameterTypes86;
	private String _methodName90;
	private String[] _methodParameterTypes90;
	private String _methodName91;
	private String[] _methodParameterTypes91;
	private String _methodName92;
	private String[] _methodParameterTypes92;
	private String _methodName93;
	private String[] _methodParameterTypes93;
	private String _methodName94;
	private String[] _methodParameterTypes94;
	private String _methodName95;
	private String[] _methodParameterTypes95;
	private String _methodName96;
	private String[] _methodParameterTypes96;
	private String _methodName97;
	private String[] _methodParameterTypes97;
	private String _methodName98;
	private String[] _methodParameterTypes98;
	private String _methodName99;
	private String[] _methodParameterTypes99;
	private String _methodName100;
	private String[] _methodParameterTypes100;
	private String _methodName101;
	private String[] _methodParameterTypes101;
	private String _methodName102;
	private String[] _methodParameterTypes102;
	private String _methodName103;
	private String[] _methodParameterTypes103;
	private String _methodName104;
	private String[] _methodParameterTypes104;
	private String _methodName105;
	private String[] _methodParameterTypes105;
	private String _methodName106;
	private String[] _methodParameterTypes106;
	private String _methodName107;
	private String[] _methodParameterTypes107;
	private String _methodName108;
	private String[] _methodParameterTypes108;
}