text:
package com.camunda.consulting.gregXMLCalendarJson;

import javax.inject.Named;

import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import org.camunda.bpm.engine.variable.value.TypedValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.camunda.consulting.gregXMLCalendarJson.data.ExampleData;

@Named
public class PrintObjectDelegate implements JavaDelegate {

  private static Logger log = LoggerFactory.getLogger(PrintObjectDelegate.class);

  @Override
  public void execute(DelegateExecution execution) throws Exception {
    TypedValue variableTyped = execution.getVariableTyped("exampleData");
    ExampleData exampleData = (ExampleData) variableTyped.getValue();
    log.info("exampleData: {}", exampleData);
  }

}

redpajama_set_name: RedPajamaGithub


text:
from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('projects', '0014_remove_project_other_perimeter'),
    ]

    operations = [
        migrations.AddField(
            model_name='project',
            name='project_leader_name',
            field=models.CharField(blank=True, max_length=255, verbose_name='Nom du porteur de projet'),
        ),
        migrations.AddField(
            model_name='project',
            name='project_leader_type',
            field=models.CharField(blank=True, choices=[('public', 'Public'), ('private', 'Priv\xe9')], max_length=255, verbose_name='Type de porteur de projet'),
        ),
    ]


text:
jQuery.fn.selectRange = function(start, end) {
    return this.each(function() {
        if (this.setSelectionRange) {
            this.focus();
            this.setSelectionRange(start, end);
        } else if (this.createTextRange) {
            var range = this.createTextRange();
            range.collapse(true);
            range.moveEnd('character', end);
            range.moveStart('character', start);
            range.select();
        }
    });
};

jQuery.fn.replaceClasses = function(newClasses) {
    this.removeAttr('class');
    if (newClasses) {
        this.attr('class', newClasses);
    }
    return this;
};

/** Clone an element, removing metamorph binding tags and ember metadata */
jQuery.fn.safeClone = function() {
    var clone = jQuery(this).clone();
    // Remove content bindings
    clone.find('script[id^=metamorph]').remove();

    // Remove attr bindings
    clone.find('*').each(function() {
        var $this = jQuery(this);
        var i, attribute;
        var length = $this[0].attributes.length;
        for (i = 0; i < length; i++) {
            attribute = $this[0].attributes[i];
            if (attribute && attribute.name.match(/^data-(bindattr|ember)/)) {
                $this.removeAttr(attr.name);
            }
        }
    });

    // Remove ember ids
    clone.find('[id^=ember]').removeAttr('id');

    return clone;
};


text:
package jenkins.advancedqueue.sorter.strategy;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import hudson.model.Queue;
import hudson.model.Queue.LeftItem;

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

import jenkins.advancedqueue.sorter.SorterStrategyCallback;

/**
 * Scheduler based on Fair Queuing algorithm.
 * @author Magnus Sandberg
 * @since 2.0
 */
abstract public class FQBaseStrategy extends MultiBucketStrategy {
	// The equivalent of a packet size for a network scheduler.
	static final protected float MIN_STEP_SIZE = 0.00001F;
	// Keeps track on the last assigned weight for a given priority
	static final Map<Integer, Float> prio2weight = new HashMap<Integer, Float>();
	static final private float MIN_STARTED_WEIGHT = 1F;
	// Keeps track on the max weight of started jobs
	static float maxStartedWeight = MIN_STARTED_WEIGHT;

	public FQBaseStrategy() {
	}

	public FQBaseStrategy(int numberOfPriorities, int defaultPriority) {
		super(numberOfPriorities, defaultPriority);
	}

	@Override
	@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
	public void onStartedItem(LeftItem item, float weight) {
		maxStartedWeight = Math.max(maxStartedWeight, weight);
	}

	public SorterStrategyCallback onNewItem(Queue.Item item, SorterStrategyCallback weightCallback) {
		int priority = weightCallback.getPriority();
		float minimumWeightToAssign = getMinimumWeightToAssign(priority);
		float weightToUse = getWeightToUse(priority, minimumWeightToAssign);
		prio2weight.put(priority, weightToUse);
		return weightCallback.setWeightSelection(weightToUse);
	}

	protected float getMinimumWeightToAssign(int priority) {
		Float minWeight = prio2weight.get(priority);
		if (minWeight == null) {
			return maxStartedWeight;
		}
		return Math.max(maxStartedWeight, minWeight);
	}

	@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
	protected float getWeightToUse(int priority, float minimumWeightToAssign) {
		float weight = minimumWeightToAssign * (1F + getStepSize(priority));
		// Protect us from values going through the roof if we run for a very
		// long time
		// This below might leave some jobs in the queue with very large weight
		// this probably improbable to happen so let's do it like this for now
		// ...
		if (Float.POSITIVE_INFINITY == weight) {
			maxStartedWeight = MIN_STARTED_WEIGHT;
			prio2weight.clear();
			return MIN_STARTED_WEIGHT;
		}
		return weight;
	}

	abstract float getStepSize(int priority);
}


text:
import { CellEditor, CellEditorProps, PortalEditingKeydown } from '@t/editor';
import { CellValue, ListItem } from '@t/store/data';
import { getListItems } from '../helper/editor';
import { cls, hasClass } from '../helper/dom';
import { getKeyStrokeString, isArrowKey } from '../helper/keyboard';
import { findIndex } from '../helper/common';
import { getContainerElement, setLayerPosition, setOpacity } from './dom';

const LAYER_CLASSNAME = cls('editor-checkbox-list-layer');
const LIST_ITEM_CLASSNAME = cls('editor-checkbox');
const HOVERED_LIST_ITEM_CLASSNAME = `${cls('editor-checkbox-hovered')} ${LIST_ITEM_CLASSNAME}`;
const UNCHECKED_RADIO_LABEL_CLASSNAME = cls('editor-label-icon-radio');
const CHECKED_RADIO_LABEL_CLASSNAME = cls('editor-label-icon-radio-checked');
const UNCHECKED_CHECKBOX_LABEL_CLASSNAME = cls('editor-label-icon-checkbox');
const CHECKED_CHECKBOX_LABEL_CLASSNAME = cls('editor-label-icon-checkbox-checked');

export class CheckboxEditor implements CellEditor {
  public el: HTMLElement;

  private layer: HTMLUListElement;

  private readonly inputType: 'checkbox' | 'radio';

  private hoveredItemId = '';

  private portalEditingKeydown: PortalEditingKeydown;

  private elementIds: string[] = [];

  public constructor(props: CellEditorProps) {
    const { columnInfo, width, value, formattedValue, portalEditingKeydown } = props;
    const el = document.createElement('div');
    el.className = cls('layer-editing-inner');
    el.innerText = formattedValue;

    this.inputType = columnInfo.editor!.options!.type;

    const listItems = getListItems(props);
    const layer = this.createLayer(listItems, width);

    this.portalEditingKeydown = portalEditingKeydown;
    this.el = el;
    this.layer = layer;

    this.setValue(value);
  }

  private createLayer(listItems: ListItem[], width: number) {
    const layer = document.createElement('ul');
    layer.className = LAYER_CLASSNAME;
    layer.style.minWidth = `${width - 10}px`;
    // To hide the initial layer which is having the position which is not calculated properly
    setOpacity(layer, 0);

    listItems.forEach(({ text, value }) => {
      const id = `checkbox-${value}`;
      const listItemEl = document.createElement('li');

      listItemEl.id = id;
      listItemEl.className = LIST_ITEM_CLASSNAME;
      listItemEl.appendChild(this.createCheckboxLabel(value, text));

      this.elementIds.push(id);

      layer.appendChild(listItemEl);
    });

    layer.addEventListener('change', this.onChange);
    layer.addEventListener('mouseover', this.onMouseover);
    layer.addEventListener('keydown', this.onKeydown);

    return layer;
  }

  private createCheckboxLabel(value: CellValue, text: string) {
    const input = document.createElement('input');
    const label = document.createElement('label');
    const span = document.createElement('span');

    label.className =
      this.inputType === 'radio'
        ? UNCHECKED_RADIO_LABEL_CLASSNAME
        : UNCHECKED_CHECKBOX_LABEL_CLASSNAME;

    input.type = this.inputType;
    input.name = 'checkbox';
    input.value = String(value);

    span.innerText = text;

    label.appendChild(input);
    label.appendChild(span);

    return label;
  }

  private getItemId(target: HTMLElement) {
    return target.id || target.parentElement!.id;
  }

  private onMouseover = (ev: MouseEvent) => {
    const targetId = this.getItemId(ev.target as HTMLElement);
    if (targetId && targetId !== this.hoveredItemId) {
      this.highlightItem(targetId);
    }
  };

  private onChange = (ev: Event) => {
    const value = (ev.target as HTMLInputElement).value;
    this.setLabelClass(value);
  };

  private onKeydown = (ev: KeyboardEvent) => {
    const keyName = getKeyStrokeString(ev);
    if (isArrowKey(keyName)) {
      ev.preventDefault();
      const elementIdx = findIndex(id => id === this.hoveredItemId, this.elementIds);
      const totalCount = this.elementIds.length;
      const offset = totalCount + (keyName === 'down' || keyName === 'right' ? 1 : -1);
      const id = this.elementIds[(elementIdx + offset) % totalCount];

      this.highlightItem(id);
    } else {
      // except arrow key, pass the event to editing layer for using existing editing keyMap
      this.portalEditingKeydown(ev);
    }
  };

  private highlightItem(targetId: string) {
    if (this.hoveredItemId) {
      this.layer.querySelector(`#${this.hoveredItemId}`)!.className = LIST_ITEM_CLASSNAME;
    }

    this.hoveredItemId = targetId;
    const item = this.layer.querySelector(`#${targetId}`)!;
    item.className = HOVERED_LIST_ITEM_CLASSNAME;
    item.querySelector('input')!.focus();
  }

  private setLabelClass(inputValue: CellValue) {
    const label = this.layer.querySelector(`#checkbox-${inputValue} label`) as HTMLLabelElement;
    if (this.inputType === 'checkbox') {
      label.className = hasClass(label, 'editor-label-icon-checkbox-checked')
        ? UNCHECKED_CHECKBOX_LABEL_CLASSNAME
        : CHECKED_CHECKBOX_LABEL_CLASSNAME;
    } else {
      const checkedLabel = this.layer.querySelector(`.${CHECKED_RADIO_LABEL_CLASSNAME}`);
      if (checkedLabel) {
        checkedLabel.className = UNCHECKED_RADIO_LABEL_CLASSNAME;
      }

      label.className = CHECKED_RADIO_LABEL_CLASSNAME;
    }
  }

  private getCheckedInput() {
    return (this.layer.querySelector('input:checked') ||
      this.layer.querySelector('input')) as HTMLInputElement;
  }

  public getElement() {
    return this.el;
  }

  private setValue(value: CellValue) {
    String(value)
      .split(',')
      .forEach(inputValue => {
        const input = this.layer.querySelector(`input[value="${inputValue}"]`) as HTMLInputElement;
        if (input) {
          input.checked = true;
          this.setLabelClass(inputValue);
        }
      });
  }

  public getValue() {
    const checkedInputs = this.layer.querySelectorAll('input:checked');
    const checkedValues = [];
    for (let i = 0, len = checkedInputs.length; i < len; i += 1) {
      checkedValues.push((checkedInputs[i] as HTMLInputElement).value);
    }

    return checkedValues.join(',');
  }

  public mounted() {
    // To prevent wrong stacked z-index context, layer append to grid container
    getContainerElement(this.el).appendChild(this.layer);
    // @ts-ignore
    setLayerPosition(this.el, this.layer);

    const checkedInput = this.getCheckedInput();
    if (checkedInput) {
      this.highlightItem(`checkbox-${checkedInput.value}`);
    }
    // To show the layer which has appropriate position
    setOpacity(this.layer, 1);
  }

  public beforeDestroy() {
    this.layer.removeEventListener('change', this.onChange);
    this.layer.removeEventListener('mouseover', this.onMouseover);
    this.layer.removeEventListener('keydown', this.onKeydown);
    getContainerElement(this.el).removeChild(this.layer);
  }
}


text:
from __future__ import absolute_import

from expects.matchers import Matcher

class BeEmail(Matcher):
    def _match(self, response):
        return response["type"] == "email", []

class BeWeblink(Matcher):
    def _match(self, response):
        return response["type"] == "weblink", []

class BeOpen(Matcher):
    def _match(self, response):
        return response["status"] == "open", []

class BeClosed(Matcher):
    def _match(self, response):
        return response["status"] == "closed", []

class BeNew(Matcher):
    def _match(self, response):
        return response["status"] == "new", []

be_email = BeEmail()
be_weblink = BeWeblink()
be_open = BeOpen()
be_closed = BeClosed()
be_new = BeNew()

__all__ = ['be_email', 'be_weblink', 'be_open', 'be_closed', 'be_new']


text:
package org.apache.flink.runtime.shuffle;

import org.apache.flink.api.common.JobID;
import org.apache.flink.runtime.io.network.partition.ResultPartitionID;

import java.util.Collection;
import java.util.concurrent.CompletableFuture;

/**
 * Job level shuffle context which can offer some job information like job ID and through it, the
 * shuffle plugin notify the job to stop tracking the lost result partitions.
 */
public interface JobShuffleContext {

    /** @return the corresponding {@link JobID}. */
    JobID getJobId();

    /**
     * Notifies the job to stop tracking and release the target result partitions, which means these
     * partitions will be removed and will be reproduced if used afterwards.
     */
    CompletableFuture<?> stopTrackingAndReleasePartitions(
            Collection<ResultPartitionID> partitionIds);
}


text:
'use strict';

import { gl } from './Context';
import Entity from './Entity';
import Attribute from './Attribute';

const lengths = {
    i: 1,
    f: 1,
    vec2: 2,
    vec3: 3,
    vec4: 4
};

class VertexArrayObject extends Entity
{
    constructor(
    {
        name = 'vertex.array.object',
        indexed = false,
        view = Float32Array,
        attributes = []
    } = {})
    {
        super({ name });

        this.primary = gl.createBuffer();

        this.secondary = undefined;

        this.indexed = indexed;

        this.stride = 0;

        this.view = view;

        this.attributes = attributes;

        this.inheritance = ['Entity', 'VertexArrayObject'];

        this.configure();
    }

    get primary()
    {
        return this._primary;
    }

    set primary(primary)
    {
        this._primary = primary;
    }

    get secondary()
    {
        return this._secondary;
    }

    set secondary(secondary)
    {
        this._secondary = secondary;
    }

    get indexed()
    {
        return this._indexed;
    }

    set indexed(indexed)
    {
        this._indexed = indexed;
    }

    get stride()
    {
        return this._stride;
    }

    set stride(stride)
    {
        this._stride = stride;
    }

    get view()
    {
        return this._view;
    }

    set view(view)
    {
        this._view = view;
    }

    get attributes()
    {
        return this._attributes;
    }

    set attributes(attributes)
    {
        this._attributes = attributes.map(this.generate.bind(this));
    }

    configure()
    {
        if (this.indexed)
        {
            this.secondary = gl.createBuffer();
        }
    }

    generate(qualifying)
    {
        let offset = this.stride;
        let vars = qualifying.split(' ');
        let length = lengths[vars[0]];
        let name = vars[1];
        let attribute = new Attribute({ attribute: name, length: length, offset: offset });

        this.stride += attribute.getByteCount(this.view.BYTES_PER_ELEMENT);

        return attribute;
    }

    enable(program, attribute)
    {
        attribute.enable(program, this.stride);
    }

    disable(attribute)
    {
        attribute.disable();
    }

    bind(program = false)
    {
        gl.bindBuffer(gl.ARRAY_BUFFER, this.primary);

        if (this.indexed)
        {
            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.secondary);
        }

        if (program)
        {
            this.attributes.map(this.enable.bind(this, program));
        }
    }

    unbind()
    {
        gl.bindBuffer(gl.ARRAY_BUFFER, null);

        if (this.indexed)
        {
            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
        }

        this.attributes.map(this.disable);
    }
}

export default VertexArrayObject;


text:
'use strict';

// Statistics routes uses statistcs controller
var statistics = require('../controllers/statistics.server.controller');

module.exports = function(app, passport) {

    // Statistics routes
    // Depends on :serverId request parameter already specified in routes/servers.js

    // FreeRADIUS server uptime
    app.get('/statistics/freeradius/uptime/:serverId', statistics.freeradiusUptime);

    // FreeRADIUS access and accounting requests
    app.get('/statistics/freeradius/accessRequests/:serverId', statistics.freeradiusWeeklyAccessRequests);
    app.get('/statistics/freeradius/accountingRequests/:serverId', statistics.freeradiusWeeklyAccountingRequests);

};


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/DemoApp/DemoApp.iml" filepath="$PROJECT_DIR$/DemoApp/DemoApp.iml" />
      <module fileurl="file://$PROJECT_DIR$/HttpApi.iml" filepath="$PROJECT_DIR$/HttpApi.iml" />
      <module fileurl="file://$PROJECT_DIR$/HttpApiLib/HttpApiLib.iml" filepath="$PROJECT_DIR$/HttpApiLib/HttpApiLib.iml" />
    </modules>
  </component>
</project>


text:
.class Lcom/android/camera/actor/VideoActor$4;
.super Ljava/lang/Object;
.source "VideoActor.java"

# interfaces
.implements Lcom/android/camera/Camera$OnSingleTapUpListener;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/camera/actor/VideoActor;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x0
    name = null
.end annotation

# instance fields
.field final synthetic this$0:Lcom/android/camera/actor/VideoActor;

# direct methods
.method constructor <init>(Lcom/android/camera/actor/VideoActor;)V
    .locals 0
    .parameter

    .prologue
    .line 253
    iput-object p1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

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

    return-void
.end method

# virtual methods
.method public onSingleTapUp(Landroid/view/View;II)V
    .locals 4
    .parameter "view"
    .parameter "x"
    .parameter "y"

    .prologue
    .line 255
    invoke-static {}, Lcom/android/camera/actor/VideoActor;->access$300()Z

    move-result v1

    if-eqz v1, :cond_0

    .line 256
    const-string v1, "VideoActor"

    new-instance v2, Ljava/lang/StringBuilder;

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

    const-string v3, "onSingleTapUp("

    invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2, p2}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;

    move-result-object v2

    const-string v3, ", "

    invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2, p3}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;

    move-result-object v2

    const-string v3, ")"

    invoke-virtual {v2, v3}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v2

    invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v2

    invoke-static {v1, v2}, Lcom/android/camera/Log;->v(Ljava/lang/String;Ljava/lang/String;)I

    .line 258
    :cond_0
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/Camera;->getFocusManager()Lcom/android/camera/FocusManager;

    move-result-object v1

    iget-object v2, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v2}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v2

    invoke-virtual {v1, v2}, Lcom/android/camera/FocusManager;->getCurrentFocusMode(Lcom/android/camera/Camera;)Ljava/lang/String;

    move-result-object v0

    .line 259
    .local v0, focusMode:Ljava/lang/String;
    if-eqz v0, :cond_1

    const-string v1, "infinity"

    invoke-virtual {v1, v0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v1

    if-nez v1, :cond_1

    const-string v1, "continuous-picture"

    invoke-virtual {v1, v0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v1

    if-eqz v1, :cond_2

    .line 275
    :cond_1
    :goto_0
    return-void

    .line 263
    :cond_2
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoCameraClosed:Z
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$600(Lcom/android/camera/actor/VideoActor;)Z

    move-result v1

    if-nez v1, :cond_1

    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/Camera;->getCameraDevice()Lcom/android/camera/CameraManager$CameraProxy;

    move-result-object v1

    if-eqz v1, :cond_1

    .line 267
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/Camera;->getFocusManager()Lcom/android/camera/FocusManager;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/FocusManager;->getFocusAreaSupported()Z

    move-result v1

    if-nez v1, :cond_3

    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/Camera;->getFocusManager()Lcom/android/camera/FocusManager;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/FocusManager;->getMeteringAreaSupported()Z

    move-result v1

    if-eqz v1, :cond_1

    .line 271
    :cond_3
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mMediaRecorderRecording:Z
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$400(Lcom/android/camera/actor/VideoActor;)Z

    move-result v1

    if-eqz v1, :cond_4

    .line 272
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    const/4 v2, -0x1

    #calls: Lcom/android/camera/actor/VideoActor;->setFocusState(I)V
    invoke-static {v1, v2}, Lcom/android/camera/actor/VideoActor;->access$1200(Lcom/android/camera/actor/VideoActor;I)V

    .line 274
    :cond_4
    iget-object v1, p0, Lcom/android/camera/actor/VideoActor$4;->this$0:Lcom/android/camera/actor/VideoActor;

    #getter for: Lcom/android/camera/actor/VideoActor;->mVideoContext:Lcom/android/camera/Camera;
    invoke-static {v1}, Lcom/android/camera/actor/VideoActor;->access$1000(Lcom/android/camera/actor/VideoActor;)Lcom/android/camera/Camera;

    move-result-object v1

    invoke-virtual {v1}, Lcom/android/camera/Camera;->getFocusManager()Lcom/android/camera/FocusManager;

    move-result-object v1

    invoke-virtual {v1, p2, p3}, Lcom/android/camera/FocusManager;->onSingleTapUp(II)V

    goto :goto_0
.end method


text:
<?php
class TypeChargeSyndique{

	//attributes
	private $_id;
	private $_nom;
	private $_created;
	private $_createdBy;
	private $_updated;
	private $_updatedBy;

	//le constructeur
    public function __construct($data){
        $this->hydrate($data);
    }

    //la focntion hydrate sert à attribuer les valeurs en utilisant les setters d\'une façon dynamique!
    public function hydrate($data){
        foreach ($data as $key => $value){
            $method = 'set'.ucfirst($key);

            if (method_exists($this, $method)){
                $this->$method($value);
            }
        }
    }

	//setters
	public function setId($id){
    	$this->_id = $id;
    }
	public function setNom($nom){
		$this->_nom = $nom;
   	}

	public function setCreated($created){
        $this->_created = $created;
    }

	public function setCreatedBy($createdBy){
        $this->_createdBy = $createdBy;
    }

	public function setUpdated($updated){
        $this->_updated = $updated;
    }

	public function setUpdatedBy($updatedBy){
        $this->_updatedBy = $updatedBy;
    }

	//getters
	public function id(){
    	return $this->_id;
    }
	public function nom(){
		return $this->_nom;
   	}

	public function created(){
        return $this->_created;
    }

	public function createdBy(){
        return $this->_createdBy;
    }

	public function updated(){
        return $this->_updated;
    }

	public function updatedBy(){
        return $this->_updatedBy;
    }

}


text:
import os
import urllib
import uuid

from pymongo import MongoClient
import requests

from framework.mongo.utils import to_mongo_key

from website.models import Node
from website.addons.wiki import settings as wiki_settings
from website.addons.wiki.exceptions import InvalidVersionError

def generate_private_uuid(node, wname):
    """
    Generate private uuid for internal use in sharejs namespacing.
    Note that this will NEVER be passed to to the client or sharejs.
    """

    private_uuid = str(uuid.uuid1())
    wiki_key = to_mongo_key(wname)
    node.wiki_private_uuids[wiki_key] = private_uuid
    node.save()

    return private_uuid

def get_sharejs_uuid(node, wname):
    """
    Format private uuid into the form used in mongo and sharejs.
    This includes node's primary ID to prevent fork namespace collision
    """
    wiki_key = to_mongo_key(wname)
    private_uuid = node.wiki_private_uuids.get(wiki_key)
    return str(uuid.uuid5(
        uuid.UUID(private_uuid),
        str(node._id)
    )) if private_uuid else None

def delete_share_doc(node, wname):
    """Deletes share document and removes namespace from model."""

    db = share_db()
    sharejs_uuid = get_sharejs_uuid(node, wname)

    db['docs'].remove({'_id': sharejs_uuid})
    db['docs_ops'].remove({'name': sharejs_uuid})

    wiki_key = to_mongo_key(wname)
    del node.wiki_private_uuids[wiki_key]
    node.save()

def migrate_uuid(node, wname):
    """Migrates uuid to new namespace."""

    db = share_db()
    old_sharejs_uuid = get_sharejs_uuid(node, wname)

    broadcast_to_sharejs('lock', old_sharejs_uuid)

    generate_private_uuid(node, wname)
    new_sharejs_uuid = get_sharejs_uuid(node, wname)

    doc_item = db['docs'].find_one({'_id': old_sharejs_uuid})
    if doc_item:
        doc_item['_id'] = new_sharejs_uuid
        db['docs'].insert(doc_item)
        db['docs'].remove({'_id': old_sharejs_uuid})

    ops_items = [item for item in db['docs_ops'].find({'name': old_sharejs_uuid})]
    if ops_items:
        for item in ops_items:
            item['_id'] = item['_id'].replace(old_sharejs_uuid, new_sharejs_uuid)
            item['name'] = new_sharejs_uuid
        db['docs_ops'].insert(ops_items)
        db['docs_ops'].remove({'name': old_sharejs_uuid})

    write_contributors = [
        user._id for user in node.contributors
        if node.has_permission(user, 'write')
    ]
    broadcast_to_sharejs('unlock', old_sharejs_uuid, data=write_contributors)

def share_db():
    """Generate db client for sharejs db"""
    client = MongoClient(wiki_settings.SHAREJS_DB_URL)
    return client[wiki_settings.SHAREJS_DB_NAME]

def get_sharejs_content(node, wname):
    db = share_db()
    sharejs_uuid = get_sharejs_uuid(node, wname)

    doc_item = db['docs'].find_one({'_id': sharejs_uuid})
    return doc_item['_data'] if doc_item else ''

def broadcast_to_sharejs(action, sharejs_uuid, node=None, wiki_name='home', data=None):
    """
    Broadcast an action to all documents connected to a wiki.
    Actions include 'lock', 'unlock', 'redirect', and 'delete'
    'redirect' and 'delete' both require a node to be specified
    'unlock' requires data to be a list of contributors with write permission
    """

    url = 'http://{host}:{port}/{action}/{id}/'.format(
        host=wiki_settings.SHAREJS_HOST,
        port=wiki_settings.SHAREJS_PORT,
        action=action,
        id=sharejs_uuid
    )

    if action == 'redirect' or action == 'delete':
        redirect_url = urllib.quote(
            node.web_url_for('project_wiki_view', wname=wiki_name, _guid=True),
            safe='',
        )
        url = os.path.join(url, redirect_url)

    try:
        requests.post(url, json=data)
    except requests.ConnectionError:
        pass    # Assume sharejs is not online

def format_wiki_version(version, num_versions, allow_preview):
    """
    :param str version: 'preview', 'current', 'previous', '1', '2', ...
    :param int num_versions:
    :param allow_preview: True if view, False if compare
    """

    if not version:
        return

    if version.isdigit():
        version = int(version)
        if version > num_versions or version < 1:
            raise InvalidVersionError
        elif version == num_versions:
            return 'current'
        elif version == num_versions - 1:
            return 'previous'
    elif version != 'current' and version != 'previous':
        if allow_preview and version == 'preview':
            return version
        raise InvalidVersionError
    elif version == 'previous' and num_versions == 0:
        raise InvalidVersionError

    return version

def serialize_wiki_settings(user, node_ids):
    """ Format wiki data for project settings page

    :param user: modular odm User object
    :param node_ids: list of parent project ids
    :return: treebeard-formatted data
    """
    items = []

    for node_id in node_ids:
        node = Node.load(node_id)
        assert node, '{} is not a valid Node.'.format(node_id)

        can_read = node.has_permission(user, 'read')
        include_wiki_settings = node.include_wiki_settings(user)

        if not include_wiki_settings:
            continue

        children = []

        if node.admin_public_wiki(user):
            children.append({
                'select': {
                    'title': 'permission',
                    'permission':
                        'public'
                        if node.get_addon('wiki').is_publicly_editable
                        else 'private'
                },
            })
        children.extend(serialize_wiki_settings(
            user,
            [
                n._id
                for n in node.nodes
                if n.primary and
                not n.is_deleted
            ]
        ))

        item = {
            'node': {
                'id': node_id,
                'url': node.url if can_read else '',
                'title': node.title if can_read else 'Private Project',
            },
            'children': children,
            'kind': 'folder' if not node.node__parent or not node.parent_node.has_permission(user, 'read') else 'node',
            'nodeType': node.project_or_component,
            'category': node.category,
            'permissions': {
                'view': can_read,
            },
        }

        items.append(item)

    return items


text:
require 'aws-sdk-core'
require 'aws-sigv4'

require_relative 'aws-sdk-iot1clickprojects/types'
require_relative 'aws-sdk-iot1clickprojects/client_api'
require_relative 'aws-sdk-iot1clickprojects/plugins/endpoints.rb'
require_relative 'aws-sdk-iot1clickprojects/client'
require_relative 'aws-sdk-iot1clickprojects/errors'
require_relative 'aws-sdk-iot1clickprojects/resource'
require_relative 'aws-sdk-iot1clickprojects/endpoint_parameters'
require_relative 'aws-sdk-iot1clickprojects/endpoint_provider'
require_relative 'aws-sdk-iot1clickprojects/endpoints'
require_relative 'aws-sdk-iot1clickprojects/customizations'

# This module provides support for AWS IoT 1-Click Projects Service. This module is available in the
# `aws-sdk-iot1clickprojects` gem.
#
# # Client
#
# The {Client} class provides one method for each API operation. Operation
# methods each accept a hash of request parameters and return a response
# structure.
#
#     io_t1_click_projects = Aws::IoT1ClickProjects::Client.new
#     resp = io_t1_click_projects.associate_device_with_placement(params)
#
# See {Client} for more information.
#
# # Errors
#
# Errors returned from AWS IoT 1-Click Projects Service are defined in the
# {Errors} module and all extend {Errors::ServiceError}.
#
#     begin
#       # do stuff
#     rescue Aws::IoT1ClickProjects::Errors::ServiceError
#       # rescues all AWS IoT 1-Click Projects Service API errors
#     end
#
# See {Errors} for more information.
#
# @!group service
module Aws::IoT1ClickProjects

  GEM_VERSION = '1.38.0'

end


text:
using System;
using System.Diagnostics.Contracts;
using System.Web.Http;
using System.Web.Http.OData.Builder;
using Microsoft.Data.Edm;

namespace MvcApi.OData
{
    internal static class ActionDescriptorExtensions
    {
        internal const string EdmModelKey = "MS_EdmModel";

        internal static IEdmModel GetEdmModel(this ApiActionDescriptor actionDescriptor, Type entityClrType)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            if (entityClrType == null)
            {
                throw Error.ArgumentNull("entityClrType");
            }

            // save the EdmModel to the action descriptor
            return actionDescriptor.Properties.GetOrAdd(EdmModelKey + entityClrType.FullName, _ =>
            {
                // It's safe to create HttpConfiguration, since it's used as an assembly Resolver.
                //ODataConventionModelBuilder builder = new ODataConventionModelBuilder(new HttpConfiguration(), isQueryCompositionMode: true);
                ODataConventionModelBuilder builder = new ODataConventionModelBuilder(new HttpConfiguration());
                EntityTypeConfiguration entityTypeConfiguration = builder.AddEntity(entityClrType);
                builder.AddEntitySet(entityClrType.Name, entityTypeConfiguration);
                IEdmModel edmModel = builder.GetEdmModel();
                Contract.Assert(edmModel != null);
                return edmModel;
            }) as IEdmModel;
        }
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="16dp"
    android:background="?android:attr/selectableItemBackground">

    <FrameLayout
        android:layout_width="144dp"
        android:layout_height="96dp">

        <ImageView
            android:id="@+id/video_thumbnail_iv"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="centerCrop"
            android:contentDescription="@string/content_desc"
            android:background="@color/grey_300"/>

        <!--android:transitionName="videoTransition"-->

        <com.etiennelawlor.loop.ui.CustomFontTextView
            android:id="@+id/duration_tv"
            android:layout_gravity="right|bottom"
            android:layout_margin="8dp"
            android:background="@drawable/duration_bg"
            android:padding="4dp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@color/primary_text_light"
            tools:text="Duration"
            android:textSize="14sp"
            app:textFont="ubuntu_regular"/>

    </FrameLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:layout_marginLeft="16dp">

        <com.etiennelawlor.loop.ui.CustomFontTextView
            android:id="@+id/title_tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@color/primary_text_dark"
            android:transitionName="titleTransition"
            tools:text="Video Title"
            android:maxLines="2"
            android:ellipsize="end"
            android:textSize="16sp"
            app:textFont="ubuntu_bold"/>

        <com.etiennelawlor.loop.ui.CustomFontTextView
            android:id="@+id/subtitle_tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@color/primary_text_dark"
            android:transitionName="subtitleTransition"
            tools:text="Video Subtitle"
            android:maxLines="5"
            android:ellipsize="end"
            android:textSize="14sp"
            app:textFont="ubuntu_medium"/>

        <com.etiennelawlor.loop.ui.CustomFontTextView
            android:id="@+id/caption_tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textColor="@color/tertiary_text_dark"
            android:transitionName="uploadedTransition"
            android:textSize="14sp"
            app:textFont="ubuntu_medium"/>

    </LinearLayout>

</LinearLayout>


text:
package kafka.zk

import java.io.File
import java.util._
import org.apache.zookeeper._
import org.apache.zookeeper.data._
import org.apache.zookeeper.server.ZooKeeperServer
import org.apache.zookeeper.server.NIOServerCnxn
import org.apache.zookeeper.ZooDefs
import junit.framework._
import junit.framework.Assert._
import kafka.TestUtils
import kafka.utils._

trait ZooKeeperTestHarness extends TestCase {
  val zkConnect: String
  var zookeeper: EmbeddedZookeeper = null

  override def setUp() {
    zookeeper = new EmbeddedZookeeper(zkConnect)
    super.setUp()
  }

  override def tearDown() {
    zookeeper.shutdown()
    super.tearDown()
  }

}


text:
require File.join(File.dirname(__FILE__), 'helper')

describe 'A model using cargo' do
  def file_count(path)
    (Dir.entries(path) - ['.', '..']).length
  end

  before do
    @model = Foo.new
    @model.set_file(snail)
  end

  after do
    @model.destroy unless @model.new_record?
  end

  it 'should be assigned a key when saving new data' do
    @model.file.new_data?.should be_true
    @model.file.key = nil
    @model.save.should be_true
    @model.file.key.should_not be_nil
  end

  it 'should be valid without an extension' do
    @model.file.extension = nil
    @model.file.should be_valid
  end

  it 'should save file on save' do
    @model.save.should be_true
    File.exist?(@model.file.path).should be_true
  end

  it 'should destroy file on destroy' do
    @model.save.should be_true
    File.exist?(@model.file.path).should be_true
    @model.destroy
    File.exist?(@model.file.path).should be_false
  end

  it 'should remove empty directories on destroy' do
    @model.save.should be_true
    file_count(@model.file.dirname).should equal(1)
    @model.destroy
    File.exist?(@model.file.dirname).should be_false
  end

  it 'should not remove non-empty directories on destroy' do
    @model.save.should be_true
    other = File.join(@model.file.dirname, 'other_file')
    FileUtils.touch(other)
    file_count(@model.file.dirname).should equal(2)
    @model.destroy
    file_count(@model.file.dirname).should equal(1)
    FileUtils.rm(other)
  end

  it 'should clear @tempfile after save' do
    @model.file.send(:instance_variable_get, :@tempfile).should_not be_nil
    @model.save.should be_true
    @model.file.send(:instance_variable_get, :@tempfile).should be_nil
  end

  it 'should raise CannotGenerateFilename for filename methods when new_record?' do
    @model.new_record?.should be_true
    proc do
      @model.file.filename
    end.should raise_error(Cargo::Errors::CannotGenerateFilename)
    proc do
      @model.file.subdir
    end.should raise_error(Cargo::Errors::CannotGenerateFilename)
    proc do
      @model.file.dirname
    end.should raise_error(Cargo::Errors::CannotGenerateFilename)
  end

  it 'should give temp path when new_data?' do
    @model.file.new_data?.should be_true
    File.dirname(@model.file.path).should eql(Dir::tmpdir)
  end

  it 'should not create without file data' do
    @model = Foo.new
    @model.build_file
    @model.file.new_data?.should be_false
    @model.save.should be_false
    @model.file.errors.full_messages.should include('File must be set')
  end

  it 'should allow save on parent with nil association' do
    @model = Foo.new
    @model.file.should be_nil
    @model.save.should be_true
    @model.file.should be_nil
  end

  it 'should remove existing file when saving a new file' do
    @model.save.should be_true
    file_count(@model.file.dirname).should equal(1)
    original_filename = @model.file.filename
    @model.file.set(snail('png'))
    @model.file.save.should be_true
    @model.file.filename.should_not eql(original_filename)
    file_count(@model.file.dirname).should equal(1)
  end

  it 'should allow set to handle filename strings and file objects' do
    @model.save.should be_true
    file_count(@model.file.dirname).should equal(1)
    original_filename = @model.file.filename
    File.open(snail('png'), 'r') do |f|
      @model.file.set(f)
    end
    @model.save.should be_true
    @model.file.filename.should_not eql(original_filename)
    file_count(@model.file.dirname).should equal(1)
  end

  it 'should raise UrlSubdirNotSet if it\'s not' do
    @model.save.should be_true
    proc do
      @model.file.relative_url
    end.should raise_error(Cargo::Errors::UrlSubdirNotSet)
    Cargo.config.url_subdir = '/url/path'
    @model.file.relative_url.should_not be_nil
  end

  it 'should save the association when saving the parent' do
    @model.set_file(snail)
    @model.save.should be_true
    @model.new_record?.should be_false
    @model.file.set(snail)
    @model.file.changed?.should be_true
    @model.save.should be_true
    @model.file.changed?.should be_false
  end

  it 'should automatically specify the name attribute when saving' do
    @model.file.name.should be_nil
    @model.save.should be_true
    @model.file.name.should_not be_nil
  end

  it 'should prevent name collisions on the same model' do
    @model.save.should be_true
    @model.set_other(snail('png'))
    @model.save.should be_true
    @model.other(true).id.should_not eql(@model.file(true).id)
  end

  it 'should only use mtime in relative_url if the file exists' do
    @model.save.should be_true
    @model.file.relative_url.should include('?')
    @model.file.destroy
    @model.file.relative_url.should_not include('?')
  end

  it 'should only use callbacks if attributes hash is not frozen' do
    # before_save calback sets name
    # after_save callback saves associated record
    @model.file.name.should be_nil
    @model.file.changed?.should be_true
    @model.save.should be_true
    @model.file.changed?.should be_false
    @model.file.name.should eql('file')
    @model.file.name = nil
    @model.file.changed?.should be_true
    @model.file.freeze
    @model.save.should be_true
    # associated record is frozen and should be unsaved
    @model.file.changed?.should be_true
    @model.file.name.should be_nil
  end
end


text:
<property name="datasource" class="com.frameworkset.commons.dbcp2.BasicDataSource">
 	<property name="driverClassName" value="org.apache.derby.jdbc.EmbeddedDriver"/>
<!-- 	<property name="url" value="jdbc:derby:/opt/tool/derby/database/cimdb"/>   -->
	<property name="url" value="jdbc:derby:E:/workspace/bbossgroups/bboss-document/database/cimdb"/>
	<property name="username" value=""/>
	<property name="password" value=""/>
	<!--initialSize: 初始化连接-->
	<property name="initialSize" value="5"/>
	<property name="maxTotal" value="5"/>
	<!--maxIdle: 最大空闲连接-->
	<property name="maxIdle" value="5"/>
	<!--minIdle: 最小空闲连接-->
	<property name="minIdle" value="5"/>

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

	<!--maxWait: 超时等待时间以毫秒为单位 6000毫秒/1000等于6秒-->
	<property name="maxWaitMillis" value="3000"/>
	<property name="validationQuery" value=""/>
	<property name="testOnBorrow" value="true"/>
</property>


text:
{% load staticfiles %}

        <title>
          Payment not found for {{ document.kind }} {{ document.series }}-{{ document.number }}
        </title>

        <link rel="stylesheet" type="text/css" href="{% static 'css/skeleton.css' %}">

        {% block extrahead %}
        {% endblock %}

            {% block content%}

Transaction expired for

                {% block document %}

{{ document.kind }} {{ document.series }}-{{ document.number }}

                {% endblock %}
            {% endblock%}


text:
package edu.harvard.we99.domain;

import javax.annotation.Generated;
import javax.validation.constraints.NotNull;

/**
 * A protocol is a set of rules/procedures that govern the experiment. These
 * are defined externally from our system and are referenced here as a simple
 * label.
 *
 * @author mford
 */
public class Protocol extends BaseEntity {
    private Long id;

    /**
     * Name of the protocol
     */
    @NotNull
    private String name;

    public Protocol() {}

    public Protocol(String name) {
        this.name = name;
    }

    @Generated(value = "generated by IDE")
    public Long getId() {
        return id;
    }

    @Generated(value = "generated by IDE")
    public void setId(Long id) {
        this.id = id;
    }

    @Generated(value = "generated by IDE")
    public String getName() {
        return name;
    }

    @Generated(value = "generated by IDE")
    public void setName(String name) {
        this.name = name;
    }

    @Generated(value = "generated by IDE")
    public Protocol withId(final Long id) {
        this.id = id;
        return this;
    }

    @Generated(value = "generated by IDE")
    public Protocol withName(final String name) {
        this.name = name;
        return this;
    }

}


text:
module.exports = {
  env: {
    browser: true,
    es6: true,
    node: true,
    'shared-node-browser': true
  },

  parserOptions: {
    sourceType: 'module',
    ecmaFeatures: {
      classes: true
    },
    ecmaVersion: 2018
  },

  plugins: ['filenames', 'eslint-comments'],

  extends: [
    'eslint:recommended',
    'plugin:import/recommended',
    'eslint-config-airbnb-base',
    'eslint-config-airbnb-base/rules/strict'
  ],

  rules: {
    'no-console': 'error',
    'comma-dangle': ['error', 'never'],
    'max-len': ['error', 120],
    'one-var': ['error', {uninitialized: 'always', initialized: 'never'}],
    'one-var-declaration-per-line': ['error', 'initializations'],
    'filenames/match-regex': ['error', '^[a-z0-9\\-\\.]+$'],
    'new-cap': ['error', {capIsNewExceptions: ['Map', 'List']}],
    yoda: ['error', 'always'],
    'handle-callback-err': 'error',
    'object-curly-spacing': ['error', 'never'],
    'import/prefer-default-export': 'off',
    'arrow-parens': ['error', 'as-needed'],
    'global-require': 'off',
    'no-underscore-dangle': ['error', {allow: ['_links', '_embedded']}],
    'no-unused-vars': ['error', {ignoreRestSiblings: true}],
    'no-multi-spaces': ['error', {ignoreEOLComments: true}],
    'eslint-comments/disable-enable-pair': 'error',
    'eslint-comments/no-duplicate-disable': 'error',
    'eslint-comments/no-unlimited-disable': 'error',
    'eslint-comments/no-unused-disable': 'error',
    'eslint-comments/no-unused-enable': 'error',
    'object-curly-newline': [
      'error',
      {
        ObjectExpression: {
          multiline: true,
          consistent: true
        },
        ObjectPattern: {
          multiline: true,
          consistent: true
        },
        ImportDeclaration: {
          multiline: true,
          consistent: true,
          minProperties: 0
        }
      }
    ]
  }
};


text:
namespace Nop.Core.Domain.Discounts
{
    /// <summary>
    /// Represents a discount requirement
    /// </summary>
    public partial class DiscountRequirement : BaseEntity
    {
        /// <summary>
        /// Gets or sets the discount identifier
        /// </summary>
        public virtual int DiscountId { get; set; }

        /// <summary>
        /// Gets or sets the discount requirement rule system name
        /// </summary>
        public virtual string DiscountRequirementRuleSystemName { get; set; }

        /// <summary>
        /// Gets or sets the the discount requirement spent amount - customer had spent/purchased x.xx amount (used when requirement is set to "Customer had spent/purchased x.xx amount")
        /// </summary>
        public virtual decimal SpentAmount { get; set; }

        /// <summary>
        /// Gets or sets the discount requirement - customer's billing country is... (used when requirement is set to "Billing country is")
        /// </summary>
        public virtual int BillingCountryId { get; set; }

        /// <summary>
        /// Gets or sets the discount requirement - customer's shipping country is... (used when requirement is set to "Shipping country is")
        /// </summary>
        public virtual int ShippingCountryId { get; set; }

        /// <summary>
        /// Gets or sets the restricted customer role identifier
        /// </summary>
        public virtual int? RestrictedToCustomerRoleId { get; set; }

        /// <summary>
        /// Gets or sets the restricted product variant identifiers (comma separated)
        /// </summary>
        public virtual string RestrictedProductVariantIds { get; set; }

        /// <summary>
        /// Gets or sets the discount
        /// </summary>
        public virtual Discount Discount { get; set; }

    }
}


text:
./bizwinclean.sh
./bizwinmakeone.sh 32 performance compress
./bizwinclean.sh
./bizwinmakeone.sh 32 accuracy compress
./bizwinclean.sh
./bizwinmakeone.sh 32 compatibility compress

#leave compatibility built as objs because thats more useful to us while devving


text:
package Algorithm::Genetic::Diploid::Logger;
use strict;
use Exporter;
use base 'Exporter';

our $AUTOLOAD;
our @EXPORT_OK = qw(DEBUG INFO WARN ERROR FATAL);
our %EXPORT_TAGS = ( 'levels' => [@EXPORT_OK] );
our $VERBOSE = 2; # i.e. WARN, default
our %VERBOSE;
my $formatter = \&_simple_formatter;

=head1 NAME

Algorithm::Genetic::Diploid::Logger - reports on progress of the experiment

=head1 METHODS

=over

=item new

This singleton constructor always returns reference to same object

=cut

my $SINGLETON;
sub new {
	my $class = shift;
	if ( not $SINGLETON ) {
		$SINGLETON = bless \$class, $class;
	}
	$SINGLETON->level(@_) if @_;
	return $SINGLETON;
}

=item level

Alters log level. Takes named arguments: C<method> provides a scalar or array of fully
qualified method names whose verbosity to alter. C<class> provides a scalar or array of
package names whose verbosity to alter. C<level> sets the verbosity to one of the levels
described below.

=cut

sub level {
	my $self = shift;
	my %args = @_;

	# set verbosity at the level of methods
	if ( $args{'method'} ) {
		if ( ref $args{'method'} eq 'ARRAY' ) {
			$VERBOSE{$_} = $args{'level'} for @{ $args{'method'} };
		}
		else {
			$VERBOSE{$args{'method'}} = $args{'level'};
		}
	}

	# set verbosity at the level of classes
	elsif ( $args{'class'} ) {
		if ( ref $args{'class'} eq 'ARRAY' ) {
			$VERBOSE{$_} = $args{'level'} for @{ $args{'class'} };
		}
		else {
			$VERBOSE{$args{'class'}} = $args{'level'};
		}
	}

	# set verbosity globally
	else {
		$VERBOSE = $args{'level'};
	}
	return $self;
}

=item formatter

Alters log string formatter. When argument is 'simple' the log string is just
the logging level and message, when argument is 'verbose', the log string has
the calling subroutine name and location in it. 'medium' omits the file location.
When the argument is a code reference, this reference is executed for every
log message, with the following named arguments:

	'level' => (DEBUG|INFO|WARN|ERROR|FATAL)
	'sub'   => fully qualified name of the calling subroutine
	'file'  => path to the calling file
	'line'  => line number from whence the call was made
	'msg'   => the log message

=cut

sub formatter {
	my ( $self, $arg ) = @_;
	if ( ref $arg and ref $arg eq 'CODE' ) {
		$formatter = $arg;
	}
	else {
		if ( 'simple' eq lc $arg ) {
			$formatter = \&_simple_formatter;
		}
		elsif ( 'medium' eq lc $arg ) {
			$formatter = \&_medium_formatter;
		}
		elsif ( 'verbose' eq lc $arg ) {
			$formatter = \&_verbose_formatter;
		}
	}
}

# destructor does nothing
sub DESTROY {}

=back

=head1 VERBOSITY LEVELS

The following constants are available when using this package with the use qualifier
':levels', i.e. C<use Algorithm::Genetic::Diploid::Logger ':levels';>. They represent
different verbosity levels that can be set globally, and/or at package level, and/or
at method level.

=over

=item FATAL

Only most severe messages are transmitted.

=cut

sub FATAL () { 0 }

=item ERROR

Possibly unrecoverable errors are transmitted.

=cut

sub ERROR () { 1 }

=item WARN

Warnings are transmitted. This is the default.

=cut

sub WARN ()  { 2 }

=item INFO

Informational messages are transmitted.

=cut

sub INFO ()  { 3 }

=item DEBUG

Everything is transmitted, including debugging messages.

=cut

sub DEBUG () { 4 }

# constants mapped to string for AUTOLOAD
my %levels = (
	'fatal' => FATAL,
	'error' => ERROR,
	'warn'  => WARN,
	'info'  => INFO,
	'debug' => DEBUG,
);

sub _simple_formatter {
	my %args = @_;
	my ( $level, $sub, $file, $line, $msg ) = @args{('level','sub','file','line','msg')};
	return sprintf "%s %s\n", $level, $msg;
}

sub _verbose_formatter {
	my %args = @_;
	my ( $level, $sub, $file, $line, $msg ) = @args{('level','sub','file','line','msg')};
	return sprintf "%s %s [%s, %s] - %s\n", $level, $sub, $file, $line, $msg;
}

sub _medium_formatter {
	my %args = @_;
	my ( $level, $sub, $file, $line, $msg ) = @args{('level','sub','file','line','msg')};
	return sprintf "%s %s [%s] - %s\n", $level, $sub, $line, $msg;
}

# this is where methods such as $log->info ultimately are routed to
sub AUTOLOAD {
	my ( $self, $msg ) = @_;
	my $method = $AUTOLOAD;
	$method =~ s/.+://;

	# only proceed if method was one of fatal..debug
	if ( exists $levels{$method} ) {
		my ( $package, $file1up, $line1up, $subroutine ) = caller( 1 );
		my ( $pack0up, $filename, $line, $sub0up )       = caller( 0 );

		# calculate what the verbosity is for the current context
		# (either at sub, package or global level)
		my $verbosity;
		if ( exists $VERBOSE{$subroutine} ) {
			$verbosity = $VERBOSE{$subroutine};
		}
		elsif ( exists $VERBOSE{$pack0up} ) {
			$verbosity = $VERBOSE{$pack0up};
		}
		else {
			$verbosity = $VERBOSE;
		}

		# we need to do something with the message
		if ( $verbosity >= $levels{$method} ) {
			printf STDERR $formatter->(
				'level' => uc $method,
				'sub'   => $subroutine,
				'file'  => $filename,
				'line'  => $line,
				'msg'   => $msg,
			);
		}
	}
}

=back

=cut

1;


text:
FIND_PATH ( LIBWEBSOCKETS_INCLUDE_DIR libwebsockets.h
    /usr/local/include
    /usr/include
)

FIND_LIBRARY ( LIBWEBSOCKETS_LIBRARIES websockets
    /usr/local/lib
    /usr/lib
)

GET_FILENAME_COMPONENT( LIBWEBSOCKETS_LIBRARY_DIR ${LIBWEBSOCKETS_LIBRARIES} PATH )

SET ( LIBWEBSOCKETS_FOUND "NO" )
IF ( LIBWEBSOCKETS_INCLUDE_DIR )
    IF ( LIBWEBSOCKETS_LIBRARIES )
        SET ( LIBWEBSOCKETS_FOUND "YES" )
    ENDIF ( LIBWEBSOCKETS_LIBRARIES )
ENDIF ( LIBWEBSOCKETS_INCLUDE_DIR )

MARK_AS_ADVANCED(
    LIBWEBSOCKETS_LIBRARY_DIR
    LIBWEBSOCKETS_INCLUDE_DIR
    LIBWEBSOCKETS_LIBRARIES
)


text:
(function () {
    var ui = glinamespace("gli.ui");
    var divClass = ui.Tab.divClass;

    var StateTab = function (w) {
        var outer = divClass("window-whole-outer");
        var whole = divClass("window-whole");
        whole.appendChild(divClass("window-whole-inner", "scrolling contents"));
        outer.appendChild(whole);
        this.el.appendChild(outer);

        this.stateView = new gli.ui.StateView(w, this.el);

        this.stateView.setState();

        this.refresh = function () {
            this.stateView.setState();
        };
    };

    ui.StateTab = StateTab;
})();


text:
package com.datastax.oss.driver.internal.core.loadbalancing.nodeset;

import com.datastax.oss.driver.api.core.metadata.Node;
import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;
import java.util.Set;
import net.jcip.annotations.ThreadSafe;

/**
 * A thread-safe abstraction around a map of nodes per datacenter, to facilitate node management by
 * load balancing policies.
 */
@ThreadSafe
public interface NodeSet {

  /**
   * Adds the given node to this set.
   *
   *
If this set was initialized with datacenter awareness, the node will be added to its
   * datacenter's specific set; otherwise, the node is added to a general set containing all nodes
   * in the cluster.
   *
   * @param node The node to add.
   * @return true if the node was added, false otherwise (because it was already present).
   */
  boolean add(@NonNull Node node);

  /**
   * Removes the node from the set.
   *
   * @param node The node to remove.
   * @return true if the node was removed, false otherwise (because it was not present).
   */
  boolean remove(@NonNull Node node);

  /**
   * Returns the current nodes in the given datacenter.
   *
   *
If this set was initialized with datacenter awareness, the returned set will contain only
   * nodes pertaining to the given datacenter; otherwise, the given datacenter name is ignored and
   * the returned set will contain all nodes in the cluster.
   *
   * @param dc The datacenter name, or null if the datacenter name is not known, or irrelevant.
   * @return the current nodes in the given datacenter.
   */
  @NonNull
  Set<Node> dc(@Nullable String dc);

  /**
   * Returns the current datacenter names known to this set. If datacenter awareness has been
   * disabled, this method returns an empty set.
   */
  Set<String> dcs();
}


text:
<?php
namespace FacultyInfo\UserBundle\Form\Type;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;

class PasswordType extends AbstractType {

	public function buildForm(FormBuilderInterface $builder, array $options) {
		$builder -> add('password', 'repeated', array('type' => 'password', 'first_name' => 'pwd', 'second_name' => 'pwd_repeat', 'invalid_message' => 'userManagement.update.passwordsDontMatch' ,'first_options' => array('label' => 'userManagement.labels.firstPassword'), 'second_options' => array('label' => 'userManagement.labels.secondPassword')));
		$builder -> add('save', 'submit', array('label' => 'userManagement.update.savePassword'));
	}

	public function getName() {
		return 'updatePassword';
	}

}


text:
var arr = [0,5,5,2,"c"];
Test.assertEquals(arr.numberOfOccurrences(0), 1);
Test.assertEquals(arr.numberOfOccurrences(4), 0);
Test.assertEquals(arr.numberOfOccurrences(5), 2);
Test.assertEquals(arr.numberOfOccurrences("c"), 1);


text:
from __future__ import unicode_literals

from django.db import models, migrations

class Migration(migrations.Migration):

    dependencies = [
        ('festival', '0013_art_project_x'),
    ]

    operations = [
        migrations.AlterModelOptions(
            name='festival',
            options={'ordering': ['year', 'title']},
        ),
        migrations.AddField(
            model_name='festival',
            name='year',
            field=models.IntegerField(default=2015),
        ),
        migrations.AddField(
            model_name='projectx',
            name='statement',
            field=models.TextField(default=b''),
        ),
    ]


text: package router


text:
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*  Fluent Bit
 *  ==========
 *  Copyright (C) 2015 Treasure Data 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.
 */

/*
 * FLB_IO
 * ======
 * This interface is used by the output plugins which needs to write over
 * the network in plain communication or through the TLS support. When dealing
 * with network operation there are a few things to keep in mind:
 *
 * - TCP hosts can be down.
 * - Network can be slow.
 * - If the amount of data to flush requires multiple 'write' operations, we
 *   should not block the main thread, instead use event-driven mechanism to
 *   write when is possible.
 *
 * Output plugins that flag their selfs with FLB_OUTPUT_TCP or FLB_OUTPUT_TLS
 * can take advante of this interface.
 *
 * The workflow to use this is the following:
 *
 * - A connection and data flow requires an flb_io_upstream context.
 * - We write data through the flb_io_write() interface.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <fluent-bit/flb_io.h>
#include <fluent-bit/flb_utils.h>
#include <fluent-bit/flb_network.h>

/* Creates a new upstream context */
struct flb_io_upstream *flb_io_upstream_new(char *host, int port, int flags)
{
    int fd;
    struct flb_io_upstream *u;

    u = malloc(sizeof(struct flb_io_upstream));
    if (!u) {
        perror("malloc");
        return NULL;
    }

    /* Upon upstream creation, we always try to perform a connection */
    flb_debug("[upstream] connecting to %s:%i", host, port);
    fd = flb_net_tcp_connect(host, port);
    if (fd == -1) {
        flb_warn("[upstream] could not connect to %s:%i", host, port);
    }
    else {
        flb_debug("[upstream] connected!");
    }

    u->fd   = fd;
    u->tcp_host = strdup(host);
    u->tcp_port = port;
    u->flags    = flags;

    return u;
}

/* Write data to an upstream connection/server */
int flb_io_write(struct flb_io_upstream *u, void *data, size_t len, size_t *out_len)
{
    int bytes;

    bytes = write(u->fd, data, len);
    *out_len = bytes;
    return bytes;
}


text:
var _ = require('underscore');
var configuration = require('../configuration');
var mysql = require('mysql');
var connection = mysql.createConnection({
    host: configuration.database.host,
    user: configuration.database.user,
    password: configuration.database.password,
    database: configuration.database.name
});
var createNodeMySQL = require('../mysql-wrap');

exports.setUp = function (done) {

    this.sql = createNodeMySQL(mysql.createPool({
        host: configuration.database.host,
        user: configuration.database.user,
        password: configuration.database.password,
        database: configuration.database.name
    }));

    connection.query('TRUNCATE TABLE `table`', function (err, res) {
        connection.query(
            'INSERT INTO `table` (`unique`, `field`) ' +
            'VALUES ("a", "foo"), ("b", "bar"), ("c", "foo")',
            function (err, res) {
                connection.query('TRUNCATE TABLE `table2`', function (err, res) {
                    connection.query(
                        'INSERT INTO `table2` (`field`) ' +
                        'VALUES ("bar")',
                        function () {
                            done();
                        }
                    );
                });
            }
        );
    });
};

_.each(require('./shared_tests.js')(connection, createNodeMySQL), function (test, name) {
    exports[name] = test;
});


text:
<?php
namespace MNS\Model;

use MNS\Constants;
use MNS\Model\MailAttributes;

/**
 * Please refer to
 * https://docs.aliyun.com/?spm=#/pub/mns/api_reference/intro&intro
 * for more details
 */
class MessageAttributes
{
    private $mailAttributes;

    public function __construct(
        $mailAttributes = NULL)
    {
        $this->mailAttributes = $mailAttributes;
    }

    public function setMailAttributes($mailAttributes)
    {
        $this->mailAttributes = $mailAttributes;
    }

    public function getMailAttributes()
    {
        return $this->mailAttributes;
    }

    public function writeXML(\XMLWriter $xmlWriter)
    {
        if ($this->mailAttributes != NULL)
        {
            $xmlWriter->startELement(Constants::MESSAGE_ATTRIBUTES);
            $this->mailAttributes->writeXML($xmlWriter);
            $xmlWriter->endElement();
        }
    }
}

?>


text:
package org.lanternpowered.server.block.provider.property;

import org.lanternpowered.server.block.BlockProperties;
import org.lanternpowered.server.block.property.FlammableInfo;
import org.spongepowered.api.block.BlockSoundGroup;
import org.spongepowered.api.block.BlockState;
import org.spongepowered.api.data.type.InstrumentType;
import org.spongepowered.api.data.type.Matter;

import java.util.function.Function;

public final class PropertyProviders {

    public static PropertyProviderCollection matter(Matter constant) {
        return PropertyProviderCollection.constant(BlockProperties.MATTER, constant);
    }

    public static PropertyProviderCollection matter(PropertyProvider<Matter> provider) {
        return PropertyProviderCollection.of(BlockProperties.MATTER, provider);
    }

    public static PropertyProviderCollection hardness(double constant) {
        return PropertyProviderCollection.constant(BlockProperties.HARDNESS, constant);
    }

    public static PropertyProviderCollection hardness(PropertyProvider<Double> provider) {
        return PropertyProviderCollection.of(BlockProperties.HARDNESS, provider);
    }

    public static PropertyProviderCollection blastResistance(double constant) {
        return PropertyProviderCollection.constant(BlockProperties.BLAST_RESISTANCE, constant);
    }

    public static PropertyProviderCollection blastResistance(PropertyProvider<Double> provider) {
        return PropertyProviderCollection.of(BlockProperties.BLAST_RESISTANCE, provider);
    }

    public static PropertyProviderCollection unbreakable(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_UNBREAKABLE, constant);
    }

    public static PropertyProviderCollection unbreakable(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_UNBREAKABLE, provider);
    }

    public static PropertyProviderCollection flammable(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_FLAMMABLE, constant);
    }

    public static PropertyProviderCollection flammable(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_FLAMMABLE, provider);
    }

    public static PropertyProviderCollection lightEmission(double constant) {
        return PropertyProviderCollection.constant(BlockProperties.LIGHT_EMISSION, constant);
    }

    public static PropertyProviderCollection lightEmission(PropertyProvider<Double> provider) {
        return PropertyProviderCollection.of(BlockProperties.LIGHT_EMISSION, provider);
    }

    public static PropertyProviderCollection replaceable(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_REPLACEABLE, constant);
    }

    public static PropertyProviderCollection replaceable(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_REPLACEABLE, provider);
    }

    public static PropertyProviderCollection solidCube(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_SOLID_CUBE, constant);
    }

    public static PropertyProviderCollection solidCube(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_SOLID_CUBE, provider);
    }

    public static PropertyProviderCollection solidSide(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_SOLID_SIDE, constant);
    }

    public static PropertyProviderCollection solidSide(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_SOLID_SIDE, provider);
    }

    public static PropertyProviderCollection solidMaterial(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_SOLID_MATERIAL, constant);
    }

    public static PropertyProviderCollection solidMaterial(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_SOLID_MATERIAL, provider);
    }

    public static PropertyProviderCollection passable(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_PASSABLE, constant);
    }

    public static PropertyProviderCollection passable(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_PASSABLE, provider);
    }

    public static PropertyProviderCollection gravityAffected(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_GRAVITY_AFFECTED, constant);
    }

    public static PropertyProviderCollection gravityAffected(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_GRAVITY_AFFECTED, provider);
    }

    public static PropertyProviderCollection statisticsTracked(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.HAS_STATISTICS_TRACKING, constant);
    }

    public static PropertyProviderCollection statisticsTracked(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.HAS_STATISTICS_TRACKING, provider);
    }

    public static PropertyProviderCollection surrogate(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.IS_SURROGATE, constant);
    }

    public static PropertyProviderCollection surrogate(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.IS_SURROGATE, provider);
    }

    public static PropertyProviderCollection fullBlockSelectionBox(boolean constant) {
        return PropertyProviderCollection.constant(BlockProperties.HAS_FULL_BLOCK_SELECTION_BOX, constant);
    }

    public static PropertyProviderCollection fullBlockSelectionBox(PropertyProvider<Boolean> provider) {
        return PropertyProviderCollection.of(BlockProperties.HAS_FULL_BLOCK_SELECTION_BOX, provider);
    }

    public static PropertyProviderCollection flammableInfo(int encouragement, int flammability) {
        return flammableInfo(new FlammableInfo(encouragement, flammability));
    }

    public static PropertyProviderCollection flammableInfo(FlammableInfo flammableInfo) {
        return PropertyProviderCollection.builder()
                .addConstant(BlockProperties.IS_FLAMMABLE, true)
                .addConstant(BlockProperties.FLAMMABLE_INFO, flammableInfo)
                .build();
    }

    public static PropertyProviderCollection flammableInfo(PropertyProvider<FlammableInfo> provider) {
        final PropertyProvider<Boolean> flammableProvider;
        if (provider instanceof SimplePropertyProvider) {
            final Function<BlockState, FlammableInfo> function = ((SimplePropertyProvider<FlammableInfo>) provider).getFunction();
            flammableProvider = new SimplePropertyProvider<>(blockState -> function.apply(blockState) != null);
        } else {
            flammableProvider = (blockState, location, face) -> provider.get(blockState, location, face) != null;
        }
        return PropertyProviderCollection.builder()
                .add(BlockProperties.IS_FLAMMABLE, flammableProvider)
                .add(BlockProperties.FLAMMABLE_INFO, provider)
                .build();
    }

    public static PropertyProviderCollection instrument(InstrumentType constant) {
        return PropertyProviderCollection.constant(BlockProperties.REPRESENTED_INSTRUMENT, constant);
    }

    public static PropertyProviderCollection blockSoundGroup(BlockSoundGroup blockSoundGroup) {
        return PropertyProviderCollection.constant(BlockProperties.BLOCK_SOUND_GROUP, blockSoundGroup);
    }
}


text:
package com.slack.api.model.block.composition;

import com.slack.api.model.block.ContextBlockElement;

/**
 * https://api.slack.com/reference/messaging/composition-objects#text
 */
public abstract class TextObject implements ContextBlockElement {
}


text:
package license

import (
	"fmt"
	"io"

	"github.com/google/go-github/github"
	"github.com/pkg/errors"

	"github.com/nmiyake/ghcli/repository"
)

type PRParams struct {
	Branch string
	Title  string
	Body   string
}

func DefaultPRParams(licenseName string) PRParams {
	return PRParams{
		Branch: "cli-update-license",
		Title:  "Update LICENSE",
		Body:   fmt.Sprintf("Use standard version of %s.", licenseName),
	}
}

// ApplyStandard applies the standard license of the specified type to the specified repository. Calls Create to get the
// content of the license and calls Apply to apply that license to the repository. copyrightAuthor is used as the author
// name for the license if it uses an author template. If the license uses an author template, then the creation year of
// the repository is used as the creation year and the last update year of the repository is used as the update year.
// See documentation for the Apply function for further information.
func ApplyStandard(client *github.Client, repo repository.Info, licenseType, copyrightAuthor string, prParams PRParams, cache Cache, stdout io.Writer) error {
	wantLicenseContent, err := Create(licenseType, cache, NewAuthorInfo(copyrightAuthor, repo.CreatedAt.Time.Year(), repo.UpdatedAt.Time.Year()))
	if err != nil {
		return err
	}
	return Apply(client, repo, wantLicenseContent, prParams, stdout)
}

// Apply applies the provided license content to the repository by opening a PR on the repository to modify the content
// of the existing license file to be the provided content. If the currently authenticated user has push permissions to
// the repository, a PR is created directly on the repository, otherwise, a PR is created on a fork of the repository
// (and a fork is created if it does not already exist). prParams is used to specify the behavior of how the PR is
// created (branch name, commit title, commit body, etc.).
func Apply(client *github.Client, repo repository.Info, licenseContent string, prParams PRParams, stdout io.Writer) error {
	defaultBranch, _, err := client.Repositories.GetBranch(*repo.Owner.Login, *repo.Name, *repo.DefaultBranch)
	if err != nil {
		return errors.Wrapf(err, "failed to get default branch for %s", *repo.Name)
	}

	latestCommit, _, err := client.Git.GetCommit(*repo.Owner.Login, *repo.Name, *defaultBranch.Commit.SHA)
	if err != nil {
		return errors.Wrapf(err, "failed to get latest commit for branch %s", *defaultBranch.Name)
	}

	// get version of repository for which push permissions are enabled (original repo or fork)
	var prRepo *github.Repository
	if (*repo.Permissions)["push"] {
		fmt.Fprintf(stdout, "User has push permissions to repository\n")
		prRepo = &repo.Repository
	} else {
		// user cannot push to repository -- find or create fork
		if userForkRepo, err := repository.GetUserFork(client, &repo.Repository); err != nil {
			return errors.Wrapf(err, "failed to get fork of repository %s for current authenticated user", *repo.Name)
		} else if userForkRepo != nil {
			// user fork of desired directory already exists -- use it
			fmt.Fprintf(stdout, "User does not have push permissions to repository, but has an existing fork\n")
			prRepo = userForkRepo
		} else {
			// user fork of desired repository does not exist -- create it
			fmt.Fprintf(stdout, "User does not have push permissions to repository and does not have an existing fork\n")

			fmt.Fprintf(stdout, "Forking repository...")
			newForkedRepo, err := repository.CreateFork(client, &repo.Repository, 0)
			if err != nil {
				return errors.Wrapf(err, "failed to create fork of repository %s for current authenticated user", *repo.Name)
			}
			prRepo = newForkedRepo
			fmt.Fprintf(stdout, "OK\n")
		}
	}

	fmt.Fprintf(stdout, "Creating tree...")
	createdTree, _, err := client.Git.CreateTree(*prRepo.Owner.Login, *prRepo.Name, *latestCommit.Tree.SHA, []github.TreeEntry{
		{
			Path:    repo.RepoLicense.Path,
			Mode:    github.String("100644"),
			Type:    github.String("blob"),
			Content: github.String(licenseContent),
		},
	})
	if err != nil {
		return errors.Wrapf(err, "failed to create tree")
	}
	fmt.Fprintf(stdout, "OK\n")

	fmt.Fprintf(stdout, "Creating commit...")
	createdCommit, _, err := client.Git.CreateCommit(*prRepo.Owner.Login, *prRepo.Name, &github.Commit{
		Message: github.String("Update license"),
		Parents: []github.Commit{
			*defaultBranch.Commit,
		},
		Tree: createdTree,
	})
	if err != nil {
		return errors.Wrapf(err, "failed to create commit")
	}
	fmt.Fprintf(stdout, "OK\n")

	fmt.Fprintf(stdout, "Creating branch...")
	_, _, err = client.Git.CreateRef(*prRepo.Owner.Login, *prRepo.Name, &github.Reference{
		Ref: github.String("refs/heads/" + prParams.Branch),
		Object: &github.GitObject{
			SHA: createdCommit.SHA,
		},
	})
	if err != nil {
		return errors.Wrapf(err, "failed to create reference")
	}
	fmt.Fprintf(stdout, "OK\n")

	prBranchName := prParams.Branch
	if *repo.ID != *prRepo.ID {
		// if repo is a fork, prepend branch name with "username:"
		prBranchName = *prRepo.Owner.Login + ":" + prBranchName
	}

	fmt.Fprintf(stdout, "Creating pull request...")
	_, _, err = client.PullRequests.Create(*repo.Owner.Login, *repo.Name, &github.NewPullRequest{
		Title: github.String(prParams.Title),
		Body:  github.String(prParams.Body),
		Head:  &prBranchName,
		Base:  defaultBranch.Name,
	})
	if err != nil {
		return errors.Wrapf(err, "failed to create PR")
	}
	fmt.Fprintf(stdout, "OK\n")
	return nil
}


text:
"use strict";

var mockito4js = getMockito4jsBuilder().build(getMockito4jsBuilder());


text:
<?xml version="1.0" encoding="UTF-8"?>
<actions>
  <action>
    <actionName>build</actionName>
    <packagings>
      <packaging>*</packaging>
    </packagings>
    <goals>
      <goal>generate-sources</goal>
      <goal>install</goal>
      <goal>-Dmaven.test.skip=true</goal>
    </goals>
  </action>
  <action>
    <actionName>rebuild</actionName>
    <packagings>
      <packaging>*</packaging>
    </packagings>
    <goals>
      <goal>clean</goal>
      <goal>generate-sources</goal>
      <goal>install</goal>
      <goal>-Dmaven.test.skip=true</goal>
    </goals>
  </action>
</actions>