text:
.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-item-value > .setting-item-control {
	width: 100%;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-pattern {
	margin-right: 3px;
	margin-left: 2px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-pattern,
.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-sibling {
	display: inline-block;
	line-height: 22px;
	font-family: Menlo, Monaco, Consolas, "Droid Sans Mono", "Courier New", monospace, "Droid Sans Fallback";
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-sibling {
	opacity: 0.7;
	margin-left: 0.5em;
	font-size: 0.9em;
	white-space: pre;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar {
	display: none;
	position: absolute;
	right: 0px;
	margin-top: 1px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row {
	position: relative;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row:focus {
	outline: none;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row:hover .monaco-action-bar,
.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row.selected .monaco-action-bar {
	display: block;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .action-label {
	width: 16px;
	height: 16px;
	padding: 2px;
	margin-right: 2px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .setting-excludeAction-edit {
	margin-right: 4px;
}

.vs .settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .setting-excludeAction-edit {
	background: url(edit.svg) center center no-repeat;
}

.vs-dark .settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .setting-excludeAction-edit {
	background: url(edit_inverse.svg) center center no-repeat;
}

.vs .settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .setting-excludeAction-remove {
	background: url(action-remove.svg) center center no-repeat;
}

.vs-dark .settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-row .monaco-action-bar .setting-excludeAction-remove {
	background: url(action-remove-dark.svg) center center no-repeat;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .monaco-text-button {
	width: initial;
	padding: 2px 14px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-item-control.setting-exclude-new-mode .setting-exclude-new-row {
	display: none;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .monaco-text-button.setting-exclude-addButton {
	margin-right: 10px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-edit-row {
	display: flex
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-patternInput,
.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-siblingInput {
	height: 22px;
	max-width: 320px;
	flex: 1;
	margin-right: 10px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-okButton {
	margin-right: 10px;
}

.settings-editor > .settings-body > .settings-tree-container .setting-item.setting-item-exclude .setting-exclude-widget {
	margin-bottom: 1px;
}


text:
package org.apache.lucene.analysis.th;

import java.io.StringReader;
import junit.framework.TestCase;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;

/**
 * Test case for ThaiAnalyzer, modified from TestFrenchAnalyzer
 *
 * @author    Samphan Raruenrom <samphan@osdev.co.th>
 * @version   0.1
 */

public class TestThaiAnalyzer extends TestCase {

	public void assertAnalyzesTo(Analyzer a, String input, String[] output)
		throws Exception {

		TokenStream ts = a.tokenStream("dummy", new StringReader(input));

		for (int i = 0; i < output.length; i++) {
			Token t = ts.next();
			assertNotNull(t);
			assertEquals(t.termText(), output[i]);
		}
		assertNull(ts.next());
		ts.close();
	}

	public void testAnalyzer() throws Exception {
		ThaiAnalyzer analyzer = new ThaiAnalyzer();

		assertAnalyzesTo(analyzer, "", new String[] {});

		assertAnalyzesTo(
			analyzer,
			"การที่ได้ต้องแสดงว่างานดี",
			new String[] { "การ", "ที่", "ได้", "ต้อง", "แสดง", "ว่า", "งาน", "ดี"});

		assertAnalyzesTo(
			analyzer,
			"บริษัทชื่อ XY&Z - คุยกับ xyz@demo.com",
			new String[] { "บริษัท", "ชื่อ", "xy&z", "คุย", "กับ", "xyz@demo.com" });

    // English stop words
		assertAnalyzesTo(
			analyzer,
			"ประโยคว่า The quick brown fox jumped over the lazy dogs",
			new String[] { "ประโยค", "ว่า", "quick", "brown", "fox", "jumped", "over", "lazy", "dogs" });
	}
}

redpajama_set_name: RedPajamaGithub


text:
package interpreter

import (
	"fmt"
	"github.com/pkg/errors"
	"strconv"
	"io"
)

// funcCreate creates variable in scope
type funcCreate struct{}

// Execute executes funcCreate logic
// Needs id and value variables in local scope
func (funcCreate) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, value string
	if id, value, err = getIDValue(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	} else if err = globalVars.Create(id, value); err != nil {
		err = errors.Wrapf(err, "Can't create variable %q", id)
	}
	return
}

// funcUpdate updates variable in scope
type funcUpdate struct{}

// Execute executes funcUpdate logic
// Needs id and value variables in local scope
func (funcUpdate) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, value string
	if id, value, err = getIDValue(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	} else if err = globalVars.Update(id, value); err != nil {
		err = errors.Wrapf(err, "Can't update variable %q", id)
	}
	return
}

// funcDelete deletes variable from scope
type funcDelete struct{}

// Execute executes funcDelete logic
// Needs id variable in local scope
func (funcDelete) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id string
	if id, err = localVars.Get("id"); err != nil {
		err = errors.Wrap(err, "Can't get value from local scope")
	} else {
		err = globalVars.Delete(id)
	}
	return
}

// funcPrint prints variable from scope
type funcPrint struct{
	output io.Writer
}

// Execute executes funcPrint logic
// Needs id variable in local scope
func (f *funcPrint) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var value string
	if value, _ = localVars.Get("value"); err != nil && err != ErrorVariableDoesNotExist {
		err = errors.Wrap(err, "Can't get value from local scope")
	} else {
		fmt.Fprintln(f.output, value)
	}
	return
}

// funcAdd adds two variables and saves result to some variable of scope
// Can concatenate strings
type funcAdd struct{}

// Execute executes funcAdd logic
// Needs id, operand1 and operand2 variables in local scope
func (funcAdd) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, operand1, operand2, result string
	if id, operand1, operand2, err = getIDOperands(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	}
	o1, err1 := strconv.ParseFloat(operand1, 64)
	o2, err2 := strconv.ParseFloat(operand2, 64)
	if err1 != nil || err2 != nil {
		result = operand1 + operand2
	} else {
		result = strconv.FormatFloat(o1+o2, 'f', -1, 64)
	}
	globalVars.Set(id, result)
	return
}

// funcSub substracks two variables and saves result to some variable of scope
type funcSub struct{}

// Execute executes funcSub logic
// Needs id, operand1 and operand2 variables in local scope
func (funcSub) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, result string
	var o1, o2 float64
	if id, o1, o2, err = getIDOperandsNum(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	}
	result = strconv.FormatFloat(o1-o2, 'f', -1, 64)
	globalVars.Set(id, result)
	return
}

// funcMul multiplies two variables and saves result to some variable of scope
type funcMul struct{}

// Execute executes funcMul logic
// Needs id, operand1 and operand2 variables in local scope
func (funcMul) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, result string
	var o1, o2 float64
	if id, o1, o2, err = getIDOperandsNum(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	}
	result = strconv.FormatFloat(o1*o2, 'f', -1, 64)
	globalVars.Set(id, result)
	return
}

// funcDiv divides two variables and saves result to some variable of scope
type funcDiv struct{}

// Execute executes funcAdd logic
// Needs id, operand1 and operand2 variables in local scope
func (funcDiv) Execute(globalVars, localVars *VarScope, _, _ *FuncScope, _ int) (err error) {
	var id, result string
	var o1, o2 float64
	if id, o1, o2, err = getIDOperandsNum(localVars); err != nil {
		err = errors.Wrap(err, "Can't get variable info")
	}
	result = strconv.FormatFloat(o1/o2, 'f', -1, 64)
	globalVars.Set(id, result)
	return
}

// NewInternalFuncScope creates FuncScope and fills it with internal functions
func NewInternalFuncScope(output io.Writer, maxDepth int) *FuncScope {
	scope := NewFuncScope(maxDepth)
	scope.Set("create", &funcCreate{})
	scope.Set("update", &funcUpdate{})
	scope.Set("delete", &funcDelete{})
	scope.Set("print", &funcPrint{output: output})
	scope.Set("add", &funcAdd{})
	scope.Set("sub", &funcSub{})
	scope.Set("mul", &funcMul{})
	scope.Set("div", &funcDiv{})
	return scope
}


text:
""" Consolidation of numpy support utilities. """
import sys

try:
    import numpy
except ImportError:
    numpy = None

HAVE_NUMPY = numpy is not None

is_64bits = sys.maxsize > 2**32

def _make_variant_dtype():
    """ Create a dtype for VARIANT. This requires support for Unions, which is
    available in numpy version 1.7 or greater.

    This does not support the decimal type.

    Returns None if the dtype cannot be created.

    """

    # pointer typecode
    ptr_typecode = '<u8' if is_64bits else '<u4'

    _tagBRECORD_format = [
        ('pvRecord', ptr_typecode),
        ('pRecInfo', ptr_typecode),
    ]

    # overlapping typecodes only allowed in numpy version 1.7 or greater
    U_VARIANT_format = dict(
        names=[
            'VT_BOOL', 'VT_I1', 'VT_I2', 'VT_I4', 'VT_I8', 'VT_INT', 'VT_UI1',
            'VT_UI2', 'VT_UI4', 'VT_UI8', 'VT_UINT', 'VT_R4', 'VT_R8', 'VT_CY',
            'c_wchar_p', 'c_void_p', 'pparray', 'bstrVal', '_tagBRECORD',
        ],
        formats=[
            '<i2', '<i1', '<i2', '<i4', '<i8', '<i4', '<u1', '<u2', '<u4',
            '<u8', '<u4', '<f4', '<f8', '<i8', ptr_typecode, ptr_typecode,
            ptr_typecode, ptr_typecode, _tagBRECORD_format,
        ],
        offsets=[0] * 19  # This is what makes it a union
    )

    tagVARIANT_format = [
        ("vt", '<u2'),
        ("wReserved1", '<u2'),
        ("wReserved2", '<u2'),
        ("wReserved3", '<u2'),
        ("_", U_VARIANT_format),
    ]

    return numpy.dtype(tagVARIANT_format)

def isndarray(value):
    """ Check if a value is an ndarray.

    This cannot succeed if numpy is not available.

    """
    if not HAVE_NUMPY:
        return False
    return isinstance(value, numpy.ndarray)

def isdatetime64(value):
    """ Check if a value is a datetime64.

    This cannot succeed if datetime64 is not available.

    """
    if not HAVE_NUMPY:
        return False
    return isinstance(value, datetime64)

com_null_date64 = None
datetime64 = None
VARIANT_dtype = None

if HAVE_NUMPY:

    # dtype for VARIANT. This allows for packing of variants into an array, and
    # subsequent conversion to a multi-dimensional safearray.
    try:
        VARIANT_dtype = _make_variant_dtype()
    except ValueError:
        pass

    # This simplifies dependent modules
    try:
        from numpy import datetime64
    except ImportError:
        pass
    else:
        try:
            # This does not work on numpy 1.6
            com_null_date64 = datetime64("1899-12-30T00:00:00", "ns")
        except TypeError:
            pass


text:
class FakeStatusIconObserver : public StatusIconObserver {
 public:
  FakeStatusIconObserver()
      : balloon_clicked_(false),
        status_icon_click_count_(0) {}
  virtual void OnStatusIconClicked() {
    ++status_icon_click_count_;
  }
  virtual void OnBalloonClicked() { balloon_clicked_ = true; }
  bool balloon_clicked() const { return balloon_clicked_; }
  size_t status_icon_click_count() const {
    return status_icon_click_count_;
  }

 private:
  size_t status_icon_click_count_;
  bool balloon_clicked_;
};

TEST(StatusTrayWinTest, CreateTray) {
  // Just tests creation/destruction.
  StatusTrayWin tray;
}

TEST(StatusTrayWinTest, CreateIconAndMenu) {
  // Create an icon, set the images, tooltip, and context menu, then shut it
  // down.
  StatusTrayWin tray;
  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
  gfx::ImageSkia* image = rb.GetImageSkiaNamed(IDR_STATUS_TRAY_ICON);
  StatusIcon* icon = tray.CreateStatusIcon(
      StatusTray::OTHER_ICON, *image, ASCIIToUTF16("tool tip"));
  icon->SetPressedImage(*image);
  ui::SimpleMenuModel* menu = new ui::SimpleMenuModel(NULL);
  menu->AddItem(0, L"foo");
  icon->SetContextMenu(menu);
}

#if !defined(USE_AURA)  // http://crbug.com/156370
TEST(StatusTrayWinTest, ClickOnIcon) {
  // Create an icon, send a fake click event, make sure observer is called.
  StatusTrayWin tray;
  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
  gfx::ImageSkia* image = rb.GetImageSkiaNamed(IDR_STATUS_TRAY_ICON);

  StatusIconWin* icon = static_cast<StatusIconWin*>(tray.CreateStatusIcon(
      StatusTray::OTHER_ICON, *image, ASCIIToUTF16("tool tip")));
  FakeStatusIconObserver observer;
  icon->AddObserver(&observer);
  // Mimic a click.
  tray.WndProc(NULL, icon->message_id(), icon->icon_id(), WM_LBUTTONDOWN);
  // Mimic a right-click - observer should not be called.
  tray.WndProc(NULL, icon->message_id(), icon->icon_id(), WM_RBUTTONDOWN);
  EXPECT_EQ(1, observer.status_icon_click_count());
  icon->RemoveObserver(&observer);
}

TEST(StatusTrayWinTest, ClickOnBalloon) {
  // Create an icon, send a fake click event, make sure observer is called.
  StatusTrayWin tray;
  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
  gfx::ImageSkia* image = rb.GetImageSkiaNamed(IDR_STATUS_TRAY_ICON);

  StatusIconWin* icon = static_cast<StatusIconWin*>(tray.CreateStatusIcon(
      StatusTray::OTHER_ICON, *image, ASCIIToUTF16("tool tip")));
  FakeStatusIconObserver observer;
  icon->AddObserver(&observer);
  // Mimic a click.
  tray.WndProc(
      NULL, icon->message_id(), icon->icon_id(), TB_INDETERMINATE);
  EXPECT_TRUE(observer.balloon_clicked());
  icon->RemoveObserver(&observer);
}

TEST(StatusTrayWinTest, HandleOldIconId) {
  StatusTrayWin tray;
  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
  gfx::ImageSkia* image = rb.GetImageSkiaNamed(IDR_STATUS_TRAY_ICON);

  StatusIconWin* icon = static_cast<StatusIconWin*>(tray.CreateStatusIcon(
      StatusTray::OTHER_ICON, *image, ASCIIToUTF16("tool tip")));
  UINT message_id = icon->message_id();
  UINT icon_id = icon->icon_id();

  tray.RemoveStatusIcon(icon);
  tray.WndProc(NULL, message_id, icon_id, WM_LBUTTONDOWN);
}
#endif  // !defined(USE_AURA)


text:
layout: page
title: Burton - Key Wedding
date: 2016-05-24
author: Michael Delacruz
tags: weekly links, java
status: published
summary: Proin faucibus est libero, id bibendum lectus pulvinar.
banner: images/banner/leisure-04.jpg
booking:
  startDate: 08/25/2016
  endDate: 08/28/2016
  ctyhocn: PORINHX
  groupCode: BKW
published: true
---
Maecenas malesuada aliquam metus vitae finibus. Nulla facilisi. Duis convallis ex ac sem eleifend, sit amet cursus sem condimentum. Nullam tincidunt volutpat justo, a eleifend neque aliquam a. Aliquam scelerisque, justo ac aliquet pharetra, leo risus faucibus justo, ut vehicula est nibh ac felis. Vestibulum eros tortor, ullamcorper vel consequat non, rhoncus sit amet diam. Donec congue condimentum elementum. Donec dictum nibh suscipit diam condimentum rhoncus.
Nulla eget neque quis lorem aliquam congue eu eu mi. Curabitur auctor lectus et dapibus fermentum. Phasellus quis bibendum sapien. Nullam risus enim, pulvinar nec volutpat in, laoreet nec erat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Nulla facilisi. Nunc rutrum nulla nec odio bibendum, ac pretium lectus fermentum. Suspendisse porta consequat magna quis semper. Donec imperdiet in tortor eget sagittis. Maecenas accumsan, ipsum vel viverra ornare, sem nunc condimentum ex, vel eleifend justo velit non turpis. Nunc consequat porta maximus. Sed a elit quis ex mattis egestas. Duis feugiat sapien facilisis, convallis sapien in, luctus justo. Etiam dui ex, tempor vitae odio luctus, pretium pharetra sem.

1 Morbi bibendum turpis et nibh cursus molestie
1 Vestibulum at sapien pulvinar, feugiat risus ut, pretium lorem
1 Nullam et metus dictum, vestibulum massa non, vestibulum diam.

Vestibulum dignissim fermentum leo eget iaculis. Nam viverra ligula vitae tortor efficitur, vel rhoncus urna ultricies. Praesent eget enim interdum sapien eleifend bibendum et ac est. Vestibulum lacinia tortor sed nibh volutpat porttitor. Morbi a risus diam. Aliquam tristique dolor in bibendum eleifend. Duis vulputate elit purus, et egestas velit pellentesque mollis. Suspendisse potenti. Nulla posuere, ante id facilisis laoreet, dolor ex sagittis lacus, id elementum diam elit ut erat. Etiam molestie mi sit amet tellus efficitur varius.


text:
//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//*********************************************************

using Windows.UI.Composition;

namespace CompositionSampleGallery.Samples.SDK_14393.NineGridResizing
{
    public interface INineGridScenario
    {
        void Selected(SpriteVisual hostVisual);

        CompositionBrush Brush { get;  }

        string Text { get; }
    }
}


text:
#pragma once
#include <aws/pinpoint-email/PinpointEmail_EXPORTS.h>
#include <aws/pinpoint-email/PinpointEmailRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace Http
{
    class URI;
} //namespace Http
namespace PinpointEmail
{
namespace Model
{

  /**
   *
A request to list all of the predictive inbox placement tests that you've
   * performed.

See Also:
   AWS
   * API Reference

   */
  class AWS_PINPOINTEMAIL_API ListDeliverabilityTestReportsRequest : public PinpointEmailRequest
  {
  public:
    ListDeliverabilityTestReportsRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "ListDeliverabilityTestReports"; }

    Aws::String SerializePayload() const override;

    void AddQueryStringParameters(Aws::Http::URI& uri) const override;

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline const Aws::String& GetNextToken() const{ return m_nextToken; }

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline bool NextTokenHasBeenSet() const { return m_nextTokenHasBeenSet; }

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline ListDeliverabilityTestReportsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline ListDeliverabilityTestReportsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}

    /**
     *
A token returned from a previous call to
     * ListDeliverabilityTestReports to indicate the position in the list
     * of predictive inbox placement tests.

     */
    inline ListDeliverabilityTestReportsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}

    /**
     *
The number of results to show in a single call to
     * ListDeliverabilityTestReports. If the number of results is larger
     * than the number you specified in this parameter, then the response includes a
     * NextToken element, which you can use to obtain additional
     * results.

The value you specify has to be at least 0, and can be no more
     * than 1000.

     */
    inline int GetPageSize() const{ return m_pageSize; }

    /**
     *
The number of results to show in a single call to
     * ListDeliverabilityTestReports. If the number of results is larger
     * than the number you specified in this parameter, then the response includes a
     * NextToken element, which you can use to obtain additional
     * results.

The value you specify has to be at least 0, and can be no more
     * than 1000.

     */
    inline bool PageSizeHasBeenSet() const { return m_pageSizeHasBeenSet; }

    /**
     *
The number of results to show in a single call to
     * ListDeliverabilityTestReports. If the number of results is larger
     * than the number you specified in this parameter, then the response includes a
     * NextToken element, which you can use to obtain additional
     * results.

The value you specify has to be at least 0, and can be no more
     * than 1000.

     */
    inline void SetPageSize(int value) { m_pageSizeHasBeenSet = true; m_pageSize = value; }

    /**
     *
The number of results to show in a single call to
     * ListDeliverabilityTestReports. If the number of results is larger
     * than the number you specified in this parameter, then the response includes a
     * NextToken element, which you can use to obtain additional
     * results.

The value you specify has to be at least 0, and can be no more
     * than 1000.

     */
    inline ListDeliverabilityTestReportsRequest& WithPageSize(int value) { SetPageSize(value); return *this;}

  private:

    Aws::String m_nextToken;
    bool m_nextTokenHasBeenSet = false;

    int m_pageSize;
    bool m_pageSizeHasBeenSet = false;
  };

} // namespace Model
} // namespace PinpointEmail
} // namespace Aws


text:
> DEPRECATED: Please use [xin](https://github.com/xinix-technology/xin)

[![License](http://img.shields.io/badge/license-MIT-red.svg?style=flat-square)](https://github.com/xinix-technology/pants-observe/blob/master/LICENSE)
[![Bower](http://img.shields.io/bower/v/xinix-technology/pants-observe.svg?style=flat-square)](https://github.com/xinix-technology/pants-observe)

pants-observe adalah sebuah pustaka untuk melakukan aktif observasi terhadap perubahan yang terjadi pada sebuah object dan akan memanggil sebuah fungsi callback jika perubahan terjadi. Hal tersebut diinginkan jika seorang developer menginginkan setiap mutasi yang terjadi pada sebuah object dapat memicu perubahan-perubahan di bagian program yang lain juga.

Meski berprefix pants, pants-observe dapat digunakan secara standalone tanpa menggunakan pants.

pants-observe juga menyediakan polyfill yang dibutuhkan dan dapat digunakan terpisah, yaitu:

- WeakMap polyfill (dan penambahan non-standard features) `js/weakmap.poly.js`
- Object.observe polyfill `js/observe.poly.js`

## Instalasi menggunakan bower

Untuk menggunakan pants-observe dapat melalui bower dengan menggunakan cli berikut ini:

```bash
bower install xinix-technology/pants-observe --save
```

Secara umum direktori pants-observe akan berada di dalam direktori `bower_components`. Apabila sebelumnya telah menggunakan perintah `bower init` pada direktori yang sama, maka perintah di atas akan mendaftarkan pants-observe sebagai salah satu dependency pada `bower.json`.

Lalu tambahkan `<script>` pada berkas html yang ingin menggunakan:

```html
<html>
  <head>
    <script type="text/javascript" src="bower_components/pants-observe/js/weakmap.poly.js"></script>
    <script type="text/javascript" src="bower_components/pants-observe/js/observe.poly.js"></script>
    <script type="text/javascript" src="bower_components/pants-observe/js/observe.js"></script>
  </head>
</html>
```

## Contoh penggunaan

Penggunaan pants-observe cukup simple, yang dibutuhkan sebagai argument adalah object yang akan di-observe, path dalam bentuk string yang menyatakan path pada object yang akan di-observe, dan sebuah fungsi callback yang akan dipanggil jika terjadi mutasi pada data.

```javascript
var data = {
  name: 'John Doe'
}

// start observing
var observable = pants.observe(data, 'name', function() {
  // this is callback
});

// do this if you want to remove observe
observable.disconnect();
```


text:
class UservoiceEvent < FlowdockEvent
  register_event "uservoice"

  def render
    @content = @message['content']

    uservoice_text = team_inbox_event(
                  "Uservoice",
                  *event_strings
                )

    render_notice(IrcServer::FLOWDOCK_USER, @target.irc_id, uservoice_text)
  end

  def valid?
    channel?
  end

  private

  def event_strings
    case @content['event']
      when 'new_suggestion'
        suggestion = @content['suggestion']
        [
          "New suggestion: " + suggestion['title'],
          suggestion['url']
        ]
      when 'new_comment'
        comment = @content['comment']
        suggestion = comment['suggestion']
        [
          "New comment on: " + suggestion['title'],
          "> #{first_line(comment['text'])}",
          suggestion['url']
        ]
      when 'new_article'
        article = @content['article']
        [
          "New article: " + article['question'],
          article['url']
        ]
      when 'new_forum'
        forum = @content['forum']
        [
          "New forum: " + forum['name'],
          forum['url']
        ]
      when 'new_kudo'
        kudo = @content['kudo']
        ticket = kudo['ticket']
        [
          kudo['message']['sender']['name'] + " received Kudos! from " + kudo['sender']['name'] + " on " + ticket['subject'],
          ticket['url']
        ]
      when 'new_ticket'
        ticket = @content['ticket']
        [
          "New ticket: " + ticket['subject'],
          ticket['url']
        ]
      when 'new_ticket_reply'
        ticket = @content['ticket']
        [
          "New reply on: " + ticket['subject'],
          ticket['url']
        ]
      when 'suggestion_status_update'
        suggestion = @content['audit_status']['suggestion']
        [
          suggestion['title'] + ": " + suggestion['status']['name'],
          suggestion['url']
        ]
      else
        ["Unknown event"]
    end
  end
end


text:
Branch of LabStreamingLayer (https://code.google.com/p/labstreaminglayer/) for use on gazzlab projects,

LSL source material released under MIT license, all modifications hereby licensed under MIT License as well


text:
package unversioned

import (
	api "k8s.io/kubernetes/pkg/api"
	watch "k8s.io/kubernetes/pkg/watch"
)

// NodeNamespacer has methods to work with Node resources in a namespace
type NodeNamespacer interface {
	Nodes(namespace string) NodeInterface
}

// NodeInterface has methods to work with Node resources.
type NodeInterface interface {
	Create(*api.Node) (*api.Node, error)
	Update(*api.Node) (*api.Node, error)
	Delete(name string, options *api.DeleteOptions) error
	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
	Get(name string) (*api.Node, error)
	List(opts api.ListOptions) (*api.NodeList, error)
	Watch(opts api.ListOptions) (watch.Interface, error)
}

// nodes implements NodeInterface
type nodes struct {
	client *LegacyClient
	ns     string
}

// newNodes returns a Nodes
func newNodes(c *LegacyClient, namespace string) *nodes {
	return &nodes{
		client: c,
		ns:     namespace,
	}
}

// Create takes the representation of a node and creates it.  Returns the server's representation of the node, and an error, if there is any.
func (c *nodes) Create(node *api.Node) (result *api.Node, err error) {
	result = &api.Node{}
	err = c.client.Post().
		Namespace(c.ns).
		Resource("nodes").
		Body(node).
		Do().
		Into(result)
	return
}

// Update takes the representation of a node and updates it. Returns the server's representation of the node, and an error, if there is any.
func (c *nodes) Update(node *api.Node) (result *api.Node, err error) {
	result = &api.Node{}
	err = c.client.Put().
		Namespace(c.ns).
		Resource("nodes").
		Name(node.Name).
		Body(node).
		Do().
		Into(result)
	return
}

// Delete takes name of the node and deletes it. Returns an error if one occurs.
func (c *nodes) Delete(name string, options *api.DeleteOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("nodes").
		Name(name).
		Body(options).
		Do().
		Error()
}

// DeleteCollection deletes a collection of objects.
func (c *nodes) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
	return c.client.Delete().
		NamespaceIfScoped(c.ns, len(c.ns) > 0).
		Resource("nodes").
		VersionedParams(&listOptions, api.Scheme).
		Body(options).
		Do().
		Error()
}

// Get takes name of the node, and returns the corresponding node object, and an error if there is any.
func (c *nodes) Get(name string) (result *api.Node, err error) {
	result = &api.Node{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("nodes").
		Name(name).
		Do().
		Into(result)
	return
}

// List takes label and field selectors, and returns the list of Nodes that match those selectors.
func (c *nodes) List(opts api.ListOptions) (result *api.NodeList, err error) {
	result = &api.NodeList{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("nodes").
		VersionedParams(&opts, api.Scheme).
		Do().
		Into(result)
	return
}

// Watch returns a watch.Interface that watches the requested nodes.
func (c *nodes) Watch(opts api.ListOptions) (watch.Interface, error) {
	return c.client.Get().
		Prefix("watch").
		Namespace(c.ns).
		Resource("nodes").
		VersionedParams(&opts, api.Scheme).
		Watch()
}


text:
package org.hellojavaer.ddal.example.example0.entity;

/**
 *
 * @author Kaiming Zou,created on 16/06/2017.
 */
public class UserEntity {

    private Long   id;
    private String name;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "UserEntity{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}


text:
@interface JGDynamicConstraint : NSObject <NSCopying>

@property (nonatomic) NSObject *object;
@property (nonatomic) NSString *keyPath;

-(id)initWithObject:(NSObject*)object keyPath:(NSString*)keyPath;
+(JGDynamicConstraint*)constraintWithObject:(NSObject*)object keyPath:(NSString*)keyPath;

@end


text:
/**
 * holiday-watchdog-api
 *
 * This file was automatically generated for Holiday Watchdog by APIMATIC v2.0 ( https://apimatic.io ) on 01/16/2017
 */

var _request = require('../Http/Client/RequestClient');
var _configuration = require('../configuration');
var _APIHelper = require('../APIHelper');

var UserReviewController = {

    /**
     * Update instances of the model matched by where from the data source.
     * @param {string|null} where    Optional parameter: Criteria to match model instances
     * @param {UserReview|null} data    Optional parameter: An object of model property name/value pairs
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {mixed}
     */
    updateAll: function (where, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/update";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "where": where,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "POST",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Update attributes for a model instance and persist it into the data source.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {UserReview|null} data    Optional parameter: An object of model property name/value pairs
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReview}
     */
    updateUserReviewupdateAttributes: function (id, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "PUT",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReview(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Counts user-review-internal-comments of UserReview.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {string|null} where    Optional parameter: Criteria to match model instances
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReviewCountUserReviewInternalCommentsResponse}
     */
    getUserReviewCountUserReviewInternalComments: function (id, where, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments/count";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "where": where,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReviewCountUserReviewInternalCommentsResponse(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Creates a new instance in user-review-internal-comments of this model.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {UserReviewInternalComment|null} data    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReviewInternalComment}
     */
    createUserReviewCreateUserReviewInternalComments: function (id, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "POST",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReviewInternalComment(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Queries user-review-internal-comments of UserReview.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {string|null} filter    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {array}
     */
    getUserReviewGetUserReviewInternalComments: function (id, filter, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "filter": filter,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = parsed.map(function(model){
                    return new UserReviewInternalComment(model);
                });
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Delete a related item by id for user-review-internal-comments.
     * @param {string} fk    Required parameter: Foreign key for user-review-internal-comments
     * @param {string} id    Required parameter: PersistedModel id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {void}
     */
    deleteUserReviewDestroyByIdUserReviewInternalComments: function (fk, id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments/{fk}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "fk": fk,
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "DELETE",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                callback(null,null,_context);
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Update a related item by id for user-review-internal-comments.
     * @param {string} fk    Required parameter: Foreign key for user-review-internal-comments
     * @param {string} id    Required parameter: PersistedModel id
     * @param {UserReviewInternalComment|null} data    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReviewInternalComment}
     */
    updateUserReviewUpdateByIdUserReviewInternalComments: function (fk, id, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments/{fk}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "fk": fk,
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "PUT",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReviewInternalComment(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Find a related item by id for user-review-internal-comments.
     * @param {string} fk    Required parameter: Foreign key for user-review-internal-comments
     * @param {string} id    Required parameter: PersistedModel id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReviewInternalComment}
     */
    getUserReviewFindByIdUserReviewInternalComments: function (fk, id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments/{fk}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "fk": fk,
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReviewInternalComment(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Create a new instance of the model and persist it into the data source.
     * @param {UserReview|null} data    Optional parameter: Model instance data
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReview}
     */
    create: function (data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "POST",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReview(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Update an existing model instance or insert a new one into the data source.
     * @param {UserReview|null} data    Optional parameter: Model instance data
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReview}
     */
    updateUpsert: function (data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "PUT",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReview(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Find all instances of the model matched by filter from the data source.
     * @param {string|null} filter    Optional parameter: Filter defining fields, where, include, order, offset, and limit
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {array}
     */
    find: function (filter, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "filter": filter,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = parsed.map(function(model){
                    return new UserReview(model);
                });
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Count instances of the model matched by where from the data source.
     * @param {string|null} where    Optional parameter: Criteria to match model instances
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {CountResponse}
     */
    getCount: function (where, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/count";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "where": where,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new CountResponse(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Find first instance of the model matched by filter from the data source.
     * @param {string|null} filter    Optional parameter: Filter defining fields, where, include, order, offset, and limit
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReview}
     */
    findOne: function (filter, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/findOne";

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "filter": filter,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReview(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Delete a model instance by id from the data source.
     * @param {string} id    Required parameter: Model id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {mixed}
     */
    deleteById: function (id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "DELETE",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Find a model instance by id from the data source.
     * @param {string} id    Required parameter: Model id
     * @param {string|null} filter    Optional parameter: Filter defining fields and include
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserReview}
     */
    findById: function (id, filter, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "filter": filter,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserReview(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Check whether a model instance exists in the data source.
     * @param {string} id    Required parameter: Model id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {ExistsGetUserReviewsIdExistsResponse}
     */
    getExistsGetUserReviewsIdExists: function (id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/exists";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new ExistsGetUserReviewsIdExistsResponse(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Deletes all user-review-internal-comments of this model.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {void}
     */
    deleteUserReviewDeleteUserReviewInternalComments: function (id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user-review-internal-comments";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "DELETE",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                callback(null,null,_context);
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Deletes user of this model.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {void}
     */
    deleteUserReviewDestroyUser: function (id, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "DELETE",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                callback(null,null,_context);
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Creates a new instance in user of this model.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {UserHwd|null} data    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserHwd}
     */
    createUserReviewCreateUser: function (id, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "POST",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserHwd(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Update user of this model.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {UserHwd|null} data    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserHwd}
     */
    updateUserReviewUpdateUser: function (id, data, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "content-type": "application/json; charset=utf-8",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Remove null values
        _APIHelper.cleanObject(data);

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "PUT",
            headers: _headers,
            body : _APIHelper.jsonSerialize(data),
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserHwd(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    },

    /**
     * Fetches hasOne relation user.
     * @param {string} id    Required parameter: PersistedModel id
     * @param {bool|null} refresh    Optional parameter: Example:
     * @param {function} callback    Required parameter: Callback function in the form of function(error, response)
     *
     * @return {UserHwd}
     */
    getUserReviewGetUser: function (id, refresh, callback) {

        //prepare query string for API call;
        var _baseUri = _configuration.BASEURI;

        var _queryBuilder = _baseUri + "/user-reviews/{id}/user";

        //Process template parameters
        _queryBuilder = _APIHelper.appendUrlWithTemplateParameters(_queryBuilder, {
            "id": id
        });

        //Process query parameters
        _queryBuilder = _APIHelper.appendUrlWithQueryParameters(_queryBuilder, {
            "refresh": refresh,
            "Authorization": _configuration.authorization
        });

        //validate and preprocess url
        var _queryUrl = _APIHelper.cleanUrl(_queryBuilder);

        //prepare headers
        var _headers = {
            "accept": "application/json",
            "user-agent": "holidaywatchdog-api-client"
        };

        //Construct the request
        var _options = {
            queryUrl: _queryUrl,
            method: "GET",
            headers: _headers,
        };

        //Build the response processing.
        function cb (_error, _response, _context) {
            if(_error) {
                callback({errorMessage: _error.message, errorCode: _error.code},null,_context);
            } else if (_response.statusCode >= 200 && _response.statusCode <= 206) {
                var parsed = JSON.parse(_response.body);
                parsed = new UserHwd(parsed);
                callback(null,parsed,_context);
            } else if (_response.statusCode == 404) {
                callback(null,null,_context);
                return;
            } else {
                callback({errorMessage: "HTTP Response Not OK", errorCode: _response.statusCode, errorResponse: _response.body}, null, _context);
            }
        }
        _request(_options, cb);
    }

};

module.exports = UserReviewController;


text:
package com.google.jplurk_oauth.module;

import com.google.jplurk_oauth.skeleton.Args;
import org.json.JSONObject;

import com.google.jplurk_oauth.skeleton.AbstractModule;
import com.google.jplurk_oauth.skeleton.HttpMethod;
import com.google.jplurk_oauth.skeleton.RequestException;

public class Emoticons extends AbstractModule {

    /**
     * Get the Emoticons list.
     *
Emoticons are a big part of Plurk since they make it easy to express feelings.

     * @return a JSON object.
     * @throws RequestException
     */
    public JSONObject get() throws RequestException {
        return requestBy("get")
            .withoutArgs().in(HttpMethod.GET).thenJsonObject();
    }

    public JSONObject addFromURL(String url) throws RequestException {
        return requestBy("addFromURL")
                .with(new Args().add("url", url))
                .in(HttpMethod.GET).thenJsonObject();
    }

    public JSONObject addFromURL(String url, Args optional) throws RequestException {
        return requestBy("addFromURL")
                .with(new Args().add("url", url).add(optional))
                .in(HttpMethod.GET).thenJsonObject();
    }

    public JSONObject delete(String url) throws RequestException {
        return requestBy("delete")
                .with(new Args().add("url", url))
                .in(HttpMethod.GET).thenJsonObject();
    }

    @Override
    protected String getModulePath() {
        return "/APP/Emoticons";
    }

}


text:
package org.jetbrains.plugins.scala
package lang
package completion
package filters.expression

import com.intellij.psi.{PsiElement, _}
import com.intellij.psi.filters.ElementFilter
import org.jetbrains.annotations.NonNls
import org.jetbrains.plugins.scala.extensions.PsiFileExt
import org.jetbrains.plugins.scala.lang.completion.ScalaCompletionUtil._
import org.jetbrains.plugins.scala.lang.psi.api.expr._
import org.jetbrains.plugins.scala.lang.scaladoc.psi.api.ScDocComment

/**
* @author Alexander Podkhalyuzin
* Date: 22.05.2008
*/

class CatchFilter extends ElementFilter {
  def isAcceptable(element: Object, context: PsiElement): Boolean = {
    if (context.isInstanceOf[PsiComment]) return false
    val (leaf, _) = processPsiLeafForFilter(getLeafByOffset(context.getTextRange.getStartOffset, context))
    if (leaf != null) {
      var i = getPrevNotWhitespaceAndComment(context.getTextRange.getStartOffset - 1, context)
      var leaf1 = getLeafByOffset(i, context)
      while (leaf1 != null && !leaf1.isInstanceOf[ScTryBlock]) leaf1 = leaf1.getParent
      if (leaf1 == null) return false
      if (leaf1.getTextRange.getEndOffset != i + 1) return false
      i = getNextNotWhitespaceAndComment(context.getTextRange.getEndOffset, context)
      if (Array("catch").contains(getLeafByOffset(i, context).getText)) return false
      return true
    }

    false
  }

  def isClassAcceptable(hintClass: java.lang.Class[_]): Boolean = true

  @NonNls
  override def toString = "statements keyword filter"
}


text:
class AddOfferingsCountToRunnables < ActiveRecord::Migration[5.1]
  def self.up
    add_column :investigations, :offerings_count, :integer, :default => 0
    add_column :resource_pages, :offerings_count, :integer, :default => 0
    add_column :pages, :offerings_count, :integer, :default => 0
    add_column :portal_teachers, :offerings_count, :integer, :default => 0

  end

  def self.down
    remove_column :investigations, :offerings_count
    remove_column :resource_pages, :offerings_count
    remove_column :pages, :offerings_count
    remove_column :portal_teachers, :offerings_count
  end
end


text:
var questions = [
  {
    question: 'HTML:',
    correct: 1,
    choices: [
      'HyperText Markup Letters',
      'HyperText Markup Language',
      'Hyper Transformation Multiple Languages'
    ]
  },
  {
    question: 'CSS:',
    correct: 0,
    choices: [
      'Cascading Style Sheets',
      'Colouring & Styling Sheets',
      'Cascading Styling Scripts'
    ]
  },
  {
    question: 'JS:',
    correct: 2,
    choices: [
      'Johnson Space',
      'Java Semantics',
      'JavaScript'
    ]
  },
  {
    question: 'URL:',
    correct: 0,
    choices: [
      'Uniform Resource Locator',
      'Underworld Reading Lounge',
      'Underline Real Letters'
    ]
  },
  {
    question: 'HTTP:',
    correct: 1,
    choices: [
      'HyperTension Transfer Point',
      'HyperText Transfer Protocol',
      'Hyper Train Transfer Point'
    ]
  },
  {
    question: 'HTTPS:',
    correct: 2,
    choices: [
      'HyperText Transfer Protocol Version "S"',
      'HyperTension Timing Placement System',
      'Secure HyperText Transfer Protocol'
    ]
  },
  {
    question: 'SVG:',
    correct: 0,
    choices: [
      'Scalable Vector Graphics',
      'Super Vector Graphics',
      'Scalable Velocity Gaming'
    ]
  },
  {
    question: 'PNG:',
    correct: 1,
    choices: [
      'Joint Photographic Experts Group',
      'Portable Network Graphics',
      'Graphics Interchange Format'
    ]
  },
  {
    question: 'WWW:',
    correct: 0,
    choices: [
      'World Wide Web',
      'Web Wonder Woman',
      'Wide World Web'
    ]
  },
  {
    question: 'DNS:',
    correct: 2,
    choices: [
      'Domain Numeral Server',
      'Domain Name Security',
      'Domain Name System'
    ]
  },
  {
    question: 'TLD:',
    correct: 2,
    choices: [
      'Tiny Little Domain',
      'Top Last Domain',
      'Top Level Domain'
    ]
  },
  {
    question: 'W3C:',
    correct: 1,
    choices: [
      'World Wide Web Controllers',
      'World Wide Web Consortium',
      'World Web Writers Company'
    ]
  }
];

MultipleChoice(ActivityRunner(), questions);


text:
namespace Photon.Pun
{
    using ExitGames.Client.Photon;
    using Photon.Realtime;
    using UnityEngine;

    #if UNITY_5_5_OR_NEWER
    using UnityEngine.Profiling;
    #endif

    ///
    /// Internal MonoBehaviour that allows Photon to run an Update loop.
    ///
    internal class PhotonHandler : ConnectionHandler, IInRoomCallbacks, IMatchmakingCallbacks
    {
        internal static PhotonHandler Instance;

        protected internal static bool AppQuits;

        protected internal int UpdateInterval; // time [ms] between consecutive SendOutgoingCommands calls

        protected internal int UpdateIntervalOnSerialize; // time [ms] between consecutive RunViewUpdate calls (sending syncs, etc)

        private int nextSendTickCount;

        private int nextSendTickCountOnSerialize;

        private SupportLogger supportLoggerComponent;

        protected override void Awake()
        {
            if (Instance != null && Instance != this && Instance.gameObject != null)
            {
                DestroyImmediate(Instance.gameObject);
            }
            Instance = this;

            this.Client = PhotonNetwork.NetworkingClient;
            base.Awake();

            if (PhotonNetwork.PhotonServerSettings.EnableSupportLogger)
            {
                this.supportLoggerComponent = this.gameObject.AddComponent<SupportLogger>();
                this.supportLoggerComponent.Client = PhotonNetwork.NetworkingClient;
                this.supportLoggerComponent.LogTrafficStats = true;
            }

            this.UpdateInterval = 1000 / PhotonNetwork.SendRate;
            this.UpdateIntervalOnSerialize = 1000 / PhotonNetwork.SerializationRate;

            this.StartFallbackSendAckThread();
        }

        public virtual void OnEnable()
        {
            PhotonNetwork.AddCallbackTarget(this);
        }

        public virtual void OnDisable()
        {
            PhotonNetwork.RemoveCallbackTarget(this);
        }

        #if UNITY_5_4_OR_NEWER

        protected void Start()
        {
            UnityEngine.SceneManagement.SceneManager.sceneLoaded += (scene, loadingMode) =>
            {
                PhotonNetwork.NewSceneLoaded();
                PhotonNetwork.SetLevelInPropsIfSynced(SceneManagerHelper.ActiveSceneName);
            };
        }

        #else

        /// Called by Unity after a new level was loaded.
        protected void OnLevelWasLoaded(int level)
        {
            PhotonNetwork.NewSceneLoaded();
            PhotonNetwork.SetLevelInPropsIfSynced(SceneManagerHelper.ActiveSceneName);
        }

        #endif

        /// Called by Unity when the application is closed. Disconnects.
        protected override void OnApplicationQuit()
        {
            AppQuits = true;
            base.OnApplicationQuit();
        }

        protected void FixedUpdate()
        {
            if (PhotonNetwork.NetworkingClient == null)
            {
                Debug.LogError("NetworkPeer broke!");
                return;
            }

            //if (PhotonNetwork.NetworkClientState == ClientState.PeerCreated || PhotonNetwork.NetworkClientState == ClientState.Disconnected || PhotonNetwork.OfflineMode)
            //{
            //    return;
            //}

            bool doDispatch = true;
            while (PhotonNetwork.IsMessageQueueRunning && doDispatch)
            {
                // DispatchIncomingCommands() returns true of it found any command to dispatch (event, result or state change)
                Profiler.BeginSample("DispatchIncomingCommands");
                doDispatch = PhotonNetwork.NetworkingClient.LoadBalancingPeer.DispatchIncomingCommands();
                Profiler.EndSample();
            }
        }

        public static int MaxDatagrams = 10;
        public static bool SendAsap;

        /// This corrects the "next time to serialize the state" value by some ms. As LateUpdate typically gets called every 15ms it's better to be early(er) than late to achieve a SerializeRate.
        private const int SerializeRateFrameCorrection = 8;

        protected void LateUpdate()
        {
            int currentMsSinceStart = (int)(Time.realtimeSinceStartup * 1000); // avoiding Environment.TickCount, which could be negative on long-running platforms
            if (PhotonNetwork.IsMessageQueueRunning && currentMsSinceStart > this.nextSendTickCountOnSerialize)
            {
                PhotonNetwork.RunViewUpdate();
                this.nextSendTickCountOnSerialize = currentMsSinceStart + this.UpdateIntervalOnSerialize - SerializeRateFrameCorrection;
                this.nextSendTickCount = 0; // immediately send when synchronization code was running
            }

            currentMsSinceStart = (int)(Time.realtimeSinceStartup * 1000);
            if (SendAsap || currentMsSinceStart > this.nextSendTickCount)
            {
                SendAsap = false;
                bool doSend = true;
                int sendCounter = 0;
                while (PhotonNetwork.IsMessageQueueRunning && doSend && sendCounter < MaxDatagrams)
                {
                    // Send all outgoing commands
                    Profiler.BeginSample("SendOutgoingCommands");
                    doSend = PhotonNetwork.NetworkingClient.LoadBalancingPeer.SendOutgoingCommands();
                    sendCounter++;
                    Profiler.EndSample();
                }

                this.nextSendTickCount = currentMsSinceStart + this.UpdateInterval;
            }
        }

        public void OnJoinedRoom()
        {
            PhotonNetwork.LoadLevelIfSynced(); //TODO: do we really need this since we do this inside OnRoomPropertiesUpdate()
        }

        public void OnCreatedRoom()
        {
            PhotonNetwork.SetLevelInPropsIfSynced(SceneManagerHelper.ActiveSceneName);
        }

        public void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
        {
            PhotonNetwork.LoadLevelIfSynced();
        }

        public void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps){}

        public void OnMasterClientSwitched(Player newMasterClient){}

        public void OnFriendListUpdate(System.Collections.Generic.List<FriendInfo> friendList){}

        public void OnCreateRoomFailed(short returnCode, string message){}

        public void OnJoinRoomFailed(short returnCode, string message){}

        public void OnJoinRandomFailed(short returnCode, string message){}

        public void OnLeftRoom(){}

        public void OnPlayerEnteredRoom(Player newPlayer){}

        public void OnPlayerLeftRoom(Player otherPlayer){}
    }
}


text:
<Record>
<Term>Aspiration Pneumonia</Term>
<SemanticType>Disease or Syndrome</SemanticType>
<ParentTerm>Pneumonia</ParentTerm>
<ClassificationPath>Findings_and_Disorders_Kind/Disease, Disorder or Finding/Disease or Disorder/Disorder by Site/Respiratory and Thoracic Disorder/Thoracic Disorder/Non-Neoplastic Thoracic Disorder/Non-Neoplastic Lung Disorder/Pneumonia/Aspiration Pneumonia</ClassificationPath>
<ClassificationPath>Respiratory Tract Diseases/Respiratory Tract Infections/Pneumonia/Pneumonia, Aspiration</ClassificationPath>
<ClassificationPath>Respiratory Tract Diseases/Lung Diseases/Pneumonia/Pneumonia, Aspiration</ClassificationPath>
<BroaderTerm>Respiratory Tract Diseases</BroaderTerm>
<BroaderTerm>Thoracic Disorder</BroaderTerm>
<BroaderTerm>Non-Neoplastic Lung Disorder</BroaderTerm>
<BroaderTerm>Respiratory Tract Infections</BroaderTerm>
<BroaderTerm>Disorder by Site</BroaderTerm>
<BroaderTerm>Lung Diseases</BroaderTerm>
<BroaderTerm>Pneumonia</BroaderTerm>
<BroaderTerm>Findings_and_Disorders_Kind</BroaderTerm>
<BroaderTerm>Disease, Disorder or Finding</BroaderTerm>
<BroaderTerm>Disease or Disorder</BroaderTerm>
<BroaderTerm>Non-Neoplastic Thoracic Disorder</BroaderTerm>
<BroaderTerm>Aspiration Pneumonia</BroaderTerm>
<BroaderTerm>Respiratory and Thoracic Disorder</BroaderTerm>
<BroaderTerm>Pneumonia, Aspiration</BroaderTerm>
<ChildTerm>Pneumonia, Lipid</ChildTerm>
<Synonym>Aspiration Pneumonias</Synonym>
<Synonym>Aspiration Pneumonia</Synonym>
<Synonym>Mendelson Syndrome</Synonym>
<Synonym>Acid Aspiration Syndrome</Synonym>
<Synonym>Mendelsons Syndrome</Synonym>
<Synonym>Acid Aspiration Syndromes</Synonym>
<Synonym>Mendelson's Syndrome</Synonym>
<Synonym>Gastric Acid Aspiration Syndrome</Synonym>
<Description>A type of lung inflammation resulting from the aspiration of food, liquid, or gastric contents into the upper RESPIRATORY TRACT.</Description>
<Source>NCI Thesaurus</Source>
<Source>MeSH</Source>
</Record>


text:
package com.gs.collections.impl;

public interface PerformanceTests
{
}


text:
<?php

// autoload_real.php @generated by Composer

class ComposerAutoloaderInit03791c80f89ebc64f9a20439054bf6e3
{
    private static $loader;

    public static function loadClassLoader($class)
    {
        if ('Composer\Autoload\ClassLoader' === $class) {
            require __DIR__ . '/ClassLoader.php';
        }
    }

    public static function getLoader()
    {
        if (null !== self::$loader) {
            return self::$loader;
        }

        spl_autoload_register(array('ComposerAutoloaderInit03791c80f89ebc64f9a20439054bf6e3', 'loadClassLoader'), true, true);
        self::$loader = $loader = new \Composer\Autoload\ClassLoader();
        spl_autoload_unregister(array('ComposerAutoloaderInit03791c80f89ebc64f9a20439054bf6e3', 'loadClassLoader'));

        $map = require __DIR__ . '/autoload_namespaces.php';
        foreach ($map as $namespace => $path) {
            $loader->set($namespace, $path);
        }

        $map = require __DIR__ . '/autoload_psr4.php';
        foreach ($map as $namespace => $path) {
            $loader->setPsr4($namespace, $path);
        }

        $classMap = require __DIR__ . '/autoload_classmap.php';
        if ($classMap) {
            $loader->addClassMap($classMap);
        }

        $loader->register(true);

        $includeFiles = require __DIR__ . '/autoload_files.php';
        foreach ($includeFiles as $file) {
            composerRequire03791c80f89ebc64f9a20439054bf6e3($file);
        }

        return $loader;
    }
}

function composerRequire03791c80f89ebc64f9a20439054bf6e3($file)
{
    require $file;
}


text:
"""Command

Collection of functions to create the command line utility.

"""

import os
import sys
import os.path as pth
from dateutil import parser
from datetime import datetime
from subprocess import Popen, PIPE

def error(msg):
    "Print a message to the standard error stream and exit. "
    sys.stderr.write(msg)
    sys.exit(2)

def warn(msg):
    "Print a message to the standard error "
    sys.stderr.write(msg)

def disp(msg):
    "Print a message to the standard output "
    sys.stdout.write(msg)

def import_mod(name):
    "Return a module by string. "
    mod = __import__(name)
    for sub in name.split(".")[1:]:
        mod = getattr(mod, sub)
    return mod

def exec_cmd(cmd, verbose=False):
    "Run a subprocess and return its output and errors. "
    if verbose:
        out = sys.stdout
        err = sys.stderr
    else:
        out = PIPE
        err = PIPE
    process = Popen(cmd, shell=True,
                    universal_newlines=True, executable="/bin/bash",
                    stdout=out, stderr=err)
    out, err = process.communicate()
    return out, err, process.returncode

# pylint: disable=E1103
# The reason for this pylint error is that it thinks of
# `now` as a `tuple` instead of a `datetime` object.
def date(short=False):
    "Return the current date as a string. "
    if isinstance(short, str):
        now = parser.parse(str(short))
        return now.strftime("%a %b %d, %Y %r")
    now = datetime.now()
    if not short:
        return now.strftime("%a %b %d, %Y %r")
    return now.strftime("%Y-%m-%d-%H-%M-%S")

def make_dir(path):
    "Create a directory if it does not exist and return True. "
    if pth.exists(path):
        return False
    os.makedirs(path)
    return True

def append_variable(var, val):
    """Return a valid bash string to append a value to a variable. """
    ans = 'if [[ ":$%s:" != *":%s:"* ]]; then\n' % (var, val)
    ans += '    export %s=%s:$%s\n' % (var, val, var)
    return ans + 'fi\n'


text:
class LeaguesCanManageGames < ActiveRecord::Migration
  def self.up
    add_column :leagues, :supports_games, :boolean, :default => true
    League.update_all ["supports_games = ?", true]
  end

  def self.down
    remove_column :leagues, :supports_games
  end
end


text:
function FakeTreeEntry(options) {
    this._name = options.name;
    this._path = options.path;
    this._mode = options.mode;
    this._target = options.target;
    this._isTree = options.isTree;
    this._isBlob = options.isBlob;
    this._getTarget = options.getTarget;
}

FakeTreeEntry.prototype.name = function () {
    return this._name;
};

FakeTreeEntry.prototype.path = function () {
    return this._path;
};

FakeTreeEntry.prototype.mode = function () {
    return this._mode;
};

FakeTreeEntry.prototype.isBlob = function () {
    return typeof this._isBlob === 'boolean' ? this._isBlob : isBlob(this._target);
};

FakeTreeEntry.prototype.getBlob = function () {
    process.nextTick(function () {
        if (this.isBlob()) {
            cb(null, this._target);
        } else {
            cb(new Error('Not a Blob'));
        }
    }.bind(this));
};

FakeTreeEntry.prototype.isTree = function () {
    return typeof this._isTree === 'boolean' ? this._isTree : isTree(this._target);
};

FakeTreeEntry.prototype.getTree = function () {
    process.nextTick(function () {
        if (this.isTree()) {
            cb(null, this._target);
        } else {
            cb(new Error('Not a Tree'));
        }
    }.bind(this));
};

module.exports = FakeTreeEntry;