text:
<?php
namespace Raml\Validator;

use Exception;
use Psr\Http\Message\RequestInterface;
use Raml\Exception\InvalidSchemaException;
use Raml\Exception\ValidationException;
use Raml\NamedParameter;

class RequestValidator
{
    /**
     * @var ValidatorSchemaHelper
     */
    private $schemaHelper;

    /**
     * @param ValidatorSchemaHelper $schema
     */
    public function __construct(ValidatorSchemaHelper $schema)
    {
        $this->schemaHelper = $schema;
    }

    /**
     * @param RequestInterface $request
     * @throws Exception
     */
    public function validateRequest(RequestInterface $request)
    {
        $this->assertNoMissingParameters($request);
        $this->assertValidParameters($request);
        $this->assertValidBody($request);
    }

    /**
     * @param RequestInterface $request
     * @throws ValidatorRequestException
     */
    private function assertNoMissingParameters(RequestInterface $request)
    {
        $method = $request->getMethod();
        $path = $request->getUri()->getPath();

        $schemaParameters = $this->schemaHelper->getQueryParameters($method, $path, true);
        $requestParameters = $this->getRequestParameters($request);

        $missingParameters = array_diff_key($schemaParameters, $requestParameters);
        if (count($missingParameters) === 0) {
            return;
        }

        throw new ValidatorRequestException(sprintf(
            'Missing request parameters required by the schema for `%s %s`: %s',
            strtoupper($method),
            $path,
            join(', ', array_keys($missingParameters))
        ));
    }

    /**
     * @param RequestInterface $request
     * @throws ValidatorRequestException
     */
    private function assertValidParameters(RequestInterface $request)
    {
        $method = $request->getMethod();
        $path = $request->getUri()->getPath();

        $schemaParameters = $this->schemaHelper->getQueryParameters($method, $path);
        $requestParameters = $this->getRequestParameters($request);

        /** @var NamedParameter $schemaParameter */
        foreach ($schemaParameters as $schemaParameter) {
            $key = $schemaParameter->getKey();

            if (!array_key_exists($key, $requestParameters)) {
                continue;
            }

            try {
                $schemaParameter->validate($requestParameters[$key]);
            } catch (ValidationException $exception) {
                $message = sprintf(
                    'Request parameter does not match schema for `%s %s`: %s',
                    strtoupper($method),
                    $path,
                    $exception->getMessage()
                );

                throw new ValidatorRequestException($message, 0, $exception);
            }
        }
    }

    /**
     * @param RequestInterface $request
     */
    private function assertValidBody(RequestInterface $request)
    {
        $body = $request->getBody()->getContents();

        $method = $request->getMethod();
        $path = $request->getUri()->getPath();
        $contentType = $request->getHeaderLine('Content-Type');

        $schemaBody = $this->schemaHelper->getRequestBody($method, $path, $contentType);

        try {
            $schemaBody->getSchema()->validate($body);
        } catch (InvalidSchemaException $exception) {
            $message = sprintf(
                'Request body for %s %s with content type %s does not match schema: %s',
                strtoupper($method),
                $path,
                $contentType,
                $this->getSchemaErrorsAsString($exception->getErrors())
            );

            throw new ValidatorRequestException($message, 0, $exception);
        }
    }

    /**
     * @param RequestInterface $request
     * @return array
     */
    private function getRequestParameters(RequestInterface $request)
    {
        parse_str($request->getUri()->getQuery(), $requestParameters);

        return $requestParameters;
    }

    /**
     * @param array $errors
     * @return string
     */
    private function getSchemaErrorsAsString(array $errors)
    {
        return join(', ', array_map(function (array $error) {
            return sprintf('%s (%s)', $error['property'], $error['constraint']);
        }, $errors));
    }
}


text:
package org.olat.data.portfolio.structure;

/**
 * Description:

 *

 * Initial Date: 11 oct. 2010

 *
 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 */
public enum ElementType {
    DEFAULT_MAP(), STRUCTURED_MAP(), TEMPLATE_MAP();

}

redpajama_set_name: RedPajamaGithub


text:
package org.slc.sli.sif.domain.converter;

import java.util.List;

import junit.framework.Assert;
import openadk.library.common.Email;
import openadk.library.common.EmailList;
import openadk.library.common.EmailType;

import org.junit.Test;

import org.slc.sli.sif.AdkTest;
import org.slc.sli.sif.domain.slientity.ElectronicMail;

/**
 * Unit tests for EmailListConverter
 *
 * @author jtully
 *
 *         <xs:enumeration value="Home/Personal" />
 *         <xs:enumeration value="Organization" />
 *         <xs:enumeration value="Other" />
 *         <xs:enumeration value="Work" />
 *
 */

public class EmailListConverterTest extends AdkTest {

    private final EmailListConverter converter = new EmailListConverter();

    @Test
    public void testNullObject() {
        List<ElectronicMail> result = converter.convert(null);
        Assert.assertNull("Address list should be null", result);
    }

    @Test
    public void testEmptyList() {
        EmailList list = new EmailList();
        List<ElectronicMail> result = converter.convert(list);
        Assert.assertEquals(0, result.size());
    }

    @Test
    public void testEmptyEmail() {
        EmailList list = new EmailList();
        list.add(new Email());
        List<ElectronicMail> result = converter.convert(list);

        Assert.assertEquals(1, result.size());

        ElectronicMail sliEmail = result.get(0);
        Assert.assertNull(sliEmail.getEmailAddressType());
        Assert.assertNull(sliEmail.getEmailAddress());
    }

    @Test
    public void testMappings() {
        EmailList emails = createEmailList();
        List<ElectronicMail> result = converter.convert(emails);
        Assert.assertEquals("Should map 5 emails", 5, result.size());

        for (int i = 0; i < 5; i++) {
            Assert.assertNotNull(result.get(i));
            Assert.assertEquals(result.get(i).getEmailAddress(), "email" + i);
            Assert.assertEquals(result.get(i).getEmailAddressType(), null);
        }
    }

    private EmailList createEmailList() {
        EmailList emails = new EmailList();
        emails.add(new Email(EmailType.PRIMARY, "email0"));
        emails.add(new Email(EmailType.ALT1, "email1"));
        emails.add(new Email(EmailType.ALT2, "email2"));
        emails.add(new Email(EmailType.ALT3, "email3"));
        emails.add(new Email(EmailType.ALT4, "email4"));
        return emails;
    }

}


text:
package com.flower.admin;

import java.io.PrintWriter;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.guyou.web.server.AbstractHttpHelper;
import org.guyou.web.server.HibernateSessionFactory;
import org.guyou.web.server.HttpListening;
import org.guyou.web.server.Response;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;

import com.flower.tables.Customer;
import com.flower.tables.FlowerTemplate;
import com.flower.tables.GoodsEntity;
import com.flower.tables.GoodsOrder;
import com.flower.tables.GoodsTemplate;
/**
 * @author 王雪冬
 *用户后台管理
 */
public class CustomerHelper  extends AbstractHttpHelper{

	private static final Logger log = Logger.getLogger(FlowersHelper.class);

	/**
	 * 用户详情
	 * @param request
	 * @param response
	 * @param out
	 * @return
	 * @throws Exception
	 */
	@HttpListening(urlPattern="/admin/customerHelper/getCustomerDetails.do",isCheckSession=true)
	public Response getCustomerDetails(HttpServletRequest request,HttpServletResponse response,PrintWriter out) throws Exception{
		String uid = request.getParameter("uid");
		//查询总消费金额
		Double sumMony = getSumMoney(uid);
		request.setAttribute("sumMony", sumMony);
		//查询所有交易记录
		List goodsOrderList = getGoodsOrderAll(uid);
		request.setAttribute("goodsOrderList", goodsOrderList);
		//用户花仓
		List goodsEntityList = getGoodsEntity(uid);
		request.setAttribute("goodsEntityList", goodsEntityList);
		//用户详情
		Object customer = getCustomer(uid);
		request.setAttribute("customer", customer);
		return Response.forward("/admin/customer_sets/customerDetails.jsp");
	}
	private Object getCustomer(String uid) {
		Session session = HibernateSessionFactory.getSession();
		Query query = session.createSQLQuery("select * from "+Customer.class.getSimpleName()+" where uid =?").setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).setString(0,uid);
		return query.uniqueResult();
	}
	private List getGoodsEntity(String uid) {
		Session db =  HibernateSessionFactory.getSession();
		String sql = "select ge.actualpay,ge.gainTime,ge.state,gt.name from "+GoodsEntity.class.getSimpleName()+" ge left join "+GoodsTemplate.class.getSimpleName()+" gt on ge.goods_template_id=gt.id where ge.uid =?";
		Query query = db.createSQLQuery(sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).setString(0,uid);
	    return query.list();
	}
	private List getGoodsOrderAll(String uid) {
		Session db =  HibernateSessionFactory.getSession();
		String sql = "select go.state,go.payTime,go.payMoney,go.goodsIds,gt.name from "+GoodsOrder.class.getSimpleName()+" go left join "+GoodsTemplate.class.getSimpleName()+" gt on gt.id in(go.goodsIds) where go.uid=?";
		Query query = db.createSQLQuery(sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).setString(0,uid);
	    return query.list();
	}
	private Double getSumMoney(String uid) {
		Session db =  HibernateSessionFactory.getSession();
		String sql = "select sum(payMoney) from "+GoodsOrder.class.getSimpleName()+" where state!=1 and uid=?";
		Query query = db.createSQLQuery(sql).setString(0,uid);
		return (Double)query.uniqueResult();
	}
	/**
	 * 用户检索
	 * @param request
	 * @param response
	 * @param out
	 * @return
	 * @throws Exception
	 */
	@HttpListening(urlPattern="/admin/customerHelper/getCustomerList.do",isCheckSession=true)
	public Response getFlowersList(HttpServletRequest request,HttpServletResponse response,PrintWriter out) throws Exception{
		String keyword = request.getParameter("keyword");
		List customerList = getCustomerList(keyword);
		request.setAttribute("customerList", customerList);
		return Response.forward("/admin/customer_sets/customerList.jsp");
	}
	private List getCustomerList(String keyword) {
        Session db =  HibernateSessionFactory.getSession();
		String sql = "select uid,phone,email,nickname,sex,flowerSeed from "+Customer.class.getSimpleName()+" where phone like '%"+keyword+"%'";
		Query query = db.createSQLQuery(sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
	    return query.list();
	}
}


text:
layout: post-no-feature
title: "Things to work on this week"
description: "Sunday night brain dump"
category: articles
comments: true
tags: [note to self]
---

* Add more features to snake game to better understand the code it's built from, particularly the CHUNK.js library. Adding an initializer to prompt the user to click 'play' before starting the game seems like an achievable next step.
* Try out Jessica Lord's Instagram grid feed.
* What fun, useful things can I do with the Fitbit data I'm accumulating? The sleep tracker has been especially fascinating.
* Make the other parts of my site responsive.
* Complete at least one Coderbyte exercise every day.
* I wonder if I could build a camera control/command center for Dad's cat-watching. Woah.


text:
/* This is a "stub" implementation of the "c_locale.h" interface,
   intended for operating systems where we have not yet written
   a real implementation.  A C++ library using this stub implementation
   is still standard-conforming, since the C++ standard does not require
   that any locales other than "C" be supported.
*/

/* Framework functions */

void _Locale_init()
{}

void _Locale_final()
{}

void *_Locale_ctype_create(const char * __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

void *_Locale_numeric_create(const char * __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

void *_Locale_time_create(const char * __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

void *_Locale_collate_create(const char *__DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

void *_Locale_monetary_create(const char * __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

void *_Locale_messages_create(const char *__DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

const char *_Locale_ctype_default(char* __DUMMY_PAR)    { return 0; }
const char *_Locale_numeric_default(char * __DUMMY_PAR) { return 0; }
const char *_Locale_time_default(char* __DUMMY_PAR)     { return 0; }
const char *_Locale_collate_default(char* __DUMMY_PAR)  { return 0; }
const char *_Locale_monetary_default(char* __DUMMY_PAR) { return 0; }
const char *_Locale_messages_default(char* __DUMMY_PAR) { return 0; }

char const* _Locale_ctype_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

char const* _Locale_numeric_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

char const* _Locale_time_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

char const* _Locale_collate_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

char const* _Locale_monetary_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

char const* _Locale_messages_name(const void* __DUMMY_PAR1, char* __DUMMY_PAR)
{ return 0; }

void _Locale_ctype_destroy(void* __DUMMY_PAR)    {}
void _Locale_numeric_destroy(void* __DUMMY_PAR)  {}
void _Locale_time_destroy(void* __DUMMY_PAR)     {}
void _Locale_collate_destroy(void* __DUMMY_PAR)  {}
void _Locale_monetary_destroy(void* __DUMMY_PAR) {}
void _Locale_messages_destroy(void* __DUMMY_PAR) {}

char const* _Locale_extract_ctype_name(const char* __DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_extract_numeric_name(const char*__DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_extract_time_name(const char*__DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_extract_collate_name(const char*__DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_extract_monetary_name(const char*__DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_extract_messages_name(const char*__DUMMY_PAR1, char* __DUMMY_PAR, struct _Locale_name_hint* hint)
{ return 0; }

char const* _Locale_compose_name(char*__DUMMY_PAR1, const char*__DUMMY_PAR2, const char*__DUMMY_PAR3,
                           const char*__DUMMY_PAR4,
                           const char*__DUMMY_PAR5, const char*__DUMMY_PAR6, const char*__DUMMY_PAR7, const char*__DUMMY_PAR8)
{ return 0; }

struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype* ctype)
{ return 0; }
struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric* numeric)
{ return 0; }
struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time* time)
{ return 0; }
struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate* collate)
{ return 0; }
struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary* monetary)
{ return 0; }
struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages* messages)
{ return 0; }

/* ctype */

const  _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* __DUMMY_PAR)
{ return 0; }

int _Locale_toupper(struct _Locale_ctype*__DUMMY_PAR1, int __DUMMY_PAR) { return 0; }

int _Locale_tolower(struct _Locale_ctype*__DUMMY_PAR1, int __DUMMY_PAR) { return 0; }

# ifndef _STLP_NO_WCHAR_T
_Locale_mask_t _Locale_wchar_ctype(struct _Locale_ctype*__DUMMY_PAR1, wint_t __DUMMY_PAR2, _Locale_mask_t __DUMMY_PAR3)
{ return 0; }

wint_t _Locale_wchar_tolower(struct _Locale_ctype*__DUMMY_PAR1, wint_t __DUMMY_PAR)
{ return 0; }

wint_t _Locale_wchar_toupper(struct _Locale_ctype*__DUMMY_PAR1, wint_t __DUMMY_PAR)
{ return 0; }
# endif

# ifndef _STLP_NO_MBSTATE_T

int _Locale_mb_cur_max (struct _Locale_ctype * __DUMMY_PAR) { return 0; }
int _Locale_mb_cur_min (struct _Locale_ctype * __DUMMY_PAR) { return 0; }
int _Locale_is_stateless (struct _Locale_ctype * __DUMMY_PAR) { return 1; }
#ifndef _STLP_NO_WCHAR_T
wint_t _Locale_btowc(struct _Locale_ctype * __DUMMY_PAR1, int __DUMMY_PAR) { return 0; }

int _Locale_wctob(struct _Locale_ctype * __DUMMY_PAR2, wint_t __DUMMY_PAR) { return 0; }

size_t _Locale_mbtowc(struct _Locale_ctype *__DUMMY_PAR1,
                      wchar_t *__DUMMY_PAR2,
                      const char *__DUMMY_PAR3, size_t __DUMMY_PAR4,
                      mbstate_t *__DUMMY_PAR5)
{ return (size_t) -1; }

size_t _Locale_wctomb(struct _Locale_ctype *__DUMMY_PAR1,
                      char *__DUMMY_PAR2, size_t __DUMMY_PAR3,
                      const wchar_t __DUMMY_PAR4,
                      mbstate_t *__DUMMY_PAR5)
{ return (size_t) -1; }
# endif

size_t _Locale_unshift(struct _Locale_ctype *__DUMMY_PAR1,
                       mbstate_t *__DUMMY_PAR2,
                       char *__DUMMY_PAR3, size_t __DUMMY_PAR4, char ** __DUMMY_PAR5)
{ return (size_t) -1; }

# endif /*  _STLP_NO_MBSTATE_T */

/* Collate */
 int _Locale_strcmp(struct _Locale_collate* __DUMMY_PAR1,
                    const char* __DUMMY_PAR2, size_t __DUMMY_PAR3, const char* __DUMMY_PAR4,
                    size_t __DUMMY_PAR5)
{ return 0; }

# ifndef _STLP_NO_WCHAR_T

int _Locale_strwcmp(struct _Locale_collate* __DUMMY_PAR1,
                    const wchar_t* __DUMMY_PAR2, size_t __DUMMY_PAR3,
                    const wchar_t* __DUMMY_PAR4, size_t __DUMMY_PAR5)
{ return 0; }

# endif

size_t _Locale_strxfrm(struct _Locale_collate* __DUMMY_PAR1,
                       char* __DUMMY_PAR2, size_t __DUMMY_PAR3,
                       const char* __DUMMY_PAR4, size_t __DUMMY_PAR5)
{ return 0; }

# ifndef _STLP_NO_WCHAR_T

size_t _Locale_strwxfrm(struct _Locale_collate* __DUMMY_PAR1,
                        wchar_t* __DUMMY_PAR2, size_t __DUMMY_PAR3,
                        const wchar_t* __DUMMY_PAR4, size_t __DUMMY_PAR5)
{ return 0; }

# endif

/* Numeric */

char _Locale_decimal_point(struct _Locale_numeric* __DUMMY_PAR) { return '.'; }
char _Locale_thousands_sep(struct _Locale_numeric* __DUMMY_PAR) { return ','; }
const char* _Locale_grouping(struct _Locale_numeric * __DUMMY_PAR)
{ return ""; }

const char * _Locale_true(struct _Locale_numeric * __DUMMY_PAR)  { return 0; }
const char * _Locale_false(struct _Locale_numeric * __DUMMY_PAR) { return 0; }

/* Monetary */

const char* _Locale_int_curr_symbol(struct _Locale_monetary * __DUMMY_PAR)
{ return 0; }
const char* _Locale_currency_symbol(struct _Locale_monetary * __DUMMY_PAR)
{ return 0; }
char        _Locale_mon_decimal_point(struct _Locale_monetary * __DUMMY_PAR)
{ return '.'; }
char        _Locale_mon_thousands_sep(struct _Locale_monetary * __DUMMY_PAR)
{ return ','; }
const char* _Locale_mon_grouping(struct _Locale_monetary * __DUMMY_PAR)
{ return ""; }
const char* _Locale_positive_sign(struct _Locale_monetary * __DUMMY_PAR)
{ return ""; }
const char* _Locale_negative_sign(struct _Locale_monetary * __DUMMY_PAR)
{ return ""; }
char        _Locale_int_frac_digits(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
char        _Locale_frac_digits(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int         _Locale_p_cs_precedes(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int         _Locale_p_sep_by_space(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int         _Locale_p_sign_posn(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int         _Locale_n_cs_precedes(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int          _Locale_n_sep_by_space(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }
int          _Locale_n_sign_posn(struct _Locale_monetary * __DUMMY_PAR)
{ return CHAR_MAX; }

/* Time */
const char * _Locale_full_monthname(struct _Locale_time * __DUMMY_PAR1, int __DUMMY_PAR2)
{ return 0; }
const char * _Locale_abbrev_monthname(struct _Locale_time * __DUMMY_PAR1, int __DUMMY_PAR2)
{ return 0; }
const char * _Locale_full_dayofweek(struct _Locale_time * __DUMMY_PAR1, int __DUMMY_PAR2)
{ return 0; }
const char * _Locale_abbrev_dayofweek(struct _Locale_time * __DUMMY_PAR1, int __DUMMY_PAR2)
{ return 0; }

const char* _Locale_d_t_fmt(struct _Locale_time* __DUMMY_PAR)    { return 0; }
const char* _Locale_d_fmt(struct _Locale_time* __DUMMY_PAR)      { return 0; }
const char* _Locale_t_fmt(struct _Locale_time* __DUMMY_PAR)      { return 0; }
const char* _Locale_long_d_t_fmt(struct _Locale_time* __DUMMY_PAR){ return 0; }
const char* _Locale_long_d_fmt(struct _Locale_time* __DUMMY_PAR)   { return 0; }
const char* _Locale_am_str(struct _Locale_time* __DUMMY_PAR)     { return 0; }
const char* _Locale_pm_str(struct _Locale_time* __DUMMY_PAR)     { return 0; }
const char* _Locale_t_fmt_ampm(struct _Locale_time* __DUMMY_PAR) { return 0; }

/* Messages */

nl_catd_type _Locale_catopen(struct _Locale_messages* __DUMMY_PAR1, const char* __DUMMY_PAR)
{ return -1; }
void _Locale_catclose(struct _Locale_messages* __DUMMY_PAR1, nl_catd_type __DUMMY_PAR) {}
const char* _Locale_catgets(struct _Locale_messages* __DUMMY_PAR1, nl_catd_type __DUMMY_PAR2,
                            int __DUMMY_PAR3, int __DUMMY_PAR4,
                            const char *dfault)
{ return dfault; }


text:
<!DOCTYPE html>

	<meta charset="utf-8">
	<title>Phaser Source: src/pixi/renderers/webgl/utils/WebGLSpriteBatch.js</title>

	<link type="text/css" rel="stylesheet" href="styles/default.css">

	<link type="text/css" rel="stylesheet" href="styles/sunlight.default.css">

	<link type="text/css" rel="stylesheet" href="styles/site.cerulean.css">

			Phaser API

					Namespaces

							Phaser

							PIXI

					Classes

							EarCut

							Event

							EventTarget

							Animation

							AnimationManager

							AnimationParser

							ArraySet

							ArrayUtils

							AudioSprite

							BitmapData

							BitmapText

							Bullet

							Button

							Cache

							Camera

							Canvas

							CanvasPool

							Circle

							Color

							Angle

							Animation

							AutoCull

							Bounds

							BringToTop

							Core

							Crop

							Delta

							Destroy

							FixedToCamera

							Health

							InCamera

							InputEnabled

							InWorld

							LifeSpan

							LoadTexture

							Overlap

							PhysicsBody

							Reset

							ScaleMinMax

							Smoothed

							Create

							Creature

							Device

							DeviceButton

							DOM

							Easing

							Back

							Bounce

							Circular

							Cubic

							Elastic

							Exponential

							Linear

							Quadratic

							Quartic

							Quintic

							Sinusoidal

							Ellipse

							Events

							Filter

							FlexGrid

							FlexLayer

							Frame

							FrameData

							Game

							GameObjectCreator

							GameObjectFactory

							Gamepad

							Graphics

							Group

							Hermite

							Image

							ImageCollection

							Input

							InputHandler

							Key

							Keyboard

							KeyCode

							Line

							LinkedList

							Loader

							LoaderParser

							Math

							Matrix

							Mouse

							MSPointer

							Net

							Particle

							Particles

							Arcade

							Emitter

							Path

							PathFollower

							PathPoint

							Physics

							Arcade

							Body

							TilemapCollision

							Ninja

							AABB

							Body

							Circle

							Tile

							P2

							Body

							BodyDebug

							CollisionGroup

							ContactMaterial

							DistanceConstraint

							FixtureList

							GearConstraint

							InversePointProxy

							LockConstraint

							Material

							PointProxy

							PrismaticConstraint

							RevoluteConstraint

							RotationalSpring

							Spring

							Plugin

							PathManager

							PluginManager

							Point

							Pointer

							PointerMode

							Polygon

							QuadTree

							RandomDataGenerator

							Rectangle

							RenderTexture

							RequestAnimationFrame

							RetroFont

							Rope

							RoundedRectangle

							ScaleManager

							Signal

							SignalBinding

							SinglePad

							Sound

							SoundManager

							Sprite

							SpriteBatch

							Stage

							State

							StateManager

							Text

							Tile

							Tilemap

							TilemapLayer

							TilemapParser

							Tileset

							TileSprite

							Time

							Timer

							TimerEvent

							Touch

							Tween

							TweenData

							TweenManager

							Utils

							Debug

							Video

							Weapon

							World

							BaseTexture

							CanvasBuffer

							CanvasGraphics

							CanvasMaskManager

							CanvasRenderer

							CanvasTinter

							ComplexPrimitiveShader

							DisplayObject

							DisplayObjectContainer

							FilterTexture

							Phaser.GraphicsData

							PIXI

							PixiFastShader

							PixiShader

							PrimitiveShader

							Sprite

							StripShader

							Texture

							WebGLBlendModeManager

							WebGLFastSpriteBatch

							WebGLFilterManager

							WebGLRenderer

					Global

							ANGLE_DOWN

							ANGLE_LEFT

							ANGLE_NORTH_EAST

							ANGLE_NORTH_WEST

							ANGLE_RIGHT

							ANGLE_SOUTH_EAST

							ANGLE_SOUTH_WEST

							ANGLE_UP

							arc

							AUTO

							beginFill

							bezierCurveTo

							BITMAPDATA

							BITMAPTEXT

							blendModes

							BOTTOM_CENTER

							BOTTOM_LEFT

							BOTTOM_RIGHT

							BUTTON

							CANVAS

							CANVAS_FILTER

							CENTER

							CIRCLE

							clear

							CREATURE

							destroyCachedSprite

							displayList

							DOWN

							drawCircle

							drawEllipse

							drawPolygon

							drawRect

							drawRoundedRect

							drawShape

							ELLIPSE

							emit

							EMITTER

							endFill

							GAMES

							generateTexture

							getBounds

							getLocalBounds

							GRAPHICS

							GROUP

							HEADLESS

							HORIZONTAL

							IMAGE

							LANDSCAPE

							LEFT

							LEFT_BOTTOM

							LEFT_CENTER

							LEFT_TOP

							LINE

							lineStyle

							lineTo

							listeners

							MATRIX

							mixin

							moveTo

							NONE

							off

							on

							once

							PENDING_ATLAS

							Phaser.Path#numPoints
return {number} The total number of PathPoints in this Path.

							POINT

							POINTER

							POLYGON

							PORTRAIT

							quadraticCurveTo

							RECTANGLE

							removeAllListeners

							RENDERTEXTURE

							RETROFONT

							RIGHT

							RIGHT_BOTTOM

							RIGHT_CENTER

							RIGHT_TOP

							ROPE

							ROUNDEDRECTANGLE

							scaleModes

							SPRITE

							SPRITEBATCH

							stopImmediatePropagation

							stopPropagation

							TEXT

							TILEMAP

							TILEMAPLAYER

							TILESPRITE

							TOP_CENTER

							TOP_LEFT

							TOP_RIGHT

							UP

							updateLocalBounds

							VERSION

							VERTICAL

							VIDEO

							WEBGL

							WEBGL_FILTER

							WEBGL_MULTI

					Core

Game

Group

World

Loader

Cache

Time

Camera

State Manager

Tween Manager

Sound Manager

Input Manager

Scale Manager

					Game Objects

Factory (game.add)

Creator (game.make)

Sprite

Image

Sound

Video

Particle Emitter

Particle

Text

Tween

BitmapText

Tilemap

BitmapData

RetroFont

Button

Animation

Graphics

RenderTexture

TileSprite

					Geometry

Circle

Ellipse

Line

Matrix

Point

Polygon

Rectangle

Rounded Rectangle

					Physics

Arcade Physics

Body

Weapon

P2 Physics

Body

Spring

CollisionGroup

ContactMaterial

Ninja Physics

Body

					Input

Input Handler

Pointer

Device Button

Mouse

Keyboard

Key

Key Codes

Gamepad

					Community

Phaser Web Site

Phaser Github

Phaser Examples

Phaser Plugins

Forum

Stack Overflow

Tutorials

Newsletter

Twitter

Slack

Donate

Texture Packer

Source: src/pixi/renderers/webgl/utils/WebGLSpriteBatch.js

/**
 * @author Mat Groves
 *
 * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/
 * for creating the original pixi version!
 * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now share 4 bytes on the vertex buffer
 *
 * Heavily inspired by LibGDX's WebGLSpriteBatch:
 * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/WebGLSpriteBatch.java
 */

/**
 *
 * @class WebGLSpriteBatch
 * @private
 * @constructor
 */
PIXI.WebGLSpriteBatch = function (game) {

    /**
    * @property {Phaser.Game} game - A reference to the currently running game.
    */
    this.game = game;

    /**
     * @property vertSize
     * @type Number
     */
    this.vertSize = 5;

    /**
     * The number of images in the SpriteBatch before it flushes
     * @property size
     * @type Number
     */
    this.size = 2000; //Math.pow(2, 16) /  this.vertSize;

    //the total number of bytes in our batch
    // Including texture index:
    // position + uv + color + textureIndex
    // vec2 + vec2 + (char * 4) + float
    this.vertexSize = (4 * 2) + (4 * 2) + (4) + (4);
    var numVerts = this.vertexSize * this.size * 4;
    //this.size * 4 * 4 * this.vertSize;
    //the total number of indices in our batch
    var numIndices = this.size * 6;

    /**
     * Holds the vertices
     *
     * @property vertices
     * @type ArrayBuffer
     */
    this.vertices = new ArrayBuffer(numVerts);

    /**
     * View on the vertices as a Float32Array
     *
     * @property positions
     * @type Float32Array
     */
    this.positions = new Float32Array(this.vertices);

    /**
     * View on the vertices as a Uint32Array
     *
     * @property colors
     * @type Uint32Array
     */
    this.colors = new Uint32Array(this.vertices);

    /**
     * Holds the indices
     *
     * @property indices
     * @type Uint16Array
     */
    this.indices = new Uint16Array(numIndices);

    /**
     * @property lastIndexCount
     * @type Number
     */
    this.lastIndexCount = 0;

    for (var i = 0, j = 0; i < numIndices; i += 6, j += 4) {
        this.indices[i + 0] = j + 0;
        this.indices[i + 1] = j + 1;
        this.indices[i + 2] = j + 2;
        this.indices[i + 3] = j + 0;
        this.indices[i + 4] = j + 2;
        this.indices[i + 5] = j + 3;
    }

    /**
     * @property drawing
     * @type Boolean
     */
    this.drawing = false;

    /**
     * @property currentBatchSize
     * @type Number
     */
    this.currentBatchSize = 0;

    /**
     * @property currentBaseTexture
     * @type BaseTexture
     */
    this.currentBaseTexture = null;

    /**
     * @property dirty
     * @type Boolean
     */
    this.dirty = true;

    /**
     * @property textures
     * @type Array
     */
    this.textures = [];

    /**
     * @property blendModes
     * @type Array
     */
    this.blendModes = [];

    /**
     * @property shaders
     * @type Array
     */
    this.shaders = [];

    /**
     * @property sprites
     * @type Array
     */
    this.sprites = [];

    /**
     * @property defaultShader
     * @type Phaser.Filter
     */
    this.defaultShader = null;
};

/**
 * @method setContext
 * @param gl {WebGLContext} the current WebGL drawing context
 */
PIXI.WebGLSpriteBatch.prototype.setContext = function (gl) {
    this.MAX_TEXTURES = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
    this.gl = gl;
    if (PIXI._enableMultiTextureToggle) {
        var dynamicIfs = '\tif (vTextureIndex == 0.0) gl_FragColor = texture2D(uSamplerArray[0], vTextureCoord) * vColor;\n'
        for (var index = 1; index < this.MAX_TEXTURES; ++index) {
            dynamicIfs += '\telse if (vTextureIndex == ' +
                index + '.0) gl_FragColor = texture2D(uSamplerArray[' +
                index + '], vTextureCoord) * vColor;\n'
        }
        this.defaultShader = new Phaser.Filter(
            this.game,
            undefined,
            [
                '//WebGLSpriteBatch Fragment Shader.',
                'precision lowp float;',
                'varying vec2 vTextureCoord;',
                'varying vec4 vColor;',
                'varying float vTextureIndex;',
                'uniform sampler2D uSamplerArray[' + this.MAX_TEXTURES + '];',
                'void main(void) {',
                    dynamicIfs,
                    '\telse gl_FragColor = texture2D(uSamplerArray[0], vTextureCoord) * vColor;',
                '}'
            ]);
    }
    else
    {
        this.defaultShader = new Phaser.Filter(
            this.game,
            undefined,
            [
                '//WebGLSpriteBatch Fragment Shader.',
                'precision lowp float;',
                'varying vec2 vTextureCoord;',
                'varying vec4 vColor;',
                'varying float vTextureIndex;',
                'uniform sampler2D uSampler;',
                'void main(void) {',
                '   gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor;',
                '}'
            ]);
    }

    // create a couple of buffers
    this.vertexBuffer = gl.createBuffer();
    this.indexBuffer = gl.createBuffer();

    // 65535 is max index, so 65535 / 6 = 10922.

    //upload the index data
    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indices, gl.STATIC_DRAW);

    gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
    gl.bufferData(gl.ARRAY_BUFFER, this.vertices, gl.DYNAMIC_DRAW);

    this.currentBlendMode = 99999;

    var shader = new PIXI.PixiShader(gl);

    shader.fragmentSrc = this.defaultShader.fragmentSrc;
    shader.uniforms = {};
    shader.init();

    this.defaultShader.shaders[gl.id] = shader;
};

/**
 * @method begin
 * @param renderSession {Object} The RenderSession object
 */
PIXI.WebGLSpriteBatch.prototype.begin = function (renderSession) {
    this.renderSession = renderSession;
    this.shader = this.renderSession.shaderManager.defaultShader;

    this.start();
};

/**
 * @method end
 */
PIXI.WebGLSpriteBatch.prototype.end = function () {
    this.flush();
};

/**
 * @method render
 * @param sprite {Sprite} the sprite to render when using this spritebatch
 * @param {Matrix} [matrix] - Optional matrix. If provided the Display Object will be rendered using this matrix, otherwise it will use its worldTransform.
 */
PIXI.WebGLSpriteBatch.prototype.render = function (sprite, matrix) {
    var texture = sprite.texture;
    var baseTexture = texture.baseTexture;
    var gl = this.gl;
    if (PIXI.WebGLRenderer.textureArray[baseTexture.textureIndex] != baseTexture) {
        this.flush();
        gl.activeTexture(gl.TEXTURE0 + baseTexture.textureIndex);
        gl.bindTexture(gl.TEXTURE_2D, baseTexture._glTextures[gl.id]);
        PIXI.WebGLRenderer.textureArray[baseTexture.textureIndex] = baseTexture;
    }

    //  They provided an alternative rendering matrix, so use it
    var wt = sprite.worldTransform;

    if (matrix) {
        wt = matrix;
    }

    // check texture..
    if (this.currentBatchSize >= this.size) {
        this.flush();
        this.currentBaseTexture = texture.baseTexture;
    }

    // get the uvs for the texture
    var uvs = texture._uvs;

    // if the uvs have not updated then no point rendering just yet!
    if (!uvs) {
        return;
    }

    var aX = sprite.anchor.x;
    var aY = sprite.anchor.y;

    var w0, w1, h0, h1;

    if (texture.trim) {
        // if the sprite is trimmed then we need to add the extra space before transforming the sprite coords.
        var trim = texture.trim;

        w1 = trim.x - aX * trim.width;
        w0 = w1 + texture.crop.width;

        h1 = trim.y - aY * trim.height;
        h0 = h1 + texture.crop.height;
    } else {
        w0 = (texture.frame.width) * (1 - aX);
        w1 = (texture.frame.width) * -aX;

        h0 = texture.frame.height * (1 - aY);
        h1 = texture.frame.height * -aY;
    }

    var i = this.currentBatchSize * this.vertexSize; //4 * this.vertSize;
    var tiOffset = this.currentBatchSize * 4;
    var resolution = texture.baseTexture.resolution;
    var textureIndex = texture.baseTexture.textureIndex;

    var a = wt.a / resolution;
    var b = wt.b / resolution;
    var c = wt.c / resolution;
    var d = wt.d / resolution;
    var tx = wt.tx;
    var ty = wt.ty;

    var cw = texture.crop.width;
    var ch = texture.crop.height;

    if (texture.rotated)
    {
        var a0 = wt.a;
        var b0 = wt.b;
        var c0 = wt.c;
        var d0 = wt.d;
        var _w1 = w1;
        var _w0 = w0;

        // Offset before rotating
        tx = wt.c * ch + tx;
        ty = wt.d * ch + ty;

        // Rotate matrix by 90 degrees
        // We use precalculated values for sine and cosine of rad(90)
        a = a0 * 6.123233995736766e-17 + -c0;
        b = b0 * 6.123233995736766e-17 + -d0;
        c = a0 + c0 * 6.123233995736766e-17;
        d = b0 + d0 * 6.123233995736766e-17;

        // Update UV coordinates
        texture._updateUvsInverted();

        // Rotate dimensions
        w0 = h0;
        w1 = h1;
        h0 = _w0;
        h1 = _w1;
    }

    var colors = this.colors;
    var positions = this.positions;
    var tint = sprite.tint;
    var color = (tint >> 16) + (tint & 0xff00) + ((tint & 0xff) << 16) + (sprite.worldAlpha * 255 << 24);

    if (this.renderSession.roundPixels) {
        positions[i++] = a * w1 + c * h1 + tx | 0;
        positions[i++] = d * h1 + b * w1 + ty | 0;
        positions[i++] = uvs.x0;
        positions[i++] = uvs.y0;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w0 + c * h1 + tx | 0;
        positions[i++] = d * h1 + b * w0 + ty | 0;
        positions[i++] = uvs.x1;
        positions[i++] = uvs.y1;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w0 + c * h0 + tx | 0;
        positions[i++] = d * h0 + b * w0 + ty | 0;
        positions[i++] = uvs.x2;
        positions[i++] = uvs.y2;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w1 + c * h0 + tx | 0;
        positions[i++] = d * h0 + b * w1 + ty | 0;
        positions[i++] = uvs.x3;
        positions[i++] = uvs.y3;
        colors[i++] = color;
        positions[i++] = textureIndex;
    } else {
        positions[i++] = a * w1 + c * h1 + tx;
        positions[i++] = d * h1 + b * w1 + ty;
        positions[i++] = uvs.x0;
        positions[i++] = uvs.y0;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w0 + c * h1 + tx;
        positions[i++] = d * h1 + b * w0 + ty;
        positions[i++] = uvs.x1;
        positions[i++] = uvs.y1;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w0 + c * h0 + tx;
        positions[i++] = d * h0 + b * w0 + ty;
        positions[i++] = uvs.x2;
        positions[i++] = uvs.y2;
        colors[i++] = color;
        positions[i++] = textureIndex;

        positions[i++] = a * w1 + c * h0 + tx;
        positions[i++] = d * h0 + b * w1 + ty;
        positions[i++] = uvs.x3;
        positions[i++] = uvs.y3;
        colors[i++] = color;
        positions[i++] = textureIndex;
    }
    // increment the batchsize
    this.sprites[this.currentBatchSize++] = sprite;
};

/**
 * Renders a TilingSprite using the spriteBatch.
 *
 * @method renderTilingSprite
 * @param sprite {TilingSprite} the sprite to render
 */
PIXI.WebGLSpriteBatch.prototype.renderTilingSprite = function (sprite) {
    var texture = sprite.tilingTexture;
    var baseTexture = texture.baseTexture;
    var gl = this.gl;
    var textureIndex = sprite.texture.baseTexture.textureIndex;
    if (PIXI.WebGLRenderer.textureArray[textureIndex] != baseTexture) {
        this.flush();
        gl.activeTexture(gl.TEXTURE0 + textureIndex);
        gl.bindTexture(gl.TEXTURE_2D, baseTexture._glTextures[gl.id]);
        PIXI.WebGLRenderer.textureArray[textureIndex] = baseTexture;
    }

    // check texture..
    if (this.currentBatchSize >= this.size) {
        this.flush();
        this.currentBaseTexture = texture.baseTexture;
    }

    // set the textures uvs temporarily
    if (!sprite._uvs) {
        sprite._uvs = new PIXI.TextureUvs();
    }

    var uvs = sprite._uvs;

    var w = texture.baseTexture.width;
    var h = texture.baseTexture.height;

    // var w = sprite._frame.sourceSizeW;
    // var h = sprite._frame.sourceSizeH;

    // w = 16;
    // h = 16;

    sprite.tilePosition.x %= w * sprite.tileScaleOffset.x;
    sprite.tilePosition.y %= h * sprite.tileScaleOffset.y;

    var offsetX = sprite.tilePosition.x / (w * sprite.tileScaleOffset.x);
    var offsetY = sprite.tilePosition.y / (h * sprite.tileScaleOffset.y);

    var scaleX = (sprite.width / w) / (sprite.tileScale.x * sprite.tileScaleOffset.x);
    var scaleY = (sprite.height / h) / (sprite.tileScale.y * sprite.tileScaleOffset.y);

    uvs.x0 = 0 - offsetX;
    uvs.y0 = 0 - offsetY;

    uvs.x1 = (1 * scaleX) - offsetX;
    uvs.y1 = 0 - offsetY;

    uvs.x2 = (1 * scaleX) - offsetX;
    uvs.y2 = (1 * scaleY) - offsetY;

    uvs.x3 = 0 - offsetX;
    uvs.y3 = (1 * scaleY) - offsetY;

    //  Get the sprites current alpha and tint and combine them into a single color
    var tint = sprite.tint;
    var color = (tint >> 16) + (tint & 0xff00) + ((tint & 0xff) << 16) + (sprite.worldAlpha * 255 << 24);

    var positions = this.positions;
    var colors = this.colors;

    var width = sprite.width;
    var height = sprite.height;

    // TODO trim??
    var aX = sprite.anchor.x;
    var aY = sprite.anchor.y;
    var w0 = width * (1 - aX);
    var w1 = width * -aX;

    var h0 = height * (1 - aY);
    var h1 = height * -aY;

    var i = this.currentBatchSize * this.vertexSize; //4 * this.vertSize;

    var resolution = texture.baseTexture.resolution;

    var wt = sprite.worldTransform;

    var a = wt.a / resolution;
    var b = wt.b / resolution;
    var c = wt.c / resolution;
    var d = wt.d / resolution;
    var tx = wt.tx;
    var ty = wt.ty;
    // xy
    positions[i++] = a * w1 + c * h1 + tx;
    positions[i++] = d * h1 + b * w1 + ty;
    // uv
    positions[i++] = uvs.x0;
    positions[i++] = uvs.y0;
    // color
    colors[i++] = color;
    // texture index
    positions[i++] = textureIndex;

    // xy
    positions[i++] = (a * w0 + c * h1 + tx);
    positions[i++] = d * h1 + b * w0 + ty;
    // uv
    positions[i++] = uvs.x1;
    positions[i++] = uvs.y1;
    // color
    colors[i++] = color;
    // texture index
    positions[i++] = textureIndex;

    // xy
    positions[i++] = a * w0 + c * h0 + tx;
    positions[i++] = d * h0 + b * w0 + ty;
    // uv
    positions[i++] = uvs.x2;
    positions[i++] = uvs.y2;
    // color
    colors[i++] = color;
    // texture index
    positions[i++] = textureIndex;

    // xy
    positions[i++] = a * w1 + c * h0 + tx;
    positions[i++] = d * h0 + b * w1 + ty;
    // uv
    positions[i++] = uvs.x3;
    positions[i++] = uvs.y3;
    // color
    colors[i++] = color;
    // texture index
    positions[i++] = textureIndex;

    // increment the batchsize
    this.sprites[this.currentBatchSize++] = sprite;
};

/**
 * Renders the content and empties the current batch.
 *
 * @method flush
 */
PIXI.WebGLSpriteBatch.prototype.flush = function () {
    // If the batch is length 0 then return as there is nothing to draw
    if (this.currentBatchSize === 0) {
        return;
    }

    var gl = this.gl;
    var shader;

    if (this.dirty) {
        this.dirty = false;

        shader = this.defaultShader.shaders[gl.id];

        // bind the main texture
        gl.activeTexture(gl.TEXTURE0);

        // bind the buffers
        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
        // this is the same for each shader?
        var stride = this.vertexSize; //this.vertSize * 4;
        gl.vertexAttribPointer(shader.aVertexPosition, 2, gl.FLOAT, false, stride, 0);
        gl.vertexAttribPointer(shader.aTextureCoord, 2, gl.FLOAT, false, stride, 8);

        // color attributes will be interpreted as unsigned bytes and normalized
        gl.vertexAttribPointer(shader.colorAttribute, 4, gl.UNSIGNED_BYTE, true, stride, 16);

        // Texture index
        gl.vertexAttribPointer(shader.aTextureIndex, 1, gl.FLOAT, false, stride, 20);
    }

    // upload the verts to the buffer
    if (this.currentBatchSize > (this.size * 0.5)) {
        gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.vertices);
    } else {
        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
        var view = this.positions.subarray(0, this.currentBatchSize * this.vertexSize);
        gl.bufferSubData(gl.ARRAY_BUFFER, 0, view);
    }

    var nextTexture, nextBlendMode, nextShader;
    var batchSize = 0;
    var start = 0;

    var currentBaseTexture = null;
    var currentBlendMode = this.renderSession.blendModeManager.currentBlendMode;
    var currentShader = null;

    var blendSwap = false;
    var shaderSwap = false;
    var sprite;
    var textureIndex = 0;

    for (var i = 0, j = this.currentBatchSize; i < j; i++) {

        sprite = this.sprites[i];

        if (sprite.tilingTexture) {
            nextTexture = sprite.tilingTexture.baseTexture;
        } else {
            nextTexture = sprite.texture.baseTexture;
        }

        nextBlendMode = sprite.blendMode;
        nextShader = sprite.shader || this.defaultShader;

        blendSwap = currentBlendMode !== nextBlendMode;
        shaderSwap = currentShader !== nextShader; // should I use _UIDS???

        var skip = nextTexture.skipRender;

        if (skip && sprite.children.length > 0) {
            skip = false;
        }
        //
        if (/*(currentBaseTexture != nextTexture && !skip) ||*/
            blendSwap ||
            shaderSwap) {
            this.renderBatch(currentBaseTexture, batchSize, start);

            start = i;
            batchSize = 0;
            currentBaseTexture = nextTexture;

            if (blendSwap) {
                currentBlendMode = nextBlendMode;
                this.renderSession.blendModeManager.setBlendMode(currentBlendMode);
            }

            if (shaderSwap) {
                currentShader = nextShader;

                shader = currentShader.shaders[gl.id];

                if (!shader) {
                    shader = new PIXI.PixiShader(gl);

                    shader.fragmentSrc = currentShader.fragmentSrc;
                    shader.uniforms = currentShader.uniforms;
                    shader.init();

                    currentShader.shaders[gl.id] = shader;
                }

                // set shader function???
                this.renderSession.shaderManager.setShader(shader);

                if (shader.dirty) {
                    shader.syncUniforms();
                }

                // both these only need to be set if they are changing..
                // set the projection
                var projection = this.renderSession.projection;
                gl.uniform2f(shader.projectionVector, projection.x, projection.y);

                // TODO - this is temporary!
                var offsetVector = this.renderSession.offset;
                gl.uniform2f(shader.offsetVector, offsetVector.x, offsetVector.y);

                // set the pointers
            }
        }

        batchSize++;
    }

    this.renderBatch(currentBaseTexture, batchSize, start);

    // then reset the batch!
    this.currentBatchSize = 0;
};

/**
 * @method renderBatch
 * @param texture {Texture}
 * @param size {Number}
 * @param startIndex {Number}
 */
PIXI.WebGLSpriteBatch.prototype.renderBatch = function (texture, size, startIndex) {
    if (size === 0) {
        return;
    }

    var gl = this.gl;

    // check if a texture is dirty..
    if (texture._dirty[gl.id]) {
        if (!this.renderSession.renderer.updateTexture(texture)) {
            //  If updateTexture returns false then we cannot render it, so bail out now
            return;
        }
    }
    gl.drawElements(gl.TRIANGLES, size * 6, gl.UNSIGNED_SHORT, startIndex * 6 * 2);
    // increment the draw count
    this.renderSession.drawCount++;
};

/**
 * @method stop
 */
PIXI.WebGLSpriteBatch.prototype.stop = function () {
    this.flush();
    this.dirty = true;
};

/**
 * @method start
 */
PIXI.WebGLSpriteBatch.prototype.start = function () {
    this.dirty = true;
};

/**
 * Destroys the SpriteBatch.
 *
 * @method destroy
 */
PIXI.WebGLSpriteBatch.prototype.destroy = function () {
    this.vertices = null;
    this.indices = null;

    this.gl.deleteBuffer(this.vertexBuffer);
    this.gl.deleteBuffer(this.indexBuffer);

    this.currentBaseTexture = null;

    this.gl = null;
};

		Phaser Copyright © 2012-2016 Photon Storm Ltd.

		Documentation generated by JSDoc 3.4.3
		on Thu Mar 23 2017 14:18:05 GMT+0000 (GMT Standard Time) using the DocStrap template.


text:
/* eslint-disable sort-keys,no-template-curly-in-string */

// `ignore` option doesn't support wildcard for extension.
// https://github.com/babel/babel/issues/12008
const moduleIgnore = [
  '**/*.stories.tsx',
  '**/*.test.tsx',
  '**/*.test.ts',
  'src/tests/*',
  'src/types.ts',
];

module.exports = {
  presets: [
    ['@babel/preset-env', { modules: false }],
    '@babel/preset-typescript',
    '@babel/preset-react',
  ],
  plugins: [
    '@babel/plugin-proposal-class-properties',
    '@babel/plugin-proposal-export-default-from',
    'dev-expression',
    [
      'transform-imports',
      {
        lodash: {
          transform: 'lodash/${member}',
          preventFullImport: true,
        },
        'react-overlays': {
          transform: 'react-overlays/${member}',
          preventFullImport: true,
        },
      },
    ],
  ],
  env: {
    cjs: {
      plugins: [
        '@babel/transform-runtime',
        '@babel/transform-modules-commonjs',
      ],
      ignore: moduleIgnore,
    },
    es: {
      plugins: ['@babel/transform-runtime'],
      ignore: moduleIgnore,
    },
    production: {
      plugins: ['transform-react-remove-prop-types'],
    },
    test: {
      plugins: [
        '@babel/transform-runtime',
        '@babel/transform-modules-commonjs',
      ],
    },
  },
};


text:
package credentials

//go:generate mockgen -destination=mocks/credentials_mocks.go -copyright_file=../../scripts/copyright_file github.com/aws/amazon-ecs-agent/agent/credentials Manager


text:
int main(int argc, char *argv[])
{
	LOG_SETUP();

	return NSApplicationMain(argc, (const char **)argv);

	LOG_FLUSH();
}


text:
package de.kaiserpfalzedv.office.access.api.users.impl;

import de.kaiserpfalzedv.office.access.api.users.OfficeEntitlement;
import de.kaiserpfalzedv.office.access.api.users.OfficeRole;

import java.security.Principal;
import java.util.*;

/**
 * @author klenkes {@literal <rlichti@kaiserpfalz-edv.de>}
 * @version 1.0.0
 * @since 2017-03-11
 */
public class OfficeRoleImpl implements OfficeRole {
    private static final long serialVersionUID = 2265558473391429590L;
    private final HashSet<OfficeRole> roles = new HashSet<>();
    private final HashSet<OfficeEntitlement> directEntitlements = new HashSet<>();
    private final HashSet<OfficeEntitlement> entitlements = new HashSet<>();
    private UUID id;
    private String displayName;
    private String fullName;

    OfficeRoleImpl(
            final UUID id,
            final String displayName,
            final String fullName,
            final Set<? extends OfficeRole> roles,
            final Set<? extends OfficeEntitlement> directEntitlements,
            final Set<? extends OfficeEntitlement> entitlements
    ) {
        this.id = id;
        this.displayName = displayName;
        this.fullName = fullName;

        this.roles.addAll(roles);
        this.directEntitlements.addAll(directEntitlements);
        this.entitlements.addAll(entitlements);
    }

    @Override
    public String getName() {
        return displayName;
    }

    public boolean isInRole(OfficeRole role) {
        boolean result = equals(role);

        Iterator<OfficeRole> roleIterator = roles.iterator();
        while (!result && roleIterator.hasNext()) {
            result = roleIterator.next().isInRole(role);
        }

        return result;
    }

    @Override
    public boolean isEntitled(Principal entitlement) {
        for (Principal e : entitlements) {
            if (e.equals(entitlement))
                return true;
        }

        return false;
    }

    @Override
    public Set<? extends OfficeRole> getIncludedRoles() {
        return Collections.unmodifiableSet(roles);
    }

    @Override
    public Set<? extends OfficeEntitlement> getEntitlements() {
        return Collections.unmodifiableSet(directEntitlements);
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder()
                .append(getClass().getSimpleName()).append('@').append(System.identityHashCode(this)).append('{')
                .append(getId()).append(", ").append(getDisplayName());

        if (roles.size() >= 1) {
            result.append(", roles=").append(roles.size());
        }

        if (directEntitlements.size() >= 1) {
            result
                    .append(", entitlements=")
                    .append(directEntitlements.size())
                    .append("/")
                    .append(entitlements.size());
        }

        return result.append('}').toString();
    }

    @Override
    public UUID getId() {
        return id;
    }

    @Override
    public String getDisplayName() {
        return displayName;
    }

    @Override
    public String getFullName() {
        return fullName;
    }
}


text:
import { Column } from "./column";
import { Row } from "./row";

export class DataSet {

    protected data: Array<any> = [];
    protected columns: Array<Column> = [];
    protected rows: Array<Row> = [];

    constructor(data: Array<any> = [], protected columnSettings: Object) {
        this.createColumns(columnSettings);
        this.setData(data);
    }

    getColumns(): Array<Column> {
        return this.columns;
    }

    getRows(): Array<Row> {
        return this.rows;
    }

    getFirstRow(): Row {
        return this.rows[0];
    }

    getLastRow(): Row {
        return this.rows[this.rows.length - 1];
    }

    findRowByData(data: any): Row {
        return this.rows.find((row: Row) => row.getData() === data);
    }

    setData(data: Array<any>) {
        this.data = data;
        this.createRows();
    }

    createColumns(settings: any) {
        for (const id in settings) {
            if (settings.hasOwnProperty(id)) {
                this.columns.push(new Column(id, settings[id], this));
            }
        }
    }
    createRows() {
        this.rows = [];
        this.data.forEach((el, index) => {
            this.rows.push(new Row(index, el, this));
        });
    }
}


text:
type GenericAdjacencyList{V, VList, AdjList} <: AbstractGraph{V, Edge{V}}
    is_directed::Bool
    vertices::VList
    nedges::Int
    adjlist::AdjList
end

typealias SimpleAdjacencyList GenericAdjacencyList{Int, Range1{Int}, Vector{Vector{Int}}}
typealias AdjacencyList{V} GenericAdjacencyList{V, Vector{V}, Vector{Vector{V}}}

@graph_implements GenericAdjacencyList vertex_list vertex_map adjacency_list

## construction

simple_adjlist(nv::Int; is_directed::Bool=true) = SimpleAdjacencyList(is_directed, 1:nv, 0, multivecs(Int, nv))

adjlist{V}(vs::Vector{V}; is_directed::Bool=true) = AdjacencyList{V}(is_directed, vs, 0, Vector{V}[])
adjlist{V}(::Type{V}; is_directed::Bool=true) = adjlist(V[]; is_directed=is_directed)

## required interfaces

is_directed(g::GenericAdjacencyList) = g.is_directed

num_vertices(g::GenericAdjacencyList) = length(g.vertices)
vertices(g::GenericAdjacencyList) = g.vertices
vertex_index{V<:ProvidedVertexType}(v::V, g::GenericAdjacencyList{V}) = vertex_index(v)

num_edges(g::GenericAdjacencyList) = g.nedges

out_degree{V}(v::V, g::GenericAdjacencyList{V}) = length(g.adjlist[vertex_index(v,g)])
out_neighbors{V}(v::V, g::GenericAdjacencyList{V}) = g.adjlist[vertex_index(v,g)]

## mutation

function add_vertex!{V}(g::GenericAdjacencyList{V}, v::V)
    push!(g.vertices, v)
    push!(g.adjlist, Array(V,0))
    v
end
add_vertex!(g::GenericAdjacencyList, x) = add_vertex!(g, make_vertex(g, x))

function add_edge!{V}(g::GenericAdjacencyList{V}, u::V, v::V)
    nv::Int = num_vertices(g)
    iu = vertex_index(u, g)::Int
    push!(g.adjlist[iu], v)
    g.nedges += 1
    if !g.is_directed
        iv = vertex_index(v, g)::Int
        push!(g.adjlist[iv], u)
    end
end

## constructing from matrices

function simple_adjlist{T<:Number}(A::AbstractMatrix{T}; is_directed::Bool=true)
    n = size(A, 1)
    size(A, 2) == n || error("A must be square")
    alist = multivecs(Int, n)
    m = 0

    @inbounds if is_directed
        for i = 1:n
            nbs = alist[i]::Vector{Int}
            for j = 1:n
                if isnz(A[i,j])
                    push!(nbs, j)
                    m += 1
                end
            end
        end
    else
        for i = 1:n
            nbs = alist[i]::Vector{Int}
            if isnz(A[i,i])
                push!(nbs, i)
                m += 1
            end
            for j = i+1:n
                if isnz(A[i,j])
                    push!(nbs, j)
                    push!(alist[j], i)
                    m += 1
                end
            end
        end
    end
    return SimpleAdjacencyList(is_directed, 1:n, m, alist)
end


text:
/* Walking handler for RPGs                                      */
/* by Haroldo de Oliveira Pinheiro                               */
/*                                                               */
/* You may do wathever you want with these sources, as long as   */
/* you give proper credit.                                       */

#ifndef _INC_RPGWALK_
#define _INC_RPGWALK_

#define RWK_FC_UP 0
#define RWK_FC_DOWN 1
#define RWK_FC_LEFT 2
#define RWK_FC_RIGHT 3

typedef struct{
	int pos_x, pos_y; /* Coordenadas atuais (em pixels) */
	uint blk_x, blk_y; /* Coordenadas atuais (em blocos) */
	int step_x, step_y; /* Caminhando em que dire‡Æo? A que velocidade? */
	uint stepcnt;
	uint walkdelay, walkdlyctrl;
    uchar facing;
	uint sprnum, palnum;
	uint basetile, baseframe, frame;
    uchar frmctrl, frmdly;
	uint flags;
}walker;

extern uint wlk_sprnum;

void init_walker(wlk,basetile);
void handle_walker(wlk);

void walker_walkto(walker,direction,blockcnt);

#endif


text:
#ifndef _PASSENGER_APACHE2_MODULE_CONFIG_GENERAL_SETTER_FUNCS_H_
#define _PASSENGER_APACHE2_MODULE_CONFIG_GENERAL_SETTER_FUNCS_H_

#include <limits>
#include <cstdlib>
#include <http_config.h>

namespace Passenger {
namespace Apache2Module {

using namespace std;

inline const char *
setIntConfig(cmd_parms *cmd, const char *rawValue, int &parsedValue,
	int minValue = std::numeric_limits<int>::min())
{
	char *end;
	long result;

	result = strtol(rawValue, &end, 10);
	if (*end != '\0') {
		return apr_psprintf(cmd->temp_pool, "Invalid number specified for %s.",
			cmd->directive->directive);
	}

	if (minValue != std::numeric_limits<int>::min() && result < (long) minValue) {
		return apr_psprintf(cmd->temp_pool, "%s must be at least %d.",
			cmd->directive->directive, minValue);
	}

	parsedValue = (int) result;
	return NULL;
}

} // namespace Apache2Module
} // namespace Passenger

#endif /* _PASSENGER_APACHE2_MODULE_CONFIG_GENERAL_SETTER_FUNCS_H_ */