text:
package myLine;

import java.lang.reflect.Method;

import javax.swing.JFrame;
import javax.swing.JTextArea;

public class Line {

	//fields
	protected int size;
	protected char pattern;
	protected boolean framese = true;

	//default constructor
	public Line()
	{
		size = 50;
		pattern = '*';
	}

	//parameterised constructor
	public Line (int s, char p )
	{
		size = s;
		pattern = p;

	}
	//setters = mutator methods
	public void setSize(int s)
	{
		size=s;
	}

	public void setpattern(char p)
	{
		pattern = p;
	}

	//method to draw a line
	//1: shared: public = shared to all
	//		  	 protected = shared with the
	//			 private = not shared
	//2: Does it return something
	//			 void = return nothing, only does something
	//			 if it does return something = state the data type
	//3: name of the method
	//4: BRACKETS
	//5: anything sent in to the method goes into the barckets
	public void drawLine()
	{
		String out="";

		//frame
		JFrame frame = new JFrame ();
		JTextArea txt = new JTextArea();

		frame.add(txt);
		frame.setSize(250,250);
		frame.setTitle("Draw LINE !!!!!!!!!!!!");

		for (int i=1;i<=size;i++)
		{
			out+=pattern;
		}
		frame.setVisible(framese);
		txt.setText(out);

	}

	//method 2 make a line and send it to the other side
	//1: shared: public = shared to all
	//		  	 protected = shared with the
	//			 private = not shared
	//2: Does it return something
	//			 void = return nothing, only does something
	//			 if it does return something = state the data type
	//3: name of the method
	//4: BRACKETS
	//5: anything sent in to the method goes into the barckets
	public String makeLine()
	{
		String out="";

		for (int i=1;i<=size;i++)
		{
			out+=pattern;
		}

		return out;
	}
	public String doubleLine()
	{
		return makeLine()+ "\n"+makeLine();

	}
	public String square()
	{
		String out = "";
		for (int i=1; i<size;i++)
		{
			out+=makeLine()+"\n";
		}
		return out;
	}
	public String rectangle(int height)
	{
		String out = "";
		for (int i=1; i<height;i++)
		{
			out+=makeLine()+"\n";
		}
		return out;
	}

}


text:
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var core_1 = require("@angular/core");
var platform_browser_1 = require("@angular/platform-browser");
var forms_1 = require("@angular/forms");
var http_1 = require("@angular/http");
var app_routing_module_1 = require("./app-routing.module");
//Components
var app_component_1 = require("./Components/AppComponent/app.component");
var assign_task_component_1 = require("./Components/AssignTaskComponent/assign-task.component");
var all_details_component_1 = require("./Components/AllDetailsComponent/all-details.component");
var notification_component_1 = require("./Components/NotificationComponent/notification.component");
var user_search_component_1 = require("./Components/UserSearchComponent/user-search.component");
var login_component_1 = require("./Components/LoginComponent/login.component");
var dashboard_component_1 = require("./Components/DashboardComponent/dashboard.component");
var task_list_component_1 = require("./Components/TaskListComponent/task-list.component");
var person_name_component_1 = require("./Components/PersonNameComponent/person-name.component");
var person_selector_component_1 = require("./Components/PersonSelectorComponent/person-selector.component");
//Services
var user_service_1 = require("./Services/UserService/user.service");
var task_service_1 = require("./Services/TaskService/task.service");
var sync_service_service_1 = require("./Services/SyncService/sync-service.service");
var auth_service_service_1 = require("./Services/AuthService/auth-service.service");
var notification_service_1 = require("./Services/NotificationService/notification.service");
var auth_guard_1 = require("./auth.guard");
var AppModule = (function () {
    function AppModule() {
    }
    return AppModule;
}());
AppModule = __decorate([
    core_1.NgModule({
        imports: [
            platform_browser_1.BrowserModule,
            forms_1.FormsModule,
            http_1.HttpModule,
            app_routing_module_1.AppRoutingModule
        ],
        declarations: [
            app_component_1.AppComponent,
            assign_task_component_1.AssignTaskComponent,
            user_search_component_1.UserSearchComponent,
            all_details_component_1.AllDetailsComponent,
            login_component_1.LoginComponent,
            dashboard_component_1.DashboardComponent,
            task_list_component_1.TaskListComponent,
            notification_component_1.NotificationComponent,
            person_name_component_1.PersonNameComponent,
            person_selector_component_1.PersonSelectorComponent
        ],
        providers: [user_service_1.UserService, task_service_1.TaskService, sync_service_service_1.SyncService, auth_service_service_1.AuthService, notification_service_1.NotificationService, auth_guard_1.AuthGuard],
        bootstrap: [app_component_1.AppComponent]
    })
], AppModule);
exports.AppModule = AppModule;
//# sourceMappingURL=app.module.js.map

redpajama_set_name: RedPajamaGithub


text:
import vcf
import logging

log = logging.getLogger(__name__)

class StreamEditor(object):
    indices = None

    output_columns = None

    def __init__(self, fin, indices=None, indel='\t', outdel=None,
                 encoding='utf-8'):
        self.fin = fin

        # Input delimiter, output delimiter, default to the same output
        # delimiter if none is defined.
        self.indel = indel
        if outdel is None:
            outdel = indel
        self.outdel = outdel

        # The first iteration will populate the indices if not defined
        self.indices = indices or self.indices

        # Encoding of the input file
        self.encoding = encoding

    def process_column(self, idx, value):
        "Process a single column."
        if value is not None:
            value = str(value).decode(self.encoding)
        return value

    def process_line(self, line):
        "Process a single complete line."
        cleaned = []
        columns = line.split(self.indel)
        # Populate indices if not defined
        if not self.indices:
            self.indices = range(len(columns))
        for i in self.indices:
            # Support turning an in col into multiple out cols
            out = self.process_column(i, columns[i])
            if isinstance(out, (list, tuple)):
                cleaned.extend(out)
            else:
                cleaned.append(out)
        return self.outdel.join(cleaned) + '\n'

    def read(self, size=-1):
        "Reads up to size bytes, but always completes the last line."
        buf = self.fin.read(size)
        if not buf:
            return ''
        lines = buf.splitlines()
        # Read the rest of the last line if necessary
        if not buf.endswith('\n'):
            last = lines.pop()
            partial = self.fin.readline()
            lines.append(last + partial)
        # Process the lines, concatenate them
        lines = [self.process_line(line.rstrip('\n')) for line in lines]
        return ''.join(lines)

    def readline(self, size=-1):
        "The size is ignored since a complete line must be read."
        line = self.fin.readline()
        if not line:
            return ''
        return self.process_line(line.rstrip('\n'))

NULL_VALUES = ('.', '', 'null', 'NA', 'N/A', 'NONE')

class VCFStreamEditor(StreamEditor):
    vcf_fields = []

    info_fields = []

    def __init__(self, *args, **kwargs):
        super(VCFStreamEditor, self).__init__(*args, **kwargs)
        self.reader = vcf.VCFReader(self.fin)

    def _clean_value(self, value):
        if isinstance(value, (tuple, list)):
            return ','.join([str(x) for x in value if x is not None])
        if value is not None:
            value = str(value)
            if value in NULL_VALUES:
                value = None
        return value

    def process_column(self, key, value):
        value = self._clean_value(value)
        return super(VCFStreamEditor, self).process_column(key, value)

    def process_line(self, record):
        "Process a single record. This assumes only a single sample output."
        cleaned = []

        for key in self.vcf_fields:
            out = self.process_column(key, getattr(record, key))
            if isinstance(out, (list, tuple)):
                cleaned.extend(out)
            else:
                cleaned.append(out)

        for key in self.info_fields:
            out = self.process_column(key, record.INFO.get(key, None))
            if isinstance(out, (list, tuple)):
                cleaned.extend(out)
            else:
                cleaned.append(out)

        return cleaned

    def read(self, size=-1):
        """Read `size` bytes from the reader relative to the parsed output.
        This is generally acceptable in practice since VCF lines are
        condensed, but if the output line <<< record, this means the actual
        memory used will be much greater than `size`.
        """
        lines = []
        parsed_size = 0

        while True:
            line = self.readline()
            if not line:
                break
            lines.append(line)
            parsed_size += len(line)
            if size and size > 0 and parsed_size >= size:
                break

        return ''.join(lines)

    def readline(self, size=-1):
        "Ignore the `size` since a complete line must be processed."
        try:
            record = next(self.reader)
            return self.outdel.join(self.process_line(record)) + '\n'
        except StopIteration:
            return ''

class PGCopyEditor(StreamEditor):
    """Ensures NoneTypes are represented as the standard \N string and tabs
    are used as the default delimiter for the output.
    """
    def __init__(self, *args, **kwargs):
        super(PGCopyEditor, self).__init__(*args, **kwargs)
        self.null = kwargs.get('null', '\\N')

    def process_column(self, idx, value):
        value = super(PGCopyEditor, self).process_column(idx, value)
        if value is None:
            value = self.null
        return value

class VCFPGCopyEditor(VCFStreamEditor):
    def __init__(self, *args, **kwargs):
        super(VCFPGCopyEditor, self).__init__(*args, **kwargs)
        self.null = kwargs.get('null', '\\N')

    def process_column(self, key, value):
        value = super(VCFPGCopyEditor, self).process_column(key, value)
        if value is None:
            value = self.null
        return value


text:
package ca.kanoa.lopixel.utils;

import java.util.logging.Level;

import org.bukkit.Bukkit;

public class Log {

	public static void stats(String message) {
		log(message, Level.FINE);
	}

	public static void info(String message) {
		log(message, Level.INFO);
	}

	public static void warning(String message) {
		log(message, Level.WARNING);
	}

	public static void error(String message) {
		log(message, Level.SEVERE);
	}

	private static void log(String message, Level level) {
		Bukkit.getLogger().log(level, message);
	}

}


text:
package com.hp.autonomy.types.requests.idol.actions.term.params;

/**
 * Parameters for the TermGetInfo action.
 */
public enum TermGetInfoParams {
    Boolean,
    DetectLanguageType,
    MatchID,
    MatchReference,
    MaxTerms,
    MinDocOccs,
    MinTermLength,
    OnlyExisting,
    OutputEncoding,
    ReferenceField,
    StateMatchID,
    Stemming,
    Synchronous,
    TermPositions,
    Text,
    TextParse,
    Type,
    Weights
}


text:
#ifndef UTIL_LINUX_MANGLE_H
#define UTIL_LINUX_MANGLE_H

/*
 * Functions for \oct encoding used in mtab/fstab/swaps/etc.
 */

extern char *mangle(const char *s);

extern void unmangle_to_buffer(const char *s, char *buf, size_t len);
void unhexmangle_to_buffer(const char *s, char *buf, size_t len);

extern char *unmangle(const char *s, char **end);

static inline void unmangle_string(char *s)
{
	unmangle_to_buffer(s, s, strlen(s) + 1);
}

static inline void unhexmangle_string(char *s)
{
	unhexmangle_to_buffer(s, s, strlen(s) + 1);
}

#endif /* UTIL_LINUX_MANGLE_H */


text:
"""
Tests for L{twisted.scripts.mktap}.
"""

import sys
try:
    import pwd, grp
except ImportError:
    pwd = None

from twisted.trial.unittest import TestCase

from twisted.scripts.mktap import run, getid, loadPlugins
from twisted.application.service import IProcess, loadApplication
from twisted.test.test_twistd import patchUserDatabase
from twisted.plugins.twisted_ftp import TwistedFTP

class RunTests(TestCase):
    """
    Tests for L{twisted.scripts.mktap.run}.
    """
    def setUp(self):
        """
        Save the original value of L{sys.argv} so that tests can change it
        as necessary.
        """
        self.argv = sys.argv[:]

    def tearDown(self):
        """
        Restore the original value of L{sys.argv}.
        """
        sys.argv[:] = self.argv

    def _saveConfiguredIDTest(self, argv, uid, gid):
        """
        Test that when L{run} is invoked and L{sys.argv} has the given
        value, the resulting application has the specified UID and GID.

        @type argv: C{list} of C{str}
        @param argv: The value to which to set L{sys.argv} before calling L{run}.

        @type uid: C{int}
        @param uid: The expected value for the resulting application's
            L{IProcess.uid}.

        @type gid: C{int}
        @param gid: The expected value for the resulting application's
            L{IProcess.gid}.
        """
        sys.argv = argv
        run()
        app = loadApplication("ftp.tap", "pickle", None)
        process = IProcess(app)
        self.assertEqual(process.uid, uid)
        self.assertEqual(process.gid, gid)

    def test_getNumericID(self):
        """
        L{run} extracts numeric UID and GID information from the command
        line and persists it with the application object.
        """
        uid = 1234
        gid = 4321
        self._saveConfiguredIDTest(
            ["mktap", "--uid", str(uid), "--gid", str(gid), "ftp"],
            uid, gid)

    def test_getNameID(self):
        """
        L{run} extracts name UID and GID information from the command
        line and persists it with the application object.
        """
        user = "foo"
        uid = 1234
        group = "bar"
        gid = 4321
        patchUserDatabase(self.patch, user, uid, group, gid)
        self._saveConfiguredIDTest(
            ["mktap", "--uid", user, "--gid", group, "ftp"],
            uid, gid)
    if pwd is None:
        test_getNameID.skip = (
            "Username/UID Group name/GID translation requires pwd and grp "
            "modules.")

class HelperTests(TestCase):
    """
    Tests for miscellaneous utility functions related to mktap.
    """
    def test_getid(self):
        """
        L{getid} returns a two-tuple of integers giving the numeric values of
        the strings it is passed.
        """
        uid = 1234
        gid = 4321
        self.assertEqual(getid(str(uid), str(gid)), (uid, gid))

    def test_loadPlugins(self):
        """
        L{loadPlugins} returns a C{dict} mapping tap names to tap plugins.
        """
        plugins = loadPlugins()
        self.assertTrue(plugins, "There should be at least one plugin.")
        # Make sure the mapping is set up properly.
        for k, v in plugins.iteritems():
            self.assertEqual(k, v.tapname)

        # Make sure one of the always-available builtin plugins is there.
        self.assertIdentical(plugins['ftp'], TwistedFTP)


text:
package com.englishtown.promises.impl;

import javax.inject.Inject;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Asynchronous executor that uses a fixed thread pool
 */
public class AsyncExecutor implements Executor {

    private ExecutorService executorService = Executors.newFixedThreadPool(20);

    @Inject
    public AsyncExecutor() {

    }

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws java.util.concurrent.RejectedExecutionException if this task cannot be
     *                                                         accepted for execution
     * @throws NullPointerException                            if command is null
     */
    @Override
    public void execute(Runnable command) {
        executorService.execute(command);
    }
}


text:
This work is licensed under the Creative Commons CC0 License
---

## Verifier support for Interface message parameters of type `inst_ref` and `inst_ref-set`

### xtUML Project Design Note

### 1. Abstract

With support for Package References available, it is now possible to use shared class in different components of an application.
If instance data is to be passed between components it is convenient to use paramters of type inst_ref and inst_ref_set as hitherto
have been available for within-component communication.

This capability is supported by the BridgePoint Editor but as yet has no execution support within Verifier.
This work aims to remedy that.

### 2. document References

https://support.onefact.net/issues/12222

https://support.onefact.net/issues/12191

### 3. Background

### 4. Requirements

When an instance is referenced as a parameter value in a send message - interface Operation or Signal - a replica of that instance
should be created and added to the instance population in the context of the receiving component. All attribute values, including
`current_state` if appropriate, but excluding any instance referencing attribute values should be copied to the newly-created instance.

Note: there is no requirement to treat receipt of a duplicate instance in any special way. It is the responsibility of the reciever
to detect such a case and handle it appropriately.

### 5. Analysis

The code which processes parameter setup for invocation of either Interface Operation or Signal must be elaborated to detect the case
where the parameter is a reference and arrange for creation of a replica instance and copying of attribute values.

In parameter setup, the receiving parameter must be established as a reference type which can be associated with one or more Local
instance-in-reference (L_IIR) instances: cardinality differs between `inst_ref` and `inst_ref_set`. The replica instance(s) must be created
and related to the execution context. Attribute values must be copied. Note that `current_state` is represented by an association rather
than an attribute.

### 6. Design

A combination of code analysis by examination, tracing of behavior with a debugger, and experimenting with code changes will be used to
determine what modifications are required.

### 7. Design Comments

Interface Operation parameters are handled somewhat differently than Signal parameters. Furthermore Interface Operations which have a return
value are treated differently; three code segments exist which are similar but not identical. For now, the choice has been to separately
elaborate these code segments to handle instance replication rather than attempt any re-factoring.

See
SignalInvocation::setupParameterValues()

ComponentInstance::transferValueToTarget()

Value::Message Value.getValue()

### 8. Documentation

None

### 9. Unit Test

A test which exercises a variety of data-passing scenarios has been implemented and run successfully.

See models/VamdMC/VerifierTest/Verify12222

### End


text:
@class NSString;
@protocol NSCopying;

@interface _DVTPlugInDescriptor : NSObject
{
    NSString *_type;
    NSString *_name;
    id <NSCopying> _version;
    NSString *_identifier;
    id _other;
}

- (void).cxx_destruct;
@property(retain) id other; // @synthesize other=_other;
@property(copy) NSString *identifier; // @synthesize identifier=_identifier;
@property(copy) id <NSCopying> version; // @synthesize version=_version;
@property(copy) NSString *name; // @synthesize name=_name;
@property(copy) NSString *type; // @synthesize type=_type;
- (id)description;
- (BOOL)isEqual:(id)arg1;
- (unsigned long long)hash;

@end


text:
package main

import (
	"github.com/quintans/grapevine"
	"github.com/quintans/grapevine/examples/echo"
	"github.com/quintans/toolkit"
	"github.com/quintans/toolkit/log"
)

func init() {
	log.Register("/", log.INFO).ShowCaller(true)
}

func main() {
	var config grapevine.Config
	if err := toolkit.LoadConfiguration(&config, "echo-service.json", true); err != nil {
		panic(err)
	}
	var logger = log.LoggerFor("echo-service")
	var peer = grapevine.NewPeer(config)
	peer.SetLogger(logger)
	peer.Handle(shared.SERVICE_ECHO, func(greeting string) string {
		return "Hi " + greeting + "!"
	})

	if err := <-peer.Bind(); err != nil {
		panic(err)
	}
}


text:
title: "Windows"

sub-nav-id: windows
sub-nav-group: streaming
sub-nav-pos: 3
---

* This will be replaced by the TOC
{:toc}

## Windows on Keyed Data Streams

Flink offers a variety of methods for defining windows on a `KeyedStream`. All of these group elements *per key*,
i.e., each window will contain elements with the same key value.

### Basic Window Constructs

Flink offers a general window mechanism that provides flexibility, as well as a number of pre-defined windows
for common use cases. See first if your use case can be served by the pre-defined windows below before moving
to defining your own windows.

      Transformation
      Description

        Tumbling time window
KeyedStream → WindowedStream

          Defines a window of 5 seconds, that "tumbles". This means that elements are
          grouped according to their timestamp in groups of 5 second duration, and every element belongs to exactly one window.
	  The notion of time is specified by the selected TimeCharacteristic (see time).
    {% highlight java %}
keyedStream.timeWindow(Time.seconds(5));
    {% endhighlight %}

          Sliding time window
KeyedStream → WindowedStream

             Defines a window of 5 seconds, that "slides" by 1 seconds. This means that elements are
             grouped according to their timestamp in groups of 5 second duration, and elements can belong to more than
             one window (since windows overlap by at most 4 seconds)
             The notion of time is specified by the selected TimeCharacteristic (see time).
      {% highlight java %}
keyedStream.timeWindow(Time.seconds(5), Time.seconds(1));
      {% endhighlight %}

        Tumbling count window
KeyedStream → WindowedStream

          Defines a window of 1000 elements, that "tumbles". This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element belongs to exactly one window.
    {% highlight java %}
keyedStream.countWindow(1000);
    {% endhighlight %}

      Sliding count window
KeyedStream → WindowedStream

          Defines a window of 1000 elements, that "slides" every 100 elements. This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element can belong to more than one window (as windows overlap by at most 900 elements).
  {% highlight java %}
keyedStream.countWindow(1000, 100)
  {% endhighlight %}

      Transformation
      Description

        Tumbling time window
KeyedStream → WindowedStream

          Defines a window of 5 seconds, that "tumbles". This means that elements are
          grouped according to their timestamp in groups of 5 second duration, and every element belongs to exactly one window.
          The notion of time is specified by the selected TimeCharacteristic (see time).
    {% highlight scala %}
keyedStream.timeWindow(Time.seconds(5))
    {% endhighlight %}

          Sliding time window
KeyedStream → WindowedStream

             Defines a window of 5 seconds, that "slides" by 1 seconds. This means that elements are
             grouped according to their timestamp in groups of 5 second duration, and elements can belong to more than
             one window (since windows overlap by at most 4 seconds)
             The notion of time is specified by the selected TimeCharacteristic (see time).
      {% highlight scala %}
keyedStream.timeWindow(Time.seconds(5), Time.seconds(1))
      {% endhighlight %}

        Tumbling count window
KeyedStream → WindowedStream

          Defines a window of 1000 elements, that "tumbles". This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element belongs to exactly one window.
    {% highlight scala %}
keyedStream.countWindow(1000)
    {% endhighlight %}

      Sliding count window
KeyedStream → WindowedStream

          Defines a window of 1000 elements, that "slides" every 100 elements. This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element can belong to more than one window (as windows overlap by at most 900 elements).
  {% highlight scala %}
keyedStream.countWindow(1000, 100)
  {% endhighlight %}

### Advanced Window Constructs

The general mechanism can define more powerful windows at the cost of more verbose syntax. For example,
below is a window definition where windows hold elements of the last 5 seconds and slides every 1 second,
but the execution of the window function is triggered when 100 elements have been added to the
window, and every time execution is triggered, 10 elements are retained in the window:

{% highlight java %}
keyedStream
    .window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1))
    .trigger(CountTrigger.of(100))
    .evictor(CountEvictor.of(10));
{% endhighlight %}

{% highlight scala %}
keyedStream
    .window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1))
    .trigger(CountTrigger.of(100))
    .evictor(CountEvictor.of(10))
{% endhighlight %}

The general recipe for building a custom window is to specify (1) a `WindowAssigner`, (2) a `Trigger` (optionally),
and (3) an `Evictor` (optionally).

The `WindowAssigner` defines how incoming elements are assigned to windows. A window is a logical group of elements
that has a begin-value, and an end-value corresponding to a begin-time and end-time. Elements with timestamp (according
to some notion of time described above within these values are part of the window).

For example, the `SlidingEventTimeWindows`
assigner in the code above defines a window of size 5 seconds, and a slide of 1 second. Assume that
time starts from 0 and is measured in milliseconds. Then, we have 6 windows
that overlap: [0,5000], [1000,6000], [2000,7000], [3000, 8000], [4000, 9000], and [5000, 10000]. Each incoming
element is assigned to the windows according to its timestamp. For example, an element with timestamp 2000 will be
assigned to the first three windows. Flink comes bundled with window assigners that cover the most common use cases. You can write your
own window types by extending the `WindowAssigner` class.

      Transformation
      Description

        Global window
KeyedStream → WindowedStream

	    All incoming elements of a given key are assigned to the same window.
	    The window does not contain a default trigger, hence it will never be triggered
	    if a trigger is not explicitly specified.

    {% highlight java %}
stream.window(GlobalWindows.create());
    {% endhighlight %}

        Tumbling time windows
KeyedStream → WindowedStream

            Incoming elements are assigned to a window of a certain size (1 second below) based on
            their timestamp. Windows do not overlap, i.e., each element is assigned to exactly one window.
            This assigner comes with a default trigger that fires for a window when a
            watermark with value higher than its end-value is received.

      {% highlight java %}
stream.window(TumblingEventTimeWindows.of(Time.seconds(1)));
      {% endhighlight %}

        Sliding time windows
KeyedStream → WindowedStream

            Incoming elements are assigned to a window of a certain size (5 seconds below) based on
            their timestamp. Windows "slide" by the provided value (1 second in the example), and hence
            overlap. This assigner comes with a default trigger that fires for a window when a
	          watermark with value higher than its end-value is received.

    {% highlight java %}
stream.window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1)));
    {% endhighlight %}

          Tumbling processing time windows
KeyedStream → WindowedStream

              Incoming elements are assigned to a window of a certain size (1 second below) based on
              the current processing time. Windows do not overlap, i.e., each element is assigned to exactly one window.
              This assigner comes with a default trigger that fires for a window a window when the current
              processing time exceeds its end-value.

      {% highlight java %}
stream.window(TumblingProcessingTimeWindows.of(Time.seconds(1)));
      {% endhighlight %}

        Sliding processing time windows
KeyedStream → WindowedStream

            Incoming elements are assigned to a window of a certain size (5 seconds below) based on
            their timestamp. Windows "slide" by the provided value (1 second in the example), and hence
            overlap. This assigner comes with a default trigger that fires for a window a window when the current
            processing time exceeds its end-value.

    {% highlight java %}
stream.window(SlidingProcessingTimeWindows.of(Time.seconds(5), Time.seconds(1)));
    {% endhighlight %}

      Transformation
      Description

        Global window
KeyedStream → WindowedStream

            All incoming elements of a given key are assigned to the same window.
	    The window does not contain a default trigger, hence it will never be triggered
	    if a trigger is not explicitly specified.

    {% highlight scala %}
stream.window(GlobalWindows.create)
    {% endhighlight %}

          Tumbling time windows
KeyedStream → WindowedStream

             Incoming elements are assigned to a window of a certain size (1 second below) based on
            their timestamp. Windows do not overlap, i.e., each element is assigned to exactly one window.
            This assigner comes with a default trigger that fires for a window when a
            watermark with value higher than its end-value is received.

      {% highlight scala %}
stream.window(TumblingEventTimeWindows.of(Time.seconds(1)))
      {% endhighlight %}

        Sliding time windows
KeyedStream → WindowedStream

            Incoming elements are assigned to a window of a certain size (5 seconds below) based on
            their timestamp. Windows "slide" by the provided value (1 second in the example), and hence
            overlap. This assigner comes with a default trigger that fires for a window when a
            watermark with value higher than its end-value is received.

    {% highlight scala %}
stream.window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1)))
    {% endhighlight %}

          Tumbling processing time windows
KeyedStream → WindowedStream

              Incoming elements are assigned to a window of a certain size (1 second below) based on
              the current processing time. Windows do not overlap, i.e., each element is assigned to exactly one window.
              This assigner comes with a default trigger that fires for a window a window when the current
              processing time exceeds its end-value.

      {% highlight scala %}
stream.window(TumblingProcessingTimeWindows.of(Time.seconds(1)))
      {% endhighlight %}

        Sliding processing time windows
KeyedStream → WindowedStream

            Incoming elements are assigned to a window of a certain size (5 seconds below) based on
            their timestamp. Windows "slide" by the provided value (1 second in the example), and hence
            overlap. This assigner comes with a default trigger that fires for a window a window when the current
            processing time exceeds its end-value.

    {% highlight scala %}
stream.window(SlidingProcessingTimeWindows.of(Time.seconds(5), Time.seconds(1)))
    {% endhighlight %}

The `Trigger` specifies when the function that comes after the window clause (e.g., `sum`, `count`) is evaluated ("fires")
for each window. If a trigger is not specified, a default trigger for each window type is used (that is part of the
definition of the `WindowAssigner`). Flink comes bundled with a set of triggers if the ones that windows use by
default do not fit the application. You can write your own trigger by implementing the `Trigger` interface. Note that
specifying a trigger will override the default trigger of the window assigner.

      Transformation
      Description

    Processing time trigger

        A window is fired when the current processing time exceeds its end-value.
        The elements on the triggered window are henceforth discarded.

{% highlight java %}
windowedStream.trigger(ProcessingTimeTrigger.create());
{% endhighlight %}

    Watermark trigger

        A window is fired when a watermark with value that exceeds the window's end-value has been received.
        The elements on the triggered window are henceforth discarded.

{% highlight java %}
windowedStream.trigger(EventTimeTrigger.create());
{% endhighlight %}

    Continuous processing time trigger

        A window is periodically considered for being fired (every 5 seconds in the example).
        The window is actually fired only when the current processing time exceeds its end-value.
        The elements on the triggered window are retained.

{% highlight java %}
windowedStream.trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(5)));
{% endhighlight %}

    Continuous watermark time trigger

        A window is periodically considered for being fired (every 5 seconds in the example).
        A window is actually fired when a watermark with value that exceeds the window's end-value has been received.
        The elements on the triggered window are retained.

{% highlight java %}
windowedStream.trigger(ContinuousEventTimeTrigger.of(Time.seconds(5)));
{% endhighlight %}

    Count trigger

        A window is fired when it has more than a certain number of elements (1000 below).
        The elements of the triggered window are retained.

{% highlight java %}
windowedStream.trigger(CountTrigger.of(1000));
{% endhighlight %}

    Purging trigger

        Takes any trigger as an argument and forces the triggered window elements to be
        "purged" (discarded) after triggering.

{% highlight java %}
windowedStream.trigger(PurgingTrigger.of(CountTrigger.of(1000)));
{% endhighlight %}

    Delta trigger

        A window is periodically considered for being fired (every 5000 milliseconds in the example).
        A window is actually fired when the value of the last added element exceeds the value of
        the first element inserted in the window according to a `DeltaFunction`.

{% highlight java %}
windowedStream.trigger(new DeltaTrigger.of(5000.0, new DeltaFunction<Double>() {
    @Override
    public double getDelta (Double old, Double new) {
        return (new - old > 0.01);
    }
}));
{% endhighlight %}

      Transformation
      Description

    Processing time trigger

        A window is fired when the current processing time exceeds its end-value.
        The elements on the triggered window are henceforth discarded.

{% highlight scala %}
windowedStream.trigger(ProcessingTimeTrigger.create);
{% endhighlight %}

    Watermark trigger

        A window is fired when a watermark with value that exceeds the window's end-value has been received.
        The elements on the triggered window are henceforth discarded.

{% highlight scala %}
windowedStream.trigger(EventTimeTrigger.create);
{% endhighlight %}

    Continuous processing time trigger

        A window is periodically considered for being fired (every 5 seconds in the example).
        The window is actually fired only when the current processing time exceeds its end-value.
        The elements on the triggered window are retained.

{% highlight scala %}
windowedStream.trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(5)));
{% endhighlight %}

    Continuous watermark time trigger

        A window is periodically considered for being fired (every 5 seconds in the example).
        A window is actually fired when a watermark with value that exceeds the window's end-value has been received.
        The elements on the triggered window are retained.

{% highlight scala %}
windowedStream.trigger(ContinuousEventTimeTrigger.of(Time.seconds(5)));
{% endhighlight %}

    Count trigger

        A window is fired when it has more than a certain number of elements (1000 below).
        The elements of the triggered window are retained.

{% highlight scala %}
windowedStream.trigger(CountTrigger.of(1000));
{% endhighlight %}

    Purging trigger

        Takes any trigger as an argument and forces the triggered window elements to be
        "purged" (discarded) after triggering.

{% highlight scala %}
windowedStream.trigger(PurgingTrigger.of(CountTrigger.of(1000)));
{% endhighlight %}

    Delta trigger

        A window is periodically considered for being fired (every 5000 milliseconds in the example).
        A window is actually fired when the value of the last added element exceeds the value of
        the first element inserted in the window according to a `DeltaFunction`.

{% highlight scala %}
windowedStream.trigger(DeltaTrigger.of(5000.0, { (old,new) => new - old > 0.01 }))
{% endhighlight %}

After the trigger fires, and before the function (e.g., `sum`, `count`) is applied to the window contents, an
optional `Evictor` removes some elements from the beginning of the window before the remaining elements
are passed on to the function. Flink comes bundled with a set of evictors You can write your own evictor by
implementing the `Evictor` interface.

      Transformation
      Description

      Time evictor

         Evict all elements from the beginning of the window, so that elements from end-value - 1 second
         until end-value are retained (the resulting window size is 1 second).

  {% highlight java %}
triggeredStream.evictor(TimeEvictor.of(Time.seconds(1)));
  {% endhighlight %}

       Count evictor

          Retain 1000 elements from the end of the window backwards, evicting all others.

   {% highlight java %}
triggeredStream.evictor(CountEvictor.of(1000));
   {% endhighlight %}

        Delta evictor

            Starting from the beginning of the window, evict elements until an element with
            value lower than the value of the last element is found (by a threshold and a
            DeltaFunction).

    {% highlight java %}
triggeredStream.evictor(DeltaEvictor.of(5000, new DeltaFunction<Double>() {
  public double (Double oldValue, Double newValue) {
      return newValue - oldValue;
  }
}));
    {% endhighlight %}

      Transformation
      Description

      Time evictor

         Evict all elements from the beginning of the window, so that elements from end-value - 1 second
         until end-value are retained (the resulting window size is 1 second).

  {% highlight scala %}
triggeredStream.evictor(TimeEvictor.of(Time.seconds(1)));
  {% endhighlight %}

       Count evictor

          Retain 1000 elements from the end of the window backwards, evicting all others.

   {% highlight scala %}
triggeredStream.evictor(CountEvictor.of(1000));
   {% endhighlight %}

        Delta evictor

            Starting from the beginning of the window, evict elements until an element with
            value lower than the value of the last element is found (by a threshold and a
            DeltaFunction).

    {% highlight scala %}
windowedStream.evictor(DeltaEvictor.of(5000.0, { (old,new) => new - old > 0.01 }))
    {% endhighlight %}

### Recipes for Building Windows

The mechanism of window assigner, trigger, and evictor is very powerful, and it allows you to define
many different kinds of windows. Flink's basic window constructs are, in fact, syntactic
sugar on top of the general mechanism. Below is how some common types of windows can be
constructed using the general mechanism

      Window type
      Definition

	  Tumbling count window

    {% highlight java %}
stream.countWindow(1000)
    {% endhighlight %}

    {% highlight java %}
stream.window(GlobalWindows.create())
  .trigger(PurgingTrigger.of(CountTrigger.of(size)))
    {% endhighlight %}

	  Sliding count window

    {% highlight java %}
stream.countWindow(1000, 100)
    {% endhighlight %}

    {% highlight java %}
stream.window(GlobalWindows.create())
  .evictor(CountEvictor.of(1000))
  .trigger(CountTrigger.of(100))
    {% endhighlight %}

	  Tumbling event time window

    {% highlight java %}
stream.timeWindow(Time.seconds(5))
    {% endhighlight %}

    {% highlight java %}
stream.window(TumblingEventTimeWindows.of((Time.seconds(5)))
  .trigger(EventTimeTrigger.create())
    {% endhighlight %}

	  Sliding event time window

    {% highlight java %}
stream.timeWindow(Time.seconds(5), Time.seconds(1))
    {% endhighlight %}

    {% highlight java %}
stream.window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1)))
  .trigger(EventTimeTrigger.create())
    {% endhighlight %}

	  Tumbling processing time window

    {% highlight java %}
stream.timeWindow(Time.seconds(5))
    {% endhighlight %}

    {% highlight java %}
stream.window(TumblingProcessingTimeWindows.of((Time.seconds(5)))
  .trigger(ProcessingTimeTrigger.create())
    {% endhighlight %}

	  Sliding processing time window

    {% highlight java %}
stream.timeWindow(Time.seconds(5), Time.seconds(1))
    {% endhighlight %}

    {% highlight java %}
stream.window(SlidingProcessingTimeWindows.of(Time.seconds(5), Time.seconds(1)))
  .trigger(ProcessingTimeTrigger.create())
    {% endhighlight %}

## Windows on Unkeyed Data Streams

You can also define windows on regular (non-keyed) data streams using the `windowAll` transformation. These
windowed data streams have all the capabilities of keyed windowed data streams, but are evaluated at a single
task (and hence at a single computing node). The syntax for defining triggers and evictors is exactly the
same:

{% highlight java %}
nonKeyedStream
    .windowAll(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1))
    .trigger(CountTrigger.of(100))
    .evictor(CountEvictor.of(10));
{% endhighlight %}

{% highlight scala %}
nonKeyedStream
    .windowAll(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1))
    .trigger(CountTrigger.of(100))
    .evictor(CountEvictor.of(10))
{% endhighlight %}

Basic window definitions are also available for windows on non-keyed streams:

      Transformation
      Description

        Tumbling time window all
DataStream → WindowedStream

          Defines a window of 5 seconds, that "tumbles". This means that elements are
          grouped according to their timestamp in groups of 5 second duration, and every element belongs to exactly one window.
          The notion of time used is controlled by the StreamExecutionEnvironment.
    {% highlight java %}
nonKeyedStream.timeWindowAll(Time.seconds(5));
    {% endhighlight %}

          Sliding time window all
DataStream → WindowedStream

             Defines a window of 5 seconds, that "slides" by 1 seconds. This means that elements are
             grouped according to their timestamp in groups of 5 second duration, and elements can belong to more than
             one window (since windows overlap by at least 4 seconds)
             The notion of time used is controlled by the StreamExecutionEnvironment.
      {% highlight java %}
nonKeyedStream.timeWindowAll(Time.seconds(5), Time.seconds(1));
      {% endhighlight %}

        Tumbling count window all
DataStream → WindowedStream

          Defines a window of 1000 elements, that "tumbles". This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element belongs to exactly one window.
    {% highlight java %}
nonKeyedStream.countWindowAll(1000)
    {% endhighlight %}

      Sliding count window all
DataStream → WindowedStream

          Defines a window of 1000 elements, that "slides" every 100 elements. This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element can belong to more than one window (as windows overlap by at least 900 elements).
  {% highlight java %}
nonKeyedStream.countWindowAll(1000, 100)
  {% endhighlight %}

      Transformation
      Description

        Tumbling time window all
DataStream → WindowedStream

          Defines a window of 5 seconds, that "tumbles". This means that elements are
          grouped according to their timestamp in groups of 5 second duration, and every element belongs to exactly one window.
          The notion of time used is controlled by the StreamExecutionEnvironment.
    {% highlight scala %}
nonKeyedStream.timeWindowAll(Time.seconds(5));
    {% endhighlight %}

          Sliding time window all
DataStream → WindowedStream

             Defines a window of 5 seconds, that "slides" by 1 seconds. This means that elements are
             grouped according to their timestamp in groups of 5 second duration, and elements can belong to more than
             one window (since windows overlap by at least 4 seconds)
             The notion of time used is controlled by the StreamExecutionEnvironment.
      {% highlight scala %}
nonKeyedStream.timeWindowAll(Time.seconds(5), Time.seconds(1));
      {% endhighlight %}

        Tumbling count window all
DataStream → WindowedStream

          Defines a window of 1000 elements, that "tumbles". This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element belongs to exactly one window.
    {% highlight scala %}
nonKeyedStream.countWindowAll(1000)
    {% endhighlight %}

      Sliding count window all
DataStream → WindowedStream

          Defines a window of 1000 elements, that "slides" every 100 elements. This means that elements are
          grouped according to their arrival time (equivalent to processing time) in groups of 1000 elements,
          and every element can belong to more than one window (as windows overlap by at least 900 elements).
  {% highlight scala %}
nonKeyedStream.countWindowAll(1000, 100)
  {% endhighlight %}


text:
namespace Microsoft.Azure.Management.IotCentral
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// Extension methods for AppsOperations.
    /// </summary>
    public static partial class AppsOperationsExtensions
    {
            /// <summary>
            /// Get the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            public static App Get(this IAppsOperations operations, string resourceGroupName, string resourceName)
            {
                return operations.GetAsync(resourceGroupName, resourceName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<App> GetAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.GetWithHttpMessagesAsync(resourceGroupName, resourceName, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Create or update the metadata of an IoT Central application. The usual
            /// pattern to modify a property is to retrieve the IoT Central application
            /// metadata and security metadata, and then combine them with the modified
            /// values in a new body to update the IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='app'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            public static App CreateOrUpdate(this IAppsOperations operations, string resourceGroupName, string resourceName, App app)
            {
                return operations.CreateOrUpdateAsync(resourceGroupName, resourceName, app).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Create or update the metadata of an IoT Central application. The usual
            /// pattern to modify a property is to retrieve the IoT Central application
            /// metadata and security metadata, and then combine them with the modified
            /// values in a new body to update the IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='app'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<App> CreateOrUpdateAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, App app, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, resourceName, app, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Update the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='appPatch'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            public static App Update(this IAppsOperations operations, string resourceGroupName, string resourceName, AppPatch appPatch)
            {
                return operations.UpdateAsync(resourceGroupName, resourceName, appPatch).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Update the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='appPatch'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<App> UpdateAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, AppPatch appPatch, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, resourceName, appPatch, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Delete an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            public static void Delete(this IAppsOperations operations, string resourceGroupName, string resourceName)
            {
                operations.DeleteAsync(resourceGroupName, resourceName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Delete an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task DeleteAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, CancellationToken cancellationToken = default(CancellationToken))
            {
                (await operations.DeleteWithHttpMessagesAsync(resourceGroupName, resourceName, null, cancellationToken).ConfigureAwait(false)).Dispose();
            }

            /// <summary>
            /// Get all IoT Central Applications in a subscription.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static IPage<App> ListBySubscription(this IAppsOperations operations)
            {
                return operations.ListBySubscriptionAsync().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all IoT Central Applications in a subscription.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<App>> ListBySubscriptionAsync(this IAppsOperations operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListBySubscriptionWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get all the IoT Central Applications in a resource group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            public static IPage<App> ListByResourceGroup(this IAppsOperations operations, string resourceGroupName)
            {
                return operations.ListByResourceGroupAsync(resourceGroupName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all the IoT Central Applications in a resource group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<App>> ListByResourceGroupAsync(this IAppsOperations operations, string resourceGroupName, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Check if an IoT Central application name is available.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='operationInputs'>
            /// Set the name parameter in the OperationInputs structure to the name of the
            /// IoT Central application to check.
            /// </param>
            public static AppAvailabilityInfo CheckNameAvailability(this IAppsOperations operations, OperationInputs operationInputs)
            {
                return operations.CheckNameAvailabilityAsync(operationInputs).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Check if an IoT Central application name is available.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='operationInputs'>
            /// Set the name parameter in the OperationInputs structure to the name of the
            /// IoT Central application to check.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<AppAvailabilityInfo> CheckNameAvailabilityAsync(this IAppsOperations operations, OperationInputs operationInputs, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.CheckNameAvailabilityWithHttpMessagesAsync(operationInputs, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Check if an IoT Central application subdomain is available.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='operationInputs'>
            /// Set the name parameter in the OperationInputs structure to the subdomain of
            /// the IoT Central application to check.
            /// </param>
            public static AppAvailabilityInfo CheckSubdomainAvailability(this IAppsOperations operations, OperationInputs operationInputs)
            {
                return operations.CheckSubdomainAvailabilityAsync(operationInputs).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Check if an IoT Central application subdomain is available.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='operationInputs'>
            /// Set the name parameter in the OperationInputs structure to the subdomain of
            /// the IoT Central application to check.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<AppAvailabilityInfo> CheckSubdomainAvailabilityAsync(this IAppsOperations operations, OperationInputs operationInputs, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.CheckSubdomainAvailabilityWithHttpMessagesAsync(operationInputs, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get all available application templates.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static IPage<AppTemplate> ListTemplates(this IAppsOperations operations)
            {
                return operations.ListTemplatesAsync().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all available application templates.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<AppTemplate>> ListTemplatesAsync(this IAppsOperations operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListTemplatesWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Create or update the metadata of an IoT Central application. The usual
            /// pattern to modify a property is to retrieve the IoT Central application
            /// metadata and security metadata, and then combine them with the modified
            /// values in a new body to update the IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='app'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            public static App BeginCreateOrUpdate(this IAppsOperations operations, string resourceGroupName, string resourceName, App app)
            {
                return operations.BeginCreateOrUpdateAsync(resourceGroupName, resourceName, app).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Create or update the metadata of an IoT Central application. The usual
            /// pattern to modify a property is to retrieve the IoT Central application
            /// metadata and security metadata, and then combine them with the modified
            /// values in a new body to update the IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='app'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<App> BeginCreateOrUpdateAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, App app, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, resourceName, app, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Update the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='appPatch'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            public static App BeginUpdate(this IAppsOperations operations, string resourceGroupName, string resourceName, AppPatch appPatch)
            {
                return operations.BeginUpdateAsync(resourceGroupName, resourceName, appPatch).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Update the metadata of an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='appPatch'>
            /// The IoT Central application metadata and security metadata.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<App> BeginUpdateAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, AppPatch appPatch, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, resourceName, appPatch, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Delete an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            public static void BeginDelete(this IAppsOperations operations, string resourceGroupName, string resourceName)
            {
                operations.BeginDeleteAsync(resourceGroupName, resourceName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Delete an IoT Central application.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group that contains the IoT Central application.
            /// </param>
            /// <param name='resourceName'>
            /// The ARM resource name of the IoT Central application.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task BeginDeleteAsync(this IAppsOperations operations, string resourceGroupName, string resourceName, CancellationToken cancellationToken = default(CancellationToken))
            {
                (await operations.BeginDeleteWithHttpMessagesAsync(resourceGroupName, resourceName, null, cancellationToken).ConfigureAwait(false)).Dispose();
            }

            /// <summary>
            /// Get all IoT Central Applications in a subscription.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<App> ListBySubscriptionNext(this IAppsOperations operations, string nextPageLink)
            {
                return operations.ListBySubscriptionNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all IoT Central Applications in a subscription.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<App>> ListBySubscriptionNextAsync(this IAppsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListBySubscriptionNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get all the IoT Central Applications in a resource group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<App> ListByResourceGroupNext(this IAppsOperations operations, string nextPageLink)
            {
                return operations.ListByResourceGroupNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all the IoT Central Applications in a resource group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<App>> ListByResourceGroupNextAsync(this IAppsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListByResourceGroupNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get all available application templates.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<AppTemplate> ListTemplatesNext(this IAppsOperations operations, string nextPageLink)
            {
                return operations.ListTemplatesNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get all available application templates.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<AppTemplate>> ListTemplatesNextAsync(this IAppsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListTemplatesNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

    }
}


text:
namespace MileageTracker.Infrastructure.Logging {
    public class LoggingFactory {
        private static ILogger _logger;

        public static void InitializeLogFactory(ILogger logger) {
            _logger = logger;
        }

        public static ILogger GetLogger() {
            return _logger;
        }
    }
}


text:
using System;
using System.Collections.Immutable;
using IronVelocity.CodeAnalysis.Text;

namespace IronVelocity.CodeAnalysis.Syntax
{
    public class SyntaxToken : SyntaxNode
    {
        public SyntaxToken(SyntaxKind kind, int position, string text)
            : this(kind, position, text, null)
        {
        }

        public SyntaxToken(SyntaxKind kind, int position, string text, object? value)
        {
            Kind = kind;
            Position = position;
            Text = text;
            Value = value;
        }

        public override SyntaxKind Kind { get; }
        public int Position { get; }
        public string Text { get; }
        public object? Value { get; }
        public override TextSpan Span => new TextSpan(Position, Text.Length);

        public override ImmutableArray<SyntaxNode> GetChildren()
            => ImmutableArray<SyntaxNode>.Empty;
    }
}


text:
<?php

namespace PHPAST;

abstract class BinaryOp extends Node {
	protected $node1;
	protected $node2;

	public function __construct(Node $node1, Node $node2, $label = NULL) {
		parent::__construct($label);
		$this->node1 = $node1;
		$this->node2 = $node2;
	}
}


text:
#pragma once
#include <rawrtcc/code.h>
#include <rawrtcdc/data_channel.h>
#include <rawrtcdc/sctp_transport.h>
#include <re.h>

// Dependencies
struct rawrtc_dtls_transport;

/*
 * Create an SCTP transport.
 * `*transportp` must be unreferenced.
 */
enum rawrtc_code rawrtc_sctp_transport_create(
    struct rawrtc_sctp_transport** const transportp,  // de-referenced
    struct rawrtc_dtls_transport* const dtls_transport,  // referenced
    uint16_t const port,  // zeroable
    rawrtc_data_channel_handler const data_channel_handler,  // nullable
    rawrtc_sctp_transport_state_change_handler const state_change_handler,  // nullable
    void* const arg  // nullable
);


text:
package com.jakub.ajamarks.repositories;

import com.jakub.ajamarks.entities.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * Created by ja on 11.01.17.
 */

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {

    //using @Praram adnotation
    //HQL (hibernate query language sytntax uses ":"
    @Query("select u from Student u where u.firstName = :firstName or u.lastName = :lastName")
    List<Student> findByLastnameOrFirstname(@Param("lastName") String lastname, @Param("firstName") String firstname);

    //native query
    @Query(value = "select * from Student where userName = ?1", nativeQuery = true)
    Student findByUserName(String userName);

    @Query("select u from Student u where u.firstName like %?1 and UPPER(u.firstName) = UPPER(?1)")
    List<Student> findByFirstNameStartsWithIgnoreCase(String firstName);

    @Query("select u from Student u where u.lastName like %?1 and UPPER(u.lastName) = UPPER(?1)")
    List<Student> findByLastNameStartsWithIgnoreCase(String firstName);

    @Query("select u from Student u order by u.lastName desc")
    List <Student> findAllOrderByLastNameDesc();

    List<Student> findByClassroomClassroomName(String classroomName);

    List <Student> findByClassroomClassroomNumber(int classroomNumber);
}


text:
//
// Copyright (c) 2004-2017 Jaroslaw Kowalski <jaak@jkowalski.net>, Kim Christensen, Julian Verdurmen
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// * Neither the name of Jaroslaw Kowalski nor the names of its
//   contributors may be used to endorse or promote products derived from this
//   software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//

namespace NLog.Targets
{
    /// <summary>
    /// <see cref="FileTarget"/> may be configured to compress archived files in a custom way
    /// by setting <see cref="FileTarget.FileCompressor"/> before logging your first event.
    /// </summary>
    public interface IFileCompressor
    {
        /// <summary>
        /// Create archiveFileName by compressing fileName.
        /// </summary>
        /// <param name="fileName">Absolute path to the log file to compress.</param>
        /// <param name="archiveFileName">Absolute path to the compressed archive file to create.</param>
        void CompressFile(string fileName, string archiveFileName);
    }
}


text:
typedef mozc::oss::OssDataManager DataManagerType;

namespace mozc {
namespace jni {
namespace {
jobject g_connection_data_buffer;
jobject g_dictionary_buffer;

// Adapter class to make a SessionHandlerInterface (held by this class)
// singleton.
// Must be accessed via mozc::Singleton<SessionHandlerSingletonAdapter>.
class SessionHandlerSingletonAdapter {
 public:
  SessionHandlerSingletonAdapter()
      : engine_(mozc::EngineFactory::Create()),
        session_handler_(new mozc::SessionHandler(engine_.get())) {}
  ~SessionHandlerSingletonAdapter() {}

  SessionHandlerInterface *getHandler() {
    return session_handler_.get();
  }

 private:
  // Must be defined earlier than session_handler_, which depends on this.
  std::unique_ptr<EngineInterface> engine_;
  std::unique_ptr<SessionHandlerInterface> session_handler_;

  DISALLOW_COPY_AND_ASSIGN(SessionHandlerSingletonAdapter);
};

void Initialize(
    JavaVM *vm,
    const char *user_profile_directory,
    void *dictionary_address, int dictionary_size,
    void *connection_data_address, int connection_data_size) {
  // First of all, set the user profile directory.
  SystemUtil::SetUserProfileDirectory(user_profile_directory);

  // Initialize Java native callback proxy.
  JavaHttpClientProxy::SetJavaVM(vm);

  // Initialize dictionary data.
  DataManagerType::SetDictionaryData(dictionary_address, dictionary_size);
  DataManagerType::SetConnectionData(connection_data_address,
                                     connection_data_size);

  mozc::Singleton<SessionHandlerSingletonAdapter>::get()->getHandler()
      ->AddObserver(Singleton<session::SessionUsageObserver>::get());

  // Start usage stats timer.
  using usage_stats::UsageStatsUploader;
  mozc::Scheduler::AddJob(Scheduler::JobSetting(
      "UsageStatsTimer",
      UsageStatsUploader::kDefaultScheduleInterval,
      UsageStatsUploader::kDefaultScheduleMaxInterval,
      UsageStatsUploader::kDefaultSchedulerDelay,
      UsageStatsUploader::kDefaultSchedulerRandomDelay,
      &UsageStatsUploader::Send,
      NULL));
}

// Concrete implementation for MozcJni.evalCommand
jbyteArray JNICALL evalCommand(JNIEnv *env,
                               jclass clazz,
                               jbyteArray in_bytes_array) {
  jboolean is_copy = false;
  jbyte *in_bytes = env->GetByteArrayElements(in_bytes_array, &is_copy);
  const jsize in_size = env->GetArrayLength(in_bytes_array);
  mozc::commands::Command command;
  command.ParseFromArray(in_bytes, in_size);
  mozc::Singleton<SessionHandlerSingletonAdapter>::get()->getHandler()
      ->EvalCommand(&command);

  // Use JNI_ABORT because in_bytes is read only.
  env->ReleaseByteArrayElements(in_bytes_array, in_bytes, JNI_ABORT);

  const int out_size = command.ByteSize();
  jbyteArray out_bytes_array = env->NewByteArray(out_size);
  jbyte *out_bytes = env->GetByteArrayElements(out_bytes_array, &is_copy);
  command.SerializeToArray(out_bytes, out_size);

  // Use 0 to copy out_bytes to out_bytes_array.
  env->ReleaseByteArrayElements(out_bytes_array, out_bytes, 0);

  return out_bytes_array;
}

void JNICALL onPostLoad(JNIEnv *env,
                        jclass clazz,
                        jstring user_profile_directory_path,
                        jobject dictionary_buffer,
                        jobject connection_data_buffer) {
  // Keep the global references of the buffers.
  g_dictionary_buffer = env->NewGlobalRef(dictionary_buffer);
  g_connection_data_buffer = env->NewGlobalRef(connection_data_buffer);

  jboolean is_copy = JNI_FALSE;
  const char *utf8_user_profile_directory_path =
      env->GetStringUTFChars(user_profile_directory_path, &is_copy);

  JavaVM *vm = NULL;
  env->GetJavaVM(&vm);

  Initialize(
      vm, utf8_user_profile_directory_path,
      env->GetDirectBufferAddress(dictionary_buffer),
      env->GetDirectBufferCapacity(dictionary_buffer),
      env->GetDirectBufferAddress(connection_data_buffer),
      env->GetDirectBufferCapacity(connection_data_buffer));
  if (is_copy) {
    env->ReleaseStringUTFChars(user_profile_directory_path,
                               utf8_user_profile_directory_path);
  }
}

jstring JNICALL getVersion(JNIEnv *env) {
  return env->NewStringUTF(Version::GetMozcVersion().c_str());
}

}  // namespace
}  // namespace jni
}  // namespace mozc

extern "C" {
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
  JNIEnv *env = mozc::AndroidUtil::GetEnv(vm);
  if (!env) {
    // Fatal error. No way to recover.
     return JNI_EVERSION;
  }
  const JNINativeMethod methods[] = {
      {"evalCommand",
       "([B)[B",
       reinterpret_cast<void*>(&mozc::jni::evalCommand)},
      {"onPostLoad",
       "(Ljava/lang/String;Ljava/nio/Buffer;Ljava/nio/Buffer;)V",
       reinterpret_cast<void*>(&mozc::jni::onPostLoad)},
      {"getVersion",
       "()Ljava/lang/String;",
       reinterpret_cast<void*>(&mozc::jni::getVersion)},
  };
  jclass clazz = env->FindClass(
      "org/mozc/android/inputmethod/japanese/session/MozcJNI");
  if (env->RegisterNatives(clazz, methods, arraysize(methods))) {
    // Fatal error. No way to recover.
     return JNI_EVERSION;
  }

  mozc::Logging::InitLogStream(
      mozc::FileUtil::JoinPath(mozc::SystemUtil::GetLoggingDirectory(),
                               "libmozc.so.log"));
  return JNI_VERSION_1_6;
}

JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved) {
  mozc::jni::JavaHttpClientProxy::SetJavaVM(NULL);

  // Delete global references.
  JNIEnv *env = mozc::AndroidUtil::GetEnv(vm);
  if (env) {
    env->DeleteGlobalRef(mozc::jni::g_connection_data_buffer);
    env->DeleteGlobalRef(mozc::jni::g_dictionary_buffer);
  }
}
}  // extern "C"

#endif  // OS_ANDROID


text:
defineSuite([
        'Core/ColorGeometryInstanceAttribute',
        'Core/Color',
        'Core/ComponentDatatype'
    ], function(
        ColorGeometryInstanceAttribute,
        Color,
        ComponentDatatype) {
    'use strict';

    it('constructor', function() {
        var attribute = new ColorGeometryInstanceAttribute(1.0, 1.0, 0.0, 0.5);
        expect(attribute.componentDatatype).toEqual(ComponentDatatype.UNSIGNED_BYTE);
        expect(attribute.componentsPerAttribute).toEqual(4);
        expect(attribute.normalize).toEqual(true);

        var value = new Uint8Array(new Color(1.0, 1.0, 0.0, 0.5).toBytes());
        expect(attribute.value).toEqual(value);
    });

    it('fromColor', function() {
        var color = Color.AQUA;
        var attribute = ColorGeometryInstanceAttribute.fromColor(color);
        expect(attribute.componentDatatype).toEqual(ComponentDatatype.UNSIGNED_BYTE);
        expect(attribute.componentsPerAttribute).toEqual(4);
        expect(attribute.normalize).toEqual(true);

        var value = new Uint8Array(color.toBytes());
        expect(attribute.value).toEqual(value);
    });

    it('fromColor throws without color', function() {
        expect(function() {
            ColorGeometryInstanceAttribute.fromColor();
        }).toThrowDeveloperError();
    });

    it('toValue', function() {
        var color = Color.AQUA;
        var expectedResult = new Uint8Array(color.toBytes());
        expect(ColorGeometryInstanceAttribute.toValue(color)).toEqual(expectedResult);
    });

    it('toValue works with result parameter', function() {
        var color = Color.AQUA;
        var expectedResult = new Uint8Array(color.toBytes());
        var result = new Uint8Array(4);
        var returnedResult = ColorGeometryInstanceAttribute.toValue(color, result);
        expect(returnedResult).toBe(result);
        expect(returnedResult).toEqual(expectedResult);
    });

    it('toValue throws without a color', function() {
        expect(function() {
            ColorGeometryInstanceAttribute.toValue();
        }).toThrowDeveloperError();
    });

    it('equals', function() {
        var color = new ColorGeometryInstanceAttribute(0.1, 0.2, 0.3, 0.4);
        expect(ColorGeometryInstanceAttribute.equals(color, color)).toEqual(true);
        expect(ColorGeometryInstanceAttribute.equals(color, new ColorGeometryInstanceAttribute(0.1, 0.2, 0.3, 0.4))).toEqual(true);
        expect(ColorGeometryInstanceAttribute.equals(color, new ColorGeometryInstanceAttribute(0.5, 0.2, 0.3, 0.4))).toEqual(false);
        expect(ColorGeometryInstanceAttribute.equals(color, new ColorGeometryInstanceAttribute(0.1, 0.5, 0.3, 0.4))).toEqual(false);
        expect(ColorGeometryInstanceAttribute.equals(color, new ColorGeometryInstanceAttribute(0.1, 0.2, 0.5, 0.4))).toEqual(false);
        expect(ColorGeometryInstanceAttribute.equals(color, new ColorGeometryInstanceAttribute(0.1, 0.2, 0.3, 0.5))).toEqual(false);
        expect(ColorGeometryInstanceAttribute.equals(color, undefined)).toEqual(false);
        expect(ColorGeometryInstanceAttribute.equals(undefined, color)).toEqual(false);
    });
});


text:
/*
 * EVE Swagger Interface
 *
 * An OpenAPI for EVE Online
 *
 * OpenAPI spec version: 1.12
 *
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 *
 * 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.
 */

package esi

/* A list of PostUniverseNames200Ok. */
//easyjson:json
type PostUniverseNames200OkList []PostUniverseNames200Ok

/* 200 ok object */
//easyjson:json
type PostUniverseNames200Ok struct {
	Category string `json:"category,omitempty"` /* category string */
	Id       int32  `json:"id,omitempty"`       /* id integer */
	Name     string `json:"name,omitempty"`     /* name string */
}


text:
body {
	color: #424b51;
	font-family: "raleway",sans-serif;
	font-style: normal;
	font-weight: 300;
	text-rendering: optimizeLegibility !important;
	-webkit-font-smoothing: auto !important;
	    height: 100%;
}

p{
	font-weight: inherit;
	font-size: 1.7rem;
	margin-top: -0.5rem;
}

.top-nav-collapse{
	background-color: rgba(0, 0, 0, 0.97);
}

.navbar-default{
	position: absolute;
}

.navbar{
	background: rgba(0, 0, 0, 0.71);
}

#servicios{
}
#portafolio{
}
#equipo{
}
#contacto{
}

h1, h2, h3, h4{
	font-family: "raleway",sans-serif;
font-style: normal;
font-weight: 500;
	margin:1rem 0;
}

hr {
margin-top: 1.5rem;
margin-bottom: 0;
border: 0;
border-top: 1px solid #eee;
}

.btn-primary {
color: #fff;
background-color: #FFD500;
border-color: #FFD500;
}

.portada {
	display: table;
	height: 350px;
	width: 100%;
	background: #FFD500;
	background: url(http://riotdesign.eu/assets/img/home-slider/bg-goodssolutions.jpg);
	background-size: cover;
	background-attachment: fixed;
}

.portada h1 {
font-size: 3rem;
color: white;
font-family: "raleway";
}

.portada p {
font-family: raleway;
font-weight: 500;
}
.barmenu{
	padding: 0;
}

nav.navbar.navbar-default {
	width: 100%;
	background: rgba(0, 0, 0, 0.5);
	border: 0;
}

.navbar-default .navbar-nav>li>a{
	font-size: 2rem;
	color:white;
	font-family: "lato",serif;
}

.displaytable{
	display: table-cell;
	vertical-align: middle;

}

.section-equipo{
	background: white;
	padding: 6rem 0;
}

.section-servicios{
	background: white;
	padding: 6rem 0;
}

.descansotexto{
	background: #424b51;
	padding: 7rem 0;
}

.descansotexto p{
	color:rgb(244, 244, 244);
	font-size: 3.5rem;
	font-weight: 100;
	padding: 0;
	margin: 0;
}

.section-portafolio{
	background: #F9F9F9;
	padding: 6rem 0;
}

.section-llamadacontacto{
	background: #F9F9F9;
	padding: 5rem 0;
	background: black;
	width: 100%;
	background-image: url(http://www.dotlogics.com/images/contct_ban.jpg);
	-webkit-background-size: cover;
	-moz-background-size: cover;
	-o-background-size: cover;
	background-size: cover;
}

.section-llamadacontacto h4{
		font-size: 2.6rem;
		color: white;
}

.section-contacto{
background-color: white;
	-webkit-background-size: cover;
	-moz-background-size: cover;
	-o-background-size: cover;
	background-size: cover;
 	padding: 6rem 0;
  }

.portafolio img{
	padding-right: 0;
padding-left: 0px;
width: 100%;
}

footer p{
	font-size: 1.5rem
}

.input-lg{
	font-size:1.4rem;
}

.iconoservicios{
	font-size: 9rem;
	transition-property:all;
	transition-duration:0.2s;
	transition-timing-function:ease-in-out;

}

.iconoservicios:hover{
	font-size: 10rem;
	color: #FFD500;
}

@media only screen and (max-width: 1100px)
.effects .img:nth-child(n) {
margin-right: 0px;
}

.intro {
    display: table;
    width: 100%;
    height: auto;
    padding: 100px 0;
    text-align: center;
    color: #fff;
    background: url(http://semanaeconomica.com/wp-content/uploads/2014/08/san-isidro.jpg) no-repeat bottom center scroll;
    background-color: #000;
    -webkit-background-size: cover;
    -moz-background-size: cover;
    background-size: cover;
    -o-background-size: cover;
    background-position: fixed;
}

.intro .intro-body {
    display: table-cell;
    vertical-align: middle;
    background: url(http://bigdropinc.com/wp-content/themes/bd/images/home/mask.png);

}

.intro .intro-body .brand-heading {
    font-size: 40px;
}

.intro .intro-body .intro-text {
    font-size: 18px;
	font-family: "raleway",sans-serif;
font-style: normal;
font-weight: 600;
}

@media(min-width:767px) {
    .intro {
        height: 100%;
        padding: 0;
    }

    .intro .intro-body .brand-heading {
        font-size: 100px;
    }

    .intro .intro-body .intro-text {
        font-size: 25px;
    }
}

.intro-web{
	background-color: gray;
}


text:
<?php namespace Subalcatel;

use Illuminate\Database\Eloquent\Model;

class Insurance extends Model {

	//

}