text:
using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Threading.Tasks;
using vm.Aspects.Security.Cryptography.Ciphers.Properties;

namespace vm.Aspects.Security.Cryptography.Ciphers
{
    /// <summary>
    /// The class <c>NullCipher</c> is a development- and test-friendly convenience class which implements trivially the <see cref="ICipherTasks"/> interface:
    /// copies the source data blindly into the output target.
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "N/A")]
    public sealed class NullCipher : ICipherTasks
    {
        #region ICipher Members
        /// <summary>
        /// Gets or sets a value indicating whether the encrypted texts are or should be Base64 encoded.
        /// </summary>
        public bool Base64Encoded { get; set; }

        /// <summary>
        /// Encrypts (here it just copies) the <paramref name="dataStream" /> stream into the <paramref name="encryptedStream" /> stream.
        /// This is the reverse method of <see cref="M:ICipherAsync.Decrypt(System.Stream, System.Stream)" />.
        /// </summary>
        /// <param name="dataStream">The unencrypted input stream.</param>
        /// <param name="encryptedStream">
        /// The output stream where to put the crypto package which will contain the encrypted data as well as some other crypto artifacts,
        /// e.g. initialization vector, hash, etc.
        /// </param>
        /// <exception cref="System.ArgumentNullException">
        /// dataStream
        /// or
        /// encryptedStream
        /// </exception>
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1")]
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0")]
        public void Encrypt(
            Stream dataStream,
            Stream encryptedStream)
        {
            if (dataStream == null)
                throw new ArgumentNullException(nameof(dataStream));
            if (encryptedStream == null)
                throw new ArgumentNullException(nameof(encryptedStream));
            if (!dataStream.CanRead)
                throw new ArgumentException(Resources.StreamNotReadable, nameof(dataStream));
            if (!encryptedStream.CanWrite)
                throw new ArgumentException(Resources.StreamNotWritable, nameof(encryptedStream));

            dataStream.CopyTo(encryptedStream);
        }

        /// <summary>
        /// Decrypts (here it just copies) the <paramref name="encryptedStream" /> stream into the <paramref name="dataStream" /> stream.
        /// This is the reverse method of <see cref="M:ICipherAsync.Encrypt(System.Stream, System.Stream)" />.
        /// </summary>
        /// <param name="encryptedStream">
        /// The input crypto package stream which contains the encrypted data as well as some other crypto artifacts,
        /// e.g. initialization vector, hash, etc.
        /// </param>
        /// <param name="dataStream">The output stream where to put the unencrypted data.</param>
        /// <exception cref="System.ArgumentNullException">
        /// dataStream
        /// or
        /// encryptedStream
        /// </exception>
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1")]
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0")]
        public void Decrypt(
            Stream encryptedStream,
            Stream dataStream)
        {
            if (encryptedStream == null)
                throw new ArgumentNullException(nameof(encryptedStream));
            if (dataStream == null)
                throw new ArgumentNullException(nameof(dataStream));
            if (!encryptedStream.CanRead)
                throw new ArgumentException(Resources.StreamNotReadable, nameof(encryptedStream));
            if (!dataStream.CanWrite)
                throw new ArgumentException(Resources.StreamNotWritable, nameof(dataStream));

            encryptedStream.CopyTo(dataStream);
        }

        /// <summary>
        /// Encrypts (here it just copies) the specified <paramref name="data" />.
        /// This is the reverse method of <see cref="M:ICipherAsync.Decrypt(byte[])" />.
        /// </summary>
        /// <param name="data">The data to be encrypted.</param>
        /// <returns>The bytes of the crypto package which contains the encrypted data as well as some other crypto artifacts, e.g. initialization vector, hash, etc.
        /// Or returns <see langword="null" /> if <paramref name="data" /> is <see langword="null" />.</returns>
        public byte[] Encrypt(
            byte[] data)
        {
            if (data == null)
                return null;

            return (byte[])data.Clone();
        }

        /// <summary>
        /// Decrypts (here it just copies) the specified <paramref name="encryptedData" />.
        /// This is the reverse method of <see cref="M:ICipherAsync.Encrypt(byte[])" />.
        /// </summary>
        /// <param name="encryptedData">The bytes of the crypto package which contains the encrypted data as well as some other crypto artifacts, e.g. initialization vector, hash, etc.
        /// If <paramref name="encryptedData" /> is <see langword="null" /> the method returns <see langword="null" />.</param>
        /// <returns>The decrypted <paramref name="encryptedData" /> or <see langword="null" /> if <paramref name="encryptedData" /> is <see langword="null" />.</returns>
        public byte[] Decrypt(
            byte[] encryptedData)
        {
            if (encryptedData == null)
                return null;

            return (byte[])encryptedData.Clone();
        }
        #endregion

        #region ICipherAsync Members
        /// <summary>
        /// encrypt as an asynchronous operation.
        /// </summary>
        /// <param name="dataStream">The unencrypted input stream.</param>
        /// <param name="encryptedStream">The output stream where to write the crypto package which will contain the encrypted data
        /// as well as some other crypto artifacts, e.g. initialization vector, hash, etc.</param>
        /// <returns>A <see cref="Task" /> object which represents the process of asynchronous encryption.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// dataStream
        /// or
        /// encryptedStream
        /// </exception>
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1")]
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0")]
        public async Task EncryptAsync(
            Stream dataStream,
            Stream encryptedStream)
        {
            if (dataStream == null)
                throw new ArgumentNullException(nameof(dataStream));
            if (encryptedStream == null)
                throw new ArgumentNullException(nameof(encryptedStream));
            if (!dataStream.CanRead)
                throw new ArgumentException(Resources.StreamNotReadable, nameof(dataStream));
            if (!encryptedStream.CanWrite)
                throw new ArgumentException(Resources.StreamNotWritable, nameof(encryptedStream));

            await dataStream.CopyToAsync(encryptedStream);
        }

        /// <summary>
        /// decrypt as an asynchronous operation.
        /// </summary>
        /// <param name="encryptedStream">The input crypto package stream which contains the encrypted data
        /// as well as some other crypto artifacts, e.g. initialization vector, hash, etc.</param>
        /// <param name="dataStream">The output stream where to put the unencrypted data.</param>
        /// <returns>A <see cref="Task" /> object which represents the process of asynchronous decryption.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// dataStream
        /// or
        /// encryptedStream
        /// </exception>
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1")]
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0")]
        public async Task DecryptAsync(
            Stream encryptedStream,
            Stream dataStream)
        {
            if (encryptedStream == null)
                throw new ArgumentNullException(nameof(encryptedStream));
            if (dataStream == null)
                throw new ArgumentNullException(nameof(dataStream));
            if (!encryptedStream.CanRead)
                throw new ArgumentException(Resources.StreamNotReadable, nameof(encryptedStream));
            if (!dataStream.CanWrite)
                throw new ArgumentException(Resources.StreamNotWritable, nameof(dataStream));

            await encryptedStream.CopyToAsync(dataStream);
        }
        #endregion

        #region IDisposable pattern implementation
        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "N/A")]
        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }
        #endregion
    }
}


text:
package org.onosproject.net.driver;

/**
 * Representation of a facet of behaviour that can be used to talk about
 * an entity (in context of {@link DriverData}) or to an entity (in context of
 * {@link DriverHandler}).
 */
public interface Behaviour {

    /**
     * Returns the driver data context.
     *
     * @return driver data
     */
    DriverData data();

    /**
     * Sets the driver data context on this this behaviour should operate.
     *
     * @param data driver data
     */
    void setData(DriverData data);

}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace IPS\core\ProfileFields\Api;

/* To prevent PHP errors (extending class does not exist) revealing path */
if ( !defined( '\IPS\SUITE_UNIQUE_KEY' ) )
{
	header( ( isset( $_SERVER['SERVER_PROTOCOL'] ) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0' ) . ' 403 Forbidden' );
	exit;
}

/**
 * API output for custom fields groups
 */
class _FieldGroup
{
	/**
	 * @brief	Name
	 */
	protected $name;

	/**
	 * @brief	Values
	 */
	protected $values;

	/**
	 * Constructor
	 *
	 * @param	string	$name	Group name
	 * @param	array	$values	Values
	 */
	public function __construct( $name, $values )
	{
		$this->name = $name;
		$this->values = $values;
	}

	/**
	 * Get output for API
	 *
	 * @return	array
	 * @apiresponse	string									name	Group name
	 * @apiresponse	[\IPS\core\ProfileFields\Api\Field]		fields	Fields
	 */
	public function apiOutput()
	{
		return array( 'name' => $this->name, 'fields' => array_map( function( $val ) {
			return $val->apiOutput();
		}, $this->values ) );
	}
}


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

<!--

    RDoc Documentation

  -->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <title>RDoc Documentation</title>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<frameset rows="20%, 80%">
    <frameset cols="25%,35%,45%">
        <frame src="fr_file_index.html"   title="Files" name="Files" />
        <frame src="fr_class_index.html"  name="Classes" />
        <frame src="fr_method_index.html" name="Methods" />
    </frameset>
    <frame src="files/driver_rb.html" name="docwin" />
</frameset>
</html>


text:
require 'geocoder/results/base'

module Geocoder::Result
  class Nominatim < Base

    def house_number
      @data['address']['house_number']
    end

    def address
      @data['display_name']
    end

    def street
      @data['address']['road']
    end

    def city
      @data['address']['city']
    end

    def village
      @data['address']['villiage']
    end

    def town
      @data['address']['town']
    end

    def state
      @data['address']['state']
    end

    alias_method :state_code, :state

    def postal_code
      @data['address']['postcode']
    end

    def county
      @data['address']['county']
    end

    def country
      @data['address']['country']
    end

    def country_code
      @data['address']['country_code']
    end

    def coordinates
      [@data['lat'].to_f, @data['lon'].to_f]
    end

    def self.response_attributes
      %w[place_id, osm_type, osm_id, boundingbox, license,
         polygonpoints, display_name, class, type, stadium, suburb]
    end

    response_attributes.each do |a|
      define_method a do
        @data[a]
      end
    end
  end
end


text:
package org.apache.druid.data.input.parquet;

import com.google.common.collect.ImmutableList;
import org.apache.druid.data.input.ColumnsFilter;
import org.apache.druid.data.input.InputEntityReader;
import org.apache.druid.data.input.InputRow;
import org.apache.druid.data.input.InputRowListPlusRawValues;
import org.apache.druid.data.input.InputRowSchema;
import org.apache.druid.data.input.impl.DimensionsSpec;
import org.apache.druid.data.input.impl.TimestampSpec;
import org.apache.druid.java.util.common.DateTimes;
import org.apache.druid.java.util.common.parsers.JSONPathFieldSpec;
import org.apache.druid.java.util.common.parsers.JSONPathFieldType;
import org.apache.druid.java.util.common.parsers.JSONPathSpec;
import org.junit.Assert;
import org.junit.Test;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.List;

/**
 * Duplicate of {@link DecimalParquetInputTest} but for {@link ParquetReader} instead of Hadoop
 */
public class DecimalParquetReaderTest extends BaseParquetReaderTest
{
  @Test
  public void testReadParquetDecimalFixedLen() throws IOException
  {
    final String file = "example/decimals/dec-in-fixed-len.parquet";
    InputRowSchema schema = new InputRowSchema(
        new TimestampSpec("timestamp", "auto", DateTimes.of("2018-09-01T00:00:00.000Z")),
        new DimensionsSpec(DimensionsSpec.getDefaultSchemas(ImmutableList.of("fixed_len_dec"))),
        ColumnsFilter.all()
    );
    List<JSONPathFieldSpec> flattenExpr = ImmutableList.of(
        new JSONPathFieldSpec(JSONPathFieldType.ROOT, "fixed_len_dec", "fixed_len_dec"),
        new JSONPathFieldSpec(JSONPathFieldType.PATH, "metric1", "$.fixed_len_dec")
    );
    JSONPathSpec flattenSpec = new JSONPathSpec(true, flattenExpr);
    InputEntityReader reader = createReader(
        file,
        schema,
        flattenSpec
    );

    List<InputRow> rows = readAllRows(reader);
    Assert.assertEquals("2018-09-01T00:00:00.000Z", rows.get(1).getTimestamp().toString());
    Assert.assertEquals("1.0", rows.get(1).getDimension("fixed_len_dec").get(0));
    Assert.assertEquals(new BigDecimal("1.0"), rows.get(1).getMetric("metric1"));

    reader = createReader(
        file,
        schema,
        flattenSpec
    );
    List<InputRowListPlusRawValues> sampled = sampleAllRows(reader);
    final String expectedJson = "{\n"
                                + "  \"fixed_len_dec\" : 1.0\n"
                                + "}";
    Assert.assertEquals(expectedJson, DEFAULT_JSON_WRITER.writeValueAsString(sampled.get(1).getRawValues()));
  }

  @Test
  public void testReadParquetDecimali32() throws IOException
  {
    final String file = "example/decimals/dec-in-i32.parquet";
    InputRowSchema schema = new InputRowSchema(
        new TimestampSpec("timestamp", "auto", DateTimes.of("2018-09-01T00:00:00.000Z")),
        new DimensionsSpec(DimensionsSpec.getDefaultSchemas(ImmutableList.of("i32_dec"))),
        ColumnsFilter.all()
    );
    List<JSONPathFieldSpec> flattenExpr = ImmutableList.of(
        new JSONPathFieldSpec(JSONPathFieldType.ROOT, "i32_dec", "i32_dec"),
        new JSONPathFieldSpec(JSONPathFieldType.PATH, "metric1", "$.i32_dec")
    );
    JSONPathSpec flattenSpec = new JSONPathSpec(true, flattenExpr);
    InputEntityReader reader = createReader(
        file,
        schema,
        flattenSpec
    );

    List<InputRow> rows = readAllRows(reader);
    Assert.assertEquals("2018-09-01T00:00:00.000Z", rows.get(1).getTimestamp().toString());
    Assert.assertEquals("100", rows.get(1).getDimension("i32_dec").get(0));
    Assert.assertEquals(new BigDecimal(100), rows.get(1).getMetric("metric1"));

    reader = createReader(
        file,
        schema,
        flattenSpec
    );
    List<InputRowListPlusRawValues> sampled = sampleAllRows(reader);
    final String expectedJson = "{\n"
                                + "  \"i32_dec\" : 100\n"
                                + "}";
    Assert.assertEquals(expectedJson, DEFAULT_JSON_WRITER.writeValueAsString(sampled.get(1).getRawValues()));
  }

  @Test
  public void testReadParquetDecimali64() throws IOException
  {
    final String file = "example/decimals/dec-in-i64.parquet";
    InputRowSchema schema = new InputRowSchema(
        new TimestampSpec("timestamp", "auto", DateTimes.of("2018-09-01T00:00:00.000Z")),
        new DimensionsSpec(DimensionsSpec.getDefaultSchemas(ImmutableList.of("i64_dec"))),
        ColumnsFilter.all()
    );
    List<JSONPathFieldSpec> flattenExpr = ImmutableList.of(
        new JSONPathFieldSpec(JSONPathFieldType.ROOT, "i32_dec", "i64_dec"),
        new JSONPathFieldSpec(JSONPathFieldType.PATH, "metric1", "$.i64_dec")
    );
    JSONPathSpec flattenSpec = new JSONPathSpec(true, flattenExpr);
    InputEntityReader reader = createReader(
        file,
        schema,
        flattenSpec
    );

    List<InputRow> rows = readAllRows(reader);
    Assert.assertEquals("2018-09-01T00:00:00.000Z", rows.get(1).getTimestamp().toString());
    Assert.assertEquals("100", rows.get(1).getDimension("i64_dec").get(0));
    Assert.assertEquals(new BigDecimal(100), rows.get(1).getMetric("metric1"));

    reader = createReader(
        file,
        schema,
        flattenSpec
    );
    List<InputRowListPlusRawValues> sampled = sampleAllRows(reader);
    final String expectedJson = "{\n"
                                + "  \"i64_dec\" : 100\n"
                                + "}";
    Assert.assertEquals(expectedJson, DEFAULT_JSON_WRITER.writeValueAsString(sampled.get(1).getRawValues()));
  }
}


text:
#include "xenia/base/logging.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xam/xam_private.h"
#include "xenia/kernel/xboxkrnl/xboxkrnl_error.h"
#include "xenia/kernel/xevent.h"
#include "xenia/kernel/xthread.h"
#include "xenia/xbox.h"

namespace xe {
namespace kernel {
namespace xam {

dword_result_t XMsgInProcessCall(dword_t app, dword_t message, dword_t arg1,
                                 dword_t arg2) {
  auto result = kernel_state()->app_manager()->DispatchMessageSync(app, message,
                                                                   arg1, arg2);
  if (result == X_ERROR_NOT_FOUND) {
    XELOGE("XMsgInProcessCall: app {:08X} undefined", app);
  }
  return result;
}
DECLARE_XAM_EXPORT1(XMsgInProcessCall, kNone, kImplemented);

dword_result_t XMsgSystemProcessCall(dword_t app, dword_t message,
                                     dword_t buffer, dword_t buffer_length) {
  auto result = kernel_state()->app_manager()->DispatchMessageAsync(
      app, message, buffer, buffer_length);
  if (result == X_ERROR_NOT_FOUND) {
    XELOGE("XMsgSystemProcessCall: app {:08X} undefined", app);
  }
  return result;
}
DECLARE_XAM_EXPORT1(XMsgSystemProcessCall, kNone, kImplemented);

struct XMSGSTARTIOREQUEST_UNKNOWNARG {
  be<uint32_t> unk_0;
  be<uint32_t> unk_1;
};

X_HRESULT xeXMsgStartIORequestEx(uint32_t app, uint32_t message,
                                 uint32_t overlapped_ptr, uint32_t buffer_ptr,
                                 uint32_t buffer_length,
                                 XMSGSTARTIOREQUEST_UNKNOWNARG* unknown) {
  auto result = kernel_state()->app_manager()->DispatchMessageAsync(
      app, message, buffer_ptr, buffer_length);
  if (result == X_E_NOTFOUND) {
    XELOGE("XMsgStartIORequestEx: app {:08X} undefined", app);
    result = X_E_INVALIDARG;
    XThread::SetLastError(X_ERROR_NOT_FOUND);
  }
  if (overlapped_ptr) {
    kernel_state()->CompleteOverlappedImmediate(overlapped_ptr, result);
    result = X_ERROR_IO_PENDING;
  }
  if (result == X_ERROR_SUCCESS || X_ERROR_IO_PENDING) {
    XThread::SetLastError(0);
  }
  return result;
}

dword_result_t XMsgStartIORequestEx(
    dword_t app, dword_t message, pointer_t<XAM_OVERLAPPED> overlapped_ptr,
    dword_t buffer_ptr, dword_t buffer_length,
    pointer_t<XMSGSTARTIOREQUEST_UNKNOWNARG> unknown_ptr) {
  return xeXMsgStartIORequestEx(app, message, overlapped_ptr, buffer_ptr,
                                buffer_length, unknown_ptr);
}
DECLARE_XAM_EXPORT1(XMsgStartIORequestEx, kNone, kImplemented);

dword_result_t XMsgStartIORequest(dword_t app, dword_t message,
                                  pointer_t<XAM_OVERLAPPED> overlapped_ptr,
                                  dword_t buffer_ptr, dword_t buffer_length) {
  return xeXMsgStartIORequestEx(app, message, overlapped_ptr, buffer_ptr,
                                buffer_length, nullptr);
}
DECLARE_XAM_EXPORT1(XMsgStartIORequest, kNone, kImplemented);

dword_result_t XMsgCancelIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
                                   dword_t wait) {
  X_HANDLE event_handle = XOverlappedGetEvent(overlapped_ptr);
  if (event_handle && wait) {
    auto ev =
        kernel_state()->object_table()->LookupObject<XEvent>(event_handle);
    if (ev) {
      ev->Wait(0, 0, true, nullptr);
    }
  }

  return 0;
}
DECLARE_XAM_EXPORT1(XMsgCancelIORequest, kNone, kImplemented);

dword_result_t XMsgCompleteIORequest(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
                                     dword_t result, dword_t extended_error,
                                     dword_t length) {
  kernel_state()->CompleteOverlappedImmediateEx(overlapped_ptr, result,
                                                extended_error, length);
  return X_ERROR_SUCCESS;
}
DECLARE_XAM_EXPORT2(XMsgCompleteIORequest, kNone, kImplemented, kSketchy);

dword_result_t XamGetOverlappedResult(pointer_t<XAM_OVERLAPPED> overlapped_ptr,
                                      lpdword_t length_ptr, dword_t unknown) {
  uint32_t result;
  if (overlapped_ptr->result != X_ERROR_IO_PENDING) {
    result = overlapped_ptr->result;
  } else if (!overlapped_ptr->event) {
    result = X_ERROR_IO_INCOMPLETE;
  } else {
    auto ev = kernel_state()->object_table()->LookupObject<XEvent>(
        overlapped_ptr->event);
    result = ev->Wait(3, 1, 0, nullptr);
    if (XSUCCEEDED(result)) {
      result = overlapped_ptr->result;
    } else {
      result = xboxkrnl::xeRtlNtStatusToDosError(result);
    }
  }
  if (XSUCCEEDED(result) && length_ptr) {
    *length_ptr = overlapped_ptr->length;
  }
  return result;
}
DECLARE_XAM_EXPORT2(XamGetOverlappedResult, kNone, kImplemented, kSketchy);

void RegisterMsgExports(xe::cpu::ExportResolver* export_resolver,
                        KernelState* kernel_state) {}

}  // namespace xam
}  // namespace kernel
}  // namespace xe


text:
package org.apache.ambari.server.state.repository;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;

import org.apache.ambari.server.state.RepositoryType;
import org.apache.commons.lang.StringUtils;

/**
 * Release information for a repository.
 */
@XmlAccessorType(XmlAccessType.FIELD)
public class Release {

  /**
   * The type of repository dictates how the repo should be installed and its upgradability.
   */
  @XmlElement(name="type")
  public RepositoryType repositoryType;

  /**
   * The stack id for the repository.
   */
  @XmlElement(name="stack-id")
  public String stackId;

  /**
   * The stack-based release version.
   */
  @XmlElement(name="version")
  public String version;

  /**
   * The build identifier.
   */
  @XmlElement(name="build")
  public String build;

  /**
   * The compatability regex.  This is used to relate the release to another release.
   */
  @XmlElement(name="compatible-with")
  public String compatibleWith;

  /**
   * The release notes or link.
   */
  @XmlElement(name="release-notes")
  public String releaseNotes;

  /**
   * The optional display name
   */
  @XmlElement(name="display")
  public String display;

  /**
   * @return the full version
   */
  public String getFullVersion() {
    StringBuilder sb = new StringBuilder(version);

    if (StringUtils.isNotBlank(build)) {
      sb.append('-').append(StringUtils.trim(build));
    }

    return sb.toString();
  }

}


text:
<?php

namespace AppBundle\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;

class DefaultController extends Controller
{
    /**
     * @Route("/", name="homepage")
     * @Template()
     */
    public function indexAction()
    {
        //return $this->render('AppBundle:Default:index.html.twig', ['nome' => $nome]);
        return [];
    }

    /**
     * @Route("/run/{marca}/{modelo}", name="runpage")
     * @Template()
     */
    public function runAction($marca, $modelo)
    {
    	$carro['marca']  = $marca;
    	$carro['modelo'] = $modelo;
    	return ['carro' => $carro];
    }
}


text:
<html>
<head>
    <title>Other Domain Popup</title>

    <script type="text/javascript" src="/build/PM.js"></script>
    <script src="js/popup.js"></script>
</head>
<body>
    <p>
        This popup is running on a different domain. With normal Javascript it wouldn't be able to communicate with your domain. However, with
        PM.js we can. Click the link below to simulate a user authentication, like Facebook and Google's authentication popup, and see the user information in
        the main domain.
    </p>
    <button onclick="authenticate();">Authenticate with FakeBook</button>
</body>
</html>


text:
using System;
using System.Linq;
using NUnit.Framework;
using Umbraco.Core;
using Umbraco.Core.Models;
using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.Caching;
using Umbraco.Core.Persistence.Querying;
using Umbraco.Core.Persistence.Repositories;
using Umbraco.Core.Persistence.UnitOfWork;
using Umbraco.Tests.TestHelpers;

namespace Umbraco.Tests.Persistence.Repositories
{
    [TestFixture]
    public class RelationTypeRepositoryTest : BaseDatabaseFactoryTest
    {
        [SetUp]
        public override void Initialize()
        {
            base.Initialize();

            CreateTestData();
        }

        private RelationTypeRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
        {
            return new RelationTypeRepository(unitOfWork, NullCacheProvider.Current);
        }

        [Test]
        public void Can_Instantiate_Repository_From_Resolver()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();

            // Act
            var repository = RepositoryResolver.Current.ResolveByType<IRelationTypeRepository>(unitOfWork);

            // Assert
            Assert.That(repository, Is.Not.Null);
        }

        [Test]
        public void Can_Perform_Add_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relateMemberToContent = new RelationType(new Guid(Constants.ObjectTypes.Member),
                                                             new Guid(Constants.ObjectTypes.Document),
                                                             "relateMemberToContent") {IsBidirectional = true, Name = "Relate Member to Content"};

                repository.AddOrUpdate(relateMemberToContent);
                unitOfWork.Commit();

                // Assert
                Assert.That(relateMemberToContent.HasIdentity, Is.True);
                Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);
            }
        }

        [Test]
        public void Can_Perform_Update_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relationType = repository.Get(3);
                relationType.Alias = relationType.Alias + "Updated";
                relationType.Name = relationType.Name + " Updated";
                repository.AddOrUpdate(relationType);
                unitOfWork.Commit();

                var relationTypeUpdated = repository.Get(3);

                // Assert
                Assert.That(relationTypeUpdated, Is.Not.Null);
                Assert.That(relationTypeUpdated.HasIdentity, Is.True);
                Assert.That(relationTypeUpdated.Alias, Is.EqualTo(relationType.Alias));
                Assert.That(relationTypeUpdated.Name, Is.EqualTo(relationType.Name));
            }
        }

        [Test]
        public void Can_Perform_Delete_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relationType = repository.Get(3);
                repository.Delete(relationType);
                unitOfWork.Commit();

                var exists = repository.Exists(3);

                // Assert
                Assert.That(exists, Is.False);
            }
        }

        [Test]
        public void Can_Perform_Get_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relationType = repository.Get(2);

                // Assert
                Assert.That(relationType, Is.Not.Null);
                Assert.That(relationType.HasIdentity, Is.True);
                Assert.That(relationType.Alias, Is.EqualTo("relateContentOnCopy"));
                Assert.That(relationType.Name, Is.EqualTo("Relate Content on Copy"));
            }
        }

        [Test]
        public void Can_Perform_GetAll_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relationTypes = repository.GetAll();

                // Assert
                Assert.That(relationTypes, Is.Not.Null);
                Assert.That(relationTypes.Any(), Is.True);
                Assert.That(relationTypes.Any(x => x == null), Is.False);
                Assert.That(relationTypes.Count(), Is.EqualTo(3));
            }
        }

        [Test]
        public void Can_Perform_GetAll_With_Params_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var relationTypes = repository.GetAll(2, 3);

                // Assert
                Assert.That(relationTypes, Is.Not.Null);
                Assert.That(relationTypes.Any(), Is.True);
                Assert.That(relationTypes.Any(x => x == null), Is.False);
                Assert.That(relationTypes.Count(), Is.EqualTo(2));
            }
        }

        [Test]
        public void Can_Perform_Exists_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var exists = repository.Exists(3);
                var doesntExist = repository.Exists(5);

                // Assert
                Assert.That(exists, Is.True);
                Assert.That(doesntExist, Is.False);
            }
        }

        [Test]
        public void Can_Perform_Count_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var query = Query<RelationType>.Builder.Where(x => x.Alias.StartsWith("relate"));
                int count = repository.Count(query);

                // Assert
                Assert.That(count, Is.EqualTo(3));
            }
        }

        [Test]
        public void Can_Perform_GetByQuery_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            using (var repository = CreateRepository(unitOfWork))
            {

                // Act
                var childObjType = new Guid(Constants.ObjectTypes.DocumentType);
                var query = Query<RelationType>.Builder.Where(x => x.ChildObjectType == childObjType);
                var result = repository.GetByQuery(query);

                // Assert
                Assert.That(result, Is.Not.Null);
                Assert.That(result.Any(), Is.True);
                Assert.That(result.Any(x => x == null), Is.False);
                Assert.That(result.Count(), Is.EqualTo(1));
            }
        }

        [TearDown]
        public override void TearDown()
        {
            base.TearDown();
        }

        public void CreateTestData()
        {
            var relateContent = new RelationType(new Guid(Constants.ObjectTypes.Document), new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"), "relateContentOnCopy") { IsBidirectional = true, Name = "Relate Content on Copy" };
            var relateContentType = new RelationType(new Guid(Constants.ObjectTypes.DocumentType), new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"), "relateContentTypeOnCopy") { IsBidirectional = true, Name = "Relate ContentType on Copy" };

            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            repository.AddOrUpdate(relateContent);//Id 2
            repository.AddOrUpdate(relateContentType);//Id 3
            unitOfWork.Commit();
        }
    }
}


text:
package info.metadude.android.library.schedule.parser.model;

import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Generated;

@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("org.jsonschema2pojo")
@JsonPropertyOrder({
        "id",
        "label_en"
})
public class Level {

    @JsonProperty("id")
    private String id;

    @JsonProperty("label_en")
    private String labelEn;

    @JsonIgnore
    private Map<String, Object> additionalProperties = new HashMap<String, Object>();

    /**
     * @return The id
     */
    @JsonProperty("id")
    public String getId() {
        return id;
    }

    /**
     * @param id The id
     */
    @JsonProperty("id")
    public void setId(String id) {
        this.id = id;
    }

    /**
     * @return The labelEn
     */
    @JsonProperty("label_en")
    public String getLabelEn() {
        return labelEn;
    }

    /**
     * @param labelEn The label_en
     */
    @JsonProperty("label_en")
    public void setLabelEn(String labelEn) {
        this.labelEn = labelEn;
    }

    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }

    @JsonAnySetter
    public void setAdditionalProperty(String name, Object value) {
        this.additionalProperties.put(name, value);
    }

}


text:
import { factory } from '../../utils/factory'
import { deepMap } from '../../utils/collection'
import { acothNumber } from '../../plain/number'

const name = 'acoth'
const dependencies = ['typed', 'config', 'Complex', 'BigNumber']

export const createAcoth = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, Complex, BigNumber }) => {
  /**
   * Calculate the hyperbolic arccotangent of a value,
   * defined as `acoth(x) = atanh(1/x) = (ln((x+1)/x) + ln(x/(x-1))) / 2`.
   *
   * For matrices, the function is evaluated element wise.
   *
   * Syntax:
   *
   *    math.acoth(x)
   *
   * Examples:
   *
   *    math.acoth(0.5)       // returns 0.8047189562170503
   *
   * See also:
   *
   *    acsch, asech
   *
   * @param {number | Complex | Array | Matrix} x  Function input
   * @return {number | Complex | Array | Matrix} Hyperbolic arccotangent of x
   */
  const acoth = typed(name, {
    number: function (x) {
      if (x >= 1 || x <= -1 || config.predictable) {
        return acothNumber(x)
      }
      return new Complex(x, 0).acoth()
    },

    Complex: function (x) {
      return x.acoth()
    },

    BigNumber: function (x) {
      return new BigNumber(1).div(x).atanh()
    },

    'Array | Matrix': function (x) {
      return deepMap(x, acoth)
    }
  })

  return acoth
})


text:
<?php
namespace Crud\Test\TestCase\Listener;

use Crud\TestSuite\TestCase;

class RelatedModelListenerTest extends TestCase
{

    /**
     * testModels
     *
     * @return void
     */
    public function testModels()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels'])
            ->getMock();

        $listener
            ->expects($this->once())
            ->method('relatedModels')
            ->with(null, null)
            ->will($this->returnValue(null));

        $result = $listener->models();
        $expected = [];
        $this->assertEquals($expected, $result);
    }

    /**
     * testModelsEmpty
     *
     * Test behavior when 'relatedModels' is empty
     *
     * @return void
     */
    public function testModelsEmpty()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels'])
            ->getMock();

        $listener
            ->expects($this->once())
            ->method('relatedModels')
            ->with(null, null)
            ->will($this->returnValue([]));

        $result = $listener->models();
        $expected = [];
        $this->assertEquals($expected, $result);
    }

    /**
     * testModelsEmpty
     *
     * Test behavior when 'relatedModels' is a string
     *
     * @return void
     */
    public function testModelsString()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels', 'getAssociatedByName'])
            ->getMock();
        $listener
            ->expects($this->once())
            ->method('relatedModels')
            ->with(null)
            ->will($this->returnValue(['posts']));
        $listener
            ->expects($this->once())
            ->method('getAssociatedByName')
            ->with(['posts']);

        $listener->models();
    }

    /**
     * testModelsTrue
     *
     * Test behavior when 'relatedModels' is true
     *
     * @return void
     */
    public function testModelsTrue()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels', 'getAssociatedByType'])
            ->getMock();
        $listener
            ->expects($this->once())
            ->method('relatedModels')
            ->with(null, null)
            ->will($this->returnValue(true));
        $listener
            ->expects($this->once())
            ->method('getAssociatedByType')
            ->with(['oneToOne', 'manyToMany', 'manyToOne']);

        $result = $listener->models();
    }

    /**
     * testGetAssociatedByTypeReturnValue
     *
     * Test return value of `getAssociatedByType`
     *
     * @return void
     */
    public function testGetAssociatedByTypeReturnValue()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels', '_table'])
            ->getMock();
        $table = $this
            ->getMockBuilder('\Cake\ORM\Table')
            ->disableOriginalConstructor()
            ->setMethods(['associations'])
            ->getMock();
        $associationCollection = $this
            ->getMockBuilder('\Cake\ORM\AssociationCollection')
            ->disableOriginalConstructor()
            ->setMethods(['get', 'keys'])
            ->getMock();
        $association = $this
            ->getMockBuilder('\Cake\ORM\Association')
            ->disableOriginalConstructor()
            ->setMethods(['type', 'name', 'eagerLoader', 'cascadeDelete', 'isOwningSide', 'saveAssociated'])
            ->getMock();

        $listener
            ->expects($this->once())
            ->method('_table')
            ->withAnyParameters()
            ->will($this->returnValue($table));
        $table
            ->expects($this->atLeastOnce())
            ->method('associations')
            ->will($this->returnValue($associationCollection));
        $associationCollection
            ->expects($this->once())
            ->method('keys')
            ->will($this->returnValue(['posts']));
        $associationCollection
            ->expects($this->once())
            ->method('get')
            ->with('posts')
            ->will($this->returnValue($association));
        $association
            ->expects($this->once())
            ->method('name')
            ->will($this->returnValue('Posts'));
        $association
            ->expects($this->once())
            ->method('type')
            ->will($this->returnValue('oneToOne'));

        $expected = ['Posts' => $association];
        $result = $listener->getAssociatedByType(['oneToOne', 'manyToMany', 'manyToOne']);

        $this->assertEquals($expected, $result);
    }

    /**
     * testModelReturnsAssociationsByName
     *
     * Test return value of `getAssociatedByName`
     *
     * @return void
     */
    public function testGetAssociatedByNameReturnValue()
    {
        $listener = $this
            ->getMockBuilder('\Crud\Listener\RelatedModelsListener')
            ->disableOriginalConstructor()
            ->setMethods(['relatedModels', '_table'])
            ->getMock();
        $table = $this
            ->getMockBuilder('\Cake\ORM\Table')
            ->disableOriginalConstructor()
            ->setMethods(['associations'])
            ->getMock();
        $associationCollection = $this
            ->getMockBuilder('\Cake\ORM\AssociationCollection')
            ->disableOriginalConstructor()
            ->setMethods(['get'])
            ->getMock();
        $association = $this
            ->getMockBuilder('\Cake\ORM\Association')
            ->disableOriginalConstructor()
            ->setMethods(['type', 'name', 'eagerLoader', 'cascadeDelete', 'isOwningSide', 'saveAssociated'])
            ->getMock();

        $listener
            ->expects($this->once())
            ->method('_table')
            ->withAnyParameters()
            ->will($this->returnValue($table));
        $table
            ->expects($this->once())
            ->method('associations')
            ->will($this->returnValue($associationCollection));
        $associationCollection
            ->expects($this->once())
            ->method('get')
            ->with('posts')
            ->will($this->returnValue($association));
        $association
            ->expects($this->once())
            ->method('name')
            ->with(null)
            ->will($this->returnValue('Posts'));

        $expected = ['Posts' => $association];
        $result = $listener->getAssociatedByName(['posts']);

        $this->assertEquals($expected, $result);
    }
}


text:
<!DOCTYPE html>

  <link rel="icon" type="image/png" href="/static/assets/icon.png">

  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0-alpha.5/css/bootstrap.min.css" integrity="sha384-AysaV+vQoT3kOAXZkl02PThvDr8HYKPZhNT5h/CXfBThSRXQ6jW5DO2ekP5ViFdi" crossorigin="anonymous">

  <link href="https://fonts.googleapis.com/css?family=Lora|Roboto|Arvo" rel="stylesheet">
  <link href="css/index.css" rel="stylesheet">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta property="og:type" content="website" />
  <meta property="og:description" content="Easily get your FBI, CIA, IRS, or NSA file by submitting Freedom of Information Act requests to the government." />
  <meta property="og:locale" content="en_US" />
  <meta property="og:site_name" content="Foia.fyi" />
  <title>Foia.fyi - easily send FOIA requests to the government</title>

Your FOIA requests.

Foia.fyi has generated a single letter which you can open, print, and mail to various government agencies. The necessary addresses are included below. You may also send this letter to agencies not listed below, provided you find their correct FOIA/record
        dissemination sections.
        Be sure to include a return address on the envelope, or your request may be subject to automatic
          filtration.

NSA

Address to:

                NSA FOIA REQUESTER SERVICE CENTER
 NSA FOIA Requester Service Center/DJ4
 9800 Savage Road, Suite 6248
 Ft. George G. Meade, MD 20755-6248

FBI

Address to:

                Federal Bureau of Investigation
 Records/Information Dissemination Section
 170 Marcel Drive
 Winchester, VA 22602-4843

CIA

Address to:

                Information and Privacy Coordinator
 Central Intelligence Agency
 Washington, DC 20505

IRS

Address to:

                NSA FOIA REQUESTER SERVICE CENTER
 NSA FOIA Requester Service Center/DJ4
 9800 Savage Road, Suite 6248
 Ft. George G. Meade, MD 20755-6248

          <button class="btn btn-primary btn-lg btn-block" onclick="openLetter()">Open or Print Letter</button>

                    John Doe

                    120 Main Street

                    Spiegal, New York 20123

                {date}

Re: Freedom of Information Act / Privacy Act Request for Personal Records

To Whom It May Concern:

This is a request for records and documents, both digital and physical, under the provisions of the Freedom of Information Act and the Privacy Act. Please process this request under both statutes to release the maximum number of records
                and documents. I request copies of all files, correspondence, or other records concerning myself. To assist you with this search, I am providing the following information about myself:

                  Full name: John Doe

Other names and online aliases: Alioshka, citizenM, Politiwatch, milesmcc

My date of birth: January 31, 2001

My place of birth: New York City, NY

My social security number:

My phone number: (917) 767-3107

My email(s): email@example.com

                This is an individual request for research and study purposes, and I agree that I will pay up to
                  $30 in fees, if necessary. Please notify me in advance if fees are expected to exceed that amount.

                Please contact me at ___________ if you have any questions.

                Under penalty of perjury, I hereby declare that I am the person named above and I understand that any falsification of this statement is punishable under the provisions of Title 18, United States Code (U.S.C.), Section 1001 by a fine of not more than
                $10,000 or by imprisonment of not more than five years, or both; and that requesting or obtaining any record(s) under false pretenses is punishable under the provisions of Title 5, U.S.C., Section 552a(i)(3) as a misdemeanor and by a fine
                of not more than $5,000.

Respectfully,

Miles McCain

Get your FBI, NSA, IRS, and CIA files by submitting a FOIA request.

        <button class="btn btn-lg btn-block btn-success" onclick="nextSlide()">Start</button>

The United States Freedom of Information Act ("FOIA") is a law enacted in 1966 which establishes a "right-to-know" legal process by which requests may be made for government-held information to be received freely or at minimal cost.

          Foia.fyi allows you to easily navigate the often intimidating practice of submitting a FOIA request on your name or company to a government agency for free. For privacy and security concerns, Foia.fyi does not submit requests on behalf of other entities.

Which government agencies from which would you like to request information?

            <input type="checkbox" checked="true" id="data-nsa">
            National Security Agency (NSA)

            <input type="checkbox" checked="true" id="data-cia">
            Central Intelligence Agency (CIA)

            <input type="checkbox" checked="true" id="data-fbi">
            Federal Bureau of Investigation (FBI)

            <input type="checkbox" checked="true" id="data-irs">
            Internal Revenue Service (IRS)

More agencies will be added soon.

        <button class="btn btn-lg btn-block btn-primary" onclick="nextSlide()">Continue</button>

Please enter the following information about yourself.

This information is temporarily stored locally and will never leave your computer, or interact with Foia.fyi or Politiwatch servers.

We are committed to your privacy.

            Full Legal Name

            <input type="text" class="form-control" placeholder="John Doe" id="data-name">

            Aliases

            Online usernames, nicknames, etc.

            <input type="text" class="form-control" placeholder="JohnDoe315, PrivacyLover222" id="data-aliases">

            Emails

            <input type="text" class="form-control" placeholder="john.doe@example.com, jdoe@school.edu" id="data-email">

            Phone Number

            <input type="text" class="form-control" placeholder="(929) 260-1602" id="data-phone">

        <button class="btn btn-lg btn-block btn-primary" onclick="nextSlide()">Continue</button>

Address information

This information is required if you wish to hear back from any agency.

            Address

            <input type="text" class="form-control" placeholder="120 Main Street" id="data-address">

            City

            <input type="text" class="form-control" placeholder="New York" id="data-city">

            State

            <input type="text" class="form-control" placeholder="NY" id="data-state">

            Zip

            <input type="text" class="form-control" placeholder="10011" id="data-zip">

            (Optional) Fee

$

              <input type="text" class="form-control" id="data-fee" placeholder="Amount" value="30">

.00

            We suggest $30. This is only paid if the records returned are in excess of 100 pages.

        <button class="btn btn-lg btn-block btn-primary" onclick="nextSlide()">Continue</button>

Additional Information

If you are uncomfortable including the following information, then you may omit it.

              Place of Birth

              <input type="text" class="form-control" placeholder="New York, NY" id="data-placeofbirth">

              Date of Birth

              <input type="text" class="form-control" placeholder="January 10th, 1960" id="data-dateofbirth">

              SSN

              <input type="text" class="form-control" placeholder="000-00-0000" id="data-ssn">

              <input type="checkbox" checked="true" onclick="ssnbox()" id="ssn-include"> Include

          If you check 'include' but do not enter your SSN, an empty space will be included on the documents where you can handwrite your SSN.

          <button class="btn btn-lg btn-block btn-success" onclick="generateLetters()">Generate My Request!</button>

        Foia.fyi is an open source tool by Politiwatch


text:
@extends('layouts.app')

@section('content')

    @include('partials.trademark')

                    The Journal of Gender, Agriculture and Food Security (Agri-Gender) is an international,
                    open access, peer-reviewed and refereed journal published by the Africa Centre for Gender,
                    Social Research and Impact Assessment. The main objective of Agri-Gender is to provide an
                    intellectual platform for international scholars to publish their research work on gender,
                    agriculture and food security. The journal aims to promote interdisciplinary research related
                    to gender and the agricultural and food sciences.

Special Issue: April 2017, Volume 2, Issue 1

                    Catalyzing and Measuring Women's Leadership and
                    Empowerment in African Agricultural Research & Development: Part 1

Guest Editors: Apollo M. Nkwake, Wanjiru Kamau-Rutenberg and Melody Mentz

                    @if(!is_null($latest_issue))
                        @foreach ($latest_issue->publications as $paper)
                            @if($paper->status == 'published')

                                slug}}">

                                        {{$paper->title}}

                                    @foreach($paper->authors as $author)
                                        {{$author->user->f_name}} {{$author->user->l_name}}

                                        @if($loop->count == 2 && !$loop->last)
                                            and
                                        @elseif(($loop->iteration == $loop->count - 1))
                                            and
                                        @elseif(!($loop->iteration == $loop->count - 1) && !$loop->last)
                                            ,
                                        @endif
                                    @endforeach

                            @endif
                        @endforeach
                    @else

 There are no publications by Agrigender Journal yet!

                    @endif

                     All issues

    @include('partials.footer')

@endsection


text:
Sort CSS properties with [CSSComb](https://github.com/csscomb/csscomb.js).

![demo](https://raw.githubusercontent.com/1000ch/atom-csscomb/master/demo.gif)

## Installation

```bash
$ apm install atom-csscomb
```

## Usage

- Packages > CSSComb > Sort properties
- Context Menu > Sort properties
- Command Palette (⌘ + shift + P) > **CSSComb: Comb**

## Configuration

To configure with [`.csscomb.json`](https://github.com/csscomb/csscomb.js/blob/master/doc/options.md), just put it to workspace.

### Preset config

Configure with presets (`csscomb`, `zen`, `yandex`).

### Extend preset

Extend selected preset config with project config if exists.

## License

[MIT](https://1000ch.mit-license.org) © [Shogo Sensui](https://github.com/1000ch)


text:
<?php

namespace App\Models;

use Carbon\Carbon;
use Eloquent as Model;
use Illuminate\Database\Eloquent\SoftDeletes;

/**
 * @SWG\Definition(
 *      definition="Product",
 *      required={"name", "supplier", "plan", "year", "year_period_count", "year_period"},
 *      @SWG\Property(
 *          property="id",
 *          description="id",
 *          type="integer",
 *          format="int32"
 *      ),
 *      @SWG\Property(
 *          property="name",
 *          description="name",
 *          type="string"
 *      ),
 *      @SWG\Property(
 *          property="supplier",
 *          description="supplier",
 *          type="string"
 *      ),
 *      @SWG\Property(
 *          property="plan",
 *          description="plan",
 *          type="string"
 *      ),
 *      @SWG\Property(
 *          property="year",
 *          description="year",
 *          type="integer",
 *          format="int32"
 *      ),
 *      @SWG\Property(
 *          property="year_period_count",
 *          description="year_period_count",
 *          type="integer",
 *          format="int32"
 *      ),
 *      @SWG\Property(
 *          property="year_period",
 *          description="year_period",
 *          type="string"
 *      )
 * )
 */
class Product extends Model
{
    use SoftDeletes;

    public $table = 'products';

    protected $dates = ['deleted_at'];

    public $fillable = [
        'name',
        'price',
        'status',
    ];

    /**
     * The attributes that should be casted to native types.
     *
     * @var array
     */
    protected $casts = [
        'name' => 'string',
    ];

    /**
     * Validation rules
     *
     * @var array
     */
    public static $rules = [
        'name' => 'required',
        'price' => 'required',
    ];

    /**** relationship ****/
    public function policies()
    {
        return $this->hasMany(Policy::class);
    }

    public function performances()
    {
        return $this->hasMany(Performance::class);
    }

    /**** function ****/
    public function isOpen()
    {
        return $this->status == 'on';
    }

}


text:
package org.wso2.carbon.apimgt.gateway.handlers.ext;

import org.apache.axis2.Constants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.Mediator;
import org.apache.synapse.MessageContext;
import org.apache.synapse.core.axis2.Axis2MessageContext;
import org.apache.synapse.rest.AbstractHandler;
import org.apache.synapse.rest.RESTConstants;
import org.wso2.carbon.apimgt.gateway.APIMgtGatewayConstants;
import org.wso2.carbon.apimgt.gateway.MethodStats;
import org.wso2.carbon.apimgt.impl.APIConstants;
import org.wso2.carbon.apimgt.tracing.TracingSpan;
import org.wso2.carbon.apimgt.tracing.TracingTracer;
import org.wso2.carbon.apimgt.tracing.Util;
import org.wso2.carbon.metrics.manager.MetricManager;
import org.wso2.carbon.metrics.manager.Timer;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * A simple extension handler for the APIs deployed in the API gateway. This handler first
 * looks for a sequence named WSO2AM--Ext--[Dir], where [Dir] could be either In or Out
 * depending on the direction of the message. If such a sequence is found, it is invoked.
 * Following that a more API specific extension sequence is looked up by using the name
 * pattern provider--api--version--[Dir]. If such an API specific sequence is found, that
 * is also invoked. If no extension is found either at the global level or at the per API level
 * this mediator simply returns true.
 */
public class APIManagerExtensionHandler extends AbstractHandler {

    private static final String EXT_SEQUENCE_PREFIX = "WSO2AM--Ext--";
    private static final String DIRECTION_IN = "In";
    private static final String DIRECTION_OUT = "Out";
    private static final Log log = LogFactory.getLog(APIManagerExtensionHandler.class);

    @MethodStats
    public boolean mediate(MessageContext messageContext, String direction) {
        // In order to avoid a remote registry call occurring on each invocation, we
        // directly get the extension sequences from the local registry.
        Map localRegistry = messageContext.getConfiguration().getLocalRegistry();

        Object sequence = localRegistry.get(EXT_SEQUENCE_PREFIX + direction);
        if (sequence instanceof Mediator) {
            if (!((Mediator) sequence).mediate(messageContext)) {
                return false;
            }
        }

        String apiName = (String) messageContext.getProperty(RESTConstants.SYNAPSE_REST_API);
        sequence = localRegistry.get(apiName + "--" + direction);
        if (sequence instanceof Mediator) {
            return ((Mediator) sequence).mediate(messageContext);
        }
        return true;
    }

    @MethodStats
    public boolean handleRequest(MessageContext messageContext) {
        // reset HTTP_METHOD, to rest api values before send them to analytics.
        // (only for graphQL APIs)
        if (messageContext.getProperty(APIConstants.API_TYPE) != null && APIConstants.GRAPHQL_API
                .equals(messageContext.getProperty(APIConstants.API_TYPE).toString())) {
            ((Axis2MessageContext) messageContext).getAxis2MessageContext().
                    setProperty(Constants.Configuration.HTTP_METHOD,
                            messageContext.getProperty(APIConstants.HTTP_VERB));
        }

        Timer.Context context = startMetricTimer(DIRECTION_IN);
        long executionStartTime = System.nanoTime();
        TracingSpan requestMediationSpan = null;
        if (Util.tracingEnabled()) {
            TracingSpan responseLatencySpan =
                    (TracingSpan) messageContext.getProperty(APIMgtGatewayConstants.RESOURCE_SPAN);
            TracingTracer tracer = Util.getGlobalTracer();
            requestMediationSpan = Util.startSpan(APIMgtGatewayConstants.REQUEST_MEDIATION, responseLatencySpan, tracer);
        }
        try {
            boolean isMediated = mediate(messageContext, DIRECTION_IN);
            if (isMediated) {
                String requestDestination = null;
                EndpointReference objectTo = ((Axis2MessageContext) messageContext).getAxis2MessageContext()
                        .getOptions().getTo();
                if (objectTo != null) {
                    requestDestination = objectTo.getAddress();
                }
                if (requestDestination != null) {
                    messageContext.setProperty(APIMgtGatewayConstants.SYNAPSE_ENDPOINT_ADDRESS, requestDestination);
                }
            }
            return isMediated;
        } catch (Exception e) {
            if (Util.tracingEnabled() && requestMediationSpan != null) {
                Util.setTag(requestMediationSpan, APIMgtGatewayConstants.ERROR,
                        APIMgtGatewayConstants.REQUEST_MEDIATION_ERROR);
            }
            throw e;
        } finally {
            if (Util.tracingEnabled()) {
                Util.finishSpan(requestMediationSpan);
            }
            messageContext.setProperty(APIMgtGatewayConstants.REQUEST_MEDIATION_LATENCY,
                    TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - executionStartTime));
            stopMetricTimer(context);
        }
    }

    @MethodStats
    public boolean handleResponse(MessageContext messageContext) {
        Timer.Context context = startMetricTimer(DIRECTION_OUT);
        long executionStartTime = System.nanoTime();
        TracingSpan responseMediationSpan = null;
        if (Util.tracingEnabled()) {
            TracingSpan responseLatencySpan =
                    (TracingSpan) messageContext.getProperty(APIMgtGatewayConstants.RESOURCE_SPAN);
            TracingTracer tracer = Util.getGlobalTracer();
            responseMediationSpan =
                    Util.startSpan(APIMgtGatewayConstants.RESPONSE_MEDIATION, responseLatencySpan, tracer);
        }
        try {
            return mediate(messageContext, DIRECTION_OUT);
        } catch (Exception e) {
            if (Util.tracingEnabled() && responseMediationSpan != null) {
                Util.setTag(responseMediationSpan, APIMgtGatewayConstants.ERROR,
                        APIMgtGatewayConstants.RESPONSE_MEDIATION_ERROR);
            }
            throw e;
        } finally {
            if (Util.tracingEnabled()) {
                Util.finishSpan(responseMediationSpan);
            }
            messageContext.setProperty(APIMgtGatewayConstants.RESPONSE_MEDIATION_LATENCY,
                    TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - executionStartTime));
            stopMetricTimer(context);
        }
    }

	protected void stopMetricTimer(Timer.Context context) {
		context.stop();
	}

	protected Timer.Context startMetricTimer(String direction) {
		Timer timer = MetricManager.timer(org.wso2.carbon.metrics.manager.Level.INFO,
				MetricManager.name(APIConstants.METRICS_PREFIX, this.getClass().getSimpleName(), direction));
		return timer.start();
	}
}


text:
package com.tianxinwei.project.nuomi.entity.tuan_all;

import java.io.Serializable;
import java.util.List;

public class TuanListFavourList implements Serializable {
	private static final long serialVersionUID = -1066986716448115374L;
	private String deal_id;
	private int reductionAmount;
	private long price;
	private List<FavourListActivityList> activityList;
	private String list_text;
	private List<FavourListHongBaoInfo> hongbao_info;
	private String price_tag_id;

	public String getDeal_id() {
		return deal_id;
	}

	public void setDeal_id(String deal_id) {
		this.deal_id = deal_id;
	}

	public int getReductionAmount() {
		return reductionAmount;
	}

	public void setReductionAmount(int reductionAmount) {
		this.reductionAmount = reductionAmount;
	}

	public long getPrice() {
		return price;
	}

	public void setPrice(long price) {
		this.price = price;
	}

	public List<FavourListActivityList> getActivityList() {
		return activityList;
	}

	public void setActivityList(List<FavourListActivityList> activityList) {
		this.activityList = activityList;
	}

	public String getList_text() {
		return list_text;
	}

	public void setList_text(String list_text) {
		this.list_text = list_text;
	}

	public List<FavourListHongBaoInfo> getHongbao_info() {
		return hongbao_info;
	}

	public void setHongbao_info(List<FavourListHongBaoInfo> hongbao_info) {
		this.hongbao_info = hongbao_info;
	}

	public String getPrice_tag_id() {
		return price_tag_id;
	}

	public void setPrice_tag_id(String price_tag_id) {
		this.price_tag_id = price_tag_id;
	}
}


text:
<title>Troubleshooting - GNU Compiler Collection (GCC) Internals</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="GNU Compiler Collection (GCC) Internals">
<meta name="generator" content="makeinfo 4.11">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Type-Information.html#Type-Information" title="Type Information">
<link rel="prev" href="Invoking-the-garbage-collector.html#Invoking-the-garbage-collector" title="Invoking the garbage collector">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">

<meta http-equiv="Content-Style-Type" content="text/css">

Previous: Invoking the garbage collector,
Up: Type Information

22.6 Troubleshooting the garbage collector

With the current garbage collector implementation, most issues should
show up as GCC compilation errors.  Some of the most commonly
encountered issues are described below.

Gengtype does not produce allocators for a GTY-marked type.
Gengtype checks if there is at least one possible path from GC roots to
at least one instance of each type before outputting allocators.  If
there is no such path, the GTY markers will be ignored and no
allocators will be output.  Solve this by making sure that there exists
at least one such path.  If creating it is unfeasible or raises a “code
smell”, consider if you really must use GC for allocating such type.

Link-time errors about undefined gt_ggc_r_foo_bar and
similarly-named symbols.  Check if your <samp>foo_bar</samp> source file has
#include "gt-foo_bar.h" as its very last line.


text:
var Icon = require('./lib/Icon.react');
module.exports = Icon;


text:
REPO=https://github.com/styled-components/polished.git

# Default tag polished
if [ -z "$1" ]; then
  export VERSION="v4.1.3"
else
  export VERSION="$1"
fi

yum install git wget -y

#Install Nodejs version 16
wget https://nodejs.org/download/release/latest-v14.x/node-v14.17.6-linux-ppc64le.tar.gz
tar -xzf node-v14.17.6-linux-ppc64le.tar.gz
export PATH=$CWD/node-v14.17.6-linux-ppc64le/bin:$PATH

#Cloning Repo
git clone $REPO
cd  polished
#Install yarn package
npm install yarn -g

#Checkout to the version
git checkout ${VERSION}

#Build repo
yarn  install

#Test repo
yarn test


text:
ape.main.main
=============

.. currentmodule:: ape.main

.. autofunction:: main


text:
import urllib
import re

def openUrl(url):
	html=urllib.urlopen(url).read()
	return html

def downloadImg(html,i):
	pat=r'class="BDE_Image" src="(.*?\.jpg)"'
	imgPat=re.compile(pat)
	imgUrl=re.findall(imgPat,html)
	num=0
	for url in imgUrl:
		urllib.urlretrieve(url,'%s_%s.jpg' % (i,num))
		num+=1

urll=raw_input("Input Url to Download Comics:")
n=int(raw_input("Input Page Number:"))
for i in range(0,n):
	addr='%s?pn=%s' % (urll,i)
	page=openUrl(addr)
	downloadImg(page,i)
print "Comics Downloaded"


text:
/*eslint-disable*/
'use strict';
process.env.BABEL_ENV = 'test';
const babelOptions = require('./package.json').babel.env.test;
module.exports = function(wallaby) {
  return {
    env: {
      type: 'node',
      runner: 'node'
    },

    testFramework: 'jest',

    files: [
      'package.json',
      'src/**/*.js',
      '!src/**/*.test.js',
    ],

    tests: [
      'src/**/*.test.js',
    ],

    compilers: {
      '**/*.js': wallaby.compilers.babel(babelOptions)
    },

    setup: function(w) {
      require('babel-polyfill');
      w.testFramework.configure(require('./package.json').jest);
    }
  };
};


text:
<?php
/*Startup stuff*/
$salt = "whyareweheredonotaskthatquestionagain";
error_reporting(0);

if (isset($_POST['stage'])) {
    $install_stage = $_POST['stage'];
}
else {
    $install_stage = 0;
}

?>

<title>
CS Virtual Tour Admin Interface Installation
</title>

CS Virtual Tour Admin Interface Installation

<?php
/*Stage0 stuff*/
if ( $install_stage == 0) {
    ?>

Step 1

    <form method='post' action='install.php'>
        <input type='hidden' name='stage' value='1'/>

Database Settings

        <input type='text' name='dbhost' id='dbhost' value='localhost' />
        Database Host

        <input type='text' name='dbname' id='dbname' value='' />
        Database Name

        <input type='text' name='readuser' id='readuser' value='' />
        Database Read User

        <input type='text' name='readpass' id='readpass' value='' />
        Database Read Password

        <input type='text' name='writeuser' id='writeuser' value='' />
        Database Write User

        <input type='text' name='writepass' id='writepass' value='' />
        Database Write Password

Admin Account Settings

        <input type='text' name='adminpass' id='adminpass' value='' />
        What password would you like to use for the admin account

        <input type='submit' value='Go'/>
    </form>
    <?php
}
else if ( $install_stage == 1) {

    echo "
Step 2
";
    $host = $_POST['dbhost'];
    $dbname = $_POST['dbname'];
    $read_user = $_POST['readuser'];
    $read_pass = $_POST['readpass'];
    $write_user = $_POST['writeuser'];
    $write_pass = $_POST['writepass'];
    $admin_pass = $_POST['adminpass'];
    $admin_pass = crypt($admin_pass, $salt);

    /*test database credentials*/
    $link = mysqli_connect($host, $read_user, $read_pass, $dbname);
    if ($link) {
        echo "
Read database credentials validated
";
    }
    else {
        die("
Read database credentials couldn't be validated. Installation aborted! ".mysqli_connect_error($link)."
");
    }
    $writedb = mysqli_connect($host, $write_user, $write_pass, $dbname);
    if ($writedb) {
        echo "
Write database credentials validated
";
    }
    else {
        die("
Write database credentials couldn't be validated. Installation aborted! ".mysqli_connect_error($writedb)."
");
    }

ob_start();
?>
CREATE TABLE IF NOT EXISTS `maps` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `url` varchar(2083) COLLATE utf8_unicode_ci NOT NULL,
  `desc` varchar(1000) COLLATE utf8_unicode_ci NOT NULL,
  `ordering` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=17 ;

CREATE TABLE IF NOT EXISTS `Stops` (
  `StopID` int(11) NOT NULL AUTO_INCREMENT,
  `StopName` varchar(80) COLLATE utf8_unicode_ci NOT NULL,
  `RoomNumber` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `StopContent` varchar(10240) COLLATE utf8_unicode_ci NOT NULL,
  `StopX` double NOT NULL,
  `StopY` double NOT NULL,
  `StopQRIdentifier` varchar(120) COLLATE utf8_unicode_ci NOT NULL,
  `StopOrder` int(11) NOT NULL,
  `MapID` int(11) NOT NULL,
  `Active` varchar(3) COLLATE utf8_unicode_ci NOT NULL DEFAULT 'yes',
  PRIMARY KEY (`StopID`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=28 ;

INSERT INTO `Stops` (`StopID`, `StopName`, `RoomNumber`, `StopContent`, `StopX`, `StopY`, `StopQRIdentifier`, `StopOrder`, `MapID`, `Active`) VALUES
(25, 'Dummy Stop', 'CF XXX', '[{"type":"text","title":"Title","content":"Dummy Content"}]', 0.25, 0.25, '25', 4, 0, 'yes');

CREATE TABLE IF NOT EXISTS `user` (
  `userid` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(30) COLLATE utf8_unicode_ci NOT NULL,
  `password` varchar(120) COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`userid`),
  UNIQUE KEY `UserID` (`userid`,`username`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=3 ;

INSERT INTO `user` (`userid`, `username`, `password`) VALUES
(1, 'admin', '<?php echo $admin_pass;?>');

<?php
$install_query = ob_get_clean();

/*Create the dbconnections file*/
ob_start();
echo "<?php";
?>

$link = mysqli_connect("<?php echo $host;?>", "<?php echo $read_user;?>", "<?php echo $read_pass;?>", "<?php echo $dbname;?>")
    or die("Error " . mysqli_connect_error($link));

$writedb = mysqli_connect("<?php echo $host;?>", "<?php echo $write_user;?>", "<?php echo $write_pass;?>", "<?php echo $dbname;?>")
    or die("Error " . mysqli_connect_error($writedb));

<?php
echo "?>";
    $dbfile_contents = ob_get_clean();

    if (file_put_contents("dbconnections.php", $dbfile_contents)) {
        echo "
dbconnections.php successfully created
";
    }
    else {
        echo "
Couldn't write file! Please create a new file in the current directory called dbconnections.php with the following contents:
".nl2br(htmlentities($dbfile_contents))."

";
    }

    if (mysqli_multi_query($writedb, $install_query)) {
        echo "
Database successfully set up
";
    }
    else {
        die("
Database setup failed! Installation aborted. ".mysqli_error($writedb)."
");
    }

    echo "
Installation appears to be successful. Please delete this file (install.php) now for security purposes.
";
}
?>


text:
from __future__ import unicode_literals

from prompt_toolkit.application import get_app
from prompt_toolkit.filters import Condition, has_focus, vi_insert_mode, vi_navigation_mode
from prompt_toolkit.key_binding import KeyBindings

import os

__all__ = (
    'create_key_bindings',
)

def _current_window_for_event(event):
    """
    Return the `Window` for the currently focussed Buffer.
    """
    return event.app.layout.current_window

def create_key_bindings(editor):
    """
    Create custom key bindings.

    This starts with the key bindings, defined by `prompt-toolkit`, but adds
    the ones which are specific for the editor.
    """
    kb = KeyBindings()

    # Filters.
    @Condition
    def vi_buffer_focussed():
        app = get_app()
        if app.layout.has_focus(editor.search_buffer) or app.layout.has_focus(editor.command_buffer):
            return False
        return True

    in_insert_mode = vi_insert_mode & vi_buffer_focussed
    in_navigation_mode = vi_navigation_mode & vi_buffer_focussed

    @kb.add('c-t')
    def _(event):
        """
        Override default behaviour of prompt-toolkit.
        (Control-T will swap the last two characters before the cursor, because
        that's what readline does.)
        """
        pass

    @kb.add('c-t', filter=in_insert_mode)
    def indent_line(event):
        """
        Indent current line.
        """
        b = event.application.current_buffer

        # Move to start of line.
        pos = b.document.get_start_of_line_position(after_whitespace=True)
        b.cursor_position += pos

        # Insert tab.
        if editor.expand_tab:
            b.insert_text('    ')
        else:
            b.insert_text('\t')

        # Restore cursor.
        b.cursor_position -= pos

    @kb.add('c-r', filter=in_navigation_mode, save_before=(lambda e: False))
    def redo(event):
        """
        Redo.
        """
        event.app.current_buffer.redo()

    @kb.add(':', filter=in_navigation_mode)
    def enter_command_mode(event):
        """
        Entering command mode.
        """
        editor.enter_command_mode()

    @kb.add('tab', filter=vi_insert_mode &
            ~has_focus(editor.command_buffer) & whitespace_before_cursor_on_line)
    def autocomplete_or_indent(event):
        """
        When the 'tab' key is pressed with only whitespace character before the
        cursor, do autocompletion. Otherwise, insert indentation.
        """
        b = event.app.current_buffer
        if editor.expand_tab:
            b.insert_text('    ')
        else:
            b.insert_text('\t')

    @kb.add('escape', filter=has_focus(editor.command_buffer))
    @kb.add('c-c', filter=has_focus(editor.command_buffer))
    @kb.add('backspace',
        filter=has_focus(editor.command_buffer) & Condition(lambda: editor.command_buffer.text == ''))
    def leave_command_mode(event):
        """
        Leaving command mode.
        """
        editor.leave_command_mode()

    @kb.add('c-w', 'c-w', filter=in_navigation_mode)
    def focus_next_window(event):
        editor.window_arrangement.cycle_focus()
        editor.sync_with_prompt_toolkit()

    @kb.add('c-w', 'n', filter=in_navigation_mode)
    def horizontal_split(event):
        """
        Split horizontally.
        """
        editor.window_arrangement.hsplit(None)
        editor.sync_with_prompt_toolkit()

    @kb.add('c-w', 'v', filter=in_navigation_mode)
    def vertical_split(event):
        """
        Split vertically.
        """
        editor.window_arrangement.vsplit(None)
        editor.sync_with_prompt_toolkit()

    @kb.add('g', 't', filter=in_navigation_mode)
    def focus_next_tab(event):
        editor.window_arrangement.go_to_next_tab()
        editor.sync_with_prompt_toolkit()

    @kb.add('g', 'T', filter=in_navigation_mode)
    def focus_previous_tab(event):
        editor.window_arrangement.go_to_previous_tab()
        editor.sync_with_prompt_toolkit()

    @kb.add('f1')
    def show_help(event):
        editor.show_help()

    @Condition
    def in_file_explorer_mode():
        return bool(editor.current_editor_buffer and
            editor.current_editor_buffer.in_file_explorer_mode)

    @kb.add('enter', filter=in_file_explorer_mode)
    def open_path(event):
        """
        Open file/directory in file explorer mode.
        """
        name_under_cursor = event.current_buffer.document.current_line
        new_path = os.path.normpath(os.path.join(
            editor.current_editor_buffer.location, name_under_cursor))

        editor.window_arrangement.open_buffer(
            new_path, show_in_current_window=True)
        editor.sync_with_prompt_toolkit()

    @kb.add('-', filter=in_file_explorer_mode)
    def to_parent_directory(event):
        new_path = os.path.normpath(os.path.join(
            editor.current_editor_buffer.location, '..'))

        editor.window_arrangement.open_buffer(
            new_path, show_in_current_window=True)
        editor.sync_with_prompt_toolkit()

    return kb

@Condition
def whitespace_before_cursor_on_line():
    """
    Filter which evaluates to True when the characters before the cursor are
    whitespace, or we are at the start of te line.
    """
    b = get_app().current_buffer
    before_cursor = b.document.current_line_before_cursor

    return bool(not before_cursor or before_cursor[-1].isspace())


text:
package org.xact.client.common;

import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientHandlerException;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.UniformInterfaceException;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.api.client.filter.HTTPBasicAuthFilter;
import com.sun.jersey.api.client.filter.LoggingFilter;

/**
 * Its a wrapper for sending calls to xact apis. Requester is responsible for sending any request to xact api.
 * @author NIKHIL (nikhil@awaaz.de, nikhil.navadiya@gmail.com)
 *
 */
public class XACTRequester {

	private String x_username; //username which would be used for authentication
	private String x_password; //password for authentication
	private String x_baseurl; //base url where each request would be send, its an optional

	private String x_token; //used in case of token based authentication
	private boolean isTokenbasedAuth = false;

	private Client m_client = null;

	private static ObjectMapper objMapper = new ObjectMapper();

	/**
	 * Content types
	 * @author NIKHIL
	 *
	 */
	public static enum ContentFormat {
		APPLICATION_JSON("application/json");
		private String value;
		private ContentFormat(String value) {
			this.value = value;
		}
		public String  getValue() {
			return value;
		}
	}

	/**
	 * Constructor
	 * @param username username using which authentication would be done
	 * @param password password for username
	 * @param baseUrl web service base url
	 */
	public XACTRequester(String username, String password, String baseUrl) {
		this.x_baseurl = baseUrl==null?"http://awaaz.de/console/xact/":baseUrl;
		this.x_username = username;
		this.x_password = password;
	}

	/**
	 * Constructor
	 * @param authToken authentication token
	 */
	public XACTRequester(String authToken) {
		this.x_token = authToken;
		this.isTokenbasedAuth = true;
	}

	/**
	 * Make a get request
	 * @param methodUrl
	 * @return
	 */
	public String get(String methodUrl) throws XACTRequesterException {
		//calling webservice
		WebResource webResource = getClient().resource(x_baseurl + "/" + methodUrl + "/");
		ClientResponse response = webResource.accept(ContentFormat.APPLICATION_JSON.getValue()).get(ClientResponse.class);

		String responseText = response.getEntity(String.class);
		if (response.getStatus() != 200)
			throw new XACTRequesterException(responseText, XACTRequesterException.XACTExceptionErrorCode.DATA_GET_ERROR);
		return responseText;
	}

	/**
	 * Make a post request
	 * @param methodUrl url
	 * @param data data which needs to be post
	 * @return
	 * @throws XACTRequesterException
	 */
	public String post(String methodUrl, Map<String, Object> data) throws XACTRequesterException {
		String responseText = null;
		try {
			WebResource webResource = getClient().resource(x_baseurl + "/" + methodUrl + "/");
			ClientResponse response;
			response = webResource.accept(ContentFormat.APPLICATION_JSON.getValue()).type(ContentFormat.APPLICATION_JSON.getValue()).post(ClientResponse.class, XACTRequester.objMapper.writeValueAsString(data));
			responseText = response.getEntity(String.class);
			if (response.getStatus() != 201)
				throw new XACTRequesterException(responseText, XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (UniformInterfaceException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (ClientHandlerException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (JsonProcessingException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		}
		return responseText;
	}

	/**
	 * Make a put request
	 * @param methodUrl url
	 * @param data data which needs to be post
	 * @return
	 * @throws XACTRequesterException
	 */
	public String put(String methodUrl, Map<String, Object> data) throws XACTRequesterException {
		String responseText = null;
		try {
		WebResource webResource = getClient().resource(x_baseurl + "/" + methodUrl + "/");
		ClientResponse response = webResource.accept(ContentFormat.APPLICATION_JSON.getValue()).type(ContentFormat.APPLICATION_JSON.getValue()).put(ClientResponse.class, XACTRequester.objMapper.writeValueAsString(data));
		responseText = response.getEntity(String.class);
		if (response.getStatus() != 200)
			throw new XACTRequesterException(responseText, XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (UniformInterfaceException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (ClientHandlerException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		} catch (JsonProcessingException e) {
			throw new XACTRequesterException(e.getLocalizedMessage(), XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		}
		return responseText;
	}

	/**
	 * Make a delete request
	 * @param methodUrl url
	 * @param data data which needs to be post
	 * @return
	 * @throws XACTRequesterException
	 */
	public boolean delete(String methodUrl) throws XACTRequesterException {
		WebResource webResource = getClient().resource(x_baseurl + "/" + methodUrl + "/");
		ClientResponse response = webResource.accept(ContentFormat.APPLICATION_JSON.getValue()).delete(ClientResponse.class);
		if (response.getStatus() != 204) {
			String responseText = response.getEntity(String.class);
			throw new XACTRequesterException(responseText, XACTRequesterException.XACTExceptionErrorCode.DATA_POST_ERROR);
		}
		return true;
	}

	/**
	 * Returns jersey client to make any call to webservice
	 * @return
	 */
	private Client getClient() {
		if(m_client == null) {
			m_client = new Client();
			if(!isTokenbasedAuth) {
				final HTTPBasicAuthFilter authFilter = new HTTPBasicAuthFilter(x_username, x_password);
				m_client.addFilter(authFilter);
				m_client.addFilter(new LoggingFilter());
			} else {
				//TODO for token based authentication
			}
		}

		return m_client;
	}
}


text:
#ifndef __CREATESAMPLES_UTILITY_HPP__
#define __CREATESAMPLES_UTILITY_HPP__

#define CV_VERBOSE  1

/*
 * cvCreateTrainingSamples
 *
 * Create training samples applying random distortions to sample image and
 * store them in .vec file
 *
 * filename        - .vec file name
 * imgfilename     - sample image file name
 * bgcolor         - background color for sample image
 * bgthreshold     - background color threshold. Pixels those colors are in range
 *   [bgcolor-bgthreshold, bgcolor+bgthreshold] are considered as transparent
 * bgfilename      - background description file name. If not NULL samples
 *   will be put on arbitrary background
 * count           - desired number of samples
 * invert          - if not 0 sample foreground pixels will be inverted
 *   if invert == CV_RANDOM_INVERT then samples will be inverted randomly
 * maxintensitydev - desired max intensity deviation of foreground samples pixels
 * maxxangle       - max rotation angles
 * maxyangle
 * maxzangle
 * showsamples     - if not 0 samples will be shown
 * winwidth        - desired samples width
 * winheight       - desired samples height
 */
#define CV_RANDOM_INVERT 0x7FFFFFFF

void cvCreateTrainingSamples( const char* filename,
                              const char* imgfilename, int bgcolor, int bgthreshold,
                              const char* bgfilename, int count,
                              int invert = 0, int maxintensitydev = 40,
                              double maxxangle = 1.1,
                              double maxyangle = 1.1,
                              double maxzangle = 0.5,
                              int showsamples = 0,
                              int winwidth = 24, int winheight = 24 );

void cvCreateTestSamples( const char* infoname,
                          const char* imgfilename, int bgcolor, int bgthreshold,
                          const char* bgfilename, int count,
                          int invert, int maxintensitydev,
                          double maxxangle, double maxyangle, double maxzangle,
                          int showsamples,
                          int winwidth, int winheight, double maxscale );

/*
 * cvCreateTrainingSamplesFromInfo
 *
 * Create training samples from a set of marked up images and store them into .vec file
 * infoname    - file in which marked up image descriptions are stored
 * num         - desired number of samples
 * showsamples - if not 0 samples will be shown
 * winwidth    - sample width
 * winheight   - sample height
 *
 * Return number of successfully created samples
 */
int cvCreateTrainingSamplesFromInfo( const char* infoname, const char* vecfilename,
                                     int num,
                                     int showsamples,
                                     int winwidth, int winheight );

/*
 * cvShowVecSamples
 *
 * Shows samples stored in .vec file
 *
 * filename
 *   .vec file name
 * winwidth
 *   sample width
 * winheight
 *   sample height
 * scale
 *   the scale each sample is adjusted to
 */
void cvShowVecSamples( const char* filename, int winwidth, int winheight, double scale );

#endif //__CREATESAMPLES_UTILITY_HPP__


text:
<?php

namespace Bookboon\Api\Exception;

class BadUUIDException extends BookboonException
{
    public function __construct()
    {
        parent::__construct("UUID Not Formatted Correctly");
    }
}


text:
using OpenQA.Selenium;
using OpenQA.Selenium.Support;
using Sdet.Auto.TestHelper;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Sdet.Auto.PageObjects
{
    public class Navigation : WebDriverBase
    {
        public static void NavToWebPageUnderTest()
        {
            var navigation = Driver.Navigate();
            navigation.GoToUrl(ConfigurationManager.AppSettings["webUrl"]);
        }
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
B. A. N. Z. Antarct. Exped. Res. Rep. 7: 188 (1948)

#### Original name
Parmelia sublugubris C.W. Dodge

### Remarks
null


text:
<!DOCTYPE html>
<link rel="author" title="Morten Stenshorne" href="mailto:mstensho@chromium.org">
<link rel="help" href="https://www.w3.org/TR/css-tables-3/#repeated-headers">
<link rel="match" href="../../../reference/ref-filled-green-100px-square.xht">

Test passes if there is a filled green square and no red.


text:
"use strict";

describe("getSelectedCountryData: init plugin to test public method getSelectedCountryData", function() {

  beforeEach(function() {
    intlSetup();
    input = $("<input>");
    input.intlTelInput();
  });

  afterEach(function() {
    input.intlTelInput("destroy");
    input = null;
  });

  it("gets the right default country data", function() {
    expect(input.intlTelInput("getSelectedCountryData").iso2).toEqual("us");
  });

  it("change country by number gets the right country data", function() {
    input.val("+44");
    triggerKeyOnInput(" ");
    expect(input.intlTelInput("getSelectedCountryData").iso2).toEqual("gb");
  });

  it("change country by selecting a flag gets the right country data", function() {
    selectFlag("ch");
    expect(input.intlTelInput("getSelectedCountryData").iso2).toEqual("ch");
  });

});


text:
装箱任务负责人列表

                                            <input type="search" placeholder="姓名" data-ng-keyup="getCustomerManagersList()" ng-model="queryParam.customerKeyword" class="form-control" aria-controls="dt_basic">

                                    <button class="btn btn-primary" type="button" data-ng-click="getCustomerManagersList()">

                                        刷新
                                    </button>

									序号
									负责人
									待操作
									操作中
									已完成
									合计
									操作

 0" ng-mouseenter="show=true" ng-mouseleave="show=false">

暂无数据

								<ug-pagination page-info="packingTaskPageInfoSetting" ></ug-pagination>

装箱任务待分配

							装箱负责人:{{currentCustomer.actorName}}     重选

                                            <input type="search" placeholder="订单号" data-ng-keyup="getOrderList()" ng-model="queryParam.keyword" class="form-control" aria-controls="dt_basic">

                                            <input type="search" placeholder="收货人" data-ng-keyup="getOrderList()" ng-model="queryParam.consigneeName" class="form-control" aria-controls="dt_basic">

                                            <select ug-select2 style="width: 250px;" ng-model="queryParam.managerId" ng-change="getOrderList()"  name="managerId" >
                                                <option value="">--请选择客服经理--</option>
                                                <option value="{{manager.customerMangerId}}" ng-repeat="manager in managers">{{manager.customerManger}}</option>
                                            </select>

                                        <input type="text" class="form-control" datepicker-popup="yyyy-MM-dd" datepicker-localdate
                                               placeholder="配送起始时间"
                                               ng-model="queryParam.appointmentTimeStart"
                                               close-text="关闭"
                                               current-text="今日"
                                               clear-text="清除"
                                               is-open="datepickerSetting.appointmentTimeStart.opened"
                                               ng-required="true" />

                                            <button type="button" class="btn btn-default" ng-click="openDate($event, 0)"></button>

                                        <input type="text" class="form-control" datepicker-popup="yyyy-MM-dd" datepicker-localdate
                                               placeholder="配送截止时间"
                                               ng-model="queryParam.appointmentTimeEnd"
                                               close-text="关闭"
                                               current-text="今日"
                                               clear-text="清除"
                                               is-open="datepickerSetting.appointmentTimeEnd.opened"
                                               ng-required="true" />

                                            <button type="button" class="btn btn-default" ng-click="openDate($event, 1)"></button>

                                    <button class="btn btn-primary" type="button" data-ng-click="getOrderList()">

                                        刷新
                                    </button>

                                    <button class="btn btn-primary" btn-loading="saveBtnLoading" type="button" data-ng-click="batchBindPackingTask()">

                                        批量分配
                                    </button>

                                            <input type="checkbox" ng-model="chooseAllCheck.isCheckOrder" ng-true-value="0" ng-false-value="1" ng-change="checkedAllOrder()" />

									序号
									订单编号
                                    客户经理
                                    收货人
                                    批次号
									装箱任务负责人
                                    订单状态
									分配状态
									配送时间
									操作

 0" ng-mouseenter="show=true" ng-mouseleave="show=false">

                                            <input type="checkbox"
                                                   checklist-model="chooseOrder"
                                                   checklist-before-change="changeOrderList()"
                                                   checklist-value="order"
                                                    >

已分配

待分配

                                            <button class="btn btn-primary" btn-loading="order.saveBtnLoading" data-ng-click="bindPackingTask($index)" title="分配">
                                                分配
                                            </button>

暂无数据

								<ug-pagination page-info="pageInfoSetting" ></ug-pagination>