text:
MAXIM
=====

* **Maxim Integrated**
* https://www.maximintegrated.com

redpajama_set_name: RedPajamaGithub


text:
package org.fest.swing.fixture;

import static java.awt.BorderLayout.CENTER;
import static javax.swing.JTabbedPane.SCROLL_TAB_LAYOUT;
import static javax.swing.SwingConstants.BOTTOM;
import static org.fest.swing.edt.GuiActionRunner.execute;
import static org.fest.util.Strings.concat;

import java.awt.BorderLayout;
import java.awt.Dimension;

import javax.swing.JPanel;
import javax.swing.JTabbedPane;

import org.fest.swing.annotation.RunsInCurrentThread;
import org.fest.swing.annotation.RunsInEDT;
import org.fest.swing.edt.GuiQuery;
import org.fest.swing.test.core.RobotBasedTestCase;
import org.fest.swing.test.swing.TestWindow;
import org.fest.swing.timing.Pause;
import org.junit.Test;

/**
 * Test case for bug FEST-309.
 *
 * @author Nicolae Bucalaete
 * @author Alex Ruiz
 */
public class FEST309_scrollAndSelectTab_Test extends RobotBasedTestCase {
  private MyWindow window;
  private FrameFixture frame;

  @Override
  protected void onSetUp() {
    window = MyWindow.createNew();
    frame = new FrameFixture(robot, window);
    frame.show();
  }

  @Test
  public void should_scroll_and_click_tab() {
    frame.tabbedPane().selectTab(90);
    Pause.pause(10000);
  }

  private static class MyWindow extends TestWindow {
    @RunsInEDT
    static MyWindow createNew() {
      return execute(new GuiQuery<MyWindow>() {
        @Override
        protected MyWindow executeInEDT() {
          return new MyWindow();
        }
      });
    }

    private final JTabbedPane tabbedPane = new JTabbedPane();

    @RunsInCurrentThread
    private MyWindow() {
      super(FEST309_scrollAndSelectTab_Test.class);
      configureTabbedPane();
      setLayout(new BorderLayout());
      add(tabbedPane, CENTER);
      setPreferredSize(new Dimension(300, 100));
    }

    private void configureTabbedPane() {
      tabbedPane.setTabLayoutPolicy(SCROLL_TAB_LAYOUT);
      tabbedPane.setTabPlacement(BOTTOM);
      for (int i = 0; i < 100; i++) {
        tabbedPane.addTab(concat("Tab ", i), new JPanel());
      }
    }
  }
}


text:
module Azure::CDN::Mgmt::V2017_10_12
  module Models
    #
    # CDN Ip address group
    #
    class IpAddressGroup

      include MsRestAzure

      # @return [String] The delivery region of the ip address group
      attr_accessor :delivery_region

      # @return [Array<CidrIpAddress>] The list of ip v4 addresses.
      attr_accessor :ipv4addresses

      # @return [Array<CidrIpAddress>] The list of ip v6 addresses.
      attr_accessor :ipv6addresses

      #
      # Mapper for IpAddressGroup class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'IpAddressGroup',
          type: {
            name: 'Composite',
            class_name: 'IpAddressGroup',
            model_properties: {
              delivery_region: {
                client_side_validation: true,
                required: false,
                serialized_name: 'deliveryRegion',
                type: {
                  name: 'String'
                }
              },
              ipv4addresses: {
                client_side_validation: true,
                required: false,
                serialized_name: 'ipv4Addresses',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'CidrIpAddressElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'CidrIpAddress'
                      }
                  }
                }
              },
              ipv6addresses: {
                client_side_validation: true,
                required: false,
                serialized_name: 'ipv6Addresses',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'CidrIpAddressElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'CidrIpAddress'
                      }
                  }
                }
              }
            }
          }
        }
      end
    end
  end
end


text: Installs the SSH keys and configuration required for an instance to access our GitHub repositories.


text:
mkdir -p ./dist/js

# Create the Vendor File
browserify \
-r react:react \
-r moment:moment \
-r ./bin/dummyFile \
-o ./dist/js/vendor.js


text:
( function () {

	class ClearPass extends THREE.Pass {

		constructor( clearColor, clearAlpha ) {

			super();
			this.needsSwap = false;
			this.clearColor = clearColor !== undefined ? clearColor : 0x000000;
			this.clearAlpha = clearAlpha !== undefined ? clearAlpha : 0;
			this._oldClearColor = new THREE.Color();

		}

		render( renderer, writeBuffer, readBuffer
			/*, deltaTime, maskActive */
		) {

			let oldClearAlpha;

			if ( this.clearColor ) {

				renderer.getClearColor( this._oldClearColor );
				oldClearAlpha = renderer.getClearAlpha();
				renderer.setClearColor( this.clearColor, this.clearAlpha );

			}

			renderer.setRenderTarget( this.renderToScreen ? null : readBuffer );
			renderer.clear();

			if ( this.clearColor ) {

				renderer.setClearColor( this._oldClearColor, oldClearAlpha );

			}

		}

	}

	THREE.ClearPass = ClearPass;

} )();


text:
$(document).ready(function(){

    (function($) {
        "use strict";

    jQuery.validator.addMethod('answercheck', function (value, element) {
        return this.optional(element) || /^\bcat\b$/.test(value)
    }, "type the correct answer -_-");

    // validate contactForm form
    $(function() {
        $('#contactForm').validate({
            rules: {
                name: {
                    required: true,
                    minlength: 2
                },
                subject: {
                    required: true,
                    minlength: 4
                },
                number: {
                    required: true,
                    minlength: 5
                },
                email: {
                    required: true,
                    email: true
                },
                message: {
                    required: true,
                    minlength: 20
                }
            },
            messages: {
                name: {
                    required: "come on, you have a name, don't you?",
                    minlength: "your name must consist of at least 2 characters"
                },
                subject: {
                    required: "come on, you have a subject, don't you?",
                    minlength: "your subject must consist of at least 4 characters"
                },
                number: {
                    required: "come on, you have a number, don't you?",
                    minlength: "your Number must consist of at least 5 characters"
                },
                email: {
                    required: "no email, no message"
                },
                message: {
                    required: "um...yea, you have to write something to send this form.",
                    minlength: "thats all? really?"
                }
            },
            submitHandler: function(form) {
                $(form).ajaxSubmit({
                    type:"POST",
                    data: $(form).serialize(),
                    url:"contact_process.php",
                    success: function() {
                        $('#contactForm :input').attr('disabled', 'disabled');
                        $('#contactForm').fadeTo( "slow", 1, function() {
                            $(this).find(':input').attr('disabled', 'disabled');
                            $(this).find('label').css('cursor','default');
                            $('#success').fadeIn()
                            $('.modal').modal('hide');
		                	$('#success').modal('show');
                        })
                    },
                    error: function() {
                        $('#contactForm').fadeTo( "slow", 1, function() {
                            $('#error').fadeIn()
                            $('.modal').modal('hide');
		                	$('#error').modal('show');
                        })
                    }
                })
            }
        })
    })

 })(jQuery)
})


text:
<?php

namespace Oro\Bundle\SearchBundle\Engine\Orm;

use Doctrine\Common\Collections\Expr\Comparison;
use Doctrine\Common\Collections\Expr\CompositeExpression;
use Doctrine\Common\Collections\Expr\ExpressionVisitor;
use Doctrine\Common\Collections\Expr\Value;
use Doctrine\ORM\QueryBuilder;

use Oro\Bundle\SearchBundle\Query\Criteria\Criteria;
use Oro\Bundle\SearchBundle\Query\Query;

class OrmExpressionVisitor extends ExpressionVisitor
{
    /** @var BaseDriver */
    protected $driver;

    /** @var QueryBuilder */
    protected $qb;

    /** @var bool */
    protected $setOrderBy;

    /**
     * @param BaseDriver   $driver
     * @param QueryBuilder $qb
     * @param bool         $setOrderBy
     */
    public function __construct(BaseDriver $driver, QueryBuilder $qb, $setOrderBy = false)
    {
        $this->driver     = $driver;
        $this->qb         = $qb;
        $this->setOrderBy = $setOrderBy;
    }

    /**
     * {@inheritdoc}
     */
    public function walkComparison(Comparison $comparison)
    {
        $value = $comparison->getValue()->getValue();
        list($type, $field) = $this->explodeCombinedFieldString($comparison->getField());

        $index = uniqid();

        $joinField = sprintf('search.%sFields', $type);
        $joinAlias = $this->driver->getJoinAlias($type, $index);
        $this->qb->leftJoin($joinField, $joinAlias);

        $searchCondition = [
            'fieldName'  => $field,
            'condition'  => Criteria::getSearchOperatorByComparisonOperator($comparison->getOperator()),
            'fieldValue' => $value,
            'fieldType'  => $type
        ];

        if ($type === Query::TYPE_TEXT) {
            if ($searchCondition['fieldValue'] === '') {
                $this->qb->setParameter('field' . $index, $searchCondition['fieldName']);

                return $joinAlias . '.field = :field' . $index;
            } else {
                return $this->driver->addTextField($this->qb, $index, $searchCondition, $this->setOrderBy);
            }
        }

        return $this->driver->addNonTextField($this->qb, $index, $searchCondition);
    }

    /**
     * {@inheritdoc}
     */
    public function walkValue(Value $value)
    {
        $value->getValue();
    }

    /**
     * {@inheritdoc}
     */
    public function walkCompositeExpression(CompositeExpression $expr)
    {
        $expressionList       = [];
        $expressionObjectList = [];

        $expressions    = $expr->getExpressionList();
        $lineExpression = true;
        foreach ($expressions as $child) {
            if ($child instanceof CompositeExpression) {
                $lineExpression       = false;
                $expressionObjectList = $expressions;
                break;
            }
        }

        // optimize search query.
        if ($lineExpression) {
            /** @var Comparison $child */
            foreach ($expressions as $child) {
                $fieldName          = $child->getField();
                $operator           = $child->getOperator();
                $value              = $child->getValue()->getValue();
                $fieldType          = Criteria::explodeFieldTypeName($fieldName)[0];
                $key                = $this->getExpressionKey($fieldType, $operator, $value);
                $combinedExpression = $child;
                if ($fieldType !== Query::TYPE_TEXT && in_array($key, array_keys($expressionObjectList))) {
                    $combinedExpression = $expressionObjectList[$key];

                    $combinedExpression = new Comparison(
                        $this->combineFieldNames($combinedExpression->getField(), $fieldName),
                        $operator,
                        $value
                    );

                }
                $expressionObjectList[$key] = $combinedExpression;
            }
        }

        foreach ($expressionObjectList as $child) {
            $expressionList[] = $this->dispatch($child);
        }

        switch ($expr->getType()) {
            case CompositeExpression::TYPE_AND:
                return '(' . implode(' AND ', $expressionList) . ')';

            case CompositeExpression::TYPE_OR:
                return '(' . implode(' OR ', $expressionList) . ')';

            default:
                throw new \RuntimeException('Unknown composite ' . $expr->getType());
        }
    }

    /**
     * @param string $fieldType
     * @param string $operator
     * @param mixed  $value
     *
     * @return string
     */
    protected function getExpressionKey($fieldType, $operator, $value)
    {
        $value = is_array($value) ? serialize($value) : (string)$value;
        return md5($fieldType . $operator . $value);
    }

    /**
     * @param string $arrayFields
     * @param string $additionalField
     *
     * @return string
     */
    protected function combineFieldNames($arrayFields, $additionalField)
    {
        list($type, $field) = Criteria::explodeFieldTypeName($additionalField);
        $fieldsString = implode(
            '|',
            array_merge(explode('|', Criteria::explodeFieldTypeName($arrayFields)[1]), [$field])
        );

        return Criteria::implodeFieldTypeName($type, $fieldsString);

    }

    /**
     * @param string $fieldString
     *
     * @return array
     */
    protected function explodeCombinedFieldString($fieldString)
    {
        list($type, $field) = Criteria::explodeFieldTypeName($fieldString);
        if (strpos($field, '|') !== false) {
            $field = explode('|', $field);
        }

        return [$type, $field];
    }
}


text:
package com.buabook.http.common;

import java.io.IOException;
import java.util.Map;

import org.json.JSONException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.buabook.http.common.auth.HttpBasicAuthenticationInitializer;
import com.buabook.http.common.auth.HttpBearerAuthenticationInitializer;
import com.buabook.http.common.exceptions.HttpClientRequestFailedException;
import com.google.api.client.http.ByteArrayContent;
import com.google.api.client.http.EmptyContent;
import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpContent;
import com.google.api.client.http.HttpHeaders;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestFactory;
import com.google.api.client.http.HttpResponse;
import com.google.api.client.http.HttpResponseException;
import com.google.api.client.http.UrlEncodedContent;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.common.base.Stopwatch;
import com.google.common.base.Strings;
import com.google.common.net.MediaType;

/**
 *
HTTP Client Access Library

 * (c) 2015 Sport Trades Ltd
 *
 * @author Jas Rajasansir
 * @version 1.0.0
 * @since 13 Oct 2015
 */
public class HttpClient {
	private static final Logger log = LoggerFactory.getLogger(HttpClient.class);

	private final HttpRequestFactory requestFactory;

	public HttpClient() {
		this.requestFactory = new NetHttpTransport().createRequestFactory();
	}

	protected HttpClient(HttpRequestFactory customRequestFactory) {
		this.requestFactory = customRequestFactory;
	}

	/**
	 * HTTP client instantiation with Basic Authentication configured. See
	 * https://en.wikipedia.org/wiki/Basic_access_authentication#Client_side.
	 * @see HttpBasicAuthenticationInitializer
	 */
	public HttpClient(String username, String password) {
		this.requestFactory = new NetHttpTransport().createRequestFactory(new HttpBasicAuthenticationInitializer(username, password));
	}

	/**
	 * HTTP client instantiation with OAuth 2.0 (Bearer) authentication.
	 * @see HttpBearerAuthenticationInitializer
	 */
	public HttpClient(String bearerAuthToken) {
		this.requestFactory = new NetHttpTransport().createRequestFactory(new HttpBearerAuthenticationInitializer(bearerAuthToken));
	}

	/**
	 *
Standard HTTP GET request to the specified URL.

	 *
NOTE: You must call {@link HttpResponse#disconnect()} after using the
	 * response. {@link #getResponseAsString(HttpResponse)} and {@link #getResponseAsJson(HttpResponse)} will do this for you when
	 * used.

	 * @param url The full URL to query. {@link HttpHelpers#appendUrlParameters(String, Map)} is useful to append query parameters to
	 * the URL before passing into this function.
	 * @throws HttpClientRequestFailedException If the GET returns any HTTP error code or the request fails due to an {@link IOException}
	 * @see #getResponseAsString(HttpResponse)
	 * @see #getResponseAsJson(HttpResponse)
	 */
	public HttpResponse doGet(String url) throws HttpClientRequestFailedException {
		if(Strings.isNullOrEmpty(url))
			throw new IllegalArgumentException("No URL specified");

		log.debug("Attempting HTTP GET [ URL: {} ]", url);

		GenericUrl target = new GenericUrl(url);

		HttpResponse response = null;
		Stopwatch timer = Stopwatch.createStarted();

		try {
			HttpRequest request = requestFactory.buildGetRequest(target);
			response = request.execute();
		} catch (HttpResponseException e) {
			log.error("HTTP client GET failed due to bad HTTP status code [ URL: {} ] [ Status Code: {} ] [ In Flight: {} ]", url, e.getStatusCode(), timer.stop());
			throw new HttpClientRequestFailedException(e);
		} catch (IOException e) {
			log.error("HTTP client GET failed [ URL: {} ] [ In Flight: {} ]. Error - {}", url, timer.stop(), e.getMessage(), e);
			throw new HttpClientRequestFailedException(e);
		}

		log.debug("HTTP GET successful [ URL: {} ] [ In Flight: {} ]", url, timer.stop());

		return response;
	}

	/**
	 *
Standard HTTP POST equivalent to <form> or Content-Type application/x-www-form-urlencoded.

	 *
NOTE: You must call {@link HttpResponse#disconnect()} after using the
	 * response. {@link #getResponseAsString(HttpResponse)} and {@link #getResponseAsJson(HttpResponse)} will do this for you when
	 * used.

	 * @param url
	 * @param map
	 * @return
	 * @throws HttpClientRequestFailedException If the POST returns any HTTP error code or the request fails due to an {@link IOException}
	 * @see #doPost(String, HttpContent, HttpHeaders)
	 * @see #getResponseAsString(HttpResponse)
	 * @see #getResponseAsJson(HttpResponse)
	 */
	public HttpResponse doPost(String url, Map<String, Object> map) throws HttpClientRequestFailedException {
		UrlEncodedContent content = new UrlEncodedContent(map);
		return doPost(url, content, null);
	}

	/**
	 *
NOTE: You must call {@link HttpResponse#disconnect()} after using the
	 * response. {@link #getResponseAsString(HttpResponse)} and {@link #getResponseAsJson(HttpResponse)} will do this for you when
	 * used.

	 * @param contentType A standard HTTP Content-Type (e.g. "application/json"). If this is null or empty string,
	 * "text/plain" will be used
	 * @param postContent The content to POST. Pass null or empty string to send no content
	 * @param headers Any custom headers that need to be set. Pass null if not required
	 * @throws HttpClientRequestFailedException If the GET returns any HTTP error code or the request fails due to an {@link IOException}
	 * @see #doPost(String, HttpContent, HttpHeaders)
	 * @see #getResponseAsString(HttpResponse)
	 * @see #getResponseAsJson(HttpResponse)
	 */
	public HttpResponse doPost(String url, MediaType contentType, String postContent, HttpHeaders headers) throws HttpClientRequestFailedException {
		HttpContent content = null;

		if(contentType == null)
			contentType = MediaType.PLAIN_TEXT_UTF_8;

		if(Strings.isNullOrEmpty(postContent))
			content = new EmptyContent();
		else
			content = ByteArrayContent.fromString(contentType.toString(), postContent);

		return doPost(url, content, headers);
	}

	/**
	 *
Performs a HTTP POST based on the specified content and URL. If you are unsure what content to pass, look at
	 * the other doPost methods.

	 *
NOTE: You must call {@link HttpResponse#disconnect()} after using the
	 * response. {@link #getResponseAsString(HttpResponse)} and {@link #getResponseAsJson(HttpResponse)} will do this for you when
	 * used.

	 * @return The response from the server
	 * @throws IllegalArgumentException If either of the parameters are null
	 * @throws HttpClientRequestFailedException If the request fails due to underlying network errors or a bad HTTP server status (e.g. 404, 500)
	 * @see #getResponseAsString(HttpResponse)
	 * @see #getResponseAsJson(HttpResponse)
	 */
	public HttpResponse doPost(String url, HttpContent content, HttpHeaders headers) throws IllegalArgumentException, HttpClientRequestFailedException {
		if(Strings.isNullOrEmpty(url))
			throw new IllegalArgumentException("No URL specified");

		if(content == null)
			throw new IllegalArgumentException("Content cannot be null");

		log.debug("Attempting HTTP POST [ URL: {} ] [ Content-Type: {} ] [ Custom Headers: {} ]", url, content.getType(), (headers == null) ? 0 : headers.size());

		GenericUrl target = new GenericUrl(url);

		HttpResponse response = null;
		Stopwatch timer = Stopwatch.createStarted();

		try {
			HttpRequest request = requestFactory.buildPostRequest(target, content);

			if(headers != null)
				request.setHeaders(headers);

			response = request.execute();
		} catch (HttpResponseException e) {
			log.error("HTTP client POST failed due to bad HTTP status code [ URL: {} ] [ Status Code: {} ] [ In Flight: {} ]", url, e.getStatusCode(), timer.stop());
			throw new HttpClientRequestFailedException(e);
		} catch (IOException e) {
			log.error("HTTP client POST failed [ URL: {} ] [ In Flight: {} ]. Error - {}", url, timer.stop(), e.getMessage(), e);
			throw new HttpClientRequestFailedException(e);
		}

		log.debug("HTTP POST successful [ URL: {} ] [ In Flight: {} ]", url, timer.stop());

		return response;
	}

	public HttpResponse doPut(String url, HttpContent content) throws IllegalArgumentException, HttpClientRequestFailedException {
		if(Strings.isNullOrEmpty(url))
			throw new IllegalArgumentException("No URL specified");

		if(content == null)
			throw new IllegalArgumentException("Content cannot be null");

		log.debug("Attempting HTTP PUT [ URL: {} ] [ Content-Type: {} ]", url, content.getType());

		GenericUrl target = new GenericUrl(url);

		HttpResponse response = null;
		Stopwatch timer = Stopwatch.createStarted();

		try {
			HttpRequest request = requestFactory.buildPutRequest(target, content);
			response = request.execute();
		} catch (HttpResponseException e) {
			log.error("HTTP client PUT failed due to bad HTTP status code [ URL: {} ] [ Status Code: {} ] [ In Flight: {} ]", url, e.getStatusCode(), timer.stop());
			throw new HttpClientRequestFailedException(e);
		} catch (IOException e) {
			log.error("HTTP client PUT failed [ URL: {} ] [ In Flight: {} ]. Error - {}", url, timer.stop(), e);
			throw new HttpClientRequestFailedException(e);
		}

		log.debug("HTTP PUT successful [ URL: {} ] [ In Flight: {} ]", url, timer.stop());

		return response;
	}

	/**
	 * NOTE: After reading the response, {@link HttpResponse#disconnect()} will be called as required
	 * by the documentation.
	 * @param response
	 * @return The body of the response as a string
	 */
	public static String getResponseAsString(HttpResponse response) {
		if(response == null)
			return "";

		String responseString = "";

		try {
			responseString = response.parseAsString();
		} catch (IOException e) {
			log.error("Failed to convert HTTP response to string. Error - {}", e.getMessage(), e);
		} finally {
			try {
				response.disconnect();
			} catch (IOException e) {}
		}

		return responseString;
	}

	/**
	 * @param response
	 * @return The body of the response as a JSON object
	 * @throws JSONException If the string response does not parse into valid JSON
	 * @see #getResponseAsString(HttpResponse)
	 */
	public static JSONObject getResponseAsJson(HttpResponse response) throws JSONException {
		return new JSONObject(getResponseAsString(response));
	}

}


text:
<?php
#########################################################
# Deutsches Sprachpaket (Informell)                     #
# Version 1.6                                           #
# Datum: 03.08.2010                                     #
# MyBB-Version 1.6                                      #
# Autor: MyBBoard.de | Webseite: http://www.mybboard.de #
# (c) 2005-2010 MyBBoard.de | Alle Rechte vorbehalten!  #
#                                                       #
# Die Lizenz/Nutzungsbedingungen finden Sie in der      #
# beiliegenden Readme.                                  #
#########################################################

$l['dashboard'] = "Übersicht";
$l['dashboard_description'] = "Dieser Bereich erlaubt dir verschiedene Statistiken zu deinem Forum zu sehen. Du kannst auch Notizen für andere Administratoren hinterlassen.";

$l['mybb_server_stats'] = "MyBB und Server Statistiken";
$l['forum_stats'] = "Forum Statistiken";
$l['mybb_version'] = "MyBB Version";
$l['threads'] = "Themen";
$l['new_today'] = "heute";
$l['unapproved'] = "Ungeprüft";
$l['php_version'] = "PHP Version";
$l['posts'] = "Beiträge";
$l['sql_engine'] = "SQL Engine";
$l['users'] = "Benutzer";
$l['registered_users'] = "Registrierte Benutzer";
$l['active_users'] = "Aktive Benutzer";
$l['registrations_today'] = "Registrierungen heute";
$l['awaiting_activation'] = "Nicht aktivierte Benutzer";
$l['server_load'] = "Server-Auslastung:";
$l['attachments'] = "Attachments";
$l['used'] = "Benutzt";

$l['last_update_check_two_weeks'] = "Der letzte MyBB Versions-Check ist mehr als zwei Wochen her.";
$l['new_version_available'] = "Du verwendest zur Zeit {1}, die neueste Version ist {2}.";

$l['admin_notes_public'] = "Diese Notizen werden jedem Administrator angezeigt.";
$l['admin_notes'] = "Administratoren-Notizen";
$l['save_notes'] = "Notizen speichern";

$l['success_notes_updated'] = "Die Administratoren-Notizen wurden erfolgreich aktualisiert.";

?>


text:
package com.blackducksoftware.ohcount4j.scan;

import com.blackducksoftware.ohcount4j.Entity;
import com.blackducksoftware.ohcount4j.Language;

public class Line {
    Language language;

    Entity entity;

    StringBuilder content;

    public Line() {
        content = new StringBuilder();
    }

    public Line(Language language) {
        this.language = language;
        content = new StringBuilder();
    }

    public Line(Language language, Entity entity) {
        this.language = language;
        this.entity = entity;
        content = new StringBuilder();
    }

    public Line(Language language, Entity entity, String content) {
        this.language = language;
        this.entity = entity;
        this.content = new StringBuilder(content);
    }

    @Override
    public String toString() {
        return String.format("%1$s\t%2$s\t%3$s", language.uname(), entity.name(), content);
    }

    public Language getLanguage() {
        return language;
    }

    public Line setLanguage(Language language) {
        this.language = language;
        return this;
    }

    public Entity getEntity() {
        return entity;
    }

    public Line setEntity(Entity entity) {
        this.entity = entity;
        return this;
    }

    public Line appendContent(char[] content) {
        this.content.append(content);
        return this;
    }

    public String getContent() {
        return content.toString();
    }

    public Line setContent(String content) {
        this.content = new StringBuilder(content);
        return this;
    }
}


text:
package pl.exsio.nestedj.config.jdbc.discriminator;

import java.util.List;

/**
 * Tree Discriminator for use with JDBC Repository implementation.
 * Allows to store multiple intependant Trees in one Repository/Collection.
 */
public interface JdbcTreeDiscriminator {

    /**
     * Returns String with SQL query part that narrows the scope of all SQL Queries used by JDBC implementation
     *
     * @return - String with SQL query part that narrows the scope of all SQL Queries used by JDBC implementation.
     */
    String getQueryPart();

    /**
     * Returns List of values that should be set in the Prepared Statement and that correspond to the parameters used in the getQueryPart() method.
     *
     * @return - List of values that should be set in the Prepared Statement and that correspond to the parameters used in the getQueryPart() method.
     */
    List<Object> getParameters();
}


text:
package dk.troelssiggaard.iacollector;

import android.os.Environment;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DataLogger extends Thread {

    private BufferedOutputStream outputStream;
    private File file;
    String dateFormatted;

    public DataLogger(String filename) {
        Date date = new Date();
        dateFormatted = new SimpleDateFormat("dd-MM-yyyy").format(date);

        file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/DATA_" + dateFormatted + "_" + filename);
        int counter = 1;

        if (file.exists()) {
            while (file.exists()) {
                file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/DATA("+counter+")_" + dateFormatted + "_" + filename);
                counter++;
            }
        } else {
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            outputStream = new BufferedOutputStream(new FileOutputStream(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public String getFilePath() {
        return file.getAbsolutePath();
    }

    public String getFilename() {
        return file.getAbsolutePath();
    }

    public void saveString(String s) throws IOException {

        outputStream.write(s.getBytes());
        outputStream.write(System.lineSeparator().getBytes()); // LineSeparator not supported in < API 4.4
        outputStream.flush();

    }

    public void saveBuffer(byte[] buffer) throws IOException {

        outputStream.write(buffer, 0, buffer.length);
        outputStream.flush();

    }

    public void close() throws IOException {
        outputStream.flush();
        outputStream.close();

    }

}


text:
#include <wtf/text/WTFString.h>

#ifndef ProcessExecutablePath_h
#define ProcessExecutablePath_h

namespace WebKit {

String executablePathOfWebProcess();
String executablePathOfPluginProcess();
#if ENABLE(NETWORK_PROCESS)
String executablePathOfNetworkProcess();
#endif

}

#endif


text:
Beta testing. First version of the CocoaPod is out.

EEJSelectMenu is a responsive single selection menu for iOS.
Project allows for implementing a menu with different number of buttons and different animations for appearance.
It will adjust the button sizes based on the device screen size!
Just provide the names for the buttons and the menu will take care of the number and layout of the buttons!

### Demo
###### Animation: FadeIn & Widen
![](firstTwo.gif)

###### Animation: Scale & MoveInFromLeft
![](secondTwo.gif)

###### Animation: MoveInFromRight & Alternate
![](lastTwo.gif)

##### Version 0.10.2

Installation
==================
### CocoaPods
Coming Soon!

### Using Source Files
Add the files in the source folder to your project

Import the header file to your source code
```objective-c
#import "EEJSelectMenu.h"
```

Getting Started
==================
Create an instance of EEJSelectMenu and provide button names
```objective-c
    NSArray *buttonNames = @[@"ONE",@"TWO",@"THREE",@"FOUR"];
    EEJSelectMenu *menu = [[EEJSelectMenu alloc]initWithButtons:buttonNames
                    animationStyle:EJAnimationStyleFadeIn andDelegate:self];
    [self presentViewController:menu animated:NO completion:nil];
```
OR
```objective-c
    EEJSelectMenu *menu = [[EEJSelectMenu alloc]init];
    menu.buttonNames = @[@"ONE",@"TWO",@"THREE",@"FOUR"];
    menu.animationStyle = EJAnimationStyleAlternate;
    menu.delegate = self;

    [self presentViewController:menu animated:NO completion:nil];
```
###### Note: for smoother animation set the animated property to "NO" when presenting the menu as shown above.

#### AnimationStyle
```objective-c
    menu.animationStyle = EJAnimationStyleFadeIn; // default
```

* `Other AnimationStyles Available:`
  - `EJAnimationStyleWiden`
  - `EJAnimationStyleScale`
  - `EJAnimationStyleMoveInFromLeft`
  - `EJAnimationStyleMoveInFromRight`
  - `EJAnimationStyleAlternate`

#### Delegate Methods
EEJSelectMenu provides two delegate methods
```objective-c
    -(void)EJSelectMenuButtonWasPressedWithTitle:(NSString *)title;
    -(void)EJSelectMenuButtonWasPressedWithTag:(long)tag;

    // button tags start at 100 and increment by one for each
```

##### Other configurations:

Change selected button color (default: Purple)
```objective-c
    menu.selectedButtonColor = [UIColor blueColor];
```
Change menu background color (default: White)
```objective-c
    menu.menuBackgroundColor = [UIColor redColor];
```

#### License:
EEJSelectMenu is released under the MIT license. See LICENSE for details.


text:
IF EXISTS(SELECT * FROM [dbo].[sysobjects] WHERE ID=object_id(N'[Data].[Query_Delete]') AND OBJECTPROPERTY(id, N'IsProcedure')=1) DROP PROC [Data].[Query_Delete]
GO--
CREATE PROCEDURE [Data].[Query_Delete]
			@QueryId int
AS --Generated--
BEGIN

	DELETE FROM	[Data].[Query]
	WHERE	[QueryId] = @QueryId

END


text:
* [Abstract](ts.nodeflags.md#abstract)
* [AccessibilityModifier](ts.nodeflags.md#accessibilitymodifier)
* [Ambient](ts.nodeflags.md#ambient)
* [Async](ts.nodeflags.md#async)
* [BlockScoped](ts.nodeflags.md#blockscoped)
* [Const](ts.nodeflags.md#const)
* [DeclarationFile](ts.nodeflags.md#declarationfile)
* [Default](ts.nodeflags.md#default)
* [Export](ts.nodeflags.md#export)
* [ExportContext](ts.nodeflags.md#exportcontext)
* [Let](ts.nodeflags.md#let)
* [Modifier](ts.nodeflags.md#modifier)
* [MultiLine](ts.nodeflags.md#multiline)
* [Namespace](ts.nodeflags.md#namespace)
* [OctalLiteral](ts.nodeflags.md#octalliteral)
* [Private](ts.nodeflags.md#private)
* [Protected](ts.nodeflags.md#protected)
* [Public](ts.nodeflags.md#public)
* [Static](ts.nodeflags.md#static)
* [Synthetic](ts.nodeflags.md#synthetic)

## Enumeration members

### Abstract:

* Defined in [lib/typescript/tsc.d.ts:320](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L320)

### AccessibilityModifier:

* Defined in [lib/typescript/tsc.d.ts:332](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L332)

### Ambient:

* Defined in [lib/typescript/tsc.d.ts:315](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L315)

### Async:

* Defined in [lib/typescript/tsc.d.ts:321](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L321)

### BlockScoped:

* Defined in [lib/typescript/tsc.d.ts:333](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L333)

### Const:

* Defined in [lib/typescript/tsc.d.ts:327](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L327)

### DeclarationFile:

* Defined in [lib/typescript/tsc.d.ts:325](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L325)

### Default:

* Defined in [lib/typescript/tsc.d.ts:322](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L322)

### Export:

* Defined in [lib/typescript/tsc.d.ts:314](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L314)

### ExportContext:

* Defined in [lib/typescript/tsc.d.ts:330](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L330)

### Let:

* Defined in [lib/typescript/tsc.d.ts:326](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L326)

### Modifier:

* Defined in [lib/typescript/tsc.d.ts:331](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L331)

### MultiLine:

* Defined in [lib/typescript/tsc.d.ts:323](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L323)

### Namespace:

* Defined in [lib/typescript/tsc.d.ts:329](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L329)

### OctalLiteral:

* Defined in [lib/typescript/tsc.d.ts:328](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L328)

### Private:

* Defined in [lib/typescript/tsc.d.ts:317](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L317)

### Protected:

* Defined in [lib/typescript/tsc.d.ts:318](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L318)

### Public:

* Defined in [lib/typescript/tsc.d.ts:316](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L316)

### Static:

* Defined in [lib/typescript/tsc.d.ts:319](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L319)

### Synthetic:

* Defined in [lib/typescript/tsc.d.ts:324](https://github.com/kimamula/typedoc/blob/HEAD/src/lib/typescript/tsc.d.ts#L324)

Generated using [TypeDoc](http://typedoc.io)


text:
/**
 * Parquet format bridge for Hive v1.
 */
package com.asakusafw.directio.hive.parquet.v1;


text:
package org.simplericity.jettyconsole.api;

import java.util.Collection;

/**
 */
public interface Settings {
    String getProperty(String name);
    Collection<String> getPropertyNames();
}


text:
using System;
using System.Collections.Generic;
using System.Text;
using IPTables.Net.Iptables.Helpers;
using IPTables.Net.Iptables.U32;
using IPTables.Net.Supporting;

namespace IPTables.Net.Iptables.Modules.U32
{
    public class U32Module : ModuleBase, IEquatable<U32Module>, IIpTablesModule
    {
        private const string OptionBytecode = "--u32";

        public U32Expression ByteCode;

        public U32Module(int version) : base(version)
        {
        }

        public bool Equals(U32Module other)
        {
            if (ReferenceEquals(null, other)) return false;
            if (ReferenceEquals(this, other)) return true;
            return ByteCode.Equals(other.ByteCode);
        }

        public int Feed(CommandParser parser, bool not)
        {
            switch (parser.GetCurrentArg())
            {
                case OptionBytecode:
                    ByteCode = U32Expression.Parse(parser.GetNextArg());
                    return 1;
            }

            return 0;
        }

        public bool NeedsLoading => true;

        public string GetRuleString()
        {
            var sb = new StringBuilder();

            if (ByteCode != null)
            {
                sb.Append("--u32 ");
                sb.Append(ShellHelper.EscapeArguments(ByteCode.ToString()));
            }

            return sb.ToString();
        }

        public static HashSet<string> GetOptions()
        {
            var options = new HashSet<string>
            {
                OptionBytecode
            };
            return options;
        }

        public static ModuleEntry GetModuleEntry()
        {
            return GetModuleEntryInternal("u32", typeof(U32Module), GetOptions);
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj)) return false;
            if (ReferenceEquals(this, obj)) return true;
            if (obj.GetType() != GetType()) return false;
            return Equals((U32Module) obj);
        }

        public override int GetHashCode()
        {
            return ByteCode != null ? ByteCode.GetHashCode() : 0;
        }
    }
}


text:
package com.google.collide.client.code.autocomplete.css;

import com.google.collide.client.testutil.SynchronousTestCase;
import com.google.gwt.core.client.JsArrayString;

public class CssSpecialValuesTest extends SynchronousTestCase {

  CssPartialParser cssPartialParser;

  @Override
  public String getModuleName() {
    return "com.google.collide.client.TestCode";
  }

  @Override
  public void gwtSetUp() throws Exception {
    super.gwtSetUp();
    cssPartialParser = CssPartialParser.getInstance();
  }

  public void testAngle() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("19deg", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("222rad", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22grad", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-22grad", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.2grad", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-22.2grad", "<angle>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22foo", "<angle>");
    assertEquals(0, proposals.length());

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-22foo", "<angle>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<angle>");
    assertEquals(0, proposals.length());
  }

  public void testColor() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("olive", "<color>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("white", "<color>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("#fa0", "<color>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("#f9a711", "<color>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("rgb(10,10,10)", "<color>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "rgb(10,  10,    10)", "<color>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "rgb(10%,10%,10%)", "<color>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "rgb(10%,  10%,    10%)", "<color>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("blueishgreen", "<color>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("rgb()", "<color>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("#f", "<color>");
    assertEquals(0, proposals.length());
  }

  public void testCounter() {
    JsArrayString proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "counter(par-num, upper-roman)", "<counter>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "counter(par-num)", "<counter>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "c(par-num, upper-roman)", "<counter>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("foo", "<counter>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<counter>");
    assertEquals(0, proposals.length());
  }

  public void testFrequency() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("100kHz", "<frequency>");
    assertTrue(proposals.length() > 0);

    // Note: this seems wrong, but is permissible as per the CSS2 spec.
    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-10Hz", "<frequency>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("100", "<frequency>");
    assertEquals(0, proposals.length());

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("foo", "<frequency>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<frequency>");
    assertEquals(0, proposals.length());
  }

  public void testInteger() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("19", "<integer>");
    assertTrue(proposals.length() > 0);

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-2200", "<integer>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("+22", "<integer>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("vvv", "<integer>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.", "<integer>");
    assertEquals(0, proposals.length());

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.2grad", "<integer>");
    assertEquals(0, proposals.length());
  }

  public void testNumber() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("19", "<number>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.2", "<number>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("-22", "<number>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("+22", "<number>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("vvv", "<number>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.", "<number>");
    assertEquals(0, proposals.length());

    proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("22.2grad", "<number>");
    assertEquals(0, proposals.length());
  }

  public void testPercentage() {
    JsArrayString proposals =
        cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("10em", "<length>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("0mm", "<length>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("10px", "<length>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("foo", "<length>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<length>");
    assertEquals(0, proposals.length());
  }

  public void testShape() {
    JsArrayString proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "rect(10em, 10em, 10em, 10em)", "<shape>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "rect(10px,     10px  ,    10px,   10px)", "<shape>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "r(10em, 10em, 10em, 10em)", "<shape>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("foo", "<shape>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<shape>");
    assertEquals(0, proposals.length());
  }

  public void testUri() {
    JsArrayString proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "https://mail.google.com", "<uri>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals(
        "http://www.google.com", "<uri>");
    assertTrue(proposals.length() > 0);

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("wwww", "<uri>");
    assertEquals(0, proposals.length());

    proposals = cssPartialParser.checkIfSpecialValueAndGetSpecialValueProposals("", "<uri>");
    assertEquals(0, proposals.length());
  }
}


text:
<?php

// autoload_psr4.php @generated by Composer

$vendorDir = dirname(dirname(__FILE__));
$baseDir = dirname($vendorDir);

return array(
    'Slim\\Views\\' => array($vendorDir . '/slim/php-view/src'),
    'Slim\\HttpCache\\' => array($vendorDir . '/slim/http-cache/src'),
    'Slim\\' => array($vendorDir . '/slim/slim/Slim'),
    'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-message/src'),
    'Monolog\\' => array($vendorDir . '/monolog/monolog/src/Monolog'),
    'Interop\\Container\\' => array($vendorDir . '/container-interop/container-interop/src/Interop/Container'),
    'FastRoute\\' => array($vendorDir . '/nikic/fast-route/src'),
);


text:
package org.apache.metron.dataloads.nonbulk.flatfile.writer;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Optional;

public class LocalWriter implements Writer {

  @Override
  public void validate(Optional<String> fileNameOptional, Configuration hadoopConfig) throws InvalidWriterOutput {
    if(!fileNameOptional.isPresent()) {
      throw new InvalidWriterOutput("Filename is not present.");
    }
    String fileName = fileNameOptional.get();
    if(StringUtils.isEmpty(fileName) || fileName.trim().equals(".") || fileName.trim().equals("..") || fileName.trim().endsWith("/")) {
      throw new InvalidWriterOutput("Filename is empty or otherwise invalid.");
    }
  }

  @Override
  public void write(byte[] obj, Optional<String> output, Configuration hadoopConfig) throws IOException {
    File outFile = new File(output.get());
    if(!outFile.getParentFile().exists()) {
      outFile.getParentFile().mkdirs();
    }
    try(FileOutputStream fs = new FileOutputStream(outFile)) {
      IOUtils.write(obj, fs);
      fs.flush();
    }
  }
}


text:
package com.lib.workshop;

public interface ImageCompare extends Comparable<ImageCompare> {
	public float getImageCoverage();

	public float getFontCoverage();

	public float relevance();

	public int tolerance();

	public FontImage getFontImage();

	public double getMedian();

}


text:
package gleam

import (
	"path"
	"strings"

	"github.com/aarzilli/golua/lua"
	"github.com/mikespook/golib/iptpool"
	"github.com/mikespook/golib/log"
	"github.com/stevedonovan/luar"
)

const module = "gleam"

type LuaIpt struct {
	state *lua.State
	path  string
}

func NewLuaIpt() iptpool.ScriptIpt {
	return &LuaIpt{}
}

func (luaipt *LuaIpt) Exec(name string, data interface{}) error {
	name = strings.Replace(name, ":", "/", -1)
	f := path.Join(luaipt.path, name+".lua")
	luaipt.Bind("Data", luar.NewLuaObjectFromValue(luaipt.state, data))
	return luaipt.state.DoFile(f)
}

func (luaipt *LuaIpt) Init(path string) error {
	luaipt.state = luar.Init()
	luaipt.Bind("Debugf", log.Debugf)
	luaipt.Bind("Debug", log.Debug)
	luaipt.Bind("Messagef", log.Messagef)
	luaipt.Bind("Message", log.Message)
	luaipt.Bind("Warningf", log.Warningf)
	luaipt.Bind("Warning", log.Warning)
	luaipt.Bind("Errorf", log.Errorf)
	luaipt.Bind("Error", log.Error)
	luaipt.path = path
	return nil
}

func (luaipt *LuaIpt) Final() error {
	luaipt.state.Close()
	return nil
}

func (luaipt *LuaIpt) Bind(name string, item interface{}) error {
	luar.Register(luaipt.state, module, luar.Map{
		name: item,
	})
	return nil
}

func (gleam *Gleam) luaGet(key string) (string, error) {
	r, err := gleam.client.Get(key, false, false)
	if err != nil {
		return "", err
	}
	return r.Node.Value, nil
}

func (gleam *Gleam) luaGetDir(key string) (map[string]string, error) {
	r, err := gleam.client.Get(key, false, false)
	if err != nil {
		return nil, err
	}
	s := make(map[string]string, r.Node.Nodes.Len())
	for _, n := range r.Node.Nodes {
		s[n.Key] = n.Value
	}
	return s, nil
}

func (gleam *Gleam) luaSet(key, value string, ttl uint64) error {
	_, err := gleam.client.Set(key, value, ttl)
	return err
}

func (gleam *Gleam) luaDelete(key string) error {
	_, err := gleam.client.Delete(key, true)
	return err
}

func (gleam *Gleam) luaWatch(key string) (string, bool, error) {
	r, err := gleam.client.Watch(key, 0, false, nil, nil)
	return r.Node.Value, r.Node.Dir, err
}


text:
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="48dp"
    android:height="48dp"
    android:viewportWidth="48"
    android:viewportHeight="48"
    android:tint="?attr/colorControlNormal">
  <path
      android:fillColor="@android:color/white"
      android:pathData="M17,22.7H31V21.15H17ZM18.25,40V36H6V8H42V36H29.75V40Z"/>
</vector>


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

    <application
        android:name=".JodaApplication"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/JodaTheme">
        <activity
            android:name=".JodaSampleActivity"
            android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>


text:
package com.redhat.ceylon.langtools.tools.javac.model;

import java.util.Collections;
import java.util.EnumSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import com.redhat.ceylon.javax.lang.model.element.*;
import com.redhat.ceylon.javax.lang.model.type.*;

import com.redhat.ceylon.langtools.tools.javac.code.*;
import com.redhat.ceylon.langtools.tools.javac.code.Symbol.*;
import com.redhat.ceylon.langtools.tools.javac.util.*;

/**
 * Utility methods for operating on types.
 *
 *
This is NOT part of any supported API.
 * If you write code that depends on this, you do so at your own
 * risk.  This code and its internal interfaces are subject to change
 * or deletion without notice.

 */
public class JavacTypes implements com.redhat.ceylon.javax.lang.model.util.Types {

    private Symtab syms;
    private Types types;

    public static JavacTypes instance(Context context) {
        JavacTypes instance = context.get(JavacTypes.class);
        if (instance == null)
            instance = new JavacTypes(context);
        return instance;
    }

    /**
     * Public for use only by JavacProcessingEnvironment
     */
    protected JavacTypes(Context context) {
        setContext(context);
    }

    /**
     * Use a new context.  May be called from outside to update
     * internal state for a new annotation-processing round.
     */
    public void setContext(Context context) {
        context.put(JavacTypes.class, this);
        syms = Symtab.instance(context);
        types = Types.instance(context);
    }

    public Element asElement(TypeMirror t) {
        switch (t.getKind()) {
            case DECLARED:
            case INTERSECTION:
            case ERROR:
            case TYPEVAR:
                Type type = cast(Type.class, t);
                return type.asElement();
            default:
                return null;
        }
    }

    public boolean isSameType(TypeMirror t1, TypeMirror t2) {
        return types.isSameType((Type) t1, (Type) t2);
    }

    public boolean isSubtype(TypeMirror t1, TypeMirror t2) {
        validateTypeNotIn(t1, EXEC_OR_PKG);
        validateTypeNotIn(t2, EXEC_OR_PKG);
        return types.isSubtype((Type) t1, (Type) t2);
    }

    public boolean isAssignable(TypeMirror t1, TypeMirror t2) {
        validateTypeNotIn(t1, EXEC_OR_PKG);
        validateTypeNotIn(t2, EXEC_OR_PKG);
        return types.isAssignable((Type) t1, (Type) t2);
    }

    public boolean contains(TypeMirror t1, TypeMirror t2) {
        validateTypeNotIn(t1, EXEC_OR_PKG);
        validateTypeNotIn(t2, EXEC_OR_PKG);
        return types.containsType((Type) t1, (Type) t2);
    }

    public boolean isSubsignature(ExecutableType m1, ExecutableType m2) {
        return types.isSubSignature((Type) m1, (Type) m2);
    }

    public List<Type> directSupertypes(TypeMirror t) {
        validateTypeNotIn(t, EXEC_OR_PKG);
        return types.directSupertypes((Type) t);
    }

    public TypeMirror erasure(TypeMirror t) {
        if (t.getKind() == TypeKind.PACKAGE)
            throw new IllegalArgumentException(t.toString());
        return types.erasure((Type) t);
    }

    public TypeElement boxedClass(PrimitiveType p) {
        return types.boxedClass((Type) p);
    }

    public PrimitiveType unboxedType(TypeMirror t) {
        if (t.getKind() != TypeKind.DECLARED)
            throw new IllegalArgumentException(t.toString());
        Type unboxed = types.unboxedType((Type) t);
        if (! unboxed.isPrimitive())    // only true primitives, not void
            throw new IllegalArgumentException(t.toString());
        return (PrimitiveType)unboxed;
    }

    public TypeMirror capture(TypeMirror t) {
        validateTypeNotIn(t, EXEC_OR_PKG);
        return types.capture((Type) t);
    }

    public PrimitiveType getPrimitiveType(TypeKind kind) {
        switch (kind) {
        case BOOLEAN:   return syms.booleanType;
        case BYTE:      return syms.byteType;
        case SHORT:     return syms.shortType;
        case INT:       return syms.intType;
        case LONG:      return syms.longType;
        case CHAR:      return syms.charType;
        case FLOAT:     return syms.floatType;
        case DOUBLE:    return syms.doubleType;
        default:
            throw new IllegalArgumentException("Not a primitive type: " + kind);
        }
    }

    public NullType getNullType() {
        return (NullType) syms.botType;
    }

    public NoType getNoType(TypeKind kind) {
        switch (kind) {
        case VOID:      return syms.voidType;
        case NONE:      return Type.noType;
        default:
            throw new IllegalArgumentException(kind.toString());
        }
    }

    public ArrayType getArrayType(TypeMirror componentType) {
        switch (componentType.getKind()) {
        case VOID:
        case EXECUTABLE:
        case WILDCARD:  // heh!
        case PACKAGE:
            throw new IllegalArgumentException(componentType.toString());
        }
        return new Type.ArrayType((Type) componentType, syms.arrayClass);
    }

    public WildcardType getWildcardType(TypeMirror extendsBound,
                                        TypeMirror superBound) {
        BoundKind bkind;
        Type bound;
        if (extendsBound == null && superBound == null) {
            bkind = BoundKind.UNBOUND;
            bound = syms.objectType;
        } else if (superBound == null) {
            bkind = BoundKind.EXTENDS;
            bound = (Type) extendsBound;
        } else if (extendsBound == null) {
            bkind = BoundKind.SUPER;
            bound = (Type) superBound;
        } else {
            throw new IllegalArgumentException(
                    "Extends and super bounds cannot both be provided");
        }
        switch (bound.getKind()) {
        case ARRAY:
        case DECLARED:
        case ERROR:
        case TYPEVAR:
            return new Type.WildcardType(bound, bkind, syms.boundClass);
        default:
            throw new IllegalArgumentException(bound.toString());
        }
    }

    public DeclaredType getDeclaredType(TypeElement typeElem,
                                        TypeMirror... typeArgs) {
        ClassSymbol sym = (ClassSymbol) typeElem;

        if (typeArgs.length == 0)
            return (DeclaredType) sym.erasure(types);
        if (sym.type.getEnclosingType().isParameterized())
            throw new IllegalArgumentException(sym.toString());

        return getDeclaredType0(sym.type.getEnclosingType(), sym, typeArgs);
    }

    public DeclaredType getDeclaredType(DeclaredType enclosing,
                                        TypeElement typeElem,
                                        TypeMirror... typeArgs) {
        if (enclosing == null)
            return getDeclaredType(typeElem, typeArgs);

        ClassSymbol sym = (ClassSymbol) typeElem;
        Type outer = (Type) enclosing;

        if (outer.tsym != sym.owner.enclClass())
            throw new IllegalArgumentException(enclosing.toString());
        if (!outer.isParameterized())
            return getDeclaredType(typeElem, typeArgs);

        return getDeclaredType0(outer, sym, typeArgs);
    }
    // where
        private DeclaredType getDeclaredType0(Type outer,
                                              ClassSymbol sym,
                                              TypeMirror... typeArgs) {
            if (typeArgs.length != sym.type.getTypeArguments().length())
                throw new IllegalArgumentException(
                "Incorrect number of type arguments");

            ListBuffer<Type> targs = new ListBuffer<Type>();
            for (TypeMirror t : typeArgs) {
                if (!(t instanceof ReferenceType || t instanceof WildcardType))
                    throw new IllegalArgumentException(t.toString());
                targs.append((Type) t);
            }
            // TODO: Would like a way to check that type args match formals.

            return (DeclaredType) new Type.ClassType(outer, targs.toList(), sym);
        }

    /**
     * Returns the type of an element when that element is viewed as
     * a member of, or otherwise directly contained by, a given type.
     * For example,
     * when viewed as a member of the parameterized type {@code Set<String>},
     * the {@code Set.add} method is an {@code ExecutableType}
     * whose parameter is of type {@code String}.
     *
     * @param containing  the containing type
     * @param element     the element
     * @return the type of the element as viewed from the containing type
     * @throws IllegalArgumentException if the element is not a valid one
     *          for the given type
     */
    public TypeMirror asMemberOf(DeclaredType containing, Element element) {
        Type site = (Type)containing;
        Symbol sym = (Symbol)element;
        if (types.asSuper(site, sym.getEnclosingElement()) == null)
            throw new IllegalArgumentException(sym + "@" + site);
        return types.memberType(site, sym);
    }

    private static final Set<TypeKind> EXEC_OR_PKG =
            EnumSet.of(TypeKind.EXECUTABLE, TypeKind.PACKAGE);

    /**
     * Throws an IllegalArgumentException if a type's kind is one of a set.
     */
    private void validateTypeNotIn(TypeMirror t, Set<TypeKind> invalidKinds) {
        if (invalidKinds.contains(t.getKind()))
            throw new IllegalArgumentException(t.toString());
    }

    /**
     * Returns an object cast to the specified type.
     * @throws NullPointerException if the object is {@code null}
     * @throws IllegalArgumentException if the object is of the wrong type
     */
    private static <T> T cast(Class<T> clazz, Object o) {
        if (! clazz.isInstance(o))
            throw new IllegalArgumentException(o.toString());
        return clazz.cast(o);
    }

    public Set<MethodSymbol> getOverriddenMethods(Element elem) {
        if (elem.getKind() != ElementKind.METHOD
                || elem.getModifiers().contains(Modifier.STATIC)
                || elem.getModifiers().contains(Modifier.PRIVATE))
            return Collections.emptySet();

        if (!(elem instanceof MethodSymbol))
            throw new IllegalArgumentException();

        MethodSymbol m = (MethodSymbol) elem;
        ClassSymbol origin = (ClassSymbol) m.owner;

        Set<MethodSymbol> results = new LinkedHashSet<MethodSymbol>();
        for (Type t : types.closure(origin.type)) {
            if (t != origin.type) {
                ClassSymbol c = (ClassSymbol) t.tsym;
                for (Scope.Entry e = c.members().lookup(m.name); e.scope != null; e = e.next()) {
                    if (e.sym.kind == Kinds.MTH && m.overrides(e.sym, origin, types, true)) {
                        results.add((MethodSymbol) e.sym);
                    }
                }
            }
        }

        return results;
    }
}


text:
import FaCog from 'react-icons/lib/fa/cog'

export default FaCog


text:
<?php

header("Content-Type: text/html; charset=utf-8");

require "vk.inc.php";

define ('LAYOUT_ROOT', dirname(__FILE__)."/in/");
define ('LAYOUT_EXT', '.klc');
define ('LAYOUT_MASK', '*'.LAYOUT_EXT);
define ('LAYOUT_OUT_FOLDER', dirname(__FILE__)."/out/");
define ('DICTIONARY_OUT_FOLDER_NAME', "d/");
define ('DICTIONARY_OUT_FOLDER', LAYOUT_OUT_FOLDER.DICTIONARY_OUT_FOLDER_NAME);
define ('LAYOUT_OUT', LAYOUT_OUT_FOLDER."layouts.js");
define ('LAYOUT_REPORT', dirname(__FILE__)."/out/layouts.tsv");
define ('LAYOUT_INSTALL', dirname(__FILE__)."/../layouts/layouts.js");

/*
*  prepare layouts file;
*/
$VK_ADDONS = array();

/**
 *  Converts plaintext keyboard layout to the valid javascript code and saves it
 *
 *  @param VirtualKeyboardLayout $f layout object
 *  @return boolean conversion state
 *  @scope public
 */
function convertKbd(&$f) {
    global $VK_ADDONS;

    $addon = $f->getAddon();
    $aname = basename($addon);

    $fname = $f->getFilename().'.js';

    if (!empty($addon)) {
        copy($addon, DICTIONARY_OUT_FOLDER.$aname);
    }

    $data = ''."VirtualKeyboard.addLayout(".$f->serialize($_REQUEST['group']).");";

    $fd = fopen (LAYOUT_OUT_FOLDER.$fname, "w");
    fwrite($fd, $data);
    fclose($fd);

    return $f->serializeHeader($_REQUEST['group']);
}

function getLayoutList () {
    return glob(LAYOUT_ROOT.LAYOUT_MASK);
}
?>

  <title>Virtual Keyboard layouts setup page</title>

Keyboard layouts setup

  <form action="" method="POST" >

        <input type="checkbox" onclick="var els=this.parentNode.parentNode.parentNode.parentNode.tBodies[0].getElementsByTagName('input'); for(var i=0, eL=els.length; i<eL; i++) els[i].checked=this.checked;">
        Layout Code
        Layout Name
        Copyright
        Saved

       <?php

         @unlink(LAYOUT_OUT_FOLDER);
         @mkdir(LAYOUT_OUT_FOLDER);
         @mkdir(DICTIONARY_OUT_FOLDER);

         $layouts = array();
         $report = array();

         $kbdl = getLayoutList();
         $saved = false;
         for ($i=0;$i<sizeof($kbdl);$i++) {
            $kl = new VirtualKeyboardLayout($kbdl[$i]);
            $kl->setAddonFolder(DICTIONARY_OUT_FOLDER_NAME);
            $cname = str_replace(".","_",urlencode($kl->name));
            $cls = $i%2?"even":"odd";
            $checked = isset($_POST[$cname])?'checked="true"':'';
            if (isset($_POST[$cname])) {
                $saved = "Yes";
//                       "No"
                $layouts[] = convertKbd($kl);
                $report[] = $kl->getCode()."\t".$kl->getName()."\t".$kl->getCopyright();
            } else {
                $saved = "";
            }
       ?>
        <tr class="<?php echo($cls)?>">
         <input type="checkbox" name="<?php echo($cname)?>" <?php echo($checked)?> />
         <?php echo($kl->getCode())?>
         <?php echo($kl->getName())?>
         <?php echo($kl->getCopyright())?>
         <?php echo($saved)?>

       <?php
         }
         if (!empty($layouts)) {

             $s  = join("\n",$VK_ADDONS);
             $s .= "VirtualKeyboard.addLayoutList(\n".join(",\n",$layouts)."\n);";

             // save layout
             @unlink(LAYOUT_OUT);
             $fd = fopen(LAYOUT_OUT,"ab");
             fwrite($fd,'');
             fwrite($fd,$s);
             fclose($fd);

             // save report
             @unlink(LAYOUT_REPORT);
             $fd = fopen(LAYOUT_REPORT,"ab");
             fwrite($fd,join("\r\n",$report));
             fclose($fd);

             if (isset($_POST['doinstall'])) {
                 $inst_res = 1;
                 if (file_exists(LAYOUT_INSTALL))
                     $inst_res = 2;
                 else
                     $inst_res = @copy(LAYOUT_OUT, LAYOUT_INSTALL);
             }
         }
       ?>

    Install layouts<input type="checkbox" name="doinstall" />
    <?php if (isset($inst_res)) { ?>
        <?php if (1==$inst_res) {?>
            success
        <?php } else { ?>
            error: <?php echo ($inst_res==0?"New layout file is not accessible. Have you selected any layouts to install?"
                                                                    :"Target file (/layouts/layouts.js) is already exists, remove it before installing new one.")?>
        <?php } ?>
    <?php } ?>

    Group languages by

    <input type="radio" name="group" id="group1" value="lng" checked="true" />Language code (en-US)
    <input type="radio" name="group" id="group2" value="domain" />Language domain (en-US)

    <input type="submit" value="Process selected" />

  </form>


text:
package com.jsteinaker.cacartografia;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import com.mapbox.mapboxsdk.geometry.LatLng;

import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;

public class BaseEditMarkerFragment extends BaseFragment {
	/* Data */
	protected View fragmentView;
	protected LatLng position;
	protected String title;
	protected String description;
	protected Point point;
	protected Database database;

	/* UI */
	protected OnFragmentInteractionListener interactionListener;
	protected TextView mTitleField;
	protected TextView mDescriptionField;
	protected TextView mLocationField;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
		setHasOptionsMenu(true);
		interactionListener = (OnFragmentInteractionListener) getActivity();
		database = new Database();
		fragmentView = inflater.inflate(R.layout.edit_marker, container, false);

		// Referencias a los campos de texto
		mTitleField = (TextView) fragmentView.findViewById(R.id.input_title);
		mDescriptionField = (TextView) fragmentView.findViewById(R.id.input_description);
		mLocationField = (TextView) fragmentView.findViewById(R.id.input_location);

		/* Rellenamos los campos, siempre y cuando tengamos los valores */
		if (position != null) {
			mLocationField.setText(position.getLatitude() + ";" + position.getLongitude());
		}

		// En cualquiera de los casos, queremos el botón de Back
		((AppCompatActivity)getActivity()).getSupportActionBar().setDisplayHomeAsUpEnabled(true);

		return fragmentView;
	}

	@Override
	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
		inflater.inflate(R.menu.edit_marker_menu, menu);
		super.onCreateOptionsMenu(menu, inflater);
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem menuItem) {
		if (menuItem.getItemId() == R.id.done)
		{
			// Terminar inmediatamente si faltan completar campos.
			if (!validateForm()) {
				return false;
			}

			Utils.hideKeyboard(getActivity());
			title = mTitleField.getText().toString();
			description = mDescriptionField.getText().toString();
			FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
			if (user == null) {
				return false;
			}
			String owner = user.getEmail();
			Geometry geometry = new Geometry();
			geometry.setCoordinatesFromLatLng(position);
			Properties properties = new Properties(title, description, owner);
			point = new Point(geometry, properties);
			return true;
		}
		return false;
	}

	private boolean validateForm() {
        boolean valid = true;

        String title = mTitleField.getText().toString();
        if (TextUtils.isEmpty(title)) {
            mTitleField.setError(getText(R.string.required));
            valid = false;
        } else {
            mTitleField.setError(null);
        }

        String description = mDescriptionField.getText().toString();
        if (TextUtils.isEmpty(description)) {
            mDescriptionField.setError(getText(R.string.required));
            valid = false;
        } else {
            mDescriptionField.setError(null);
        }

        return valid;
	}

	/* Control de la tecla back */
	@Override
	public boolean onBackPressed() {
		return false;
	}

}


text:
<?php

namespace Fulfillment\Postage\Api;

use Fulfillment\Postage\Models\Request\Base\BaseAddressValidationRequest;
use Fulfillment\Postage\Models\Response\AddressValidationResponse;
use Fulfillment\Postage\Models\Response\ValidatedAddressResult;

class AddressApi extends ApiRequestBase
{
	/**
	 * Validate an address using a shipper-service
	 *
	 *
	 * @param BaseAddressValidationRequest|array $validationRequest
	 * @param array|null            $queryString
	 *
	 * @return AddressValidationResponse|mixed
	 */
	public function validate($validationRequest, $queryString = null)
	{
		$json = $this->apiClient->post('address/validate', $validationRequest, $queryString);

		return ($this->jsonOnly ? $json : $this->jsonMapper->mapArray($json, [], ValidatedAddressResult::class));
	}
}


text:
.class Landroid/service/media/IMediaBrowserService$Stub$Proxy;
.super Ljava/lang/Object;
.source "IMediaBrowserService.java"

# interfaces
.implements Landroid/service/media/IMediaBrowserService;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/service/media/IMediaBrowserService$Stub;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0xa
    name = "Proxy"
.end annotation

# instance fields
.field private mRemote:Landroid/os/IBinder;

# direct methods
.method constructor <init>(Landroid/os/IBinder;)V
    .locals 0
    .param p1, "remote"    # Landroid/os/IBinder;

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

    .line 118
    iput-object p1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    .line 116
    return-void
.end method

# virtual methods
.method public addSubscription(Ljava/lang/String;Landroid/service/media/IMediaBrowserServiceCallbacks;)V
    .locals 5
    .param p1, "uri"    # Ljava/lang/String;
    .param p2, "callbacks"    # Landroid/service/media/IMediaBrowserServiceCallbacks;
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    const/4 v1, 0x0

    .line 162
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 164
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string/jumbo v2, "android.service.media.IMediaBrowserService"

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 165
    invoke-virtual {v0, p1}, Landroid/os/Parcel;->writeString(Ljava/lang/String;)V

    .line 166
    if-eqz p2, :cond_0

    invoke-interface {p2}, Landroid/service/media/IMediaBrowserServiceCallbacks;->asBinder()Landroid/os/IBinder;

    move-result-object v1

    :cond_0
    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeStrongBinder(Landroid/os/IBinder;)V

    .line 167
    iget-object v1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x3

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 170
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 160
    return-void

    .line 169
    :catchall_0
    move-exception v1

    .line 170
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 169
    throw v1
.end method

.method public asBinder()Landroid/os/IBinder;
    .locals 1

    .prologue
    .line 122
    iget-object v0, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    return-object v0
.end method

.method public connect(Ljava/lang/String;Landroid/os/Bundle;Landroid/service/media/IMediaBrowserServiceCallbacks;)V
    .locals 5
    .param p1, "pkg"    # Ljava/lang/String;
    .param p2, "rootHints"    # Landroid/os/Bundle;
    .param p3, "callbacks"    # Landroid/service/media/IMediaBrowserServiceCallbacks;
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    const/4 v1, 0x0

    .line 130
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 132
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string/jumbo v2, "android.service.media.IMediaBrowserService"

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 133
    invoke-virtual {v0, p1}, Landroid/os/Parcel;->writeString(Ljava/lang/String;)V

    .line 134
    if-eqz p2, :cond_1

    .line 135
    const/4 v2, 0x1

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInt(I)V

    .line 136
    const/4 v2, 0x0

    invoke-virtual {p2, v0, v2}, Landroid/os/Bundle;->writeToParcel(Landroid/os/Parcel;I)V

    .line 141
    :goto_0
    if-eqz p3, :cond_0

    invoke-interface {p3}, Landroid/service/media/IMediaBrowserServiceCallbacks;->asBinder()Landroid/os/IBinder;

    move-result-object v1

    :cond_0
    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeStrongBinder(Landroid/os/IBinder;)V

    .line 142
    iget-object v1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x1

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 145
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 128
    return-void

    .line 139
    :cond_1
    const/4 v2, 0x0

    :try_start_1
    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 144
    :catchall_0
    move-exception v1

    .line 145
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 144
    throw v1
.end method

.method public disconnect(Landroid/service/media/IMediaBrowserServiceCallbacks;)V
    .locals 5
    .param p1, "callbacks"    # Landroid/service/media/IMediaBrowserServiceCallbacks;
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    const/4 v1, 0x0

    .line 150
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 152
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string/jumbo v2, "android.service.media.IMediaBrowserService"

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 153
    if-eqz p1, :cond_0

    invoke-interface {p1}, Landroid/service/media/IMediaBrowserServiceCallbacks;->asBinder()Landroid/os/IBinder;

    move-result-object v1

    :cond_0
    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeStrongBinder(Landroid/os/IBinder;)V

    .line 154
    iget-object v1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x2

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 157
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 148
    return-void

    .line 156
    :catchall_0
    move-exception v1

    .line 157
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 156
    throw v1
.end method

.method public getInterfaceDescriptor()Ljava/lang/String;
    .locals 1

    .prologue
    .line 126
    const-string/jumbo v0, "android.service.media.IMediaBrowserService"

    return-object v0
.end method

.method public getMediaItem(Ljava/lang/String;Landroid/os/ResultReceiver;)V
    .locals 5
    .param p1, "uri"    # Ljava/lang/String;
    .param p2, "cb"    # Landroid/os/ResultReceiver;
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 188
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 190
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string/jumbo v1, "android.service.media.IMediaBrowserService"

    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 191
    invoke-virtual {v0, p1}, Landroid/os/Parcel;->writeString(Ljava/lang/String;)V

    .line 192
    if-eqz p2, :cond_0

    .line 193
    const/4 v1, 0x1

    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeInt(I)V

    .line 194
    const/4 v1, 0x0

    invoke-virtual {p2, v0, v1}, Landroid/os/ResultReceiver;->writeToParcel(Landroid/os/Parcel;I)V

    .line 199
    :goto_0
    iget-object v1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x5

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 202
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 186
    return-void

    .line 197
    :cond_0
    const/4 v1, 0x0

    :try_start_1
    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 201
    :catchall_0
    move-exception v1

    .line 202
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 201
    throw v1
.end method

.method public removeSubscription(Ljava/lang/String;Landroid/service/media/IMediaBrowserServiceCallbacks;)V
    .locals 5
    .param p1, "uri"    # Ljava/lang/String;
    .param p2, "callbacks"    # Landroid/service/media/IMediaBrowserServiceCallbacks;
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    const/4 v1, 0x0

    .line 175
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 177
    .local v0, "_data":Landroid/os/Parcel;
    :try_start_0
    const-string/jumbo v2, "android.service.media.IMediaBrowserService"

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 178
    invoke-virtual {v0, p1}, Landroid/os/Parcel;->writeString(Ljava/lang/String;)V

    .line 179
    if-eqz p2, :cond_0

    invoke-interface {p2}, Landroid/service/media/IMediaBrowserServiceCallbacks;->asBinder()Landroid/os/IBinder;

    move-result-object v1

    :cond_0
    invoke-virtual {v0, v1}, Landroid/os/Parcel;->writeStrongBinder(Landroid/os/IBinder;)V

    .line 180
    iget-object v1, p0, Landroid/service/media/IMediaBrowserService$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v2, 0x4

    const/4 v3, 0x0

    const/4 v4, 0x1

    invoke-interface {v1, v2, v0, v3, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 183
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 173
    return-void

    .line 182
    :catchall_0
    move-exception v1

    .line 183
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 182
    throw v1
.end method


text:
/**
 *
 */
package org.sylvani.bot.dialogs;

import java.util.List;

import org.sylvani.bot.IActivity;
import org.sylvani.bot.ISession;
import org.sylvani.bot.util.IModel;
import org.sylvani.bot.util.ISessionModel;
import org.sylvani.bot.util.Model;

/**
 * @author Harald Kuhn
 *
 */
public abstract class Decision<T> extends Question<T> {

	private List<Choice<T>> choices;

	public Decision(ISessionModel<T> anwerModel, List<Choice<T>> choices) {
		super(anwerModel);
		this.choices = choices;
	}

	@Override
	protected T findAnswer(String text) {
		if (text == null) {
			return null;
		}
		String answer = text.trim();
		for (int i = 0; i < choices.size(); i++) {
			if (answer.indexOf(String.valueOf(i + 1)) >= 0) {
				return choices.get(i).getValue();
			}
			String choiceString = choices.get(i).getLabel().getObject();
			if (answer.indexOf(choiceString) >= 0) {
				return choices.get(i).getValue();
			}
		}
		return null;
	}

	public IModel<String> getConfirmText(Choice<?> choice) {
		return new Model<>("OK, added ");
	}

	@Override
	protected void fillActivity(IActivity request, IActivity response, ISession session) {
		super.fillActivity(request, response, session);
		StringBuilder builder = new StringBuilder();
		builder.append(response.getText());
		builder.append("\n");
		for (int i = 0; i < choices.size(); i++) {
			builder.append((i + 1) + ": ");
			builder.append(choices.get(i).getLabelString());
			builder.append("\n");
		}
		response.setText(builder.toString());
	}
}


text:
<?php

/**
 * @namespace
 */
namespace Solarium\QueryType\Analysis\Result;

/**
 * Analysis item
 */
class Item
{
    /**
     * Text string
     *
     * @var string
     */
    protected $text;

    /**
     * RawText string
     *
     * @var string
     */
    protected $rawText;

    /**
     * Start
     *
     * @var int
     */
    protected $start;

    /**
     * End
     *
     * @var int
     */
    protected $end;

    /**
     * Position
     *
     * @var int
     */
    protected $position;

    /**
     * Position history
     *
     * @var array
     */
    protected $positionHistory;

    /**
     * Type
     *
     * @var string
     */
    protected $type;

    /**
     * Match
     *
     * @var boolean
     */
    protected $match = false;

    /**
     * Constructor
     *
     * @param array $analysis
     */
    public function __construct($analysis)
    {
        $this->text = $analysis['text'];
        $this->start = $analysis['start'];
        $this->end = $analysis['end'];
        $this->position = $analysis['position'];
        $this->positionHistory = $analysis['positionHistory'];
        $this->type = $analysis['type'];

        if (isset($analysis['raw_text'])) {
            $this->rawText = $analysis['raw_text'];
        }

        if (isset($analysis['match'])) {
            $this->match = $analysis['match'];
        }
    }

    /**
     * Get text value
     *
     * @return string
     */
    public function getText()
    {
        return $this->text;
    }

    /**
     * Get raw text value
     *
     * This values is not available in all cases
     *
     * @return string
     */
    public function getRawText()
    {
        return $this->rawText;
    }

    /**
     * Get start value
     *
     * @return int
     */
    public function getStart()
    {
        return $this->start;
    }

    /**
     * Get end value
     *
     * @return int
     */
    public function getEnd()
    {
        return $this->end;
    }

    /**
     * Get postion value
     *
     * @return int
     */
    public function getPosition()
    {
        return $this->position;
    }

    /**
     * Get position history value
     *
     * @return array
     */
    public function getPositionHistory()
    {
        if (is_array($this->positionHistory)) {
            return $this->positionHistory;
        } else {
            return array();
        }
    }

    /**
     * Get type value
     *
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Get match value
     *
     * @return boolean
     */
    public function getMatch()
    {
        return $this->match;
    }
}


text:
  var nodemailer = require("nodemailer");

  // create reusable transport method (opens pool of SMTP connections)
   var transporter = nodemailer.createTransport("SMTP",{
       service: "Gmail",
        auth: {
           user: "noreply@foxyninjastudios.com",
           pass: "HasNothing11"
        }
    });
  // setup e-mail data with unicode symbols
  var mailOptions = {
    from: "FNS No-reply<noreply@foxyninjastudios.com>", // sender address
    to: "",
    subject: "CONTACT: foxyninjastudios.com", // Subject line
    text: '',
    html: ""
  }
  var express = require("express"),
        app = express(),
            bodyParser = require('body-parser'),
                errorHandler = require('errorhandler'),
                    methodOverride = require('method-override'),
                        hostname = process.env.HOSTNAME || 'localhost',
                     //       port = parseInt(process.env.PORT, 10) || 4567;
                              port = 8080;

app.get("/", function (req, res) {
      res.redirect("/index.html");
});

app.get("/handleContact", function (req, res) {
	mailOptions.to = req.query.email;
	mailOptions.bcc = "contact@foxyninjastudios.com"
	mailOptions.replyTo = "contact@foxyninjastudios.com"
	mailOptions.subject = "Thank you for your interest in Foxy Ninja Studios";
	mailOptions.text =
    "We will get back to you ASAP. We recieved the following information from you at " + new Date().toUTCString() + " :\n\n\n" + JSON.stringify(req.query, null, 2) + "\n";

	transporter.sendMail(mailOptions, function(error, response){console.log(error)});
    res.end("1");
});

app.use(methodOverride());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
      extended: true
}));
app.use(express.static(__dirname + '/'));
app.use(errorHandler({
      dumpExceptions: true,
      showStack: true
}));

console.log("Simple static server listening at http://" + hostname + ":" + port);
app.listen(port);