text:
<!DOCTYPE html >

          <meta http-equiv="X-UA-Compatible" content="IE=edge" />
          <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
          <title></title>
          <meta name="description" content="" />
          <meta name="keywords" content="" />
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />

      <link href="../../../../lib/index.css" media="screen" type="text/css" rel="stylesheet" />
      <link href="../../../../lib/template.css" media="screen" type="text/css" rel="stylesheet" />
      <link href="../../../../lib/diagrams.css" media="screen" type="text/css" rel="stylesheet" id="diagrams-css" />

        < Back

            <input autocapitalize="none" placeholder="Search" id="index-input" type="text" accesskey="/" />
            
            

Packages

        

        package

              root

Definition Classes

root

        

        package

              kr

Definition Classes

root

        

        package

              bydelta

Definition Classes

kr

        

        package

              koala

각 Package의 Parser와 Tagger를 참조하세요.

 KoalaNLP

 통합 Scala 한국어 분석기, Koala

각 Package의 Parser와 Tagger를 참조하세요.

Definition Classes

bydelta

        

        package

              kkma

꼬꼬마 분석기 패키지입니다.

꼬꼬마 분석기 패키지입니다.

Definition Classes

koala

                          Dictionary

                          JavaDictionary

                          Parser

                          Tagger

c

kr.bydelta.koala.kkma

Tagger

        

        final
        class

        Tagger extends CanTagOnlyAParagraph[Sentence]

꼬꼬마 형태소분석기.

            Linear Supertypes

CanTagOnlyAParagraph[Sentence], CanTag, AnyRef, Any

          

            <input id="mbrsel-input" placeholder="Filter all members" type="text" accesskey="/" />

          

            Ordering

Alphabetic

By Inheritance

                  Inherited

Tagger

CanTagOnlyAParagraph

CanTag

AnyRef

Any

Hide All

Show All

              Visibility

Public

All

Instance Constructors

        

        new

        Tagger()

꼬꼬마 형태소분석기.

        

        new

        Tagger(logPath: String)

logPath

꼬꼬마 형태소분석기의 log를 저장할 위치.

Value Members

        

        final
        def

        !=(arg0: Any): Boolean

Definition Classes

AnyRef → Any

        

        final
        def

        ##(): Int

Definition Classes

AnyRef → Any

        

        final
        def

        ==(arg0: Any): Boolean

Definition Classes

AnyRef → Any

        

        final
        def

        asInstanceOf[T0]: T0

Definition Classes

Any

        

        def

        clone(): AnyRef

Attributes

protected[java.lang]

Definition Classes

AnyRef

Annotations

                @throws(

      ...
    )

        

        final
        def

        eq(arg0: AnyRef): Boolean

Definition Classes

AnyRef

        

        def

        equals(arg0: Any): Boolean

Definition Classes

AnyRef → Any

        

        def

        finalize(): Unit

Attributes

protected[java.lang]

Definition Classes

AnyRef

Annotations

                @throws(

      classOf[java.lang.Throwable]
    )

        

        final
        def

        getClass(): Class[_]

Definition Classes

AnyRef → Any

        

        def

        hashCode(): Int

Definition Classes

AnyRef → Any

        

        final
        def

        isInstanceOf[T0]: Boolean

Definition Classes

Any

        

        final
        def

        jTag(text: String): List[Sentence]

(Java) 주어진 String 문단을 분석하여 품사를 부착함.

(Java) 주어진 String 문단을 분석하여 품사를 부착함.

text

품사분석을 시행할 문단 String

returns

품사분석 결과를 문장단위로 잘라서 포함한 java.util.List<Sentence> 객체

Definition Classes

CanTag

        

        final
        def

        ne(arg0: AnyRef): Boolean

Definition Classes

AnyRef

        

        final
        def

        notify(): Unit

Definition Classes

AnyRef

        

        final
        def

        notifyAll(): Unit

Definition Classes

AnyRef

        

        final
        def

        synchronized[T0](arg0: ⇒ T0): T0

Definition Classes

AnyRef

        

        final
        def

        tag(text: String): Seq[Sentence]

주어진 String 문단을 분석하여 품사를 부착함.

주어진 String 문단을 분석하여 품사를 부착함.

text

품사분석을 시행할 문단 String

returns

품사분석 결과를 문장단위로 잘라서 포함한 Seq[Sentence] 객체

Definition Classes

CanTagOnlyAParagraph → CanTag

        

        def

        tagParagraphOriginal(text: String): Seq[Sentence]

변환되지않은, 분석결과를 반환.

변환되지않은, 분석결과를 반환.

text

분석할 String.

returns

원본 문단객체의 Sequence

Definition Classes

Tagger → CanTagOnlyAParagraph

        

        final
        def

        tagSentence(text: String): Sentence

주어진 String 문장을 분석하여 품사를 부착함.

주어진 String 문장을 분석하여 품사를 부착함.

text

품사분석을 시행할 문장 String

returns

품사분석 결과를 포함한 Sentence 객체

Definition Classes

CanTagOnlyAParagraph → CanTag

        

        def

        toString(): String

Definition Classes

AnyRef → Any

        

        final
        def

        wait(): Unit

Definition Classes

AnyRef

Annotations

                @throws(

      ...
    )

        

        final
        def

        wait(arg0: Long, arg1: Int): Unit

Definition Classes

AnyRef

Annotations

                @throws(

      ...
    )

        

        final
        def

        wait(arg0: Long): Unit

Definition Classes

AnyRef

Annotations

                @throws(

      ...
    )

Deprecated Value Members

        

        final
        def

        jTagParagraph(text: String): List[Sentence]

(Java) 주어진 String 문단을 분석하여 품사를 부착함.

(Java) 주어진 String 문단을 분석하여 품사를 부착함.

text

품사분석을 시행할 문단 String

returns

품사분석 결과를 문장단위로 잘라서 포함한 java.util.List<Sentence> 객체

Definition Classes

CanTag

Annotations

                @deprecated

Deprecated

(Since version 2.0.0) Use jTag(String) instead. This will be removed at v2.0.0

        

        final
        def

        tagParagraph(text: String): Seq[Sentence]

주어진 String 문단을 분석하여 품사를 부착함.

주어진 String 문단을 분석하여 품사를 부착함.

text

품사분석을 시행할 문단 String

returns

품사분석 결과를 문장단위로 잘라서 포함한 Seq[Sentence] 객체

Definition Classes

CanTag

Annotations

                @deprecated

Deprecated

(Since version 1.6.0) Use tag(String) instead. This will be removed at v2.0.0

Inherited from CanTagOnlyAParagraph[Sentence]

Inherited from CanTag

Inherited from AnyRef

Inherited from Any

Ungrouped


text:
package agents.finite_states;

import exceptions.BadFrontierClass;
import exceptions.UnsolvableProblem;
import problem_elements.Action;
import agents.frontiers.Frontier;
import problems.Problem;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.lang.invoke.MethodHandles;

/**
 * An agent that, iteratively, tries looking for solutions
 * at greater depth.
 * The agent represents the algorithms: Limited-DFS, Limited-BFS, Iterative-Deepening-DFS, Iterative-Deepening-BFS.
 */
public class IterativeGoalBasedAgent extends GoalBasedAgent {

    private static final Logger logger = LogManager.getLogger(MethodHandles.lookup().lookupClass().getSimpleName());

    /**
     * Do not try trees greater than this value.
     */
    public int max_depth_increase = Integer.MAX_VALUE;

    /**
     * Build a new agent, starting from an instance of problem.
     *
     * @param problem        The problem to be solved.
     * @param frontier_class The class of the Frontier to be used while searching.
     */
    public IterativeGoalBasedAgent(@NotNull Problem problem, @NotNull Class<? extends Frontier> frontier_class) {
        super(problem, frontier_class);
    }

    @Override
    public @Nullable Action nextAction() throws UnsolvableProblem, BadFrontierClass {
        this.depth_limit = 0;

        while (true) {
            try {
                if (this.actions_sequence == null) {
                    logger.info("Trying exploration with depth: {}.", this.depth_limit);
                }

                return super.nextAction();
            } catch (UnsolvableProblem e) {
                this.depth_limit++;

                if (this.depth_limit >= max_depth_increase) {
                    throw new UnsolvableProblem("Unable to find a solution in selected depth range.");
                }
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
from django import forms
from crispy_forms.helper import FormHelper
from crispy_forms import layout, bootstrap

from . import models

from ex2 import widgets as ex2_widgets

class EventModelForm(forms.ModelForm):

    class Meta:
        model = models.Event
        fields = '__all__'
        widgets = {
            'image': ex2_widgets.DropClearableFileInput
        }

    class Media:
        js = (
            'js/jquery.js',
            'js/react.js',
            'js/ex3/form-preview.js',
        )

    helper = FormHelper()
    helper.form_id = 'event_form'
    helper.layout = layout.Layout(
        bootstrap.TabHolder(
            bootstrap.Tab(
                'Event Fields',
                'name',
                'image',
                'description',
            ),
            bootstrap.Tab(
                'Preview',
                layout.Div(css_id='preview')
            ),
        )
    )


text:
require 'spec_helper'

describe "Puppet::Resource::Ral" do

  it "is deprecated on the network, but still allows requests" do
    Puppet.expects(:deprecation_warning)

    expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(true)
  end

  describe "find" do
    before do
      @request = stub 'request', :key => "user/root"
    end

    it "should find an existing instance" do
      my_resource    = stub "my user resource"

      wrong_instance = stub "wrong user", :name => "bob"
      my_instance    = stub "my user",    :name => "root", :to_resource => my_resource

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
      Puppet::Resource::Ral.new.find(@request).should == my_resource
    end

    it "should produce Puppet::Error instead of ArgumentError" do
      @bad_request = stub 'thiswillcauseanerror', :key => "thiswill/causeanerror"
      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
    end

    it "if there is no instance, it should create one" do
      wrong_instance = stub "wrong user", :name => "bob"
      root = mock "Root User"
      root_resource = mock "Root Resource"

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
      Puppet::Type::User.expects(:new).with(has_entry(:name => "root")).returns(root)
      root.expects(:to_resource).returns(root_resource)

      result = Puppet::Resource::Ral.new.find(@request)

      result.should == root_resource
    end
  end

  describe "search" do
    before do
      @request = stub 'request', :key => "user/", :options => {}
    end

    it "should convert ral resources into regular resources" do
      my_resource = stub "my user resource"
      my_instance = stub "my user", :name => "root", :to_resource => my_resource

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ my_instance ])
      Puppet::Resource::Ral.new.search(@request).should == [my_resource]
    end

    it "should filter results by name if there's a name in the key" do
      my_resource    = stub "my user resource"
      my_resource.stubs(:to_resource).returns(my_resource)
      my_resource.stubs(:[]).with(:name).returns("root")

      wrong_resource = stub "wrong resource"
      wrong_resource.stubs(:to_resource).returns(wrong_resource)
      wrong_resource.stubs(:[]).with(:name).returns("bad")

      my_instance    = stub "my user",    :to_resource => my_resource
      wrong_instance = stub "wrong user", :to_resource => wrong_resource

      @request = stub 'request', :key => "user/root", :options => {}

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
      Puppet::Resource::Ral.new.search(@request).should == [my_resource]
    end

    it "should filter results by query parameters" do
      wrong_resource = stub "my user resource"
      wrong_resource.stubs(:to_resource).returns(wrong_resource)
      wrong_resource.stubs(:[]).with(:name).returns("root")

      my_resource = stub "wrong resource"
      my_resource.stubs(:to_resource).returns(my_resource)
      my_resource.stubs(:[]).with(:name).returns("bob")

      my_instance    = stub "my user",    :to_resource => my_resource
      wrong_instance = stub "wrong user", :to_resource => wrong_resource

      @request = stub 'request', :key => "user/", :options => {:name => "bob"}

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
      Puppet::Resource::Ral.new.search(@request).should == [my_resource]
    end

    it "should return sorted results" do
      a_resource = stub "alice resource"
      a_resource.stubs(:to_resource).returns(a_resource)
      a_resource.stubs(:title).returns("alice")

      b_resource = stub "bob resource"
      b_resource.stubs(:to_resource).returns(b_resource)
      b_resource.stubs(:title).returns("bob")

      a_instance = stub "alice user", :to_resource => a_resource
      b_instance = stub "bob user",   :to_resource => b_resource

      @request = stub 'request', :key => "user/", :options => {}

      require 'puppet/type/user'
      Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
      Puppet::Resource::Ral.new.search(@request).should == [a_resource, b_resource]
    end
  end

  describe "save" do
    before do
      @rebuilt_res = stub 'rebuilt instance'
      @ral_res     = stub 'ral resource', :to_resource => @rebuilt_res
      @instance    = stub 'instance', :to_ral => @ral_res
      @request     = stub 'request',  :key => "user/", :instance => @instance
      @catalog     = stub 'catalog'
      @report      = stub 'report'
      @transaction = stub 'transaction', :report => @report

      Puppet::Resource::Catalog.stubs(:new).returns(@catalog)
      @catalog.stubs(:apply).returns(@transaction)
      @catalog.stubs(:add_resource)
    end

    it "should apply a new catalog with a ral object in it" do
      Puppet::Resource::Catalog.expects(:new).returns(@catalog)
      @catalog.expects(:add_resource).with(@ral_res)
      @catalog.expects(:apply).returns(@transaction)
      Puppet::Resource::Ral.new.save(@request).should
    end

    it "should return a regular resource that used to be the ral resource" do
      Puppet::Resource::Ral.new.save(@request).should == [@rebuilt_res, @report]
    end
  end
end


text:
namespace Shkembedjijnica.App.Core.Contracts
{
    public interface ICommand
    {
        string Execute(string[] args);
    }
}


text:
import Vue from 'vue';
import * as types from './mutation_types';

export default {
  [types.SET_INITIAL_DATA](state, data) {
    Object.assign(state, data);
  },

  [types.SET_FILTER](state, filter) {
    state.filter = filter;
  },

  [types.REQUEST_REPOS](state) {
    state.isLoadingRepos = true;
  },

  [types.RECEIVE_REPOS_SUCCESS](state, { importedProjects, providerRepos, namespaces }) {
    state.isLoadingRepos = false;

    state.importedProjects = importedProjects;
    state.providerRepos = providerRepos;
    state.namespaces = namespaces;
  },

  [types.RECEIVE_REPOS_ERROR](state) {
    state.isLoadingRepos = false;
  },

  [types.REQUEST_IMPORT](state, repoId) {
    state.reposBeingImported.push(repoId);
  },

  [types.RECEIVE_IMPORT_SUCCESS](state, { importedProject, repoId }) {
    const existingRepoIndex = state.reposBeingImported.indexOf(repoId);
    if (state.reposBeingImported.includes(repoId))
      state.reposBeingImported.splice(existingRepoIndex, 1);

    const providerRepoIndex = state.providerRepos.findIndex(
      providerRepo => providerRepo.id === repoId,
    );
    state.providerRepos.splice(providerRepoIndex, 1);
    state.importedProjects.unshift(importedProject);
  },

  [types.RECEIVE_IMPORT_ERROR](state, repoId) {
    const repoIndex = state.reposBeingImported.indexOf(repoId);
    if (state.reposBeingImported.includes(repoId)) state.reposBeingImported.splice(repoIndex, 1);
  },

  [types.RECEIVE_JOBS_SUCCESS](state, updatedProjects) {
    updatedProjects.forEach(updatedProject => {
      const existingProject = state.importedProjects.find(
        importedProject => importedProject.id === updatedProject.id,
      );

      Vue.set(existingProject, 'importStatus', updatedProject.importStatus);
    });
  },
};


text:
namespace kmd.Core.Command
{
    public interface IViewModelWithCommandBindings
    {
        CommandBindings CommandBindings { get; }
    }
}


text:
package com.aspose.pdf.examples.AsposePdfExamples.DocumentConversion;

import com.aspose.pdf.Document;
import com.aspose.pdf.Font;
import com.aspose.pdf.FontRepository;
import com.aspose.pdf.HtmlSaveOptions;
import com.aspose.pdf.text.CustomFontSubstitutionBase;

public class DefaultFontWhenSpecificFontMissing {

	public static void main(String[] args) {
		String myDir = "PathToDir";
		Document pdf = new Document(myDir + "Redis.pdf");
		// configure font substitution
		CustomSubst1 subst1 = new CustomSubst1();
		FontRepository.getSubstitutions().add(subst1);
		// Configure notifier to console
		pdf.FontSubstitution.add(new Document.FontSubstitutionHandler() {
			public void invoke(Font font, Font newFont) {
				// print substituted FontNames into console
				System.out.println("Warning: Font " + font.getFontName() + " was substituted with another font -> " + newFont.getFontName());
			}
		});
		HtmlSaveOptions htmlSaveOps = new HtmlSaveOptions();
		pdf.save(myDir + "Redis_1150_substitutedWithMSGothic_release.html", htmlSaveOps);
	}
	/**
	 * The class to implement font substitution
	 */
	private static class CustomSubst1 extends CustomFontSubstitutionBase {
		public boolean trySubstitute(OriginalFontSpecification originalFontSpecification, /* out */com.aspose.pdf.Font[] substitutionFont) {
			// 1. substitute Arial font with TimesNewRoman font
			// if
			// ("Arial".equals(originalFontSpecification.getOriginalFontName()))
			// {
			// substitutionFont[0] =
			// FontRepository.findFont("TimesNewRoman");
			// return true;
			// }
			// else
			// return super.trySubstitute(originalFontSpecification, /*out*/
			// substitutionFont);
			// 2. or substitute all the fonts with the MSGothic font
			substitutionFont[0] = FontRepository.findFont("MSGothic");
			return true;
		}
	}
}


text:
package jmeter

import (
	perfv1alpha1 "github.com/xridge/kubestone/api/v1alpha1"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/intstr"
)

func NewService(cr *perfv1alpha1.JMeter, selector map[string]string) *v1.Service {
	objectMeta := metav1.ObjectMeta{
		Name:      cr.Name,
		Namespace: cr.Namespace,
	}

	service := &v1.Service{
		ObjectMeta: objectMeta,
		Spec: v1.ServiceSpec{
			ClusterIP: "None",
			Ports: []v1.ServicePort{
				{Port: 1099, TargetPort: intstr.FromString("rmi")},
			},
			Selector: selector,
		},
	}

	return service
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<CustomFieldTranslation xmlns="http://soap.sforce.com/2006/04/metadata">
    <name>Language_Details__c</name>
    <label>Taaldetails</label>
</CustomFieldTranslation>


text:
<?php

namespace App\Http\Controllers\Admins;

use Illuminate\Foundation\Bus\DispatchesJobs;
use Illuminate\Routing\Controller as CoreController;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
//use App\Http\Controllers\Admins\AdminController;
use Symfony\Component\Yaml\Yaml;
use Symfony\Component\Yaml\Exception\ParseException;

class AdminController extends CoreController
{
    use AuthorizesRequests, DispatchesJobs, ValidatesRequests;

    public function __construct()
    {
        $this->middleware('auth');
    }

    /**
     * @param string $file
     * @return mixed
     * @throws \Exception
     */
    public function getYamlContent($file = '')
    {
        try {
            if (is_file($file)) {
                return Yaml::parse(file_get_contents($file));
            }
            throw new \Exception("File Not Found: " . $file);
        } catch (ParseException $e) {
            throw new \Exception(sprintf("Unable to parse the YAML string: %s", $e->getMessage()));
        }
    }
}


text:
<%#
 Copyright 2013-2017 the original author or authors from the JHipster project.

 This file is part of the JHipster project, see http://www.jhipster.tech/
 for more information.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-%>
<?xml version="1.0" encoding="UTF-8"?>

<configuration scan="true">
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    <logger name="<%=packageName%>" level="INFO"/>

    <logger name="io.github.jhipster" level="WARN"/>

    <%_ if (databaseType === 'cassandra') { _%>
    <logger name="io.netty" level="WARN"/>
    <%_ } _%>
    <logger name="javax.activation" level="WARN"/>
    <logger name="javax.mail" level="WARN"/>
    <logger name="javax.xml.bind" level="WARN"/>
    <logger name="ch.qos.logback" level="WARN"/>
    <logger name="com.codahale.metrics" level="WARN"/>
    <%_ if (databaseType === 'cassandra') { _%>
    <logger name="com.datastax" level="WARN"/>
    <%_ } _%>
    <%_ if (applicationType === 'microservice' || applicationType === 'gateway') { _%>
    <logger name="com.netflix" level="WARN"/>
    <logger name="com.netflix.discovery" level="INFO"/>
    <%_ } _%>
    <logger name="com.ryantenney" level="WARN"/>
    <logger name="com.sun" level="WARN"/>
    <logger name="com.zaxxer" level="WARN"/>
    <logger name="io.undertow" level="WARN"/>
    <logger name="io.undertow.websockets.jsr" level="ERROR"/>
    <%_ if (hibernateCache === 'ehcache') { _%>
    <logger name="org.ehcache" level="WARN"/>
    <%_ } _%>
    <logger name="org.apache" level="WARN"/>
    <logger name="org.apache.catalina.startup.DigesterFactory" level="OFF"/>
    <logger name="org.bson" level="WARN"/>
    <%_ if (searchEngine === 'elasticsearch') { _%>
    <logger name="org.elasticsearch" level="WARN"/>
    <%_ } _%>
    <logger name="org.hibernate.validator" level="WARN"/>
    <%_ if (databaseType === 'sql') { _%>
    <logger name="org.hibernate" level="WARN"/>
    <logger name="org.hibernate.ejb.HibernatePersistence" level="OFF"/>
    <%_ } else if (databaseType === 'mongodb') { _%>
    <logger name="org.mongodb.driver" level="WARN"/>
    <%_ } else if (databaseType === 'couchbase') { _%>
    <logger name="com.couchbase.client" level="WARN"/>
    <logger name="org.testcontainers" level="INFO"/>
    <logger name="org.github.couchmove" level="INFO"/>
    <%_ } _%>
    <%_ if (databaseType === 'mongodb' || databaseType === 'couchbase') { _%>
    <logger name="org.reflections" level="WARN"/>
    <%_ } _%>
    <%_ if (hibernateCache === 'infinispan') { _%>
    <logger name="org.infinispan" level="WARN"/>
    <%_ } _%>
    <logger name="org.springframework" level="WARN"/>
    <logger name="org.springframework.web" level="WARN"/>
    <logger name="org.springframework.security" level="WARN"/>
    <logger name="org.springframework.cache" level="WARN"/>
    <logger name="org.thymeleaf" level="WARN"/>
    <logger name="org.xnio" level="WARN"/>
    <%_ if (messageBroker === 'kafka') { _%>
    <logger name="kafka" level="WARN"/>
    <logger name="org.I0Itec" level="WARN"/>
    <%_ } _%>
    <%_ if (devDatabaseType === 'mssql') { _%>
    <logger name="com.microsoft.sqlserver.jdbc.internals" level="WARN"/>
    <%_ } _%>
    <logger name="springfox" level="WARN"/>
    <logger name="sun.rmi" level="WARN"/><% if (databaseType === 'sql') { %>
    <logger name="liquibase" level="WARN"/>
    <logger name="LiquibaseSchemaResolver" level="INFO"/><% } %>
    <%_ if (applicationType === 'microservice' || applicationType === 'gateway') { _%>
    <logger name="sun.net.www" level="INFO"/>
    <%_ } _%>
    <logger name="sun.rmi.transport" level="WARN"/>
    <%_ if (hibernateCache === 'infinispan') { _%>
    <logger name="unknown.jul.logger" level="WARN"/>
    <%_ } _%>

    <root level="WARN">
        <appender-ref ref="CONSOLE"/>
    </root>

</configuration>


text:
package org.springframework.expression.spel.support;

import java.util.List;

import org.junit.Test;

import org.springframework.core.convert.TypeDescriptor;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.Operation;
import org.springframework.expression.OperatorOverloader;
import org.springframework.expression.TypeComparator;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.TypeLocator;

import static org.junit.Assert.*;

public class StandardComponentsTests {

	@Test
	public void testStandardEvaluationContext() {
		StandardEvaluationContext context = new StandardEvaluationContext();
		assertNotNull(context.getTypeComparator());

		TypeComparator tc = new StandardTypeComparator();
		context.setTypeComparator(tc);
		assertEquals(tc, context.getTypeComparator());

		TypeLocator tl = new StandardTypeLocator();
		context.setTypeLocator(tl);
		assertEquals(tl, context.getTypeLocator());
	}

	@Test(expected = EvaluationException.class)
	public void testStandardOperatorOverloader() throws EvaluationException {
		OperatorOverloader oo = new StandardOperatorOverloader();
		assertFalse(oo.overridesOperation(Operation.ADD, null, null));
		oo.operate(Operation.ADD, 2, 3);
	}

	@Test
	public void testStandardTypeLocator() {
		StandardTypeLocator tl = new StandardTypeLocator();
		List<String> prefixes = tl.getImportPrefixes();
		assertEquals(1, prefixes.size());
		tl.registerImport("java.util");
		prefixes = tl.getImportPrefixes();
		assertEquals(2, prefixes.size());
		tl.removeImport("java.util");
		prefixes = tl.getImportPrefixes();
		assertEquals(1, prefixes.size());
	}

	@Test
	public void testStandardTypeConverter() throws EvaluationException {
		TypeConverter tc = new StandardTypeConverter();
		tc.convertValue(3, TypeDescriptor.forObject(3), TypeDescriptor.valueOf(Double.class));
	}

}


text:
package hu.icss.notificationexperiments;

import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class NotificationSender extends Activity {
	private Button notifyBtn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_notification_sender);
        notifyBtn = (Button) findViewById(R.id.notifyer_btn);
        notifyBtn.setOnClickListener(new OnClickListener(){

			@Override
			public void onClick(View v) {
				createNotification(v);

			}

        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.notification_sender, menu);
        return true;
    }

    public void createNotification(View view){
    	NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    	Notification notification = new Notification(R.drawable.ic_launcher, "A new notification", System.currentTimeMillis());
    	notification.flags |= Notification.FLAG_AUTO_CANCEL;

    	Intent intent = new Intent(this, NotificationReciever.class);
    	PendingIntent activity = PendingIntent.getActivity(this, 0, intent, 0);
    	notification.number ++;
    	notification.setLatestEventInfo(this, "You have " + notification.number + " notifications", "from the same Button :)", activity);

    	notificationManager.notify(0, notification);
    }
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}


text:
function ProfileUIWindow(title) {

	var func = require('/lib/functions');

	var self = func.createAppWindow(title);
	self.add(func.profile());

	// Create a Button.
	var Logout = Ti.UI.createButton({
		title : 'Logout',

	});

	// Listen for click events.
	Logout.addEventListener('click', function() {

		Ti.App.fireEvent('app:logout');
	});

	// Add to the parent view.

	if (Ti.Platform.osname === 'iphone' || Ti.Platform.osname === 'ipad')
		self.setRightNavButton(Logout);

	return self;

};

module.exports = ProfileUIWindow;


text:
package org.wso2.carbon.activemq.server.internal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.activemq.server.ActiveMQServerController;

/**
 * @scr.component name="org.wso2.carbon.activemq.server.component" immediate="true"
 * */

public class ActiveMQServerDSComponent {

    private static Log log = LogFactory.getLog(ActiveMQServerDSComponent.class);
    private ActiveMQServerController activeMQServerController;

    protected void activate(ComponentContext componentContext) {
        activeMQServerController = new ActiveMQServerController();
        activeMQServerController.start();
    }

    protected void deactivate(ComponentContext componentContext) {

        if (log.isDebugEnabled()) {
            log.debug("Stopping the ActiveMQ Server component");
        }
        activeMQServerController.shutdown();
    }

}


text:
<html>
<body style="margin:0px">
  <script src="../lib/three.min.js"></script>
  <script src="../ObjectControls.js"></script>
  <script>

    var scene, camera, renderer;

    var objectControls;
    var objects = [];

    init();
    animate();

    function init(){

      /*

         Default threejs stuff!

      */
      scene = new THREE.Scene();

      var ar = window.innerWidth / window.innerHeight;

      camera = new THREE.PerspectiveCamera( 75, ar , 1, 1000 );
      camera.position.z = 100;

      renderer = new THREE.WebGLRenderer();
      renderer.setSize( window.innerWidth, window.innerHeight );

      document.body.appendChild( renderer.domElement );

      /*

         Object Control stuff!!!!

      */

      objectControls = new ObjectControls( camera );

      var hoverMaterial     = new THREE.MeshNormalMaterial();
      var neutralMaterial   = new THREE.MeshBasicMaterial({color:0xffcccc});
      var selectedMaterial  = new THREE.MeshBasicMaterial({color:0x55ff88});

      var geo = new THREE.IcosahedronGeometry( 10 , 1 );

      for( var i = 0; i < 50; i++ ){

        var mesh = new THREE.Mesh( geo , neutralMaterial );

        mesh.hoverMaterial    = hoverMaterial;
        mesh.neutralMaterial  = neutralMaterial;
        mesh.selectedMaterial = selectedMaterial;

        mesh.selected = false;

        mesh.hoverOver = function(){

          this.material = this.hoverMaterial;
          this.materialNeedsUpdate = true;

        }.bind( mesh );

        mesh.hoverOut = function(){

          if( this.selected ){
            this.material = this.selectedMaterial;
            this.materialNeedsUpdate = true;
          }else{
            this.material = this.neutralMaterial;
            this.materialNeedsUpdate = true;
          }

        }.bind( mesh );

        mesh.select = function(){

          this.selected = true;
          this.material = this.selectedMaterial;
          this.materialNeedsUpdate = true;

        }

        mesh.deselect = function(){

          this.selected = false;
          this.material = this.neutralMaterial;
          this.materialNeedsUpdate = true;

        }

        mesh.position.x = (Math.random() -.5 ) * 200;
        mesh.position.y = (Math.random() -.5 ) * 200;
        mesh.position.z = (Math.random() -.5 ) * 100;
        scene.add( mesh );

        objectControls.add( mesh );

      }

    }

    function animate(){

      requestAnimationFrame( animate );

      objectControls.update();

      renderer.render( scene , camera );

    }

  </script>

</body>
<html>


text:
#include "SkBlendImageFilter.h"
#include "SkCanvas.h"
#include "SkColorPriv.h"
#include "SkFlattenableBuffers.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLEffectMatrix.h"
#include "GrTBackendEffectFactory.h"
#include "SkImageFilterUtils.h"
#endif

namespace {

SkXfermode::Mode modeToXfermode(SkBlendImageFilter::Mode mode) {
    switch (mode) {
        case SkBlendImageFilter::kNormal_Mode:
            return SkXfermode::kSrcOver_Mode;
        case SkBlendImageFilter::kMultiply_Mode:
            return SkXfermode::kMultiply_Mode;
        case SkBlendImageFilter::kScreen_Mode:
            return SkXfermode::kScreen_Mode;
        case SkBlendImageFilter::kDarken_Mode:
            return SkXfermode::kDarken_Mode;
        case SkBlendImageFilter::kLighten_Mode:
            return SkXfermode::kLighten_Mode;
    }
    SkASSERT(0);
    return SkXfermode::kSrcOver_Mode;
}

};

///////////////////////////////////////////////////////////////////////////////

SkBlendImageFilter::SkBlendImageFilter(SkBlendImageFilter::Mode mode, SkImageFilter* background, SkImageFilter* foreground)
  : INHERITED(background, foreground), fMode(mode)
{
}

SkBlendImageFilter::~SkBlendImageFilter() {
}

SkBlendImageFilter::SkBlendImageFilter(SkFlattenableReadBuffer& buffer)
  : INHERITED(buffer)
{
    fMode = (SkBlendImageFilter::Mode) buffer.readInt();
}

void SkBlendImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
    this->INHERITED::flatten(buffer);
    buffer.writeInt((int) fMode);
}

bool SkBlendImageFilter::onFilterImage(Proxy* proxy,
                                       const SkBitmap& src,
                                       const SkMatrix& ctm,
                                       SkBitmap* dst,
                                       SkIPoint* offset) {
    SkBitmap background, foreground = src;
    SkImageFilter* backgroundInput = getBackgroundInput();
    SkImageFilter* foregroundInput = getForegroundInput();
    SkASSERT(NULL != backgroundInput);
    if (!backgroundInput->filterImage(proxy, src, ctm, &background, offset)) {
        return false;
    }
    if (foregroundInput && !foregroundInput->filterImage(proxy, src, ctm, &foreground, offset)) {
        return false;
    }
    SkAutoLockPixels alp_foreground(foreground), alp_background(background);
    if (!foreground.getPixels() || !background.getPixels()) {
        return false;
    }
    dst->setConfig(background.config(), background.width(), background.height());
    dst->allocPixels();
    SkCanvas canvas(*dst);
    SkPaint paint;
    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
    canvas.drawBitmap(background, 0, 0, &paint);
    paint.setXfermodeMode(modeToXfermode(fMode));
    canvas.drawBitmap(foreground, 0, 0, &paint);
    return true;
}

///////////////////////////////////////////////////////////////////////////////

#if SK_SUPPORT_GPU
class GrGLBlendEffect : public GrGLEffect {
public:
    GrGLBlendEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
    virtual ~GrGLBlendEffect();

    virtual void emitCode(GrGLShaderBuilder*,
                          const GrDrawEffect&,
                          EffectKey,
                          const char* outputColor,
                          const char* inputColor,
                          const TextureSamplerArray&) SK_OVERRIDE;

    static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);

    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;

private:
    static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;

    SkBlendImageFilter::Mode    fMode;
    GrGLEffectMatrix            fForegroundEffectMatrix;
    GrGLEffectMatrix            fBackgroundEffectMatrix;

    typedef GrGLEffect INHERITED;
};

///////////////////////////////////////////////////////////////////////////////

class GrBlendEffect : public GrEffect {
public:
    static GrEffectRef* Create(SkBlendImageFilter::Mode mode,
                               GrTexture* foreground,
                               GrTexture* background) {
        AutoEffectUnref effect(SkNEW_ARGS(GrBlendEffect, (mode, foreground, background)));
        return CreateEffectRef(effect);
    }

    virtual ~GrBlendEffect();

    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
    SkBlendImageFilter::Mode mode() const { return fMode; }

    typedef GrGLBlendEffect GLEffect;
    static const char* Name() { return "Blend"; }

    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;

private:
    virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;

    GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground, GrTexture* background);
    GrTextureAccess             fForegroundAccess;
    GrTextureAccess             fBackgroundAccess;
    SkBlendImageFilter::Mode    fMode;

    typedef GrEffect INHERITED;
};

bool SkBlendImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, SkBitmap* result) {
    SkBitmap backgroundBM;
    if (!SkImageFilterUtils::GetInputResultGPU(getBackgroundInput(), proxy, src, &backgroundBM)) {
        return false;
    }
    GrTexture* background = (GrTexture*) backgroundBM.getTexture();
    SkBitmap foregroundBM;
    if (!SkImageFilterUtils::GetInputResultGPU(getForegroundInput(), proxy, src, &foregroundBM)) {
        return false;
    }
    GrTexture* foreground = (GrTexture*) foregroundBM.getTexture();
    GrContext* context = foreground->getContext();

    GrTextureDesc desc;
    desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
    desc.fWidth = src.width();
    desc.fHeight = src.height();
    desc.fConfig = kSkia8888_GrPixelConfig;

    GrAutoScratchTexture ast(context, desc);
    SkAutoTUnref<GrTexture> dst(ast.detach());

    GrContext::AutoRenderTarget art(context, dst->asRenderTarget());

    GrPaint paint;
    paint.colorStage(0)->setEffect(
        GrBlendEffect::Create(fMode, foreground, background))->unref();
    SkRect srcRect;
    src.getBounds(&srcRect);
    context->drawRect(paint, srcRect);
    return SkImageFilterUtils::WrapTexture(dst, src.width(), src.height(), result);
}

///////////////////////////////////////////////////////////////////////////////

GrBlendEffect::GrBlendEffect(SkBlendImageFilter::Mode mode,
                             GrTexture* foreground,
                             GrTexture* background)
    : fForegroundAccess(foreground)
    , fBackgroundAccess(background)
    , fMode(mode) {
    this->addTextureAccess(&fForegroundAccess);
    this->addTextureAccess(&fBackgroundAccess);
}

GrBlendEffect::~GrBlendEffect() {
}

bool GrBlendEffect::onIsEqual(const GrEffect& sBase) const {
    const GrBlendEffect& s = CastEffect<GrBlendEffect>(sBase);
    return fForegroundAccess.getTexture() == s.fForegroundAccess.getTexture() &&
           fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture() &&
           fMode == s.fMode;
}

const GrBackendEffectFactory& GrBlendEffect::getFactory() const {
    return GrTBackendEffectFactory<GrBlendEffect>::getInstance();
}

void GrBlendEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
    // The output alpha is always 1 - (1 - FGa) * (1 - BGa). So if either FGa or BGa is known to
    // be one then the output alpha is one. (This effect ignores its input. We should have a way to
    // communicate this.)
    if (GrPixelConfigIsOpaque(fForegroundAccess.getTexture()->config()) ||
        GrPixelConfigIsOpaque(fBackgroundAccess.getTexture()->config())) {
        *validFlags = kA_GrColorComponentFlag;
        *color = GrColorPackRGBA(0, 0, 0, 0xff);
    } else {
        *validFlags = 0;
    }
}

///////////////////////////////////////////////////////////////////////////////

GrGLBlendEffect::GrGLBlendEffect(const GrBackendEffectFactory& factory,
                                 const GrDrawEffect& drawEffect)
    : INHERITED(factory)
    , fMode(drawEffect.castEffect<GrBlendEffect>().mode())
    , fForegroundEffectMatrix(kCoordsType)
    , fBackgroundEffectMatrix(kCoordsType) {
}

GrGLBlendEffect::~GrGLBlendEffect() {
}

void GrGLBlendEffect::emitCode(GrGLShaderBuilder* builder,
                               const GrDrawEffect&,
                               EffectKey key,
                               const char* outputColor,
                               const char* inputColor,
                               const TextureSamplerArray& samplers) {
    const char* fgCoords;
    const char* bgCoords;
    GrSLType fgCoordsType = fForegroundEffectMatrix.emitCode(builder, key, &fgCoords, NULL, "FG");
    GrSLType bgCoordsType = fBackgroundEffectMatrix.emitCode(builder, key, &bgCoords, NULL, "BG");

    const char* bgColor = "bgColor";
    const char* fgColor = "fgColor";

    builder->fsCodeAppendf("\t\tvec4 %s = ", fgColor);
    builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
                                 samplers[0],
                                 fgCoords,
                                 fgCoordsType);
    builder->fsCodeAppend(";\n");

    builder->fsCodeAppendf("\t\tvec4 %s = ", bgColor);
    builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
                                 samplers[1],
                                 bgCoords,
                                 bgCoordsType);
    builder->fsCodeAppendf(";\n");

    builder->fsCodeAppendf("\t\t%s.a = 1.0 - (1.0 - %s.a) * (1.0 - %s.b);\n", outputColor, bgColor, fgColor);
    switch (fMode) {
      case SkBlendImageFilter::kNormal_Mode:
        builder->fsCodeAppendf("\t\t%s.rgb = (1.0 - %s.a) * %s.rgb + %s.rgb;\n", outputColor, fgColor, bgColor, fgColor);
        break;
      case SkBlendImageFilter::kMultiply_Mode:
        builder->fsCodeAppendf("\t\t%s.rgb = (1.0 - %s.a) * %s.rgb + (1.0 - %s.a) * %s.rgb + %s.rgb * %s.rgb;\n", outputColor, fgColor, bgColor, bgColor, fgColor, fgColor, bgColor);
        break;
      case SkBlendImageFilter::kScreen_Mode:
        builder->fsCodeAppendf("\t\t%s.rgb = %s.rgb + %s.rgb - %s.rgb * %s.rgb;\n", outputColor, bgColor, fgColor, fgColor, bgColor);
        break;
      case SkBlendImageFilter::kDarken_Mode:
        builder->fsCodeAppendf("\t\t%s.rgb = min((1.0 - %s.a) * %s.rgb + %s.rgb, (1.0 - %s.a) * %s.rgb + %s.rgb);\n", outputColor, fgColor, bgColor, fgColor, bgColor, fgColor, bgColor);
        break;
      case SkBlendImageFilter::kLighten_Mode:
        builder->fsCodeAppendf("\t\t%s.rgb = max((1.0 - %s.a) * %s.rgb + %s.rgb, (1.0 - %s.a) * %s.rgb + %s.rgb);\n", outputColor, fgColor, bgColor, fgColor, bgColor, fgColor, bgColor);
        break;
    }
}

void GrGLBlendEffect::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
    const GrBlendEffect& blend = drawEffect.castEffect<GrBlendEffect>();
    GrTexture* fgTex = blend.texture(0);
    GrTexture* bgTex = blend.texture(1);
    fForegroundEffectMatrix.setData(uman,
                                    GrEffect::MakeDivByTextureWHMatrix(fgTex),
                                    drawEffect,
                                    fgTex);
    fBackgroundEffectMatrix.setData(uman,
                                    GrEffect::MakeDivByTextureWHMatrix(bgTex),
                                    drawEffect,
                                    bgTex);

}

GrGLEffect::EffectKey GrGLBlendEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
    const GrBlendEffect& blend = drawEffect.castEffect<GrBlendEffect>();

    GrTexture* fgTex = blend.texture(0);
    GrTexture* bgTex = blend.texture(1);

    EffectKey fgKey = GrGLEffectMatrix::GenKey(GrEffect::MakeDivByTextureWHMatrix(fgTex),
                                               drawEffect,
                                               kCoordsType,
                                               fgTex);

    EffectKey bgKey = GrGLEffectMatrix::GenKey(GrEffect::MakeDivByTextureWHMatrix(bgTex),
                                               drawEffect,
                                               kCoordsType,
                                               bgTex);
    bgKey <<= GrGLEffectMatrix::kKeyBits;
    EffectKey modeKey = blend.mode() << (2 * GrGLEffectMatrix::kKeyBits);

    return  modeKey | bgKey | fgKey;
}
#endif


text:
[Read and abide by the Code of Conduct](CODE_OF_CONDUCT.md)! Even if you don't read it,
it still applies to you. Ignorance is not an exemption.

Contents
- [Pull Requests](#pull-requests)
  - [Coding Style](#code)
  - [Commit Messages](#commit)
- [Performance Tests](#performance-tests)
  - [Macro](#macro)
  - [Micro](#micro)

(This document is a work and progress and is subject to change)

###  Submitting a Pull Request (PR)
Before you submit your Pull Request (PR) consider the following guidelines:

* Search [GitHub](https://github.com/ReactiveX/RxJS/pulls) for an open or closed PR
  that relates to your submission. You don't want to duplicate effort.
* Make your changes in a new git branch:

     ```shell
     git checkout -b my-fix-branch master
     ```

* Create your patch, following [code style guidelines](#code), and **including appropriate test cases**.
* Run the full test suite and ensure that all tests pass.
* Run the micro and macro performance tests against your feature branch and compare against master
  to ensure performance wasn't changed for the worse.
* Commit your changes using a descriptive commit message that follows our
  [commit message conventions](#commit). Adherence to these conventions
  is necessary because release notes are automatically generated from these messages.

     ```shell
     git commit -a
     ```
  Note: the optional commit `-a` command line option will automatically "add" and "rm" edited files.

* Push your branch to GitHub:

    ```shell
    git push origin my-fix-branch
    ```

* In GitHub, send a pull request to `RxJS:master`.
* If we suggest changes then:
  * Make the required updates.
  * Re-run the test suites to ensure tests are still passing.
  * Re-run performance tests to make sure your changes didn't hurt performance.
  * Rebase your branch and force push to your GitHub repository (this will update your Pull Request):

    ```shell
    git rebase master -i
    git push -f
    ```

That's it! Thank you for your contribution!

#### After your pull request is merged

After your pull request is merged, you can safely delete your branch and pull the changes
from the main (upstream) repository:

* Delete the remote branch on GitHub either through the GitHub web UI or your local shell as follows:

    ```shell
    git push origin --delete my-fix-branch
    ```

* Check out the master branch:

    ```shell
    git checkout master -f
    ```

* Delete the local branch:

    ```shell
    git branch -D my-fix-branch
    ```

* Update your master with the latest upstream version:

    ```shell
    git pull --ff upstream master
    ```

###  Coding Style Guidelines

- Please use proper types and generics throughout your code.
- 2 space indentation only
- favor readability over terseness

(TBD): For now try to follow the style that exists elsewhere in the source, and use your best judgment.

### Performance Tests

One of the primary goals of this library is (and will continue to be) great performance. As such, we've employed a variety of performance
testing techniques.

  - DON'T labor over minute variations in ops/sec or milliseconds, there will always be varience in perf test results.
  - DON'T alter a performance test unless absolutely necessary. Performance tests may be compared to previous results from previous builds.
  - DO run tests multiple times and make sure the margins of error are low
  - DO run tests in your feature branches and compare them to master
  - DO add performance tests for all new operators
  - DO add performance tests that you feel are missing from other operators
  - DO add additional performance tests for all worthy code paths. If you develop an operator with special handling for scalar observables,
    please add tests for those scenarios

#### Macro

[Macro performance tests](perf/macro) are best written for scenarios where many object instance allocations (or deallocations) are occuring. Operators
that create a lot of child subscriptions, or operators that emit new objects like Observables and Subjects are definitely worth creating
macro performance tests for.

Other scenarios for macro performance testing may include common end-to-end scenarios from real-world apps. If you have a situation in your
app where you feal RxJS is performing poorly, please [submit and issue](/ReactiveX/RxJS/issues) and include a minimal code example showing
your performance issues. We would love to solve perf for your real-world problems and add those tests to our perf test battery.

Macro performance tests can be run by hosting the root directory with any web server (we use [http-server](https://www.npmjs.com/package/http-server)),
then running:

```sh
npm run build_all
protractor protractor.conf.js
```

#### Micro

[Micro performance tests](perf/micro) really only serve to test operations per second. They're quick and easy to develop, and provide a reasonable look into the
relative performance of our operators versus prior versions. All operators should have corresponding micro performance tests.

Micro performance test can be run with:

```sh
npm run build_all
node perf/micro
```

If you wish to run a single micro performance test, you can do so by providing a single argument with the name of the perf test file(s):

```sh
node perf/micro zip
```

##  Commit Message Guidelines

We have very precise rules over how our git commit messages can be formatted.  This leads to **more
readable messages** that are easy to follow when looking through the **project history**.  But also,
we use the git commit messages to **generate the RxJS change log**.

### Commit Message Format
Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
format that includes a **type**, a **scope** and a **subject**:

```
<type>(<scope>): <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>
```

The **header** is mandatory and the **scope** of the header is optional.

Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
to read on GitHub as well as in various git tools.

### Revert
If the commit reverts a previous commit, it should begin with `revert: `, followed by the header of the reverted commit. In the body it should say: `This reverts commit <hash>.`, where the hash is the SHA of the commit being reverted.

### Type
Must be one of the following:

* **feat**: A new feature
* **fix**: A bug fix
* **docs**: Documentation only changes
* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
  semi-colons, etc)
* **refactor**: A code change that neither fixes a bug nor adds a feature
* **perf**: A code change that improves performance
* **test**: Adding missing tests
* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
  generation

### Scope
The scope could be anything specifying place of the commit change. For example
`Observable`, `Subject`, `switchLatest`, etc.

### Subject
The subject contains succinct description of the change:

* use the imperative, present tense: "change" not "changed" nor "changes"
* don't capitalize first letter
* no dot (.) at the end

### Body
Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with previous behavior.

### Footer
The footer should contain any information about **Breaking Changes** and is also the place to
reference GitHub issues that this commit **Closes**.

**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.


text:
<?php

namespace Oro\Bundle\AddressBundle\Entity;

use BeSimple\SoapBundle\ServiceDefinition\Annotation as Soap;

use Oro\Bundle\SoapBundle\Entity\SoapEntityInterface;

/**
 * @Soap\Alias("Oro.Bundle.AddressBundle.Entity.AddressType")
 */
class AddressTypeSoap extends AddressType implements SoapEntityInterface
{
    /**
     * @Soap\ComplexType("string", nillable=true)
     */
    protected $name;

    /**
     * @Soap\ComplexType("string", nillable=true)
     */
    protected $label;

    /**
     * @param AddressType $addressType
     */
    public function soapInit($addressType)
    {
        $this->name = $addressType->name;
        $this->label = $addressType->label;
    }
}


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

// This package contains all the global variables and constants. ONLY TO BE ACCESSED VIA GET/SET FUNCTIONS.
package main

import "github.com/minio/minio/pkg/iodine"

var (
	globalQuietFlag = false // Quiet flag set via command line
	globalForceFlag = false // Force flag set via command line
	globalAliasFlag = false // Alias flag set via command line
	globalJSONFlag  = false // Json flag set via command line
	globalDebugFlag = false // Debug flag set via command line

	mcCurrentConfigVersion = "1.0.0"
)

// mc configuration related constants.
const (
	mcConfigDir        = ".mc/"
	mcConfigWindowsDir = "mc\\"
	mcConfigFile       = "config.json"
)

// session config related constants
const (
	sessionDir = "session"
)

// default access and secret key
const (
	// do not pass accesskeyid and secretaccesskey through cli
	// users should manually edit them, add a stub entry
	globalAccessKeyID     = "YOUR-ACCESS-KEY-ID-HERE"
	globalSecretAccessKey = "YOUR-SECRET-ACCESS-KEY-HERE"
)

// default host
const (
	exampleHostURL = "YOUR-EXAMPLE.COM"
)

// NewIodine - iodine wrapper for debug flag behavior
func NewIodine(err error) error {
	if !globalDebugFlag {
		return iodine.ToError(err)
	}
	return err
}


text:
package org.apache.hadoop.fs.obs;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.contract.AbstractContractGetFileStatusTest;
import org.apache.hadoop.fs.contract.AbstractFSContract;

/**
 * Get file status test cases on obs file system.
 */
public class TestOBSContractGetFileStatus extends
    AbstractContractGetFileStatusTest {

  @Override
  protected AbstractFSContract createContract(
      final Configuration conf) {
    return new OBSContract(conf);
  }
}


text:
/*************************************************************************
**************************************************************************/
//

#include "stdafx.h"
#include "Transport.h"
#include "TCPIPSystemDrvr.h"
#include "swap.h"
#include "TCPIPV4.h"
#include "../drvrglobal.h"

FPTCPIPSET_ERROR fpTCPIPSET_ERROR = NULL;

BOOL APIENTRY DllMain( HANDLE hInst,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
			DisableThreadLibraryCalls((HINSTANCE)hInst);
			break;
		case DLL_THREAD_ATTACH:
			break;
		case DLL_THREAD_DETACH:
			break;
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}

int WINAPI TCPIPInitIO(HMODULE Handle)
{
	HMODULE gModuleHandle;
	if (Handle == NULL)
		return DRVR_ERR_INVALID_DLLHANDLE;
	gModuleHandle = Handle;
	if ((fpTCPIPSET_ERROR = (FPTCPIPSET_ERROR)GetProcAddress( gModuleHandle, TCPIPSETERROR_PROCNAME)) == (FPTCPIPSET_ERROR)NULL)
		return DRVR_ERR_CANNOTLOAD_PROCADDRESS;

	return 0;
}

void WINAPI TCPIPExitIO()
{
}

void WINAPI TCPIPCloseSession (void* ipTCPIPSystem)
{
	CTCPIPSystemDrvr* pTCPIPSystem = (CTCPIPSystemDrvr*)ipTCPIPSystem;

	if (pTCPIPSystem->m_hSocket == NULL)
		return;
	shutdown(pTCPIPSystem->m_hSocket,SD_BOTH);
	closesocket(pTCPIPSystem->m_hSocket);
	memset(pTCPIPSystem->m_object_ref,0,sizeof(pTCPIPSystem->m_object_ref));
	pTCPIPSystem->m_hSocket = NULL;

	if (pTCPIPSystem->m_hEvents[0] != NULL)
		CloseHandle(pTCPIPSystem->m_hEvents[0]);
	pTCPIPSystem->m_hEvents[0] = NULL;

	if (pTCPIPSystem->m_hEvents[1] != NULL)
		CloseHandle(pTCPIPSystem->m_hEvents[1]);
	pTCPIPSystem->m_hEvents[1] = NULL;
}

bool WINAPI TCPIPOpenSession(void* ipTCPIPSystem, char* object_ref)
{
	long haddr = 0;
	struct hostent *hostEntry = NULL;
	unsigned short ushPort=0;
	char pchIP[MAX_OBJECT_REF + 1];
	struct sockaddr_in addr,* paddr;
	bool bConnected = false;

	CTCPIPSystemDrvr* pTCPIPSystem = (CTCPIPSystemDrvr*)ipTCPIPSystem;

	if (pTCPIPSystem->m_hSocket != NULL)
		return true;

	if (pTCPIPSystem->odbcAPI != AS_API_GETOBJREF &&
		pTCPIPSystem->odbcAPI != AS_API_UPDATESRVRSTATE &&
		pTCPIPSystem->odbcAPI != AS_API_STOPSRVR &&
		pTCPIPSystem->odbcAPI != AS_API_STATUSDSALL &&
		pTCPIPSystem->odbcAPI != SRVR_API_SQLCONNECT)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_SOCKET, 10054, (int)0);
		return false;
	}

	if ((pTCPIPSystem->m_hSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_SOCKET, WSAGetLastError(), (int)0);
		pTCPIPSystem->m_hSocket = NULL;
		return false;
	}

	ParseObjectRef(object_ref, pchIP, ushPort);
	strcpy(pTCPIPSystem->m_object_ref, object_ref);

	int nBlockSIze = MAX_TCP_BUFFER_LENGTH;
	if (setsockopt(pTCPIPSystem->m_hSocket, SOL_SOCKET, SO_SNDBUF, (char*)&nBlockSIze, sizeof(int)) != 0)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_SETSOCOPT, WSAGetLastError(), (int)SO_SNDBUF);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	};
	nBlockSIze = MAX_TCP_BUFFER_LENGTH;
	if (setsockopt(pTCPIPSystem->m_hSocket, SOL_SOCKET, SO_RCVBUF, (char*)&nBlockSIze, sizeof(int)) != 0)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_SETSOCOPT, WSAGetLastError(), (int)SO_RCVBUF);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	};

	paddr = &addr;
	memset((char *)paddr, 0, sizeof(struct sockaddr_in));
	paddr->sin_family = AF_INET;
	paddr->sin_port = htons(ushPort);

	if(( haddr = inet_addr(pchIP)) == INADDR_NONE )
	{
		int count = 0;
		hostEntry = gethostbyname(pchIP );
		if (hostEntry)
			while( hostEntry->h_addr_list[count] )
			{
				memcpy((char *)&paddr->sin_addr.s_addr, hostEntry->h_addr_list[count], hostEntry->h_length );
				if (connect(pTCPIPSystem->m_hSocket, (const struct sockaddr *)&addr, sizeof(SOCKADDR)) != SOCKET_ERROR)
				{
					bConnected = true;
					break;
				}
				else
					count++;
			}
	}
	else
	{
		paddr->sin_addr.s_addr = haddr;
		if (connect(pTCPIPSystem->m_hSocket, (const struct sockaddr *)&addr, sizeof(SOCKADDR)) != SOCKET_ERROR)
		{
			bConnected = true;
		}
	}
	if (bConnected == false)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_CONNECT, DRVR_ERR_WRONG_IP_ADDRESS, (int)0);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	}

	struct linger_def
	{
		u_short l_onoff;
		u_short l_linger;
	} linger;
	linger.l_onoff = 1;
	linger.l_linger = 0;
	if (setsockopt(pTCPIPSystem->m_hSocket, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger)) != 0)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_SETSOCOPT, WSAGetLastError(), (int)SO_LINGER);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	};

	if (NULL == (pTCPIPSystem->m_hEvents[0] = CreateEvent(NULL, FALSE, FALSE,"")))
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_WSACREATEEVENT, WSAGetLastError(), (int)0);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	}
	if (NULL == (pTCPIPSystem->m_hEvents[1] = CreateEvent(NULL, FALSE, FALSE,"")))
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, object_ref, O_OPEN_SESSION, F_WSACREATEEVENT, WSAGetLastError(), (int)1);
		TCPIPCloseSession (ipTCPIPSystem);
		return false;
	}
	return true;
}

bool WINAPI TCPIPDoWriteRead(void* ipTCPIPSystem, HEADER*& hdr, char*& buffer, int& bufcount, unsigned int timeout)
{
	HEADER close_hdr;
	HEADER* error_hdr;
	short error = 0;
	short error_detail = 0;
	int wcount;
	int data_length = 0;
	CTCPIPSystemDrvr* pTCPIPSystem = (CTCPIPSystemDrvr*)ipTCPIPSystem;

	if (pTCPIPSystem->m_hSocket == NULL)
	{
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_CHECKCONNECTION, 999, (int)0);
		return false;
	}

	switch(hdr->hdr_type)
	{
	default:
	case WRITE_REQUEST_FIRST:
		memcpy(pTCPIPSystem->m_IObuffer,hdr,sizeof(HEADER));
		HEADER_swap((HEADER*)pTCPIPSystem->m_IObuffer);
		data_length = sizeof(HEADER);
	case WRITE_REQUEST_NEXT:
		if (buffer != NULL)
			memcpy(pTCPIPSystem->m_IObuffer + data_length, buffer, bufcount);
		data_length += bufcount;
		if ((wcount = send_nblk(pTCPIPSystem->m_hSocket,
								pTCPIPSystem->m_IObuffer,
								data_length,
								0,
								timeout,
								pTCPIPSystem)) == SOCKET_ERROR|| wcount == 0)
		{
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		break;
	case READ_RESPONSE_FIRST:
	case READ_RESPONSE_NEXT:
		if ((wcount = recv_nblk(pTCPIPSystem->m_hSocket,
								pTCPIPSystem->m_IObuffer,
								MAX_TCP_BUFFER_LENGTH,
								0,
								timeout,
								pTCPIPSystem)) == SOCKET_ERROR || wcount == 0)
		{
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		if (hdr->hdr_type == READ_RESPONSE_FIRST && wcount < sizeof HEADER)
		{
			if ((wcount = recv_header(pTCPIPSystem->m_hSocket,
									pTCPIPSystem->m_IObuffer,
									wcount,
									MAX_TCP_BUFFER_LENGTH,
									sizeof HEADER,
									0,
									timeout,
									pTCPIPSystem)) == SOCKET_ERROR || wcount == 0)
			{
				TCPIPCloseSession (ipTCPIPSystem);
				return false;
			}
		}
		break;
	case CLOSE_TCPIP_SESSION:
		memcpy(&close_hdr,hdr,sizeof(HEADER));
		HEADER_swap((HEADER*)&close_hdr);
		data_length = sizeof(HEADER);
		send_close_session(pTCPIPSystem->m_hSocket,
								(char*)&close_hdr,
								data_length,
								0,
								30,
								pTCPIPSystem);
		return true;
	}
	bufcount = 0;
	switch(hdr->hdr_type)
	{
	case WRITE_REQUEST_FIRST:
		bufcount -= sizeof(HEADER);
	case WRITE_REQUEST_NEXT:
		bufcount += wcount;
		if (bufcount < 0)
		{
			error = DRVR_ERR_INCORRECT_LENGTH;
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_SEND, error, bufcount);
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		break;
	case READ_RESPONSE_FIRST:
		bufcount = wcount - sizeof(HEADER);
		if (bufcount < 0)
		{
			error = DRVR_ERR_INCORRECT_LENGTH;
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, error, bufcount);
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		buffer = pTCPIPSystem->m_IObuffer + sizeof(HEADER);
		hdr = (HEADER*)pTCPIPSystem->m_IObuffer;
		if (hdr->signature != SIGNATURE)
		{
			error = DRVR_ERR_WRONGSIGNATURE;
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, error, (int)0);
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		if (hdr->error != 0 )
		{
			error = DRVR_ERR_ERROR_FROM_SERVER;
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, hdr->error, hdr->error_detail);
			TCPIPCloseSession (ipTCPIPSystem);
			return false;
		}
		break;
	case READ_RESPONSE_NEXT:
		bufcount = wcount;
		memcpy(buffer, pTCPIPSystem->m_IObuffer, bufcount);
		break;
	case SRVR_TRANSPORT_ERROR:
		error_hdr = (HEADER*)(pTCPIPSystem->m_IObuffer);
		error = error_hdr->error;
		error_detail = error_hdr->error_detail;
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_SRVR_TRANSPORT_ERROR, error, error_detail);
		TCPIPCloseSession (ipTCPIPSystem);
		break;
	default:
		error = 1000;
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_HDR_TYPE, error, (int)0);
		TCPIPCloseSession (ipTCPIPSystem);
		break;
	}
	return error == 0;
}

void ParseObjectRef(char* object_ref, char* pchIP, unsigned short& ushPort)
{
	char buffer[MAX_OBJECT_REF + 1];

	strncpy(buffer, object_ref, MAX_OBJECT_REF);
	buffer[MAX_OBJECT_REF] = 0;
	char* pIp = NULL, * pPort = NULL;

	pchIP[0] = 0;
	ushPort = 0;

	if ( strtok(buffer, ":") != NULL)
		if ((pIp = strtok(NULL,"/")) != NULL )
			if ((pPort = strtok(NULL, ":")) != NULL)
			{
				strcpy (pchIP, pIp);
				ushPort = atoi(pPort);
			}
}

int send_nblk( SOCKET s, char *buf, int len, int flags, unsigned int timeout, CTCPIPSystemDrvr* pTCPIPSystem)
{
	unsigned long sflags = 0;
	int nLeft = len;
	int idx = 0;
	int retcode;
	long lastResult;

	DWORD written = 0;
	WSABUF wsabuf;
	WSAOVERLAPPED overlapped;

	SEND_INFO si;
	si.hEvent = pTCPIPSystem->m_hEvents[1];
	si.s = s;
	si.timeout = timeout;

	overlapped.hEvent = pTCPIPSystem->m_hEvents[1];

	while (nLeft > 0)
	{
		wsabuf.buf = &buf[idx];
		wsabuf.len = nLeft;
		if (WSASend(s, &wsabuf, 1, &written, 0, &overlapped, NULL) == 0)
		{
			lastResult = written;
		}
		else
		{
			if (WSAGetLastError() != WSA_IO_PENDING)
			{
				(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_SEND, WSAGetLastError(), (int)0);
				return false;
			}
			retcode = wait_for_event(&si, FD_WRITE, pTCPIPSystem);
			if (retcode == 0)
				return false;
			if (FALSE==WSAGetOverlappedResult(s, &overlapped, &written, false, &sflags))
			{
				(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_SEND_GETOVERLAPPEDRESULTS, WSAGetLastError(), (int)0);
				return false;
			}
			lastResult = written;
		}

		nLeft -= lastResult;
		idx += lastResult;
	}
	return idx;
}

int recv_nblk( SOCKET s, char *buf, int len, int flags, unsigned int timeout, CTCPIPSystemDrvr* pTCPIPSystem)
{
	unsigned long lastResult;
	unsigned long rflags = 0;
	int retcode;
	WSABUF wsabuf = {len, (char *)buf};
	WSAOVERLAPPED overlapped;

	SEND_INFO si;
	si.hEvent = pTCPIPSystem->m_hEvents[0];
	si.s = s;
	si.timeout = timeout;

	overlapped.hEvent = pTCPIPSystem->m_hEvents[0];

	if (WSARecv(s, &wsabuf, 1, &lastResult, &rflags, &overlapped, NULL) == 0)
	{
		if (lastResult == 0)
		{
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, COMM_LINK_FAIL_EXCEPTION, (int)0);
			return 0;
		}
	}
	else
	{
		switch (WSAGetLastError())
		{
		default:
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, WSAGetLastError(), (int)0);
			return SOCKET_ERROR;
		case WSAEDISCON:
			(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV, COMM_LINK_FAIL_EXCEPTION, (int)0);
			return WSAEDISCON;
		case WSA_IO_PENDING:
			retcode = wait_for_event(&si, FD_READ, pTCPIPSystem);
			if (retcode == false)
				return 0;
			if (WSAGetOverlappedResult(s, &overlapped, &lastResult, false, &rflags))
			{
				if (lastResult == 0)
				{
					(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV_GETOVERLAPPEDRESULTS, COMM_LINK_FAIL_EXCEPTION, (int)0);
					return 0;
				}
			}
			else
			{
				switch (WSAGetLastError())
					{
					default:
						(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV_GETOVERLAPPEDRESULTS, WSAGetLastError(), (int)0);
						return SOCKET_ERROR;
					case WSAEDISCON:
						(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_RECV_GETOVERLAPPEDRESULTS, COMM_LINK_FAIL_EXCEPTION, (int)0);
						return WSAEDISCON;
					}
			}
		}
	}
	return lastResult;
}

void send_close_session( SOCKET s, char *buf, int len, int flags, unsigned int timeout, CTCPIPSystemDrvr* pTCPIPSystem)
{
	send_nblk(s, buf, len, flags, timeout, pTCPIPSystem);
}

int recv_header(SOCKET s, char* buf, int wcount, int bufSize, int headerSize, int flags, unsigned int timeout, CTCPIPSystemDrvr* pTCPIPSystem)
{

	int already_read = wcount;
	char* pbuf;
	int len;
	int retcode;

	while (already_read < headerSize )
	{
		pbuf = buf + already_read;
		len = bufSize - already_read;

		retcode = recv_nblk(s, pbuf, len, flags, timeout, pTCPIPSystem);
		if (retcode == 0 || retcode == SOCKET_ERROR)
			return retcode;
		already_read += retcode;
	}
	return already_read;
}
int wait_for_event(SEND_INFO* si, long operation, CTCPIPSystemDrvr* pTCPIPSystem)
{
	DWORD dwEvent;
	unsigned int wtimeout = (si->timeout == 0)? INFINITE: si->timeout * 1000;

	dwEvent = WaitForSingleObject(si->hEvent,wtimeout);
	switch(dwEvent)
	{
	case WAIT_OBJECT_0:
		break;
	case WAIT_FAILED:
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_WSAWAITFORMULTIPLEEVENTS, GetLastError(), (int)operation);
		TCPIPCloseSession (pTCPIPSystem);
		return false;
	case WAIT_TIMEOUT:
		(fpTCPIPSET_ERROR)((long)pTCPIPSystem, PC, TCPIP, pTCPIPSystem->odbcAPI, E_DRIVER, pTCPIPSystem->m_object_ref, O_DO_WRITE_READ, F_WSAWAITFORMULTIPLEEVENTS, TIMEOUT_EXCEPTION, (unsigned int)wtimeout);
		TCPIPCloseSession (pTCPIPSystem);
		return false;
	}

	return true;
}


text:
package weibo4j;

import java.util.List;

import weibo4j.model.Favorites;
import weibo4j.model.FavoritesTag;
import weibo4j.model.Paging;
import weibo4j.model.PostParameter;
import weibo4j.model.Tag;
import weibo4j.model.WeiboException;
import weibo4j.org.json.JSONException;
import weibo4j.org.json.JSONObject;
import weibo4j.util.WeiboConfig;

public class Favorite extends Weibo{
	/**
	 *
	 */
	private static final long serialVersionUID = 2298934944028795652L;

	/*----------------------------收藏接口----------------------------------------*/
	/**
	 * 获取当前登录用户的收藏列表
	 *
	 * @return list of the Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites
	 * @since JDK 1.5
	 */
	public List<Favorites> getFavorites() throws WeiboException {
		return Favorites.constructFavorites(client.get(WeiboConfig
				.getValue("baseURL") + "favorites.json"));
	}

	/**
	 * 获取当前登录用户的收藏列表
	 *
	 * @param page
	 *            、count
	 * @return list of the Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites
	 * @since JDK 1.5
	 */
	public List<Favorites> getFavorites(Paging page) throws WeiboException {
		return Favorites.constructFavorites(client.get(
						WeiboConfig.getValue("baseURL") + "favorites.json",
						null, page));
	}
	/**
	 * 获取当前登录用户的收藏列表ID
	 *
	 * @return list of the Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites
	 * @since JDK 1.5
	 */
	public JSONObject getFavoritesIds() throws WeiboException {
		return client.get(WeiboConfig
				.getValue("baseURL") + "favorites/ids.json").asJSONObject();
	}
	/**
	 * 获取当前登录用户的收藏列表ID
	 *
	 * @return list of the Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites
	 * @since JDK 1.5
	 */
	public JSONObject getFavoritesIds(Paging page) throws WeiboException {
		return client.get(WeiboConfig
				.getValue("baseURL") + "favorites/ids.json",null,page).asJSONObject();
	}
	/**
	 * 根据收藏ID获取指定的收藏信息
	 *
	 * @param id
	 * @return Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites/show
	 * @since JDK 1.5
	 */
	public Favorites showFavorites(String id) throws WeiboException {
		return new Favorites(client.get(WeiboConfig.getValue("baseURL")
				+ "favorites/show.json",
				new PostParameter[] { new PostParameter("id", id) }));
	}

	/**
	 * 根据标签获取当前登录用户该标签下的收藏列表
	 *
	 * @param tid
	 * @return list of the favorite Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites/by_tags
	 * @since JDK 1.5
	 */
	public List<Favorites> getFavoritesByTags(String tid) throws WeiboException {
		return Favorites.constructFavorites(client.get(
				WeiboConfig.getValue("baseURL") + "favorites/by_tags.json",
				new PostParameter[] { new PostParameter("tid", tid) }));
	}

	/**
	 * 根据标签获取当前登录用户该标签下的收藏列表
	 *
	 * @param tid
	 * @param page
	 * @return list of the favorite Status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/show
	 * @since JDK 1.5
	 */
	public List<Favorites> getFavoritesByTags(String tid, Paging page)
			throws WeiboException {
		return Favorites.constructFavorites(client.get(
				WeiboConfig.getValue("baseURL") + "favorites/by_tags.json",
				new PostParameter[] { new PostParameter("tid", tid) }, page));
	}

	/**
	 * 获取当前登录用户的收藏标签列表
	 *
	 * @param page
	 * @return list of the favorite tags
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.1
	 * @see favorites/tags
	 * @since JDK 1.5
	 */
	public List<FavoritesTag> getFavoritesTags() throws WeiboException {
		return Tag.constructTag(client.get(WeiboConfig
				.getValue("baseURL") + "favorites/tags.json"));

	}

	/**
	 * 添加一条微博到收藏里
	 *
	 * @param 要收藏的微博ID
	 *            。
	 * @return Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/create
	 * @since JDK 1.5
	 */
	public Favorites createFavorites(String id) throws WeiboException {
		return new Favorites(client.post(WeiboConfig.getValue("baseURL")
				+ "favorites/create.json",
				new PostParameter[] { new PostParameter("id", id) }));
	}

	/**
	 * 取消收藏一条微博
	 *
	 * @param 要取消收藏的微博ID
	 *            。
	 * @return Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/destroy
	 * @since JDK 1.5
	 */
	public Favorites destroyFavorites(String id) throws WeiboException {
		return new Favorites(client.post(WeiboConfig.getValue("baseURL")
				+ "favorites/destroy.json",
				new PostParameter[] { new PostParameter("id", id) }));
	}

	/**
	 * 批量删除收藏
	 *
	 * @param ids
	 *            要取消收藏的收藏ID,用半角逗号分隔,最多不超过10个。
	 * @return destroy list of Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/destroy_batch
	 * @since JDK 1.5
	 */
	public Boolean destroyFavoritesBatch(String ids) throws WeiboException {
		try {
			return client
					.post(WeiboConfig.getValue("baseURL")
							+ "favorites/destroy_batch.json",
							new PostParameter[] { new PostParameter("ids", ids) })
					.asJSONObject().getBoolean("result");
		} catch (JSONException e) {
			throw new WeiboException(e);
		}
	}

	/**
	 * 更新一条收藏的收藏标签
	 *
	 * @param id
	 *            要需要更新的收藏ID
	 * @return update tag of Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/tags/update
	 * @since JDK 1.5
	 */
	public Favorites updateFavoritesTags(String id) throws WeiboException {
		return new Favorites(client.post(WeiboConfig.getValue("baseURL")
				+ "favorites/tags/update.json",
				new PostParameter[] { new PostParameter("id", id) }));
	}

	/**
	 * 更新一条收藏的收藏标签
	 *
	 * @param id
	 *            要需要更新的收藏ID
	 * @param tags
	 *            需要更新的标签内容,必须做URLencode,用半角逗号分隔,最多不超过2条。
	 * @return update tag of Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/tags/update
	 * @since JDK 1.5
	 */
	public Favorites updateFavoritesTags(String id, String tags)
			throws WeiboException {
		return new Favorites(client.post(WeiboConfig.getValue("baseURL")
				+ "favorites/tags/update.json", new PostParameter[] {
				new PostParameter("id", id), new PostParameter("tags", tags) }));
	}

	/**
	 * 更新当前登录用户所有收藏下的指定标签
	 *
	 * @param id
	 *            需要更新的标签ID。
	 * @return update tags of Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/tags/update_batch
	 * @since JDK 1.5
	 */
	public JSONObject updateFavoritesTagsBatch(String tid, String tag)
			throws WeiboException {
		return client.post(
				WeiboConfig.getValue("baseURL")
						+ "favorites/tags/update_batch.json",
				new PostParameter[] { new PostParameter("tid", tid),
						new PostParameter("tag", tag) }).asJSONObject();
	}

	/**
	 * 删除当前登录用户所有收藏下的指定标签
	 *
	 * @param id
	 *            需要删除的标签ID。。
	 * @return destroy tags of Favorites status
	 * @throws WeiboException
	 *             when Weibo service or network is unavailable
	 * @version weibo4j-V2 1.0.0
	 * @see favorites/tags/destroy_batch
	 * @since JDK 1.5
	 */
	public Boolean destroyFavoritesTagsBatch(String ids) throws WeiboException {
		try {
			return client
					.post(WeiboConfig.getValue("baseURL")
							+ "favorites/destroy_batch.json",
							new PostParameter[] { new PostParameter("ids", ids) })
					.asJSONObject().getBoolean("result");
		} catch (JSONException e) {
			throw new WeiboException(e);
		}
	}
}


text:
namespace base {
struct Feature;
}

namespace shared_highlighting {

// Enables link to text to be generated in advance.
extern const base::Feature kPreemptiveLinkToTextGeneration;
// Sets the timeout length for pre-emptive link generation.
extern const base::FeatureParam<int> kPreemptiveLinkGenTimeoutLengthMs;

// Enables the new UI features for highlighted text.
extern const base::Feature kSharedHighlightingV2;

// Enables shared highlighting for AMP viewers pages.
extern const base::Feature kSharedHighlightingAmp;

// Feature flag that enable Shared Highlighting V2 in iOS.
extern const base::Feature kIOSSharedHighlightingV2;

// Returns the pre-emptive link generation timeout length.
int GetPreemptiveLinkGenTimeoutLengthMs();

}  // namespace shared_highlighting

#endif  // COMPONENTS_SHARED_HIGHLIGHTING_CORE_COMMON_SHARED_HIGHLIGHTING_FEATURES_H_


text:
package com.getiton.android.app.overview;

import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AlertDialog;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.ProgressBar;

import com.getiton.android.app.core.ApplicationController;
import com.getiton.android.app.core.CoreActivity;
import com.getiton.android.app.core.bindable.BindableRecyclerViewAdapter;
import com.getiton.android.app.core.collections.ArrayQueryable;
import com.getiton.android.app.core.data.NamedLanModulesViewModel;
import com.getiton.android.app.core.data.db.NamedLanModule;
import com.getiton.android.app.core.util.SnackbarUtil;
import com.getiton.android.app.rgb.RgbV1Activity;
import com.getiton.android.app.tutorial.TutorialSetupInfoActivity;

import java.util.ArrayList;

import javax.inject.Inject;

import butterknife.ButterKnife;
import butterknife.InjectView;
import com.christophesmet.getiton.library.GetItOn;
import com.christophesmet.getiton.library.core.discovery.lan.repo.model.LanModule;
import com.christophesmet.getiton.library.core.module.WifiModule;
import com.christophesmet.getiton.library.logging.ILoggingService;
import com.christophesmet.getiton.library.modules.RGBV1Module;
import com.christophesmet.ledsgetiton.R;
import rx.Observable;
import rx.Subscriber;
import rx.android.observables.AndroidObservable;
import rx.functions.Func1;

/**
 * Created by christophesmet on 06/09/15.
 */

public class OverviewActivity extends CoreActivity {

    private static final int MAX_SCAN_TRIES = 3;

    @InjectView(R.id.toolbar)
    Toolbar mToolbar;
    @InjectView(R.id.lst_items)
    RecyclerView mLstItems;
    @InjectView(R.id.prg_loading)
    ProgressBar mPrgLoading;
    private int mScanTries = 0;

    @Inject
    protected GetItOn mGetItOn;
    @Inject
    protected ILoggingService mILoggingService;
    @Inject
    protected NamedLanModulesViewModel mNamedLanModulesViewModel;

    private BindableRecyclerViewAdapter<OverViewListItem> mAdapter;
    private ArrayList<OverViewListItem> mItems = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ((ApplicationController) getApplicationContext()).inject(this);
        setContentView(R.layout.overview_activity);
        ButterKnife.inject(this);
        loadData();
        loadListeners();
        startSearching();
    }

    private void loadData() {
        mAdapter = new BindableRecyclerViewAdapter<>(this, R.layout.overview_module_listitemview, new ArrayQueryable<>(mItems));
        mLstItems.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
        mLstItems.setAdapter(mAdapter);
    }

    private void loadListeners() {
        mAdapter.setItemClickListener(new BindableRecyclerViewAdapter.ItemClickListener() {
            @Override
            public void onItemClicked(@NonNull Object view, int position) {
                openDetail(mAdapter.getCollection().getItem(position));
            }
        });
    }

    private void openDetail(@NonNull OverViewListItem item) {
        if (item.getLanModule() != null && item.getLanModule() instanceof RGBV1Module) {
            Intent intent = RgbV1Activity.creatIntent(this, item.getLanModule().getMac(), 0xFFFF0000);
            startActivity(intent);
        } else if (item.getWifiModule() != null) {
            Intent intent = TutorialSetupInfoActivity.createIntent(this, item.getWifiModule());
            startActivity(intent);
        }
    }

    private void startSearching() {
        showLoading(true);
        mItems.clear();
        mAdapter.setCollection(new ArrayQueryable<OverViewListItem>(mItems), true);
        AndroidObservable.bindActivity(this,
                getNamedLanModuleScanResults()
                        .mergeWith(getWifiScanResults())
        )
                .subscribe(new Subscriber<OverViewListItem>() {
                    @Override
                    public void onCompleted() {
                        onSearchComplete();
                    }

                    @Override
                    public void onError(Throwable e) {
                        showloading(mPrgLoading, false);
                        mILoggingService.log(e);
                        SnackbarUtil.show(OverviewActivity.this, e, new View.OnClickListener() {
                            @Override
                            public void onClick(View v) {
                                mScanTries = 0;
                                startSearching();
                            }
                        });
                    }

                    @Override
                    public void onNext(OverViewListItem overViewListItem) {
                        mItems.add(0, overViewListItem);
                        mAdapter.notifyItemInserted(0);
                    }
                });
    }

    private void onSearchComplete() {
        mScanTries++;
        mILoggingService.log("Scan completed: times -> " + mScanTries);
        showloading(mPrgLoading, false);
        if (mScanTries >= MAX_SCAN_TRIES) {
            if (mItems.size() == 0) {
                onNoModulesFound();
            }
        } else {
            if (mItems.size() == 0) {
                startSearching();
            }
        }
    }

    private Observable<OverViewListItem> getNamedLanModuleScanResults() {
        return mGetItOn.scanForLanModules()
                .map(new Func1<LanModule, OverViewListItem>() {
                    @Override
                    public OverViewListItem call(LanModule lanModule) {
                        OverViewListItem output = new OverViewListItem(lanModule);
                        NamedLanModule namedLanModule = mNamedLanModulesViewModel.findModuleForId(lanModule.getMac());
                        if (namedLanModule != null) {
                            output.setName(namedLanModule.getName());
                        } else {
                            output.setName("Unknown");
                        }
                        return output;
                    }
                });
    }

    private Observable<OverViewListItem> getWifiScanResults() {
        return mGetItOn
                .getRegistrator()
                .scanWifiForCanidates(false)
                .flatMap(new Func1<ArrayList<WifiModule>, Observable<? extends WifiModule>>() {
                    @Override
                    public Observable<? extends WifiModule> call(ArrayList<WifiModule> wifiModules) {
                        return Observable.from(wifiModules);
                    }
                })
                .map(new Func1<WifiModule, OverViewListItem>() {
                    @Override
                    public OverViewListItem call(WifiModule wifiModule) {
                        String name = wifiModule.getSSID().equalsIgnoreCase("leds get it on") ? "RGB Module" : "Unknown Module";
                        OverViewListItem output = new OverViewListItem(wifiModule, name);
                        return output;
                    }
                });
    }

    private void onNoModulesFound() {
        new AlertDialog.Builder(this)
                .setTitle(getString(R.string.tutorial_scan_timeout_title))
                .setMessage(getString(R.string.tutorial_scan_timeout_description))
                .setPositiveButton(getString(R.string.general_ok_got_it), new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        mScanTries = 0;
                        dialog.dismiss();
                        startSearching();
                    }
                }).show();
    }

    private void showLoading(boolean show) {
        mPrgLoading.setVisibility(show ? View.VISIBLE : View.GONE);
    }
}


text:
package org.yeastrc.xlink.www.searcher_via_cached_data.return_objects_from_searchers_for_cached_data;

public class LooplinkProteinPositionsFor_LooplinkPeptide_Result_Entry {

	private int proteinSequenceVersionId;
	private int proteinSequencePosition_1;
	private int proteinSequencePosition_2;

	public int getProteinSequenceVersionId() {
		return proteinSequenceVersionId;
	}
	public void setProteinSequenceVersionId(int proteinSequenceVersionId) {
		this.proteinSequenceVersionId = proteinSequenceVersionId;
	}
	public int getProteinSequencePosition_1() {
		return proteinSequencePosition_1;
	}
	public void setProteinSequencePosition_1(int proteinSequencePosition_1) {
		this.proteinSequencePosition_1 = proteinSequencePosition_1;
	}
	public int getProteinSequencePosition_2() {
		return proteinSequencePosition_2;
	}
	public void setProteinSequencePosition_2(int proteinSequencePosition_2) {
		this.proteinSequencePosition_2 = proteinSequencePosition_2;
	}

}


text:
<?php
/* Prototype  : proto array compact(mixed var_names [, mixed ...])
 * Description: Creates a hash containing variables and their values
 * Source code: ext/standard/array.c
 * Alias to functions:
 */

/*
 * Test basic functionality
 */

echo "*** Testing compact() : basic functionality ***\n";

$a=1;
$b=0.2;
$c=true;
$d=array("key"=>"val");
$e=NULL;
$f="string";

// simple array test
var_dump (compact(array("a", "b", "c", "d", "e", "f")));
// simple parameter test
var_dump (compact("a", "b", "c", "d", "e", "f"));
var_dump (compact(array("keyval"=>"a", "b"=>"b", "c"=>1)));

// cases which should not yield any output.
var_dump (compact(array(10, 0.3, true, array(20), NULL)));
var_dump (compact(10, 0.3, true, array(20), NULL));
var_dump (compact(array("g")));

echo "Done";
?>