text:
import Cycle from 'cyclejs';
import { Rx } from 'cyclejs';

export default function createAutocompletedTextModel() {
    var autocompletedTextModel = Cycle.createModel(function (autocompletedTextIntent, inputAttributes) {
        // available autocompletions for current text value
        // autocompletions are sorted based on ranking, which is
        // calculated based on strict string matching and position of current field value in autocompletion
        // autocompetion "Car" will be higher than "Carusel" when text is "ca"
        // autocompletion "the best of all" will be higher than "he is the best" when text is "best"
        // autocompletions are case-insensitive
        var autocompletions$ = Rx.Observable.combineLatest(
            autocompletedTextIntent.get('valueChange$'),
            inputAttributes.get('datalist$'),
            (value, datalist) =>
                value.length ?
                datalist // choose keywords matching to value and sort them by ranking
                    .map((keywords) => ({
                        value: keywords[0], // show only the first keyword
                        // but match all of them and choose one with the highest ranking
                        score: Math.max.apply(Math, keywords.map(function(keyword, index) {
                            var index = keyword.toLowerCase().indexOf(value.toLowerCase());

                            if(index === -1) {
                                return -Infinity;
                            }

                            return (100 - index * Math.abs(keyword.length - value.length));
                        }))
                    }))
                    .filter(({ score }) => (score >= 0))
                    .sort((a, b) => b.score - a.score)
                    .map(({ value }) => value) :
                datalist // or show all and sort alphabetically if value is empty
                    .map((keywords) => keywords[0])
                    .sort()
        );

        // autocompletions shouldn't be visible when text field is not focused, list is empty
        // and right after when autocompletion was choosen
        var areAutocompletionsVisible$ = Rx.Observable.merge(
            autocompletions$
                .filter((autocompletions) => autocompletions.length === 0)
                .map(() => false),
            autocompletedTextIntent.get('showAutocompletions$')
                .map(() => true),
            autocompletedTextIntent.get('hideAutocompletions$')
                .map(() => false)
        )
        .distinctUntilChanged()
        .startWith(false);

        // index of autocompletion selected on the list
        var highlightedAutocompletionIndex$ = Rx.Observable.combineLatest(
            Rx.Observable.merge(
                Rx.Observable.merge( // reset position on text and when autocompletions list hides
                    autocompletedTextIntent.get('valueChange$'),
                    autocompletedTextIntent.get('hideAutocompletions$')
                )
                .map(() => ({ direct: 0 }))
                .delay(1), // reset after fetching value from autocompletions
                autocompletedTextIntent.get('selectedAutocompletionInput$')
            ),
            autocompletions$,
            (positionModifier, autocompletions) => ({ positionModifier, autocompletions })
        ).scan(0, (position, { positionModifier, autocompletions }) => {
            if(positionModifier.hasOwnProperty('modifier')) {
                position = position + positionModifier.modifier;
            } else if(positionModifier.hasOwnProperty('direct')) {
                position = positionModifier.direct;
            } else {
                return;
            }

            if(position < 0) {
                position = 0;
            } else if(position > (autocompletions.length - 1)) {
                position = autocompletions.length - 1;
            }

            return position;
        }).distinctUntilChanged();

        // autocompletion that was highlighted and applied
        var selectedAutocompletion$ = autocompletedTextIntent.get('selectedAutocompletionChange$')
        .withLatestFrom(
            highlightedAutocompletionIndex$,
            (( enter, position ) => position)
        )
        .withLatestFrom(
            autocompletions$,
            ((position, autocompletions) => autocompletions[position])
        )
        .filter((value) => 'undefined' !== typeof value)
        .distinctUntilChanged();

        // value is invalid when no autocompletions available
        var isValueInvalid$ = Rx.Observable.merge(
            autocompletions$
                .map((autocompletions) =>
                    autocompletions.length === 0
                ),
            autocompletedTextIntent.get('finish$')
                .map(() => false)
        )
        .distinctUntilChanged()
        .startWith(false);

        // text entered to field or propagated from component attribute
        var notValidatedTextFieldValue$ = autocompletedTextIntent.get('valueChange$');

        // current text in field, can be entered directly or by choosing autocompletion
        // when text field looses focus and value is not valid, previous valid value
        var textFieldValue$ = Rx.Observable.merge(
            notValidatedTextFieldValue$,
            selectedAutocompletion$,
            autocompletedTextIntent.get('finish$')
                .withLatestFrom(
                    Rx.Observable.defer(() => value$),
                    (finish, value) => value
                )
        )
        .distinctUntilChanged();

        // value that will be exported to attribute and emitted with change event of the component
        // it has to match exactly with some autocompletion
        var value$ = Rx.Observable.merge(
            selectedAutocompletion$,
            autocompletedTextIntent.get('finish$')
                .withLatestFrom(
                    notValidatedTextFieldValue$,
                    autocompletions$,
                    (finish, value, autocompletions) => value === autocompletions[0] ? value : null
                )
                .filter((value) => value !== null)
        ).distinctUntilChanged();

        return { value$, textFieldValue$, autocompletions$, highlightedAutocompletionIndex$, areAutocompletionsVisible$, isValueInvalid$ };
    });

    return autocompletedTextModel;
}


text: export { default } from 'ember-formfor/components/form-control/text-field/component';

redpajama_set_name: RedPajamaGithub


text:
<?php
class Insert_model extends CI_Model{
function __construct() {
parent::__construct();
}
function form_insert($data){
// Inserting in Table(students) of Database(college)
$this->db->insert('students', $data);
}
}
?>


text:
package hydra.blackboard;

//import java.util.*;

/**
 *
 *  Manages a set of indexed counters.  Methods are not thread-safe.
 *  Instances of this class are intended only for use by other classes
 *  such as ({@link RmiSharedCountersImpl}
 *  that overlay a transport type for cross-vm access and provide
 *  synchronization.
 *
 */

public class SharedCountersImpl implements SharedCounters {

  private long[] counters;

  /**
   *  Creates an instance with its counters set to the provided initial values.
   *  The number of counters managed by this instance is equal to the number of
   *  initial values.
   */
  public SharedCountersImpl( long[] initialValues ) {
    this.counters = initialValues;
  }

  /**
   *  Implements {@link SharedCounters#read(int)}.
   */
  public long read( int index ) {
    return counters[index];
  }
  /**
   *  Implements {@link SharedCounters#add(int,long)}.
   */
  public long add( int index, long i ) {
    counters[index] += i;
    return counters[index];
  }
  /**
   *  Implements {@link SharedCounters#subtract(int,long)}.
   */
  public long subtract( int index, long i ) {
    counters[index] -= i;
    return counters[index];
  }
  /**
   *  Implements {@link SharedCounters#increment(int)}.
   */
  public void increment( int index ) {
    ++counters[index];
  }
  /**
   *  Implements {@link SharedCounters#decrement(int)}.
   */
  public void decrement( int index ) {
    --counters[index];
  }
  /**
   *  Increments the counter at index by 1 and returns the new count.
   */
  public long incrementAndRead( int index ) {
    ++counters[index];
    return counters[index];
  }
  /**
   *  Implements {@link SharedCounters#incrementAndRead(int)}.
   */
  public long decrementAndRead( int index ) {
    --counters[index];
    return counters[index];
  }
  /**
   *  Implements {@link SharedCounters#zero(int)}.
   */
  public void zero( int index ) {
    counters[index] = 0;
  }
  /**
   *  Implements {@link SharedCounters#setIfLarger(int,long)}.
   */
  public void setIfLarger( int index, long i ) {
    if ( i > counters[index] ) counters[index] = i;
  }
  /**
   *  Implements {@link SharedCounters#setIfSmaller(int,long)}.
   */
  public void setIfSmaller( int index, long i ) {
    if ( i < counters[index] ) counters[index] = i;
  }
  /**
   *  Implements {@link SharedCounters#getCounterValues}.
   */
  public long[] getCounterValues() {
    return this.counters;
  }
}


text:
@implementation DFCache (Tests)

- (void)storeStringsWithCount:(NSUInteger)count strings:(NSDictionary *__autoreleasing *)s {
    NSMutableDictionary *strings = [NSMutableDictionary new];
    for (NSUInteger i = 0; i < count; i++) {
        NSString *key = [NSString stringWithFormat:@"key_%lu", (unsigned long)i];
        NSString *string = [self _randomStringWithLength:(arc4random_uniform(30) + 1)];
        [self storeObject:string forKey:key];
        strings[key] = string;
    }
    *s = strings;
}

- (NSString *)_randomStringWithLength:(NSUInteger)length {
    char data[length];
    for (int x = 0; x < length; x++) {
        data[x] = (char)('A' + arc4random_uniform(26));
    };
    return [[NSString alloc] initWithBytes:data length:length encoding:NSUTF8StringEncoding];
}

@end

@implementation TDFCacheUnsupportedDummy {
    NSUUID *_UUID;

}

- (instancetype)initWithUUID:(NSUUID *)UUID {
    if (self = [super init]) {
        _UUID = UUID;
    }
    return self;
}

- (instancetype)init {
    return [self initWithUUID:[NSUUID UUID]];
}

- (instancetype)initWithData:(NSData *)data {
    NSString *UUID = [[NSString alloc] initWithBytes:[data bytes] length:[data length] encoding:NSUTF8StringEncoding];
    return [self initWithUUID:[[NSUUID alloc] initWithUUIDString:UUID]];
}

- (BOOL)isEqual:(id)object {
    if (!object) {
        return NO;
    }
    if ([object class] != [self class]) {
        return NO;
    }
    TDFCacheUnsupportedDummy *other = object;
    return [other->_UUID isEqual:_UUID];
}

- (NSData *)dataRepresentation {
    return [[_UUID UUIDString] dataUsingEncoding:NSUTF8StringEncoding];
}

@end

@implementation TDFValueTransformerCacheUnsupportedDummy

- (NSData *)transformedValue:(id)value {
    return value ? [((TDFCacheUnsupportedDummy *)value) dataRepresentation] : nil;
}

- (id)reverseTransfomedValue:(NSData *)data {
    return data ? [[TDFCacheUnsupportedDummy alloc] initWithData:data] : nil;
}

@end


text:
require './app/bitmap_editor'

BitmapEditor.new.run


text:
require "spec_helper"

describe Onebox::Engine::VideoOnebox do
  it "supports ogv" do
    expect(Onebox.preview('http://upload.wikimedia.org/wikipedia/commons/3/37/STS-134_launch_2.ogv').to_s).to match(/<video/)
  end

  it "supports mp4" do
    expect(Onebox.preview('http://download.wavetlan.com/svv/dev/test.mp4').to_s).to match(/<video/)
  end

  it "supports mov" do
    expect(Onebox.preview('http://download.wavetlan.com/SVV/Media/HTTP/BlackBerry.MOV').to_s).to match(/<video/)
  end

  it "supports webm" do
    expect(Onebox.preview('http://video.webmfiles.org/big-buck-bunny_trailer.webm').to_s).to match(/<video/)
  end

  it "supports URLs with query parameters" do
    expect(Onebox.preview('http://video.webmfiles.org/big-buck-bunny_trailer.webm?foo=bar').to_s).to match(/<video/)
  end

  it "supports protocol relative URLs" do
    expect(Onebox.preview('//video.webmfiles.org/big-buck-bunny_trailer.webm').to_s).to match(/<video/)
  end

  it "includes a fallback direct link to the video" do
    expect(Onebox.preview('http://download.wavetlan.com/svv/dev/test.mp4').to_s).to match(/<a.*mp4/)
  end
end


text:
package main

import "github.com/spf13/cobra"

var (
	// Not using alias because we want 'rkt app exec' appears as
	// a subcommand of 'rkt app'.
	cmdAppExec = &cobra.Command{
		Use:   "exec [--app=APP_NAME] UUID [CMD [ARGS ...]]",
		Short: "Execute commands in the given app's namespace.",
		Long:  "This executes the commands in the given app's namespace. The UUID is the UUID of a running pod. the app name is specified by --app. If CMD and ARGS are empty, then it will execute '/bin/bash' by default.",
		Run:   ensureSuperuser(runWrapper(runEnter)),
	}
)

func init() {
	cmdApp.AddCommand(cmdAppExec)
	cmdAppExec.Flags().StringVar(&flagAppName, "app", "", "name of the app to exec within the specified pod, can be empty if there is only one app in the pod.")
	// Disable interspersed flags to stop parsing after the first non flag
	// argument. This is need to permit to correctly handle
	// ARGS for the CMD.
	cmdAppExec.Flags().SetInterspersed(false)
}


text:
    New Topic

<form (submit)="save()">

Name*

      <input class="protractor-test-new-topic-name-field required"
             [(ngModel)]="newlyCreatedTopic.name"
             [ngModelOptions]="{standalone: true}"
             [maxlength]="MAX_CHARS_IN_TOPIC_NAME"
             (change)="onTopicNameChange()" autofocus>

          Topic name should be at most {{ MAX_CHARS_IN_TOPIC_NAME }} characters.

          A topic with this name already exists.

Topic URL Fragment*

      <input class="protractor-test-new-topic-url-fragment-field required"
             [(ngModel)]="newlyCreatedTopic.urlFragment"
             [ngModelOptions]="{standalone: true}"
             [maxlength]="MAX_CHARS_IN_TOPIC_URL_FRAGMENT"
             [ngClass]="{'invalid-field': topicUrlFragmentExists || !validUrlFragmentRegex.test(newlyCreatedTopic.urlFragment)}"
             (change)="onTopicUrlFragmentChange()">

            The topic URL fragment is used to uniquely access the topic viewer page. It should consist of one or more hyphen-separated words, all in lowercase, with at most {{ MAX_CHARS_IN_TOPIC_URL_FRAGMENT }} characters in total. Please use meaningful keywords, and avoid using words like "and", "of", or "the".
            This topic can be accessed at the following URL:

            {{ hostname }}/learn/staging/{{ newlyCreatedTopic.urlFragment }}

            This topic URL fragment already exists.

Description*

      <textarea class="protractor-test-new-topic-description-field required"
                rows="4" cols="50" placeholder="Enter description"
                [maxlength]="MAX_CHARS_IN_TOPIC_DESCRIPTION"
                [(ngModel)]="newlyCreatedTopic.description"
                [ngModelOptions]="{standalone: true}">
      </textarea>

          Topic description should be at most {{ MAX_CHARS_IN_TOPIC_DESCRIPTION }} characters.

      Topic Thumbnail*
      <oppia-thumbnail-uploader [previewTitle]="newlyCreatedTopic.name"
                                [aspectRatio]="'4:3'"
                                [disabled]="false"
                                [useLocalStorage]="true"
                                [allowedBgColors]="allowedBgColors"
                                previewDescriptionBgColor="#2F6687">
      </oppia-thumbnail-uploader>

    <button class="btn btn-secondary" (click)="cancel()" type="button">Cancel</button>
    <button class="btn btn-success protractor-test-confirm-topic-creation-button" type="submit" [disabled]="!isValid()">
      Create Topic
    </button>

</form>


text:
class MatrixUtils {
    constructor() {
        this.mvMatrix = undefined;
        this.mvMatrixStack = [];
        this.perspectiveMatrix = undefined;
    }
    //
    // Matrix utility functions
    //

    loadIdentity() {
        this.mvMatrix = Matrix.I(4);
    }

    multMatrix(m) {
        this.mvMatrix = this.mvMatrix.x(m);
    }

    mvTranslate(v) {
        this.multMatrix(Matrix.Translation($V([v[0], v[1], v[2]])).ensure4x4());
    }

    makePerspective(fieldOfView, aspectRatio, nearDist, farDist) {
        this.perspectiveMatrix = makePerspective(fieldOfView, aspectRatio, nearDist, farDist);
    }

    setMatrixUniforms(gl, shaderProgram) {
        const pUniform = gl.getUniformLocation(shaderProgram, "uPMatrix");
        gl.uniformMatrix4fv(pUniform, false, new Float32Array(this.perspectiveMatrix.flatten()));

        const mvUniform = gl.getUniformLocation(shaderProgram, "uMVMatrix");
        gl.uniformMatrix4fv(mvUniform, false, new Float32Array(this.mvMatrix.flatten()));

        let normalMatrix = this.mvMatrix.inverse();
        normalMatrix = normalMatrix.transpose();
        const nUniform = gl.getUniformLocation(shaderProgram, "uNormalMatrix");
        gl.uniformMatrix4fv(nUniform, false, new Float32Array(normalMatrix.flatten()));
    }

    mvPushMatrix(m) {
        if (m) {
            this.mvMatrixStack.push(m.dup());
            this.mvMatrix = m.dup();
        } else {
            this.mvMatrixStack.push(this.mvMatrix.dup());
        }
    }

    mvPopMatrix() {
        if (!this.mvMatrixStack.length) {
            throw("Can't pop from an empty matrix stack.");
        }

        this.mvMatrix = this.mvMatrixStack.pop();
        return this.mvMatrix;
    }

    mvRotate(angle, v) {
        const inRadians = angle * Math.PI / 180.0;

        const m = Matrix.Rotation(inRadians, $V([v[0], v[1], v[2]])).ensure4x4();
        multMatrix(m);
    }

}

class Pixelator {
    constructor(canvasID, sliderID, fragShaderUrl, vertShaderUrl) {
        this.fragShaderUrl = fragShaderUrl;
        this.vertShaderUrl = vertShaderUrl;

        this.matrixUtils = new MatrixUtils();

        this.pixSize = 70/255;
        const that = this;
        $(function(){
            $(document.getElementById(sliderID)).slider({
                max: 255,
                value: 70,
                slide: function(event, ui){
                    that.updatePixSize(ui.value);
                }
            });
        });

        this.canvas = document.getElementById(canvasID);
        this.start();
    }

    //
    // start
    //
    // Called when the canvas is created to get the ball rolling.
    //
    async start() {
        this.initWebGL(this.canvas);            // Initialize the GL context

        // Only continue if WebGL is available and working

        if (this.gl) {
            this.gl.clearColor(0.0, 0.0, 0.0, 1.0); // Clear to black, fully opaque
            this.gl.clearDepth(1.0);                // Clear everything
            this.gl.enable(this.gl.DEPTH_TEST);          // Enable depth testing
            this.gl.depthFunc(this.gl.LEQUAL);           // Near things obscure far things

            await this.initShaders();
            this.initBuffers();
            this.initTextures();
            this.drawScene();
        }
    }

    //
    // initWebGL
    //
    // Initialize WebGL, returning the GL context or null if
    // WebGL isn't available or could not be initialized.
    //
    initWebGL() {
        this.gl = this.canvas.getContext("experimental-webgl");

        // If we don't have a GL context, give up now
        if (!this.gl) {
            alert("Unable to initialize WebGL. Your browser may not support it.");
        }
    }

    //
    // initBuffers
    //
    // Initialize the buffers we'll need. For this demo, we just have
    // one object -- a simple two-dimensional square.
    //
    initBuffers() {

        // Create a buffer for the square's vertices.

        this.squareVerticesBuffer = this.gl.createBuffer();

        // Select the squareVerticesBuffer as the one to apply vertex
        // operations to from here out.

        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesBuffer);

        // Now create an array of vertices for the square.

        let vertices = [
            // Front face
            -2.0, -2.0, 1.0,
             2.0, -2.0, 1.0,
             2.0,  2.0, 1.0,
            -2.0,  2.0, 1.0,
        ];

        // Now pass the list of vertices into WebGL to build the shape. We
        // do this by creating a Float32Array from the JavaScript array,
        // then use it to fill the current vertex buffer.

        this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array(vertices), this.gl.STATIC_DRAW);

        // Set up the normals for the vertices, so that we can compute lighting.

        this.squareVerticesNormalBuffer = this.gl.createBuffer();
        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesNormalBuffer);

        let vertexNormals = [
            // Front
             0.0, 0.0, 1.0,
             0.0, 0.0, 1.0,
             0.0, 0.0, 1.0,
             0.0, 0.0, 1.0,
        ];

        this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array(vertexNormals),
                                    this.gl.STATIC_DRAW);

        // Map the texture onto the square's faces.

        this.squareVerticesTextureCoordBuffer = this.gl.createBuffer();
        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesTextureCoordBuffer);

        let textureCoordinates = [
            // Front
            0.0, 0.0,
            1.0, 0.0,
            1.0, 1.0,
            0.0, 1.0,
        ];

        this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array(textureCoordinates), this.gl.STATIC_DRAW);

        // Build the element array buffer; this specifies the indices
        // into the vertex array for each face's vertices.

        this.squareVerticesIndexBuffer = this.gl.createBuffer();
        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.squareVerticesIndexBuffer);

        // This array defines each face as two triangles, using the
        // indices into the vertex array to specify each triangle's
        // position.

        let squareVertexIndices = [
            0,  1,  2,      0,  2,  3,    // front
        ]

        // Now send the element array to GL
        this.gl.bufferData(this.gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(squareVertexIndices), this.gl.STATIC_DRAW);
    }

    //
    // initTextures
    //
    // Initialize the textures we'll be using, then initiate a load of
    // the texture images. The handleTextureLoaded() callback will finish
    // the job; it gets called each time a texture finishes loading.
    //
    initTextures() {
        this.squareTexture = this.gl.createTexture();
        this.gl.bindTexture(this.gl.TEXTURE_2D, this.squareTexture);
        this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, true);
        this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.gl.RGBA, this.gl.UNSIGNED_BYTE, document.getElementById('galaxy'));

        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);

        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);

        this.gl.generateMipmap(this.gl.TEXTURE_2D);
        this.gl.bindTexture(this.gl.TEXTURE_2D, null);
    }

    //
    // drawScene
    //
    // Draw the scene.
    //
    drawScene() {
        // Clear the canvas before we start drawing on it.

        this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);

        // Establish the perspective with which we want to view the
        // scene. Our field of view is 45 degrees, with a width/height
        // ratio of 640:480, and we only want to see objects between 0.1 units
        // and 100 units away from the camera.

        this.matrixUtils.makePerspective(45, this.canvas.width / this.canvas.height, 0.1, 100.0);

        // Set the drawing position to the "identity" point, which is
        // the center of the scene.

        this.matrixUtils.loadIdentity();
        // Now move the drawing position a bit to where we want to start
        // drawing the square.
        this.matrixUtils.mvTranslate([0.0, 0.0, -3.0]);
        this.matrixUtils.mvPushMatrix();

        // Draw the square by binding the array buffer to the square's vertices
        // array, setting attributes, and pushing it to GL.

        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesBuffer);
        this.gl.vertexAttribPointer(this.vertexPositionAttribute, 3, this.gl.FLOAT, false, 0, 0);

        // Set the texture coordinates attribute for the vertices.

        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesTextureCoordBuffer);
        this.gl.vertexAttribPointer(this.textureCoordAttribute, 2, this.gl.FLOAT, false, 0, 0);

        // Bind the normals buffer to the shader attribute.

        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.squareVerticesNormalBuffer);
        this.gl.vertexAttribPointer(this.vertexNormalAttribute, 3, this.gl.FLOAT, false, 0, 0);

        // Specify the texture to map onto the faces.

        this.gl.activeTexture(this.gl.TEXTURE0);
        this.gl.bindTexture(this.gl.TEXTURE_2D, this.squareTexture);
        this.gl.uniform1i(this.gl.getUniformLocation(this.shaderProgram, "uSampler"), 0);
        this.gl.uniform1f(
            this.gl.getUniformLocation(this.shaderProgram, "uPixSize"), this.pixSize);

        // Draw the square.
        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.squareVerticesIndexBuffer);
        this.matrixUtils.setMatrixUniforms(this.gl, this.shaderProgram);
        this.gl.drawElements(this.gl.TRIANGLES, 6, this.gl.UNSIGNED_SHORT, 0);

        // Restore the original matrix
        this.matrixUtils.mvPopMatrix();
    }

    //
    // initShaders
    //
    // Initialize the shaders, so WebGL knows how to light our scene.
    //
    async initShaders() {
        let fragmentShader = await this.getShader(this.fragShaderUrl);
        let vertexShader = await this.getShader(this.vertShaderUrl);

        // Create the shader program

        this.shaderProgram = this.gl.createProgram();
        this.gl.attachShader(this.shaderProgram, vertexShader);
        this.gl.attachShader(this.shaderProgram, fragmentShader);
        this.gl.linkProgram(this.shaderProgram);

        // If creating the shader program failed, alert

        if (!this.gl.getProgramParameter(this.shaderProgram, this.gl.LINK_STATUS)) {
            alert("Unable to initialize the shader program: " + this.gl.getProgramInfoLog(shader));
        }

        this.gl.useProgram(this.shaderProgram);

        this.vertexPositionAttribute = this.gl.getAttribLocation(this.shaderProgram, "aVertexPosition");
        this.gl.enableVertexAttribArray(this.vertexPositionAttribute);

        this.textureCoordAttribute = this.gl.getAttribLocation(this.shaderProgram, "aTextureCoord");
        this.gl.enableVertexAttribArray(this.textureCoordAttribute);

        this.vertexNormalAttribute = this.gl.getAttribLocation(this.shaderProgram, "aVertexNormal");
        this.gl.enableVertexAttribArray(this.vertexNormalAttribute);
    }

    //
    // getShader
    //
    // Loads a shader program by scouring the current document,
    // looking for a script with the specified ID.
    //
    async getShader(url) {
        const isVertShader = url.endsWith('.vert.c');
        const isFragShader = url.endsWith('.frag.c');
        if (!isVertShader && !isFragShader)
            throw("Shader file " + url + " must end with one of ['.vert.c', '.frag.c']");

        const resp = await fetch(url);
        if (resp.status !== 200)
            throw("Could not find shader " + url);

        const shaderBody = await resp.body.getReader().read();
        const shaderSource = String.fromCharCode.apply(null, shaderBody.value)

        let shader;
        if (isFragShader) {
            shader = this.gl.createShader(this.gl.FRAGMENT_SHADER);
        } else {
            shader = this.gl.createShader(this.gl.VERTEX_SHADER);
        }

        this.gl.shaderSource(shader, shaderSource);
        this.gl.compileShader(shader);

        if (!this.gl.getShaderParameter(shader, this.gl.COMPILE_STATUS)) {
            alert("An error occurred compiling the shaders: " + this.gl.getShaderInfoLog(shader));
            return null;
        }
        return shader;
    }

    updatePixSize(val){
        this.pixSize = val/255;
        this.drawScene();
    }
}

var pixelObj;
function startWebgl() {
    // hexelObj = new Pixelator("glcanvas", "slider", "shader-fs-hx");
    pixelObj = new Pixelator("glcanvas-pixel", "slider-pixel", pixelShader);
    // new Pixelator("glcanvas2", "slider2", "shader-fs-hx-test");
}


text:
package org.apache.fineract.portfolio.savings.service;

import org.apache.fineract.infrastructure.jobs.exception.JobExecutionException;

public interface SavingsSchedularService {

    void postInterestForAccounts() throws JobExecutionException;

    void updateSavingsDormancyStatus() throws JobExecutionException;

}


text:
<?php

namespace ClipBundle\Form;

use AppBundle\Form\AppDateType;
use AppBundle\Form\BaseType;
use AppBundle\Form\DummyChoiceType;
use AppBundle\Form\MedewerkerType;
use Doctrine\ORM\EntityRepository;
use ClipBundle\Entity\Deelname;
use ClipBundle\Entity\Training;
use ClipBundle\Entity\Vrijwilliger;
use Symfony\Bridge\Doctrine\Form\Type\EntityType;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class DeelnameType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('datum', AppDateType::class, ['data' => new \DateTime('now')])
            ->add('training', EntityType::class,['class'=> Training::class])
            ->add('overig',null,['required'=>false])
            ->add('submit', SubmitType::class)
        ;
    }

    /**
     * {@inheritdoc}
     */
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'data_class' => Deelname::class,

        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function getParent()
    {
        return BaseType::class;
    }
}


text:
package kobdig.ESPACE;

/**
 * Created by Meili on 21/06/2016.
 */
public class Family {

    // ATRIBUTES

    /**
     * Unique ID for the family
     */
    private String id;

    /**
     * Family's lastname
     */
    private String lastname;

    /**
     * ID of the family's property
     */
    private String property;

    /**
     * ID of the family's rented property
     */
    private String rentedProperty;

    /**
     * Purchasing power to buy home
     */
    private double previousPurchasingPower;

    /**
     * Net monthly income to pay rent
     */
    private double previousNetMonthlyIncome;

    /**
     * Purchasing power to buy home
     */
    private double currentPurchasingPower;

    /**
     * Net monthly income to pay rent
     */
    private double currentNetMonthlyIncome;

    // CONSTRUCTOR

    public Family(String id, String lastname, double purchasingPower, double netMonthlyIncome) {
        this.id = id;
        this.property = null;
        this.rentedProperty = null;
        this.lastname = lastname;
        this.previousPurchasingPower = purchasingPower;
        this.previousNetMonthlyIncome = netMonthlyIncome;
        this.currentPurchasingPower = purchasingPower;
        this.currentNetMonthlyIncome = netMonthlyIncome;
    }

    // GETTERS AND SETTERS

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public String getRentedProperty() {
        return rentedProperty;
    }

    public void setRentedProperty(String rentedProperty) {
        this.rentedProperty = rentedProperty;
    }

    public double getPreviousPurchasingPower() {
        return previousPurchasingPower;
    }

    public void setPreviousPurchasingPower(double previousPurchasingPower) {
        this.previousPurchasingPower = previousPurchasingPower;
    }

    public double getPreviousNetMonthlyIncome() {
        return previousNetMonthlyIncome;
    }

    public void setPreviousNetMonthlyIncome(double previousNetMonthlyIncome) {
        this.previousNetMonthlyIncome = previousNetMonthlyIncome;
    }

    public double getCurrentPurchasingPower() {
        return currentPurchasingPower;
    }

    public void setCurrentPurchasingPower(double currentPurchasingPower) {
        this.currentPurchasingPower = currentPurchasingPower;
    }

    public double getCurrentNetMonthlyIncome() {
        return currentNetMonthlyIncome;
    }

    public void setCurrentNetMonthlyIncome(double currentNetMonthlyIncome) {
        this.currentNetMonthlyIncome = currentNetMonthlyIncome;
    }

// METHODS

    /**
     * Returns YES if the family is landlord, otherwise, returns NO
     * @return YES if the family is landlord, otherwise, returns NO
     */
    public String hasProperty(){
        if (property != null) return "YES";
        return "NO";
    }

    /**
     * Returns YES if the family is renting, otherwise, returns NO
     * @return YES if the family is renting, otherwise, returns NO
     */
    public String isRenting(){
        if (rentedProperty != null) return "YES";
        return "NO";
    }

    /**
     * Generates a step in the simulation
     * @param time The time in the simulation
     */
    public void step(int time){
        previousPurchasingPower = currentPurchasingPower;
        previousNetMonthlyIncome = currentNetMonthlyIncome;
        currentPurchasingPower = previousPurchasingPower + (previousPurchasingPower*Math.log(time + 1))/20;
        currentNetMonthlyIncome = previousNetMonthlyIncome + (previousPurchasingPower*(0.001));
    }

    public String toString(){
        if (property != null)
            return lastname  + "," + hasProperty() + "," + property + "," + isRenting() + ",," + currentPurchasingPower  + "," + currentNetMonthlyIncome;
        if (rentedProperty != null)
            return lastname  + "," + hasProperty() + ",," + isRenting() + "," + rentedProperty + "," + currentPurchasingPower  + "," + currentNetMonthlyIncome;
        else
            return lastname  + "," + hasProperty() + ",,"  + isRenting() + ",," + currentPurchasingPower  + "," + currentNetMonthlyIncome;
    }
}


text:
import * as ayu from 'ayu'

export type SchemeName = 'light' | 'dark' | 'mirage'

const terminalColors = {
  light: {
    black: '#000000',
    white: '#c7c7c7',
    brightBlack: '#686868',
    brightWhite: '#d1d1d1'
  },
  dark: {
    black: ayu.dark.ui.line.hex(),
    white: '#c7c7c7',
    brightBlack: '#686868',
    brightWhite: '#ffffff'
  },
  mirage: {
    black: ayu.mirage.ui.line.hex(),
    white: '#c7c7c7',
    brightBlack: '#686868',
    brightWhite: '#ffffff'
  }
}

export default (variant: SchemeName, bordered: boolean) => {
  const scheme = ayu[variant]
  return {
    type: variant === 'light' ? 'light' : 'dark',
    colors: {
      // Colour reference https://code.visualstudio.com/docs/getstarted/theme-color-reference

      // CONTRAST COLOURS
      // --

      // BASE COLOURS
      focusBorder: scheme.common.accent.alpha(0.7).hex(),
      foreground: scheme.ui.fg.hex(),
      'widget.shadow': scheme.ui.panel.shadow.hex(),
      'selection.background': scheme.editor.selection.active.hex(),
      'icon.foreground': scheme.ui.fg.hex(),
      errorForeground: scheme.common.error.hex(),
      descriptionForeground: scheme.ui.fg.hex(),

      // TEXT COLOURS
      'textBlockQuote.background': scheme.ui.panel.bg.hex(),
      'textLink.foreground': scheme.common.accent.hex(),
      'textLink.activeForeground': scheme.common.accent.hex(),
      'textPreformat.foreground': scheme.editor.fg.hex(),

      // BUTTON CONTROL
      'button.background': scheme.common.accent.hex(),
      'button.foreground': scheme.ui.bg.hex(),
      'button.hoverBackground': scheme.common.accent.darken(0.1).hex(),
      'button.secondaryBackground': scheme.ui.fg.alpha(0.2).hex(),
      'button.secondaryForeground': scheme.editor.fg.hex(),
      'button.secondaryHoverBackground': scheme.ui.fg.alpha(0.5).hex(),

      // DROPDOWN CONTROL
      'dropdown.background': scheme.editor.bg.hex(),
      'dropdown.foreground': scheme.ui.fg.hex(),
      'dropdown.border': scheme.ui.fg.alpha(0.27).hex(),

      // INPUT CONTROL
      'input.background': scheme.editor.bg.hex(),
      'input.border': scheme.ui.fg.alpha(0.27).hex(),
      'input.foreground': scheme.editor.fg.hex(),
      'input.placeholderForeground': scheme.ui.fg.alpha(0.5).hex(),
      'inputOption.activeBorder': (variant == 'light' ? scheme.common.accent.darken(0.2) : scheme.common.accent)
        .alpha(0.3)
        .hex(),
      'inputOption.activeBackground': scheme.common.accent.alpha(0.2).hex(),
      'inputOption.activeForeground':
        variant == 'light' ? scheme.common.accent.darken(0.2).hex() : scheme.common.accent.hex(),
      'inputValidation.errorBackground': scheme.editor.bg.hex(),
      'inputValidation.errorBorder': scheme.common.error.hex(),
      'inputValidation.infoBackground': scheme.ui.bg.hex(),
      'inputValidation.infoBorder': scheme.syntax.tag.hex(),
      'inputValidation.warningBackground': scheme.ui.bg.hex(),
      'inputValidation.warningBorder': scheme.syntax.func.hex(),

      // SCROLLBAR CONTROL
      'scrollbar.shadow': scheme.ui.line.alpha(0).hex(),
      'scrollbarSlider.background': scheme.ui.fg.alpha(0.4).hex(),
      'scrollbarSlider.hoverBackground': scheme.ui.fg.alpha(0.6).hex(),
      'scrollbarSlider.activeBackground': scheme.ui.fg.alpha(0.7).hex(),

      // BADGE
      'badge.background': scheme.common.accent.alpha(0.2).hex(),
      'badge.foreground': variant == 'light' ? scheme.common.accent.darken(0.2).hex() : scheme.common.accent.hex(),

      // PROGRESS BAR
      'progressBar.background': scheme.common.accent.hex(),

      // LISTS AND TREES
      'list.activeSelectionBackground': scheme.ui.selection.active.hex(),
      'list.activeSelectionForeground': scheme.editor.fg.hex(),
      // 'list.activeSelectionIconForeground': scheme.editor.fg.alpha(.7).hex(),
      'list.focusBackground': scheme.ui.selection.active.hex(),
      'list.focusForeground': scheme.editor.fg.hex(),
      'list.focusOutline': scheme.ui.selection.active.hex(),
      'list.highlightForeground': scheme.common.accent.hex(),
      'list.deemphasizedForeground': scheme.common.error.hex(),
      'list.hoverBackground': scheme.ui.selection.active.hex(),
      // 'list.hoverForeground': scheme.ui.fg.hex(),
      'list.inactiveSelectionBackground': scheme.ui.selection.normal.hex(),
      'list.inactiveSelectionForeground': scheme.ui.fg.hex(),
      'list.invalidItemForeground': scheme.ui.fg.alpha(0.3).hex(),
      'list.errorForeground': scheme.common.error.hex(),
      'tree.indentGuidesStroke': scheme.editor.indentGuide.active.hex(),

      'listFilterWidget.background': scheme.ui.panel.bg.hex(),
      'listFilterWidget.outline': scheme.common.accent.hex(),
      'listFilterWidget.noMatchesOutline': scheme.common.error.hex(),
      'list.filterMatchBackground': scheme.editor.findMatch.inactive.darken(0.3).hex(),
      'list.filterMatchBorder': scheme.editor.findMatch.inactive.hex(),

      // ACTIVITY BAR
      'activityBar.background': bordered ? scheme.editor.bg.hex() : scheme.ui.bg.hex(),
      'activityBar.foreground': scheme.ui.fg.alpha(0.8).hex(),
      'activityBar.inactiveForeground': scheme.ui.fg.alpha(0.6).hex(),
      'activityBar.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),
      'activityBar.activeBorder': scheme.common.accent.alpha(0.7).hex(),
      'activityBarBadge.background': scheme.common.accent.hex(),
      'activityBarBadge.foreground': scheme.ui.bg.hex(),

      // SIDE BAR
      'sideBar.background': scheme.ui.bg.hex(),
      'sideBar.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),
      'sideBarTitle.foreground': scheme.ui.fg.hex(),
      'sideBarSectionHeader.background': scheme.ui.bg.hex(),
      'sideBarSectionHeader.foreground': scheme.ui.fg.hex(),
      'sideBarSectionHeader.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),

      // MINIMAP
      'minimap.background': bordered ? scheme.editor.bg.hex() : scheme.ui.bg.hex(),
      'minimap.selectionHighlight': scheme.editor.selection.active.hex(),
      'minimap.errorHighlight': scheme.common.error.hex(),
      'minimap.findMatchHighlight': scheme.editor.findMatch.active.hex(),
      'minimapGutter.addedBackground': scheme.vcs.added.hex(),
      'minimapGutter.modifiedBackground': scheme.vcs.modified.hex(),
      'minimapGutter.deletedBackground': scheme.vcs.removed.hex(),

      // EDITOR GROUPS & TABS
      'editorGroup.border': scheme.ui.line.hex(),
      'editorGroup.background': scheme.ui.panel.bg.hex(),
      'editorGroupHeader.noTabsBackground': scheme.ui.bg.hex(),
      'editorGroupHeader.tabsBackground': scheme.ui.bg.hex(),
      'editorGroupHeader.tabsBorder': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),
      'tab.activeBackground': bordered ? scheme.editor.bg.hex() : scheme.ui.bg.hex(),
      'tab.activeForeground': scheme.editor.fg.hex(),
      'tab.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),
      'tab.activeBorder': bordered ? scheme.editor.bg.hex() : scheme.common.accent.hex(),
      'tab.activeBorderTop': bordered ? scheme.common.accent.hex() : undefined,
      'tab.unfocusedActiveBorder': bordered ? undefined : scheme.ui.fg.hex(),
      'tab.unfocusedActiveBorderTop': bordered ? scheme.ui.fg.hex() : undefined,
      'tab.inactiveBackground': scheme.ui.bg.hex(),
      'tab.inactiveForeground': scheme.ui.fg.hex(),
      'tab.unfocusedActiveForeground': scheme.ui.fg.hex(),
      'tab.unfocusedInactiveForeground': scheme.ui.fg.hex(),

      // EDITOR
      'editor.background': bordered ? scheme.editor.bg.hex() : scheme.ui.bg.hex(),
      'editor.foreground': scheme.editor.fg.hex(),
      'editorLineNumber.foreground': scheme.editor.gutter.normal.hex(),
      'editorLineNumber.activeForeground': scheme.editor.gutter.active.hex(),
      'editorCursor.foreground': scheme.common.accent.hex(),

      // EDITOR SELECTIONS
      'editor.inactiveSelectionBackground': scheme.editor.selection.inactive.hex(),
      'editor.selectionBackground': scheme.editor.selection.active.hex(),
      'editor.selectionHighlightBackground': scheme.vcs.added.alpha(0.15).hex(),
      'editor.selectionHighlightBorder': scheme.vcs.added.alpha(0).hex(),
      'editor.wordHighlightBackground': scheme.vcs.modified.alpha(0.08).hex(),
      'editor.wordHighlightStrongBackground': scheme.vcs.added.alpha(0.08).hex(),
      'editor.wordHighlightBorder': scheme.vcs.modified.alpha(0.5).hex(),
      'editor.wordHighlightStrongBorder': scheme.vcs.added.alpha(0.5).hex(),

      // EDITOR SEARCH
      'editor.findMatchBackground': scheme.editor.findMatch.active.hex(),
      'editor.findMatchBorder': scheme.editor.findMatch.active.hex(),
      'editor.findMatchHighlightBackground': scheme.editor.findMatch.inactive.hex(),
      'editor.findMatchHighlightBorder': scheme.editor.findMatch.inactive.darken(0.3).hex(),
      'editor.findRangeHighlightBackground': scheme.editor.findMatch.inactive.alpha(0.25).hex(),
      // 'editor.findRangeHighlightBorder': scheme.editor.findMatch.inactive.forceAlpha(0).hex(),
      'editor.rangeHighlightBackground': scheme.editor.findMatch.active.alpha(0.2).hex(),

      // 'editor.hoverHighlightBackground': '',

      'editor.lineHighlightBackground': scheme.editor.line.hex(),
      // 'editor.lineHighlightBorder': '',

      'editorLink.activeForeground': scheme.common.accent.hex(),

      'editorWhitespace.foreground': scheme.editor.gutter.normal.hex(),

      'editorIndentGuide.background': scheme.editor.indentGuide.normal.hex(),
      'editorIndentGuide.activeBackground': scheme.editor.indentGuide.active.hex(),

      'editorRuler.foreground': scheme.editor.indentGuide.normal.hex(),
      'editorCodeLens.foreground': scheme.syntax.comment.hex(),

      'editorBracketMatch.background': scheme.editor.gutter.normal.alpha(0.3).hex(),
      'editorBracketMatch.border': scheme.editor.gutter.active.alpha(0.3).hex(),

      // SNIPPETS
      'editor.snippetTabstopHighlightBackground': scheme.vcs.added.alpha(0.2).hex(),

      // OVERVIEW RULER
      'editorOverviewRuler.border': scheme.ui.line.hex(),
      'editorOverviewRuler.modifiedForeground': scheme.vcs.modified.hex(),
      'editorOverviewRuler.addedForeground': scheme.vcs.added.hex(),
      'editorOverviewRuler.deletedForeground': scheme.vcs.removed.hex(),
      'editorOverviewRuler.errorForeground': scheme.common.error.hex(),
      'editorOverviewRuler.warningForeground': scheme.common.accent.hex(),
      'editorOverviewRuler.bracketMatchForeground': scheme.editor.gutter.normal.alpha(0.7).hex(),
      'editorOverviewRuler.wordHighlightForeground': scheme.vcs.modified.alpha(0.4).hex(),
      'editorOverviewRuler.wordHighlightStrongForeground': scheme.vcs.added.alpha(0.4).hex(),
      'editorOverviewRuler.findMatchForeground': scheme.editor.findMatch.active.hex(),

      // ERRORS AND WARNINGS
      'editorError.foreground': scheme.common.error.hex(),
      'editorWarning.foreground': scheme.common.accent.hex(),

      // GUTTER
      'editorGutter.modifiedBackground': scheme.vcs.modified.alpha(0.8).hex(),
      'editorGutter.addedBackground': scheme.vcs.added.alpha(0.8).hex(),
      'editorGutter.deletedBackground': scheme.vcs.removed.alpha(0.8).hex(),

      // DIFF EDITOR
      'diffEditor.insertedTextBackground': scheme.vcs.added.alpha(0.12).hex(),
      'diffEditor.removedTextBackground': scheme.vcs.removed.alpha(0.12).hex(),
      'diffEditor.diagonalFill': scheme.ui.line.hex(),

      // EDITOR WIDGET
      'editorWidget.background': bordered ? scheme.ui.bg.hex() : scheme.ui.panel.bg.hex(),
      'editorWidget.border': scheme.ui.line.hex(),
      'editorHoverWidget.background': bordered ? scheme.ui.bg.hex() : scheme.ui.panel.bg.hex(),
      'editorHoverWidget.border': scheme.ui.line.hex(),
      'editorSuggestWidget.background': scheme.ui.panel.bg.hex(),
      'editorSuggestWidget.border': scheme.ui.line.hex(),
      'editorSuggestWidget.highlightForeground': scheme.common.accent.hex(),
      'editorSuggestWidget.selectedBackground': scheme.ui.selection.active.hex(),

      // DEBUG EXCEPTION
      'debugExceptionWidget.border': scheme.ui.line.hex(),
      'debugExceptionWidget.background': scheme.ui.panel.bg.hex(),

      // EDITOR MARKER
      'editorMarkerNavigation.background': scheme.ui.panel.bg.hex(),

      // PEEK VIEW
      'peekView.border': scheme.ui.selection.active.hex(),

      'peekViewTitle.background': scheme.ui.selection.active.hex(),
      'peekViewTitleDescription.foreground': scheme.ui.fg.hex(),
      'peekViewTitleLabel.foreground': scheme.editor.fg.hex(),

      'peekViewEditor.background': bordered ? scheme.ui.bg.hex() : scheme.ui.panel.bg.hex(),
      'peekViewEditor.matchHighlightBackground': scheme.editor.findMatch.inactive.hex(), // ??
      'peekViewEditor.matchHighlightBorder': scheme.editor.findMatch.inactive.darken(0.3).hex(), // ??

      'peekViewResult.background': bordered ? scheme.ui.bg.hex() : scheme.ui.panel.bg.hex(),
      'peekViewResult.fileForeground': scheme.editor.fg.hex(),
      'peekViewResult.lineForeground': scheme.ui.fg.hex(),
      'peekViewResult.matchHighlightBackground': scheme.editor.findMatch.inactive.hex(), // ???
      // 'peekViewResult.matchHighlightBorder': scheme.editor.findMatch.inactive.darken(.3).hex(), // doesn't exist
      'peekViewResult.selectionBackground': scheme.ui.selection.active.hex(), // ???
      // 'peekViewResult.selectionForeground': scheme.editor.fg.hex(), // ???

      // Merge Conflicts
      // 'merge.currentHeaderBackground': '?',
      // 'merge.currentContentBackground': '?',
      // 'merge.incomingHeaderBackground': '?',
      // 'merge.incomingContentBackground': '?',
      // 'merge.border': '?',
      // 'merge.commonContentBackground': '?',
      // 'merge.commonHeaderBackground': '?',
      // 'editorOverviewRuler.currentContentForeground': '?',
      // 'editorOverviewRuler.incomingContentForeground': '?',
      // 'editorOverviewRuler.commonContentForeground': '?',

      // Panel
      'panel.background': scheme.ui.bg.hex(),
      'panel.border': scheme.ui.line.hex(),
      'panelTitle.activeBorder': scheme.common.accent.hex(), // ???
      'panelTitle.activeForeground': scheme.editor.fg.hex(),
      'panelTitle.inactiveForeground': scheme.ui.fg.hex(),

      // STATUS BAR
      'statusBar.background': scheme.ui.bg.hex(),
      'statusBar.foreground': scheme.ui.fg.hex(),
      'statusBar.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),
      'statusBar.debuggingBackground': scheme.syntax.operator.hex(),
      'statusBar.debuggingForeground': scheme.editor.bg.hex(),
      'statusBar.noFolderBackground': scheme.ui.panel.bg.hex(),
      'statusBarItem.activeBackground': scheme.ui.fg.alpha(0.2).hex(),
      'statusBarItem.hoverBackground': scheme.ui.fg.alpha(0.2).hex(),
      'statusBarItem.prominentBackground': scheme.ui.line.hex(),
      'statusBarItem.prominentHoverBackground': '#00000030',
      'statusBarItem.remoteBackground': scheme.common.accent.hex(),
      'statusBarItem.remoteForeground': scheme.editor.bg.hex(),

      // TITLE BAR
      'titleBar.activeBackground': scheme.ui.bg.hex(),
      'titleBar.activeForeground': scheme.editor.fg.hex(),
      'titleBar.inactiveBackground': scheme.ui.bg.hex(),
      'titleBar.inactiveForeground': scheme.ui.fg.hex(),
      'titleBar.border': bordered ? scheme.ui.line.hex() : scheme.ui.bg.hex(),

      // MENU BAR
      // 'menubar.selectionForeground': '?',
      // 'menubar.selectionBackground': '?',
      // 'menubar.selectionBorder': '?',
      // 'menu.foreground': '?',
      // 'menu.background': '?',
      // 'menu.selectionForeground': '?',
      // 'menu.selectionBackground': '?',
      // 'menu.selectionBorder': '?',

      // NOTIFICATION
      // 'notificationCenter.border': '?',
      // 'notificationCenterHeader.foreground': '?',
      // 'notificationCenterHeader.background': '?',
      // 'notificationToast.border': '?',
      // 'notifications.foreground': '?',
      // 'notifications.background': '?',
      // 'notifications.border': '?',
      // 'notificationLink.foreground': '?',

      // EXTENSIONS
      'extensionButton.prominentForeground': scheme.editor.bg.hex(),
      'extensionButton.prominentBackground': scheme.common.accent.hex(),
      'extensionButton.prominentHoverBackground': scheme.common.accent.darken(0.1).hex(),

      // QUICK PICKER
      'pickerGroup.border': scheme.ui.line.hex(),
      'pickerGroup.foreground': scheme.ui.fg.alpha(0.5).hex(),

      // DEBUG
      'debugToolBar.background': scheme.ui.panel.bg.hex(),
      'debugIcon.breakpointForeground': scheme.syntax.operator.hex(),
      'debugIcon.breakpointDisabledForeground': scheme.syntax.operator.alpha(0.5).hex(),
      'debugConsoleInputIcon.foreground': scheme.common.accent.hex(),
      // 'debugToolBar.border': '',

      // WELCOME PAGE
      'welcomePage.tileBackground': scheme.ui.bg.hex(),
      'welcomePage.tileShadow': scheme.ui.panel.shadow.hex(),
      'welcomePage.progress.background': scheme.editor.line.hex(),
      'welcomePage.buttonBackground': scheme.common.accent.alpha(0.4).hex(),
      // 'welcomePage.buttonHoverBackground': '?'
      'walkThrough.embeddedEditorBackground': scheme.ui.panel.bg.hex(),

      // GIT
      'gitDecoration.modifiedResourceForeground': scheme.vcs.modified.alpha(0.7).hex(),
      'gitDecoration.deletedResourceForeground': scheme.vcs.removed.alpha(0.7).hex(),
      'gitDecoration.untrackedResourceForeground': scheme.vcs.added.alpha(0.7).hex(),
      'gitDecoration.ignoredResourceForeground': scheme.ui.fg.alpha(0.5).hex(),
      'gitDecoration.conflictingResourceForeground': '',
      'gitDecoration.submoduleResourceForeground': scheme.syntax.constant.alpha(0.7).hex(),

      // Settings
      'settings.headerForeground': scheme.editor.fg.hex(),
      'settings.modifiedItemIndicator': scheme.vcs.modified.hex(),

      // KEYBINDING
      'keybindingLabel.background': scheme.ui.fg.alpha(0.1).hex(),
      'keybindingLabel.foreground': scheme.editor.fg.hex(),
      'keybindingLabel.border': scheme.editor.fg.alpha(0.1).hex(),
      'keybindingLabel.bottomBorder': scheme.editor.fg.alpha(0.1).hex(),

      // TERMINAL
      'terminal.background': scheme.ui.bg.hex(),
      'terminal.foreground': scheme.editor.fg.hex(),
      'terminal.ansiBlack': terminalColors[variant].black,
      'terminal.ansiRed': scheme.syntax.markup.darken(0.1).hex(),
      'terminal.ansiGreen': scheme.vcs.added.hex(),
      'terminal.ansiYellow': scheme.syntax.func.darken(0.1).hex(),
      'terminal.ansiBlue': scheme.syntax.entity.darken(0.1).hex(),
      'terminal.ansiMagenta': scheme.syntax.constant.darken(0.1).hex(),
      'terminal.ansiCyan': scheme.syntax.regexp.darken(0.1).hex(),
      'terminal.ansiWhite': terminalColors[variant].white,
      'terminal.ansiBrightBlack': terminalColors[variant].brightBlack,
      'terminal.ansiBrightRed': scheme.syntax.markup.hex(),
      'terminal.ansiBrightGreen': scheme.syntax.string.hex(),
      'terminal.ansiBrightYellow': scheme.syntax.func.hex(),
      'terminal.ansiBrightBlue': scheme.syntax.entity.hex(),
      'terminal.ansiBrightMagenta': scheme.syntax.constant.hex(),
      'terminal.ansiBrightCyan': scheme.syntax.regexp.hex(),
      'terminal.ansiBrightWhite': terminalColors[variant].brightWhite
    },

    tokenColors: [
      {
        settings: {
          background: scheme.ui.bg.hex(),
          foreground: scheme.editor.fg.hex()
        }
      },
      {
        name: 'Comment',
        scope: ['comment'],
        settings: {
          fontStyle: 'italic',
          foreground: scheme.syntax.comment.hex()
        }
      },

      {
        name: 'String',
        scope: ['string', 'constant.other.symbol'], //+
        settings: {
          foreground: scheme.syntax.string.hex()
        }
      },
      {
        name: 'Regular Expressions and Escape Characters',
        scope: ['string.regexp', 'constant.character', 'constant.other'],
        settings: {
          foreground: scheme.syntax.regexp.hex()
        }
      },

      {
        name: 'Number',
        scope: ['constant.numeric'],
        settings: {
          foreground: scheme.syntax.constant.hex()
        }
      },
      {
        name: 'Built-in constants',
        scope: ['constant.language'],
        settings: {
          foreground: scheme.syntax.constant.hex()
        }
      },

      {
        name: 'Variable',
        scope: ['variable', 'variable.parameter.function-call'],
        settings: {
          foreground: scheme.editor.fg.hex()
        }
      },
      {
        name: 'Member Variable',
        scope: ['variable.member'],
        settings: {
          foreground: scheme.syntax.markup.hex()
        }
      },
      {
        name: 'Language variable',
        scope: ['variable.language'],
        settings: {
          fontStyle: 'italic',
          foreground: scheme.syntax.tag.hex()
        }
      },

      // ------
      // Keywords
      {
        name: 'Storage',
        scope: ['storage'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },
      {
        name: 'Keyword',
        scope: ['keyword'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },

      // ------
      // Operators
      {
        name: 'Operators',
        scope: ['keyword.operator'],
        settings: {
          foreground: scheme.syntax.operator.hex()
        }
      },

      // ------
      // Punctuation
      {
        name: 'Separators like ; or ,',
        scope: ['punctuation.separator', 'punctuation.terminator'],
        settings: {
          foreground: scheme.editor.fg.alpha(0.7).hex()
        }
      },
      {
        name: 'Punctuation',
        scope: ['punctuation.section'],
        settings: {
          foreground: scheme.editor.fg.hex()
        }
      },
      {
        name: 'Accessor',
        scope: ['punctuation.accessor'],
        settings: {
          foreground: scheme.syntax.operator.hex()
        }
      },
      {
        name: 'JavaScript/TypeScript interpolation punctuation',
        scope: ['punctuation.definition.template-expression'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },
      {
        name: 'Ruby interpolation punctuation',
        scope: ['punctuation.section.embedded'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },
      {
        name: 'Interpolation text',
        scope: ['meta.embedded'],
        settings: {
          foreground: scheme.editor.fg.hex()
        }
      },

      // ------
      // Types
      {
        name: 'Types fixes',
        scope: ['source.java storage.type', 'source.haskell storage.type', 'source.c storage.type'],
        settings: {
          foreground: scheme.syntax.entity.hex()
        }
      },
      {
        name: 'Inherited class type',
        scope: ['entity.other.inherited-class'],
        settings: {
          foreground: scheme.syntax.tag.hex()
        }
      },
      // Fixes
      {
        name: 'Lambda arrow',
        scope: ['storage.type.function'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },
      {
        name: 'Java primitive variable types',
        scope: ['source.java storage.type.primitive'],
        settings: {
          foreground: scheme.syntax.tag.hex()
        }
      },

      // ------
      // Function/method names in definitions
      // and calls
      {
        name: 'Function name',
        scope: ['entity.name.function'],
        settings: {
          foreground: scheme.syntax.func.hex()
        }
      },
      {
        name: 'Function arguments',
        scope: ['variable.parameter', 'meta.parameter'],
        settings: {
          foreground: scheme.syntax.constant.hex()
        }
      },
      {
        name: 'Function call',
        scope: ['variable.function', 'variable.annotation', 'meta.function-call.generic', 'support.function.go'],
        settings: {
          foreground: scheme.syntax.func.hex()
        }
      },
      {
        name: 'Library function',
        scope: ['support.function', 'support.macro'],
        settings: {
          foreground: scheme.syntax.markup.hex()
        }
      },

      // ------
      // Import/export paths
      {
        name: 'Imports and packages',
        scope: ['entity.name.import', 'entity.name.package'],
        settings: {
          foreground: scheme.syntax.string.hex()
        }
      },
      {
        name: 'Entity name',
        scope: ['entity.name'],
        settings: {
          foreground: scheme.syntax.entity.hex()
        }
      },

      // Tag and their attributes
      {
        name: 'Tag',
        scope: ['entity.name.tag', 'meta.tag.sgml'],
        settings: {
          foreground: scheme.syntax.tag.hex()
        }
      },
      {
        name: 'JSX Component',
        scope: ['support.class.component'],
        settings: {
          foreground: scheme.syntax.entity.hex()
        }
      },
      {
        name: 'Tag start/end',
        scope: ['punctuation.definition.tag.end', 'punctuation.definition.tag.begin', 'punctuation.definition.tag'],
        settings: {
          foreground: scheme.syntax.tag.alpha(0.5).hex()
        }
      },
      {
        name: 'Tag attribute',
        scope: ['entity.other.attribute-name'],
        settings: {
          foreground: scheme.syntax.func.hex()
        }
      },

      {
        name: 'Library constant',
        scope: ['support.constant'],
        settings: {
          fontStyle: 'italic',
          foreground: scheme.syntax.operator.hex()
        }
      },
      {
        name: 'Library class/type',
        scope: ['support.type', 'support.class', 'source.go storage.type'],
        settings: {
          foreground: scheme.syntax.tag.hex()
        }
      },
      {
        name: 'Decorators/annotation',
        scope: ['meta.decorator variable.other', 'meta.decorator punctuation.decorator', 'storage.type.annotation'],
        settings: {
          foreground: scheme.syntax.special.hex()
        }
      },
      {
        name: 'Invalid',
        scope: ['invalid'],
        settings: {
          foreground: scheme.common.error.hex()
        }
      },
      {
        name: 'diff.header',
        scope: ['meta.diff', 'meta.diff.header'],
        settings: {
          foreground: '#c594c5'
        }
      },
      {
        name: 'Ruby class methods',
        scope: ['source.ruby variable.other.readwrite'],
        settings: {
          foreground: scheme.syntax.func.hex()
        }
      },
      {
        name: 'CSS tag names',
        scope: [
          'source.css entity.name.tag',
          'source.sass entity.name.tag',
          'source.scss entity.name.tag',
          'source.less entity.name.tag',
          'source.stylus entity.name.tag'
        ],
        settings: {
          foreground: scheme.syntax.entity.hex()
        }
      },
      {
        name: 'CSS browser prefix',
        scope: [
          'source.css support.type',
          'source.sass support.type',
          'source.scss support.type',
          'source.less support.type',
          'source.stylus support.type'
        ],
        settings: {
          foreground: scheme.syntax.comment.hex()
        }
      },
      {
        name: 'CSS Properties',
        scope: ['support.type.property-name'],
        settings: {
          fontStyle: 'normal',
          foreground: scheme.syntax.tag.hex()
        }
      },
      {
        name: 'Search Results Numbers',
        scope: ['constant.numeric.line-number.find-in-files - match'],
        settings: {
          foreground: scheme.syntax.comment.hex()
        }
      },
      {
        name: 'Search Results Match Numbers',
        scope: ['constant.numeric.line-number.match'],
        settings: {
          foreground: scheme.syntax.keyword.hex()
        }
      },
      {
        name: 'Search Results Lines',
        scope: ['entity.name.filename.find-in-files'],
        settings: {
          foreground: scheme.syntax.string.hex()
        }
      },
      {
        scope: ['message.error'],
        settings: {
          foreground: scheme.common.error.hex()
        }
      },
      {
        name: 'Markup heading',
        scope: ['markup.heading', 'markup.heading entity.name'],
        settings: {
          fontStyle: 'bold',
          foreground: scheme.syntax.string.hex()
        }
      },
      {
        name: 'Markup links',
        scope: ['markup.underline.link', 'string.other.link'],
        settings: {
          foreground: scheme.syntax.tag.hex()
        }
      },
      {
        name: 'Markup Italic',
        scope: ['markup.italic'],
        settings: {
          fontStyle: 'italic',
          foreground: scheme.syntax.markup.hex()
        }
      },
      {
        name: 'Markup Bold',
        scope: ['markup.bold'],
        settings: {
          fontStyle: 'bold',
          foreground: scheme.syntax.markup.hex()
        }
      },
      {
        name: 'Markup Bold/italic',
        scope: ['markup.italic markup.bold', 'markup.bold markup.italic'],
        settings: {
          fontStyle: 'bold italic'
        }
      },
      {
        name: 'Markup Code',
        scope: ['markup.raw'],
        settings: {
          background: scheme.editor.fg.alpha(0.02).hex()
        }
      },
      {
        name: 'Markup Code Inline',
        scope: ['markup.raw.inline'],
        settings: {
          background: scheme.editor.fg.alpha(0.06).hex()
        }
      },
      {
        name: 'Markdown Separator',
        scope: ['meta.separator'],
        settings: {
          fontStyle: 'bold',
          background: scheme.editor.fg.alpha(0.06).hex(),
          foreground: scheme.syntax.comment.hex()
        }
      },
      {
        name: 'Markup Blockquote',
        scope: ['markup.quote'],
        settings: {
          foreground: scheme.syntax.regexp.hex(),
          fontStyle: 'italic'
        }
      },
      {
        name: 'Markup List Bullet',
        scope: ['markup.list punctuation.definition.list.begin'],
        settings: {
          foreground: scheme.syntax.func.hex()
        }
      },
      {
        name: 'Markup added',
        scope: ['markup.inserted'],
        settings: {
          foreground: scheme.vcs.added.hex()
        }
      },
      {
        name: 'Markup modified',
        scope: ['markup.changed'],
        settings: {
          foreground: scheme.vcs.modified.hex()
        }
      },
      {
        name: 'Markup removed',
        scope: ['markup.deleted'],
        settings: {
          foreground: scheme.vcs.removed.hex()
        }
      },
      {
        name: 'Markup Strike',
        scope: ['markup.strike'],
        settings: {
          foreground: scheme.syntax.special.hex()
        }
      },
      {
        name: 'Markup Table',
        scope: ['markup.table'],
        settings: {
          background: scheme.editor.fg.alpha(0.06).hex(),
          foreground: scheme.syntax.tag.hex()
        }
      },
      {
        name: 'Markup Raw Inline',
        scope: ['text.html.markdown markup.inline.raw'],
        settings: {
          foreground: scheme.syntax.operator.hex()
        }
      },
      {
        name: 'Markdown - Line Break',
        scope: ['text.html.markdown meta.dummy.line-break'],
        settings: {
          background: scheme.syntax.comment.hex(),
          foreground: scheme.syntax.comment.hex()
        }
      },
      {
        name: 'Markdown - Raw Block Fenced',
        scope: ['punctuation.definition.markdown'],
        settings: {
          background: scheme.editor.fg.hex(),
          foreground: scheme.syntax.comment.hex()
        }
      }
    ],

    semanticHighlighting: true,
    semanticTokenColors: {
      'parameter.label': scheme.editor.fg.hex()
    }
  }
}


text:
package org.apache.spark.mllib.fpm

import scala.language.existentials

import org.apache.spark.SparkFunSuite
import org.apache.spark.mllib.util.MLlibTestSparkContext

class FPTreeSuite extends SparkFunSuite with MLlibTestSparkContext {

  test("add transaction") {
    val tree = new FPTree[String]
      .add(Seq("a", "b", "c"))
      .add(Seq("a", "b", "y"))
      .add(Seq("b"))

    assert(tree.root.children.size == 2)
    assert(tree.root.children.contains("a"))
    assert(tree.root.children("a").item.equals("a"))
    assert(tree.root.children("a").count == 2)
    assert(tree.root.children.contains("b"))
    assert(tree.root.children("b").item.equals("b"))
    assert(tree.root.children("b").count == 1)
    var child = tree.root.children("a")
    assert(child.children.size == 1)
    assert(child.children.contains("b"))
    assert(child.children("b").item.equals("b"))
    assert(child.children("b").count == 2)
    child = child.children("b")
    assert(child.children.size == 2)
    assert(child.children.contains("c"))
    assert(child.children.contains("y"))
    assert(child.children("c").item.equals("c"))
    assert(child.children("y").item.equals("y"))
    assert(child.children("c").count == 1)
    assert(child.children("y").count == 1)
  }

  test("merge tree") {
    val tree1 = new FPTree[String]
      .add(Seq("a", "b", "c"))
      .add(Seq("a", "b", "y"))
      .add(Seq("b"))

    val tree2 = new FPTree[String]
      .add(Seq("a", "b"))
      .add(Seq("a", "b", "c"))
      .add(Seq("a", "b", "c", "d"))
      .add(Seq("a", "x"))
      .add(Seq("a", "x", "y"))
      .add(Seq("c", "n"))
      .add(Seq("c", "m"))

    val tree3 = tree1.merge(tree2)

    assert(tree3.root.children.size == 3)
    assert(tree3.root.children("a").count == 7)
    assert(tree3.root.children("b").count == 1)
    assert(tree3.root.children("c").count == 2)
    val child1 = tree3.root.children("a")
    assert(child1.children.size == 2)
    assert(child1.children("b").count == 5)
    assert(child1.children("x").count == 2)
    val child2 = child1.children("b")
    assert(child2.children.size == 2)
    assert(child2.children("y").count == 1)
    assert(child2.children("c").count == 3)
    val child3 = child2.children("c")
    assert(child3.children.size == 1)
    assert(child3.children("d").count == 1)
    val child4 = child1.children("x")
    assert(child4.children.size == 1)
    assert(child4.children("y").count == 1)
    val child5 = tree3.root.children("c")
    assert(child5.children.size == 2)
    assert(child5.children("n").count == 1)
    assert(child5.children("m").count == 1)
  }

  test("extract freq itemsets") {
    val tree = new FPTree[String]
      .add(Seq("a", "b", "c"))
      .add(Seq("a", "b", "y"))
      .add(Seq("a", "b"))
      .add(Seq("a"))
      .add(Seq("b"))
      .add(Seq("b", "n"))

    val freqItemsets = tree.extract(3L).map { case (items, count) =>
      (items.toSet, count)
    }.toSet
    val expected = Set(
      (Set("a"), 4L),
      (Set("b"), 5L),
      (Set("a", "b"), 3L))
    assert(freqItemsets === expected)
  }
}


text:
[//000000001]: # (grammar::me::util \- Grammar operations and usage)
[//000000002]: # (Generated from file 'me\_util\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright © 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (grammar::me::util\(n\) 0\.1 tcllib "Grammar operations and usage")

 [ Main Table Of Contents | Table Of Contents | Keyword Index | Categories | Modules | Applications ]

# NAME

grammar::me::util \- AST utilities

# Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [Bugs, Ideas, Feedback](#section2)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# SYNOPSIS

package require Tcl 8\.4
package require grammar::me::util ?0\.1?

[__::grammar::me::util::ast2tree__ *ast* *tree* ?*root*?](#1)
[__::grammar::me::util::ast2etree__ *ast* *mcmd* *tree* ?*root*?](#2)
[__mcmd__ __lc__ *location*](#3)
[__mcmd__ __tok__ *from* ?*to*?](#4)
[__::grammar::me::util::tree2ast__ *tree* ?*root*?](#5)

# DESCRIPTION

This package provides a number of utility command for the conversion between the
various representations of abstract syntax trees as specified in the document
__[grammar::me\_ast](me\_ast\.md)__\.

  - __::grammar::me::util::ast2tree__ *ast* *tree* ?*root*?

    This command converts an *ast* from value to object representation\. All
    nodes in the *ast* will be converted into nodes of this *tree*, with the
    root of the AST a child of the node *root*\. If this node is not explicitly
    specified the root of the tree is used\. Existing content of tree is not
    touched, i\.e\. neither removed nor changed, with the exception of the
    specified root node, which will gain a new child\.

  - __::grammar::me::util::ast2etree__ *ast* *mcmd* *tree* ?*root*?

    This command is like __::grammar::me::util::ast2tree__, except that the
    result is in the extended object representation of the input AST\. The source
    of the extended information is the command prefix *mcmd*\. It has to
    understand two methods, __lc__, and __tok__, with the semantics
    specified below\.

      * __mcmd__ __lc__ *location*

        Takes the location of a token given as offset in the input stream and
        return a 2\-element list containing the associated line number and column
        index, in this order\.

      * __mcmd__ __tok__ *from* ?*to*?

        Takes one or two locations *from* and *to* as offset in the input
        stream and returns a Tcl list containing the specified part of the input
        stream\. Both location are inclusive\. If *to* is not specified it will
        default to the value of *from*\.

        Each element of the returned list is a list containing the token, its
        associated lexeme, the line number, and column index, in this order\.

    Both the ensemble command __::grammar::me::tcl__ provided by the package
    __[grammar::me::tcl](me\_tcl\.md)__ and the objects command created by
    the package __::grammar::me::cpu__ fit the above specification\.

  - __::grammar::me::util::tree2ast__ *tree* ?*root*?

    This command converts an *ast* in \(extended\) object representation into a
    value and returns it\. If a *root* node is specified the AST is generated
    from that node downward\. Otherwise the root of the tree object is used as
    the starting point\.

# Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *grammar\_me* of the
[Tcllib Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report
any ideas for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# KEYWORDS

[abstract syntax tree](\.\./\.\./\.\./\.\./index\.md\#abstract\_syntax\_tree), [syntax
tree](\.\./\.\./\.\./\.\./index\.md\#syntax\_tree),
[tree](\.\./\.\./\.\./\.\./index\.md\#tree)

# CATEGORY

Grammars and finite automata

# COPYRIGHT

Copyright © 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>


text:
<?php

/**
 * @file
 * Contains \Drupal\Core\Session\SessionManagerInterface.
 */

namespace Drupal\Core\Session;

use Symfony\Component\HttpFoundation\Session\Storage\SessionStorageInterface;

/**
 * Defines the session manager interface.
 */
interface SessionManagerInterface extends SessionStorageInterface {

  /**
   * Ends a specific user's session(s).
   *
   * @param int $uid
   *   User ID.
   */
  public function delete($uid);

  /**
   * Determines whether to save session data of the current request.
   *
   * @return bool
   *   FALSE if writing session data has been disabled. TRUE otherwise.
   */
  public function isEnabled();

  /**
   * Temporarily disables saving of session data.
   *
   * This function allows the caller to temporarily disable writing of
   * session data, should the request end while performing potentially
   * dangerous operations, such as manipulating the global $user object.
   *
   * @see https://drupal.org/node/218104
   *
   * @return $this
   */
  public function disable();

  /**
   * Re-enables saving of session data.
   *
   * @return $this
   */
  public function enable();

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
        xmlns:android="http://schemas.android.com/apk/res/android"
        id="org.surpass.cordova.CallphonePlugin"
        version="1.0.0">

    <name>Callphone Plugin</name>
    <description>Callphone for cordova plugin</description>
    <author>lizc</author>
    <keywords>Callphone</keywords>
    <license>Apache 2.0 License</license>

    <engines>
        <engine name="cordova" version=">=3.0"/>
    </engines>

    <js-module src="www/CallphonePlugin.js" name="CallphonePlugin">
            <clobbers target="window.plugins.callphonePlugin"/>
    </js-module>

    <!-- android -->
    <platform name="android">

        <config-file target="res/xml/config.xml" parent="/*">
            <feature name="CallphonePlugin">
                <param name="android-package" value="org.surpass.cordova.CallphonePlugin"/>
            </feature>
        </config-file>
         <config-file target="AndroidManifest.xml" parent="/manifest">
				    <uses-permission android:name="android.permission.CALL_PHONE" />
				  <uses-permission android:name="android.permission.READ_CALL_LOG" />
				  <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
				  <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
        </config-file>
        <source-file src="src/android/CallphonePlugin.java" target-dir="src/org/surpass/cordova"/>
        <source-file src="src/android/PhoneResult.java" target-dir="src/org/surpass/cordova"/>

	</platform>
</plugin>


text:
@interface FMSCoffeeShop ()

@end

@implementation FMSCoffeeShop

-(instancetype)initWithName:(NSString *)storeName rating:(NSString *)address Lat:(double)lat andLng:(double)lng
{
    self = [super init];

    if (self) {
        _cofeeShopName = storeName;
        _storeAddress = address;
        _lat = lat;
        _lng = lng;
    }

    return self;
}

#pragma mark -
#pragma mark MKAnnotation Methods
- (NSString *)title
{
    return self.cofeeShopName;
}

- (NSString *)subtitle
{
    return self.storeAddress;
}

- (CLLocationCoordinate2D)coordinate
{
    CLLocationCoordinate2D coord;
    coord.latitude = self.lat;
    coord.longitude = self.lng;
    return coord;
}
@end


text:
<!doctype html>

    <meta charset="utf-8">
    <title></title>
    <meta name="description" content="">
    <meta name="viewport" content="width=device-width">

    <link rel="stylesheet" href="bower_components/bootstrap/dist/css/bootstrap.css" />

    <link rel="stylesheet" href="styles/main.css">
    <link rel="stylesheet" href="styles/base.css">

Home

Participants

About Author


text: A T4SubCategoryTest is a test class for testing the behavior of T4SubCategory


text:
package com.intellij.debugger.engine;

import com.intellij.debugger.engine.evaluation.EvaluateException;
import com.intellij.debugger.impl.DebuggerUtilsEx;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.Computable;
import com.intellij.psi.*;
import com.intellij.util.Range;
import com.sun.jdi.Location;
import com.sun.jdi.Method;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * @author Eugene Zhuravlev
 *         Date: 10/26/13
 */
public class BasicStepMethodFilter implements NamedMethodFilter {
  private static final Logger LOG = Logger.getInstance(BasicStepMethodFilter.class);

  @NotNull
  protected final JVMName myDeclaringClassName;
  @NotNull
  private final String myTargetMethodName;
  @Nullable
  protected final JVMName myTargetMethodSignature;
  private final Range<Integer> myCallingExpressionLines;

  public BasicStepMethodFilter(@NotNull PsiMethod psiMethod, Range<Integer> callingExpressionLines) {
    this(JVMNameUtil.getJVMQualifiedName(psiMethod.getContainingClass()),
         JVMNameUtil.getJVMMethodName(psiMethod),
         JVMNameUtil.getJVMSignature(psiMethod),
         callingExpressionLines);
  }

  protected BasicStepMethodFilter(@NotNull JVMName declaringClassName,
                                  @NotNull String targetMethodName,
                                  @Nullable JVMName targetMethodSignature,
                                  Range<Integer> callingExpressionLines) {
    myDeclaringClassName = declaringClassName;
    myTargetMethodName = targetMethodName;
    myTargetMethodSignature = targetMethodSignature;
    myCallingExpressionLines = callingExpressionLines;
  }

  @NotNull
  public String getMethodName() {
    return myTargetMethodName;
  }

  public boolean locationMatches(final DebugProcessImpl process, final Location location) throws EvaluateException {
    final Method method = location.method();
    boolean lambdaMatched = false;
    String name = method.name();
    if (!myTargetMethodName.equals(name)) {
      if (LambdaMethodFilter.isLambdaName(name)) {
        lambdaMatched = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
          @Override
          public Boolean compute() {
            PsiParameterListOwner psiMethod = DebuggerUtilsEx.getContainingMethod(process.getPositionManager().getSourcePosition(location));
            if (psiMethod instanceof PsiLambdaExpression) {
              PsiType type = ((PsiLambdaExpression)psiMethod).getFunctionalInterfaceType();
              PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(type);
              if (type != null && interfaceMethod != null && myTargetMethodName.equals(interfaceMethod.getName())) {
                try {
                  return type.getCanonicalText().equals(myDeclaringClassName.getName(process).replace('$', '.'));
                }
                catch (EvaluateException e) {
                  LOG.info(e);
                }
              }
            }
            return false;
          }
        });
      }
      if (!lambdaMatched) return false;
    }
    if (myTargetMethodSignature != null) {
      if (!signatureMatches(method, myTargetMethodSignature.getName(process))) {
        return false;
      }
    }
    return lambdaMatched || DebuggerUtilsEx.isAssignableFrom(myDeclaringClassName.getName(process), location.declaringType());
  }

  private static boolean signatureMatches(Method method, final String expectedSignature) throws EvaluateException {
    if (expectedSignature.equals(method.signature())) {
      return true;
    }
    // check if there are any bridge methods that match
    for (Method candidate : method.declaringType().methodsByName(method.name())) {
      if (candidate != method && candidate.isBridge() && expectedSignature.equals(candidate.signature())) {
        return true;
      }
    }
    return false;
  }

  @Nullable
  @Override
  public Range<Integer> getCallingExpressionLines() {
    return myCallingExpressionLines;
  }
}


text:
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Windows.Controls;
using RocketProfiler.UI.ViewModels;

namespace RocketProfiler.UI.Views
{
    /// <summary>
    ///     Interaction logic for TemperatureSensorWidget.xaml
    /// </summary>
    public partial class TemperatureSensorWidget : UserControl
    {
        public TemperatureSensorWidget(TemperatureSensorWidgetViewModel viewModel)
        {
            InitializeComponent();
            DataContext = viewModel;
        }
    }
}