text:
function rounding(arr) {
    let [number,precision]=arr;
    if (precision > 15)
        precision = 15;
    let result = number.toFixed(precision);
    console.log(parseFloat(result));

}
rounding([3.1415926535897932384626433832795, 7]);


text:
package org.fao.fenix.commons.msd.dto.templates.standard.metadata;

import com.fasterxml.jackson.annotation.JsonProperty;
import org.fao.fenix.commons.msd.dto.templates.ResponseHandler;
import org.fao.fenix.commons.msd.dto.type.DimensionType;

import java.util.Map;

public class SeResourceDimensions extends ResponseHandler {

    public SeResourceDimensions() {}
    public SeResourceDimensions(Object source) {
        super(source);
    }

    @JsonProperty
    public Map<String, String> getDimensionName() {
        return null;
    }
    @JsonProperty
    public DimensionType getDimensionType() {
        return null;
    }
    @JsonProperty
    public Map<String,String> getDimensionTypeLabel() {
        DimensionType value = getDimensionType();
        return value!=null ? value.getLabel() : null;
    }

    @JsonProperty
    public OjCodeList getDimensionSubject() {
        return null;
    }
    @JsonProperty
    public Object getDimensionContent() {
        return null;
    }
    @JsonProperty
    public OjMeasure getDimensionMU() {
        return null;
    }

}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>
<html>
  <head>
    <title>Swipe</title>

    <link href='http://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
    <link href="css/main.css" rel="stylesheet" type="text/css"></link>

    <script src="http://www.google.com/jsapi" type="text/javascript"></script>
    <script type="text/javascript">google.load("jquery", "1", {uncompressed:true});</script>
    <!-- jQuery is required for the depth.js plugin / it works in no conflict mode -->

  </head>
  <body>
    <canvas id="track" class="track" width="200" height="200"></canvas>
    <script src="js/depth.js"></script>
    <script src="js/main.js"></script>
  </body>
</html>


text:
agoServerLoginExample
============

Example of using OAuth User and Application Logins on the server with ArcGIS Online.

This is a Node Server application that serves as a proxy to ArcGIS Online.

Steps to make it work:
1.  Download/Clone to your server
2.  Run `npm install` to install the libraries (request and JSON)
3.  Register as an application in ArcGIS Online (if you're not already in an ArcGIS Online organization, goto [developers.arcgis.com](https://developers.arcgis.com/en/plans/) to get a developer account
4.  Get the application ID and application secret
5.  Deploy:
    a. Option A : run each server with `node server.js <APP ID> <APP SECRET>` in the servers folders- you'll need to set the port in server.js
    b. Option B : use [iisnode](https://github.com/tjanczuk/iisnode) module to deploy on IIS

This application is provided as a demo at the [Esri DC DevSummit](http://www.esri.com/events/devsummit-dc) and further refined with user logins for the [Esri 2014 UC](http://www.exrit.com/events/uc).


text:
<!DOCTYPE html>

  <title>spritespin.beh-hold.js</title>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <meta name="viewport" content="width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
  <link rel="stylesheet" media="all" href="docco.css" />

spritespin.beh-hold.js

                ¶

(function ($, SpriteSpin) {
  "use strict";

  function start(e, data) {
    if (data.loading || data.dragging || !data.stage.is(':visible')) return;
    SpriteSpin.updateInput(e, data);
    data.dragging = true;
    data.animate = true;
    SpriteSpin.setAnimation(data);
  }

  function stop(e, data) {
    data.dragging = false;
    SpriteSpin.resetInput(data);
    SpriteSpin.stopAnimation(data);
  }

  function update(e, data) {
    if (!data.dragging) return;
    SpriteSpin.updateInput(e, data);

    var half, delta, target = data.target, offset = target.offset();
    if (data.orientation === "horizontal") {
      half = target.innerWidth() / 2;
      delta = (data.currentX - offset().left - half) / half;
    } else {
      half = (data.height / 2);
      delta = (data.currentY - offset().top - half) / half;
    }
    data.reverse = delta < 0;
    delta = delta < 0 ? -delta : delta;
    data.frameTime = 80 * (1 - delta) + 20;

    if (((data.orientation === 'horizontal') && (data.dX < data.dY)) ||
      ((data.orientation === 'vertical') && (data.dX < data.dY))) {
      e.preventDefault();
    }
  }

  SpriteSpin.registerModule('hold', {

    mousedown: start,
    mousemove: update,
    mouseup: stop,
    mouseleave: stop,

    touchstart: start,
    touchmove: update,
    touchend: stop,
    touchcancel: stop,

    onFrame: function () {
      $(this).spritespin("api").startAnimation();
    }
  });

}(window.jQuery || window.Zepto || window.$, window.SpriteSpin));


text:
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >

    <item>
        <shape android:shape="rectangle" >
            <solid android:color="#ff0b0e0e" />
            <padding
                android:top="1dp"
                android:bottom="1dp"
                android:left="1dp"
                android:right="1dp"
                />

            <corners android:radius="5dp" />
        </shape>
    </item>
    <item>
        <shape android:shape="rectangle" >
            <padding
                android:bottom="5dp"
                android:left="5dp"
                android:right="5dp"
                android:top="5dp" />

            <solid android:color="#ffffffff" />
        </shape>
    </item>
</layer-list>


text:
import * as babel from '@babel/types';

import {ScannedInlineDocument} from '../model/model';

import {getIdentifierName} from './ast-value';
import {Visitor} from './estree-visitor';
import {JavaScriptDocument} from './javascript-document';
import {JavaScriptScanner} from './javascript-scanner';

/**
 * Finds inline HTML documents in Javascript source.
 *
 * e.g.
 *     html`<div></div>`;
 */
export class InlineHtmlDocumentScanner implements JavaScriptScanner {
  async scan(
      document: JavaScriptDocument,
      visit: (visitor: Visitor) => Promise<void>) {
    const features: ScannedInlineDocument[] = [];

    const myVisitor: Visitor = {
      enterTaggedTemplateExpression(node) {
        const tagName = getIdentifierName(node.tag);
        if (tagName === undefined || !/(^|\.)html$/.test(tagName)) {
          return;
        }
        const inlineDocument = getInlineDocument(node, document);
        if (inlineDocument !== undefined) {
          features.push(inlineDocument);
        }
      }
    };

    await visit(myVisitor);

    return {features};
  }
}

export interface Options {
  /**
   * If true, uses the "raw" template string contents rather than the "cooked"
   * contents. For example: raw contents yields `\n` as two characters, cooked
   * yields it as a newline.
   */
  useRawContents?: boolean;
}

/**
 * Parses the given string as an inline HTML document.
 */
export function getInlineDocument(
    node: babel.TaggedTemplateExpression,
    parsedDocument: JavaScriptDocument,
    options: Options = {}): ScannedInlineDocument|undefined {
  const sourceRangeForLiteral = parsedDocument.sourceRangeForNode(node.quasi);
  if (sourceRangeForLiteral === undefined) {
    return;
  }
  const sourceRangeForContents = {
    file: sourceRangeForLiteral.file,
    start: {
      line: sourceRangeForLiteral.start.line,
      column: sourceRangeForLiteral.start.column + 1
    },
    end: {
      line: sourceRangeForLiteral.end.line,
      column: sourceRangeForLiteral.end.column - 1
    }
  };

  let contents = '';
  let previousEnd: number|undefined;
  for (const quasi of node.quasi.quasis) {
    if (previousEnd !== undefined) {
      const fullExpressionTextWithDelimitors =
          parsedDocument.contents.slice(previousEnd, quasi.start);
      /**
       * Replace everything but whitespace in ${expressions} (including the
       * ${} delimitor part) with whitespace.
       * This skips over the problem of handling expressions, and there's lots
       * of cases it doesn't handle correctly, but it's a start.
       * Consider the js file:
       * ```js
       *   html`<div>${
       *     'Hello world'
       *   }</div>
       * ```
       *
       * If we remove the expression entirely, the html parser receives
       * `<div></div>` and when we ask for the source range of the closing tag
       * it'll give one on the first line, and starting just after the `<div>`.
       * By preserving whitespace and replacing every other character with a
       * space, the HTML parser will receive
       *
       * ```html
       *   <div>
       *     (a bunch of spaces on this line)
       *    </div>
       * ```
       *
       * and so the html parser's source locations will map cleanly onto offsets
       * in the original template literal (excluding characters like `\n`). We
       * could do something more sophisticated later, but this works for most
       * cases and is quick and easy to implement.
       */
      contents += fullExpressionTextWithDelimitors.replace(/\S/g, ' ');
    }
    if (options.useRawContents) {
      contents += quasi.value.raw;
    } else {
      contents += quasi.value.cooked;
    }
    previousEnd = quasi.end;
  }

  let commentText;
  if (node.leadingComments != null) {
    commentText = node.leadingComments.map((c) => c.value).join('\n');
  } else {
    commentText = '';
  }

  return new ScannedInlineDocument(
      'html',
      contents,
      {
        filename: sourceRangeForContents.file,
        col: sourceRangeForContents.start.column,
        line: sourceRangeForContents.start.line
      },
      commentText,
      sourceRangeForContents,
      {language: 'js', node, containingDocument: parsedDocument});
}


text:
class mlTransform
{
public:
	mlTransform();

	mlTransform(const mlQuaternion & rotation, const mlVector3D & translation, mlFloat scale = 1.0f);

	const mlTransform& operator=(const mlTransform& cloneFrom);
	mlTransform(const mlTransform& cloneFrom);

	const mlTransform& operator=(const mlMatrix3x4 & cloneFrom);
	explicit mlTransform(const mlMatrix3x4& cloneFrom);

    bool			operator==(const mlTransform & other) const;
	bool			IsIdentity() const;

    void            SetIdentity();

	void			TransformSelf(const mlTransform &transform);

	void			Normalise();

	void			SetTranslation(const mlVector3D & translation);
	void			SetRotation(const mlQuaternion & rotation);
    void			SetScale(const mlVector3D & scale);
    void			SetScale(float scale);
    void			SetMatrix(const mlMatrix3x4 & matrix);

	void			ApplyTranslation(const mlVector3D & translation);
	void			ApplyRotation(const mlQuaternion & rotation);
    void			ApplyScale(const mlVector3D & scale);
    void			ApplyScale(mlFloat scale);

	void			Invert();

	void			Interpolate(mlFloat alpha, const mlTransform &from, const mlTransform &to);

	mlVector3D		TransformPoint(const mlVector3D &in) const;
	mlVector3D		TransformPointInverse(const mlVector3D &in) const;
	mlVector3D		TransformVector(const mlVector3D &in) const;
	mlVector3D		TransformVectorInverse(const mlVector3D &in) const;

	void			TransformPoints			(mlVector3D outArray[], const mlVector3D inArray[], int pointCount) const;
	void			TransformPointsInverse	(mlVector3D outArray[], const mlVector3D inArray[], int pointCount) const;
	void			TransformVectors		(mlVector3D outArray[], const mlVector3D inArray[], int vectorCount) const;
	void			TransformVectorsInverse	(mlVector3D outArray[], const mlVector3D inArray[], int vectorCount) const;

    mlVector3D		GetScale() const;
    mlQuaternion	GetRotation() const;
	mlVector3D		GetTranslation() const;

	const mlMatrix3x4 &	GetMatrix() const;

private:
    mlQuaternion			m_rotation;
	mlVector3D				m_translation;

    mutable mlMatrix3x4		m_matrix;
    mlVector3D              m_scale;

    mutable bool			m_matrix_valid;

	void					UpdateMatrixAlways() const;
	void					UpdateMatrixIfNecessary() const;
};

extern const mlTransform 		mlTransformIdentity;

void		mlCombineTransform		 (mlTransform &AtoC, const mlTransform &AtoB, const mlTransform &BtoC);
void		mlCombineTransformInverse(mlTransform &AtoC, const mlTransform &AtoB, const mlTransform &CtoB);

class mlTransformUtility
{
public:
	static mlTransform			TransformFromReflection(const mlVector3D & pointOnPlane, const mlVector3D & planeNormalNormalised);
	static void					TransformFromPointForwardUp(mlTransform & trnTransform, const mlVector3D & vPosition, const mlVector3D & vForward, const mlVector3D & vUp);
};

inline const mlTransform & mlTransform::operator=(const mlTransform & cloneFrom)
{
	m_matrix_valid = false;
	m_rotation = cloneFrom.m_rotation;
	m_translation = cloneFrom.m_translation;
	m_scale = cloneFrom.m_scale;

	return *this;
}

inline mlTransform::mlTransform(const mlTransform& cloneFrom)
{
	*this = cloneFrom;
}

inline const mlTransform & mlTransform::operator=(const mlMatrix3x4 & cloneFrom)
{
	SetMatrix(cloneFrom);
	return *this;
}

inline mlTransform::mlTransform(const mlMatrix3x4& cloneFrom)
{
	*this = cloneFrom;
}

inline void	mlTransform::UpdateMatrixIfNecessary() const
{
	if (!m_matrix_valid)
		UpdateMatrixAlways();
}

inline const mlMatrix3x4 & mlTransform::GetMatrix() const
{
	UpdateMatrixIfNecessary();

	return m_matrix;
}

inline bool mlTransform::operator==(const mlTransform & other) const
{
	return	(m_translation == other.m_translation) &&
			(m_scale == other.m_scale) &&
			(m_rotation == other.m_rotation);
}

inline bool	mlTransform::IsIdentity() const
{
	return	(m_translation.x == 0.0f && m_translation.y == 0.0f && m_translation.z == 0.0f) &&
            (m_scale == mlVector3D(1.0f, 1.0f, 1.0f)) &&
			(m_rotation.w == 1.0f && m_rotation.x == 0.0f && m_rotation.y == 0.0f && m_rotation.z == 0.0f);
}

#endif // ML_TRANSFORM_H


text:
package org.apache.cassandra.db.commitlog;

import java.io.IOException;
import java.util.*;

import com.google.common.collect.ImmutableSortedMap;

import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.ISerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;

/**
 * An immutable set of closed intervals, stored in normalized form (i.e. where overlapping intervals are converted
 * to a single interval covering both).
 *
 * The set is stored as a sorted map from interval starts to the corresponding end. The map satisfies
 *   {@code curr().getKey() <= curr().getValue() < next().getKey()}
 */
public class IntervalSet<T extends Comparable<T>>
{
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private static final IntervalSet EMPTY = new IntervalSet(ImmutableSortedMap.of());

    final private NavigableMap<T, T> ranges;

    private IntervalSet(ImmutableSortedMap<T, T> ranges)
    {
        this.ranges = ranges;
    }

    /**
     * Construct new set containing the interval with the given start and end position.
     */
    public IntervalSet(T start, T end)
    {
        this(ImmutableSortedMap.of(start, end));
    }

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<T>> IntervalSet<T> empty()
    {
        return EMPTY;
    }

    public boolean contains(T position)
    {
        // closed (i.e. inclusive) intervals
        Map.Entry<T, T> range = ranges.floorEntry(position);
        return range != null && position.compareTo(range.getValue()) <= 0;
    }

    public boolean isEmpty()
    {
        return ranges.isEmpty();
    }

    public Optional<T> lowerBound()
    {
        return isEmpty() ? Optional.empty() : Optional.of(ranges.firstKey());
    }

    public Optional<T> upperBound()
    {
        return isEmpty() ? Optional.empty() : Optional.of(ranges.lastEntry().getValue());
    }

    public Collection<T> starts()
    {
        return ranges.keySet();
    }

    public Collection<T> ends()
    {
        return ranges.values();
    }

    public String toString()
    {
        return ranges.toString();
    }

    @Override
    public int hashCode()
    {
        return ranges.hashCode();
    }

    @Override
    public boolean equals(Object obj)
    {
        return obj instanceof IntervalSet && ranges.equals(((IntervalSet<?>) obj).ranges);
    }

    public static final <T extends Comparable<T>> ISerializer<IntervalSet<T>> serializer(ISerializer<T> pointSerializer)
    {
        return new ISerializer<IntervalSet<T>>()
        {
            public void serialize(IntervalSet<T> intervals, DataOutputPlus out) throws IOException
            {
                out.writeInt(intervals.ranges.size());
                for (Map.Entry<T, T> en : intervals.ranges.entrySet())
                {
                    pointSerializer.serialize(en.getKey(), out);
                    pointSerializer.serialize(en.getValue(), out);
                }
            }

            public IntervalSet<T> deserialize(DataInputPlus in) throws IOException
            {
                int count = in.readInt();
                NavigableMap<T, T> ranges = new TreeMap<>();
                for (int i = 0; i < count; ++i)
                    ranges.put(pointSerializer.deserialize(in), pointSerializer.deserialize(in));
                return new IntervalSet<T>(ImmutableSortedMap.copyOfSorted(ranges));
            }

            public long serializedSize(IntervalSet<T> intervals)
            {
                long size = TypeSizes.sizeof(intervals.ranges.size());
                for (Map.Entry<T, T> en : intervals.ranges.entrySet())
                {
                    size += pointSerializer.serializedSize(en.getKey());
                    size += pointSerializer.serializedSize(en.getValue());
                }
                return size;
            }
        };
    };

    /**
     * Builder of interval sets, applying the necessary normalization while adding ranges.
     *
     * Data is stored as above, as a sorted map from interval starts to the corresponding end, which satisfies
     *   {@code curr().getKey() <= curr().getValue() < next().getKey()}
     */
    static public class Builder<T extends Comparable<T>>
    {
        final NavigableMap<T, T> ranges;

        public Builder()
        {
            this.ranges = new TreeMap<>();
        }

        public Builder(T start, T end)
        {
            this();
            assert start.compareTo(end) <= 0;
            ranges.put(start, end);
        }

        /**
         * Add an interval to the set and perform normalization.
         */
        public void add(T start, T end)
        {
            assert start.compareTo(end) <= 0;
            // extend ourselves to cover any ranges we overlap
            // record directly preceding our end may extend past us, so take the max of our end and its
            Map.Entry<T, T> extend = ranges.floorEntry(end);
            if (extend != null && extend.getValue().compareTo(end) > 0)
                end = extend.getValue();

            // record directly preceding our start may extend into us; if it does, we take it as our start
            extend = ranges.lowerEntry(start);
            if (extend != null && extend.getValue().compareTo(start) >= 0)
                start = extend.getKey();

            // remove all covered intervals
            // since we have adjusted start and end to cover the ones that would be only partially covered, we
            // are certain that anything whose start falls within the span is completely covered
            ranges.subMap(start, end).clear();
            // add the new interval
            ranges.put(start, end);
        }

        public void addAll(IntervalSet<T> otherSet)
        {
            for (Map.Entry<T, T> en : otherSet.ranges.entrySet())
            {
                add(en.getKey(), en.getValue());
            }
        }

        public IntervalSet<T> build()
        {
            return new IntervalSet<T>(ImmutableSortedMap.copyOfSorted(ranges));
        }
    }

}


text:
package nl.hanze.leertaak2;

import java.util.List;

/**
 * A class representing shared characteristics of animals.
 *
 * @author David J. Barnes and Michael Kölling
 * @version 2011.07.31
 */
public abstract class Animal implements Actor
{
    // Whether the animal is alive or not.
    private boolean alive;
    // The animal's field.
    private Field field;
    // The animal's position in the field.
    private Location location;

    /**
     * Create a new animal at location in field.
     *
     * @param field The field currently occupied.
     * @param location The location within the field.
     */
    public Animal(Field field, Location location)
    {
        alive = true;
        this.field = field;
        setLocation(location);
    }

    /**
     * Make this animal act - that is: make it do
     * whatever it wants/needs to do.
     * @param newAnimals A list to receive newly born animals.
     */
    abstract public void act(List<Actor> newAnimals);

    /**
     * Check whether the animal is alive or not.
     * @return true if the animal is still alive.
     */
    protected boolean isAlive()
    {
        return alive;
    }
    /**
     * Implements the isActive method from interface Actor
     */
    @Override
    public boolean isActive()
    {
    	return isAlive();
    }

    /**
     * Indicate that the animal is no longer alive.
     * It is removed from the field.
     */
    protected void setDead()
    {
        alive = false;
        if(location != null) {
            field.clear(location);
            location = null;
            field = null;
        }
    }

    /**
     * Return the animal's location.
     * @return The animal's location.
     */
    protected Location getLocation()
    {
        return location;
    }

    /**
     * Place the animal at the new location in the given field.
     * @param newLocation The animal's new location.
     */
    protected void setLocation(Location newLocation)
    {
        if(location != null) {
            field.clear(location);
        }
        location = newLocation;
        field.place(this, newLocation);
    }

    /**
     * Return the animal's field.
     * @return The animal's field.
     */
    protected Field getField()
    {
        return field;
    }
}


text:
namespace deqp
{
namespace gles31
{

Context::Context (tcu::TestContext& testCtx)
	: m_testCtx		(testCtx)
	, m_renderCtx	(DE_NULL)
	, m_contextInfo	(DE_NULL)
{
	if (m_testCtx.getCommandLine().getRunMode() == tcu::RUNMODE_EXECUTE)
		createRenderContext();
	else
	{
		// \todo [2016-11-15 pyry] Many tests (erroneously) inspect context type
		//						   during test hierarchy construction. We should fix that
		//						   and revert dummy context to advertise unknown context type.
		m_renderCtx = new glu::DummyRenderContext(glu::ContextType(glu::ApiType::es(3,1)));
	}
}

Context::~Context (void)
{
	destroyRenderContext();
}

void Context::createRenderContext (void)
{
	DE_ASSERT(!m_renderCtx && !m_contextInfo);

	try
	{
// Issue 3687
// OpenGL ES 3.2 contexts are not supported yet, and the 3.2 context creation failure results in
// tests that pass with the recreated 3.1 context being marked "fail".
// Revert with Issue 3688
#if 0
		try
		{
			m_renderCtx		= glu::createDefaultRenderContext(m_testCtx.getPlatform(), m_testCtx.getCommandLine(), glu::ApiType::es(3, 2));
		}
		catch (...)
		{
			m_renderCtx		= glu::createDefaultRenderContext(m_testCtx.getPlatform(), m_testCtx.getCommandLine(), glu::ApiType::es(3, 1));
		}
#else
		// Override the original behavior (above) to only create a 3.1 context
		m_renderCtx		= glu::createDefaultRenderContext(m_testCtx.getPlatform(), m_testCtx.getCommandLine(), glu::ApiType::es(3, 1));
#endif
		m_contextInfo	= glu::ContextInfo::create(*m_renderCtx);
	}
	catch (...)
	{
		destroyRenderContext();
		throw;
	}
}

void Context::destroyRenderContext (void)
{
	delete m_contextInfo;
	delete m_renderCtx;

	m_contextInfo	= DE_NULL;
	m_renderCtx		= DE_NULL;
}

const tcu::RenderTarget& Context::getRenderTarget (void) const
{
	return m_renderCtx->getRenderTarget();
}

} // gles31
} // deqp

// clang-format on


text:
Filter

                Filter applies to Tunes, Sets, Playlists, Tune Randomizer

                <form role="form" class="form-horizontal">

                        Type

                            <select class="form-control" id="typeFilter" [(ngModel)]="type" name="type" (change)="setType($event)">
                                <option *ngFor="let t of types" [value]="t">{{t}}</option>
                            </select>

                        Key

                            <select class="form-control" id="keyFilter" [(ngModel)]="key" name="key" (change)="setKey($event)">
                                <option *ngFor="let k of keys" [value]="k">{{k}}</option>
                            </select>

                        Color

                            <select class="form-control" id="colorFilter" [style.background-color]="color" [(ngModel)]="color" name="color" (change)="setColor($event)">
                                <option *ngFor="let c of colors" [value]="c">{{c}}</option>
                            </select>

                        Event

                            <select class="form-control" id="eventFilter" [(ngModel)]="event" name="event" (change)="setEvent($event)">
                                <option *ngFor="let e of events" [value]="e">{{e}}</option>
                            </select>

                        Band

                            <select  class="form-control" id="bandFilter" [(ngModel)]="band" name="band" (change)="setBand($event)">
                                <option *ngFor="let b of bands" [value]="b">{{b}}</option>
                            </select>

                </form>


text:
"""HelloWorldWeb URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from . import view,testdb,search,settings
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^hello$', view.hello),
    url(r'^testdb$', testdb.testdb),
    url(r'^update$', testdb.update),
    url(r'^delete$', testdb.delete),
    url(r'^add$', testdb.add),
    url(r'^search$', search.search),
    url(r'^vinparse$', search.vin_parse),
    url(r'^vin_parse$', search.vin_parse),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/cloud/resourcemanager/v3/projects.proto

namespace Google\Cloud\ResourceManager\V3;

use Google\Protobuf\Internal\GPBType;
use Google\Protobuf\Internal\RepeatedField;
use Google\Protobuf\Internal\GPBUtil;

/**
 * The request sent to the
 * [SearchProjects][google.cloud.resourcemanager.v3.Projects.SearchProjects]
 * method.
 *
 * Generated from protobuf message google.cloud.resourcemanager.v3.SearchProjectsRequest
 */
class SearchProjectsRequest extends \Google\Protobuf\Internal\Message
{
    /**
     * Optional. A query string for searching for projects that the caller has
     * `resourcemanager.projects.get` permission to. If multiple fields are
     * included in the query, the it will return results that match any of the
     * fields. Some eligible fields are:
     * ```
     * | Field                   | Description                                  |
     * |-------------------------|----------------------------------------------|
     * | displayName, name       | Filters by displayName.                      |
     * | parent                  | Project's parent. (for example: folders/123,
     * organizations/*) Prefer parent field over parent.type and parent.id. |
     * | parent.type             | Parent's type: `folder` or `organization`.   |
     * | parent.id               | Parent's id number (for example: 123)        |
     * | id, projectId           | Filters by projectId.                        |
     * | state, lifecycleState   | Filters by state.                            |
     * | labels                  | Filters by label name or value.              |
     * | labels.<key> (where *key* is the name of a label) | Filters by label
     * name. |
     * ```
     * Search expressions are case insensitive.
     * Some examples queries:
     * ```
     * | Query            | Description                                         |
     * |------------------|-----------------------------------------------------|
     * | name:how*        | The project's name starts with "how".               |
     * | name:Howl        | The project's name is `Howl` or `howl`.             |
     * | name:HOWL        | Equivalent to above.                                |
     * | NAME:howl        | Equivalent to above.                                |
     * | labels.color:*   | The project has the label `color`.                  |
     * | labels.color:red | The project's label `color` has the value `red`.    |
     * | labels.color:red labels.size:big | The project's label `color` has
     * the value `red` and its label `size` has the value `big`.                |
     * ```
     * If no query is specified, the call will return projects for which the user
     * has the `resourcemanager.projects.get` permission.
     *
     * Generated from protobuf field string query = 1 [(.google.api.field_behavior) = OPTIONAL];
     */
    private $query = '';
    /**
     * Optional. A pagination token returned from a previous call to [ListProjects]
     * [google.cloud.resourcemanager.v3.Projects.ListProjects]
     * that indicates from where listing should continue.
     *
     * Generated from protobuf field string page_token = 2 [(.google.api.field_behavior) = OPTIONAL];
     */
    private $page_token = '';
    /**
     * Optional. The maximum number of projects to return in the response.
     * The server can return fewer projects than requested.
     * If unspecified, server picks an appropriate default.
     *
     * Generated from protobuf field int32 page_size = 3 [(.google.api.field_behavior) = OPTIONAL];
     */
    private $page_size = 0;

    /**
     * Constructor.
     *
     * @param array $data {
     *     Optional. Data for populating the Message object.
     *
     *     @type string $query
     *           Optional. A query string for searching for projects that the caller has
     *           `resourcemanager.projects.get` permission to. If multiple fields are
     *           included in the query, the it will return results that match any of the
     *           fields. Some eligible fields are:
     *           ```
     *           | Field                   | Description                                  |
     *           |-------------------------|----------------------------------------------|
     *           | displayName, name       | Filters by displayName.                      |
     *           | parent                  | Project's parent. (for example: folders/123,
     *           organizations/*) Prefer parent field over parent.type and parent.id. |
     *           | parent.type             | Parent's type: `folder` or `organization`.   |
     *           | parent.id               | Parent's id number (for example: 123)        |
     *           | id, projectId           | Filters by projectId.                        |
     *           | state, lifecycleState   | Filters by state.                            |
     *           | labels                  | Filters by label name or value.              |
     *           | labels.<key> (where *key* is the name of a label) | Filters by label
     *           name. |
     *           ```
     *           Search expressions are case insensitive.
     *           Some examples queries:
     *           ```
     *           | Query            | Description                                         |
     *           |------------------|-----------------------------------------------------|
     *           | name:how*        | The project's name starts with "how".               |
     *           | name:Howl        | The project's name is `Howl` or `howl`.             |
     *           | name:HOWL        | Equivalent to above.                                |
     *           | NAME:howl        | Equivalent to above.                                |
     *           | labels.color:*   | The project has the label `color`.                  |
     *           | labels.color:red | The project's label `color` has the value `red`.    |
     *           | labels.color:red labels.size:big | The project's label `color` has
     *           the value `red` and its label `size` has the value `big`.                |
     *           ```
     *           If no query is specified, the call will return projects for which the user
     *           has the `resourcemanager.projects.get` permission.
     *     @type string $page_token
     *           Optional. A pagination token returned from a previous call to [ListProjects]
     *           [google.cloud.resourcemanager.v3.Projects.ListProjects]
     *           that indicates from where listing should continue.
     *     @type int $page_size
     *           Optional. The maximum number of projects to return in the response.
     *           The server can return fewer projects than requested.
     *           If unspecified, server picks an appropriate default.
     * }
     */
    public function __construct($data = NULL) {
        \GPBMetadata\Google\Cloud\Resourcemanager\V3\Projects::initOnce();
        parent::__construct($data);
    }

    /**
     * Optional. A query string for searching for projects that the caller has
     * `resourcemanager.projects.get` permission to. If multiple fields are
     * included in the query, the it will return results that match any of the
     * fields. Some eligible fields are:
     * ```
     * | Field                   | Description                                  |
     * |-------------------------|----------------------------------------------|
     * | displayName, name       | Filters by displayName.                      |
     * | parent                  | Project's parent. (for example: folders/123,
     * organizations/*) Prefer parent field over parent.type and parent.id. |
     * | parent.type             | Parent's type: `folder` or `organization`.   |
     * | parent.id               | Parent's id number (for example: 123)        |
     * | id, projectId           | Filters by projectId.                        |
     * | state, lifecycleState   | Filters by state.                            |
     * | labels                  | Filters by label name or value.              |
     * | labels.<key> (where *key* is the name of a label) | Filters by label
     * name. |
     * ```
     * Search expressions are case insensitive.
     * Some examples queries:
     * ```
     * | Query            | Description                                         |
     * |------------------|-----------------------------------------------------|
     * | name:how*        | The project's name starts with "how".               |
     * | name:Howl        | The project's name is `Howl` or `howl`.             |
     * | name:HOWL        | Equivalent to above.                                |
     * | NAME:howl        | Equivalent to above.                                |
     * | labels.color:*   | The project has the label `color`.                  |
     * | labels.color:red | The project's label `color` has the value `red`.    |
     * | labels.color:red labels.size:big | The project's label `color` has
     * the value `red` and its label `size` has the value `big`.                |
     * ```
     * If no query is specified, the call will return projects for which the user
     * has the `resourcemanager.projects.get` permission.
     *
     * Generated from protobuf field string query = 1 [(.google.api.field_behavior) = OPTIONAL];
     * @return string
     */
    public function getQuery()
    {
        return $this->query;
    }

    /**
     * Optional. A query string for searching for projects that the caller has
     * `resourcemanager.projects.get` permission to. If multiple fields are
     * included in the query, the it will return results that match any of the
     * fields. Some eligible fields are:
     * ```
     * | Field                   | Description                                  |
     * |-------------------------|----------------------------------------------|
     * | displayName, name       | Filters by displayName.                      |
     * | parent                  | Project's parent. (for example: folders/123,
     * organizations/*) Prefer parent field over parent.type and parent.id. |
     * | parent.type             | Parent's type: `folder` or `organization`.   |
     * | parent.id               | Parent's id number (for example: 123)        |
     * | id, projectId           | Filters by projectId.                        |
     * | state, lifecycleState   | Filters by state.                            |
     * | labels                  | Filters by label name or value.              |
     * | labels.<key> (where *key* is the name of a label) | Filters by label
     * name. |
     * ```
     * Search expressions are case insensitive.
     * Some examples queries:
     * ```
     * | Query            | Description                                         |
     * |------------------|-----------------------------------------------------|
     * | name:how*        | The project's name starts with "how".               |
     * | name:Howl        | The project's name is `Howl` or `howl`.             |
     * | name:HOWL        | Equivalent to above.                                |
     * | NAME:howl        | Equivalent to above.                                |
     * | labels.color:*   | The project has the label `color`.                  |
     * | labels.color:red | The project's label `color` has the value `red`.    |
     * | labels.color:red labels.size:big | The project's label `color` has
     * the value `red` and its label `size` has the value `big`.                |
     * ```
     * If no query is specified, the call will return projects for which the user
     * has the `resourcemanager.projects.get` permission.
     *
     * Generated from protobuf field string query = 1 [(.google.api.field_behavior) = OPTIONAL];
     * @param string $var
     * @return $this
     */
    public function setQuery($var)
    {
        GPBUtil::checkString($var, True);
        $this->query = $var;

        return $this;
    }

    /**
     * Optional. A pagination token returned from a previous call to [ListProjects]
     * [google.cloud.resourcemanager.v3.Projects.ListProjects]
     * that indicates from where listing should continue.
     *
     * Generated from protobuf field string page_token = 2 [(.google.api.field_behavior) = OPTIONAL];
     * @return string
     */
    public function getPageToken()
    {
        return $this->page_token;
    }

    /**
     * Optional. A pagination token returned from a previous call to [ListProjects]
     * [google.cloud.resourcemanager.v3.Projects.ListProjects]
     * that indicates from where listing should continue.
     *
     * Generated from protobuf field string page_token = 2 [(.google.api.field_behavior) = OPTIONAL];
     * @param string $var
     * @return $this
     */
    public function setPageToken($var)
    {
        GPBUtil::checkString($var, True);
        $this->page_token = $var;

        return $this;
    }

    /**
     * Optional. The maximum number of projects to return in the response.
     * The server can return fewer projects than requested.
     * If unspecified, server picks an appropriate default.
     *
     * Generated from protobuf field int32 page_size = 3 [(.google.api.field_behavior) = OPTIONAL];
     * @return int
     */
    public function getPageSize()
    {
        return $this->page_size;
    }

    /**
     * Optional. The maximum number of projects to return in the response.
     * The server can return fewer projects than requested.
     * If unspecified, server picks an appropriate default.
     *
     * Generated from protobuf field int32 page_size = 3 [(.google.api.field_behavior) = OPTIONAL];
     * @param int $var
     * @return $this
     */
    public function setPageSize($var)
    {
        GPBUtil::checkInt32($var);
        $this->page_size = $var;

        return $this;
    }

}


text:
package com.dremio.exec.store.dfs;

import java.util.Set;

import com.dremio.common.AutoCloseables;
import com.dremio.exec.store.EmptyRecordReader;
import com.dremio.exec.store.RecordReader;
import com.dremio.exec.store.parquet.InputStreamProvider;
import com.dremio.exec.store.parquet.MutableParquetMetadata;
import com.dremio.io.file.Path;

/**
 * Reader creator which creates {@link EmptyRecordReader}
 */
public class EmptySplitReaderCreator extends SplitReaderCreator {

  public EmptySplitReaderCreator(Path path, InputStreamProvider inputStreamProvider) {
    super(inputStreamProvider);
    this.path = path;
  }

  @Override
  public void createInputStreamProvider(InputStreamProvider lastInputStreamProvider, MutableParquetMetadata lastFooter) {}

  @Override
  public InputStreamProvider getInputStreamProvider() {
    return inputStreamProvider;
  }

  @Override
  public void addRowGroupsToRead(Set<Integer> rowGroupsToRead) {
  }

  @Override
  public MutableParquetMetadata getFooter() {
    return null;
  }

  @Override
  public RecordReader createRecordReader(MutableParquetMetadata footer) {
    return new EmptyRecordReader();
  }

  @Override
  public void close() throws Exception {
    AutoCloseables.close(inputStreamProvider);
  }
}


text:
package org.elasticsearch.xpack.watcher.support.xcontent;

import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.xpack.core.watcher.support.xcontent.XContentSource;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
import static org.elasticsearch.common.xcontent.XContentFactory.smileBuilder;
import static org.elasticsearch.common.xcontent.XContentFactory.yamlBuilder;

public class XContentSourceTests extends ESTestCase {
    public void testToXContent() throws Exception {
        XContentBuilder builder = randomBoolean() ? jsonBuilder() : randomBoolean() ? yamlBuilder() : smileBuilder();
        BytesReference bytes = randomBoolean() ?
                BytesReference.bytes(builder.startObject().field("key", "value").endObject()) :
                BytesReference
                        .bytes(builder.startObject()
                                .field("key_str", "value")
                                .startArray("array_int").value(randomInt(10)).endArray()
                                .nullField("key_null")
                                .endObject());
        XContentSource source = new XContentSource(bytes, builder.contentType());
        XContentBuilder builder2 = XContentFactory.contentBuilder(builder.contentType());
        BytesReference bytes2 = BytesReference.bytes(source.toXContent(builder2, ToXContent.EMPTY_PARAMS));
        assertEquals(bytes.toBytesRef(), bytes2.toBytesRef());
    }
}


text:
import $ from 'jquery';
import Pikaday from 'pikaday';
import { parsePikadayDate, pikadayToString } from './lib/utils/datetime_utility';

// Add datepickers to all `js-access-expiration-date` elements. If those elements are
// children of an element with the `clearable-input` class, and have a sibling
// `js-clear-input` element, then show that element when there is a value in the
// datepicker, and make clicking on that element clear the field.
//
export default function memberExpirationDate(selector = '.js-access-expiration-date') {
  function toggleClearInput() {
    $(this)
      .closest('.clearable-input')
      .toggleClass('has-value', $(this).val() !== '');
  }
  const inputs = $(selector);

  inputs.each((i, el) => {
    const $input = $(el);

    const calendar = new Pikaday({
      field: $input.get(0),
      theme: 'gitlab-theme animate-picker',
      format: 'yyyy-mm-dd',
      minDate: new Date(),
      container: $input.parent().get(0),
      parse: dateString => parsePikadayDate(dateString),
      toString: date => pikadayToString(date),
      onSelect(dateText) {
        $input.val(calendar.toString(dateText));

        $input.trigger('change');

        toggleClearInput.call($input);
      },
    });

    calendar.setDate(parsePikadayDate($input.val()));
    $input.data('pikaday', calendar);
  });

  inputs.next('.js-clear-input').on('click', function clicked(event) {
    event.preventDefault();

    const input = $(this)
      .closest('.clearable-input')
      .find(selector);
    const calendar = input.data('pikaday');

    calendar.setDate(null);
    input.trigger('change');
    toggleClearInput.call(input);
  });

  inputs.on('blur', toggleClearInput);

  inputs.each(toggleClearInput);
}


text:
package fr.inra.maiage.bibliome.util.mappers;

public final class ToStringMapper<T> implements Mapper<T,String> {
    @Override
    public String map(T x) {
        return x.toString();
    }
}


text:
<?php

namespace Jet\Router\Test;

use Jet\Router\Router;

class RouterTest extends \PHPUnit_Framework_TestCase
{
    public static $fixturesDir;

    public static function setUpBeforeClass()
    {
        self::$fixturesDir = __DIR__."/../Fixtures/";
        require_once(self::$fixturesDir.'TestFixtures.php');
    }

    public function testConstructor()
    {
        $test = array('test' => 'test');
        $router = new Router($test);

        $this->assertEquals($test, $router->routes, "Constructor don't add routes");
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testConstructorException()
    {
        $router = new Router('string');
    }

    public function testAddRoutes()
    {
        $router = new Router();
        $test = array('test' => 'test');
        $router->addRoutes($test);

        $this->assertEquals($test, $router->routes, "addRoutes don't add routes");
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testAddRoutesException()
    {
        $router = new Router();
        $router->addRoutes('string');
    }

    public function testLauchReturnValue()
    {
        $router = new Router();
        $router->addRoutes(array('/' => function(){
            return true;
        }));

        $this->assertTrue($router->launch(), "Router can't launch default URI");
    }

    /**
     * @expectedException RuntimeException
     */
    public function testLaunchException()
    {
        $router = new Router();
        $router->launch();
        $router->launch('/test');
    }

    public function testDefault()
    {
        $router = new Router(array(
            '/' => function(){
                return 'default';
            }
        ));

        $this->assertEquals('default', $router->launch(), 'Default route not working');
    }

    public function testError()
    {
        $router = new Router(array(
            'error' => function(){
                return 'error';
            }
        ));

        $this->assertEquals('error', $router->launch(), 'Default route not working');
    }

    public function testPattern()
    {
        $urlContent = array(
            'any'   => 'this.is-a/Test',
            'slug'  => 'this-is-a-test',
            'alpha' => 'abcd',
            'num'   => '1234'
        );

        $router = new Router(array(
            'any/[test]:any' => function($test){
                return $test;
            },
            'slug/[test]:slug' => function($test){
                return $test;
            },
            'alpha/[test]:alpha' => function($test){
                return $test;
            },
            'num/[test]:num' => function($test){
                return $test;
            },
            'error' => function($url){
                return false;
            }
        ));

        $this->assertEquals($urlContent['any'], $router->launch('any/'.$urlContent['any']), 'pattern :any not working');
        $this->assertEquals($urlContent['slug'], $router->launch('slug/'.$urlContent['slug']), 'pattern :slug not working');
        $this->assertEquals($urlContent['alpha'], $router->launch('alpha/'.$urlContent['alpha']), 'pattern :alpha not working');
        $this->assertEquals($urlContent['num'], $router->launch('num/'.$urlContent['num']), 'pattern :num not working');
    }

    public function testCalledObject()
    {
        $router = new Router();
        $router->addRoutes(array(
            '/' => '\Tests\Fixtures\TestFixtures:testDefault',
            'error' => '\Tests\Fixtures\TestFixtures:testError',
            'test/[arg]:any' => '\Tests\Fixtures\TestFixtures:testWithArgument'
        ));
        $value = sha1(time());

        $this->assertTrue($router->launch('/'), "Router can't call object default method");
        $this->assertFalse($router->launch($value), "Router can't call object error method");
        $this->assertEquals($value, $router->launch('test/'.$value), "Router can't call object method with arguments");
    }

    public function testRouteArray()
    {
        $router = new Router();
        $value = sha1(time());
        $router->addRoutes(array(
            '/' => array(
                '\Tests\Fixtures\TestFixtures:testDefault',
                function(){
                    return true;
                }
            )
        ));

        $this->assertTrue($router->launch('/'), "Router can't call object default method");
    }
}


text:
package foo;

public class MemberEndJava {
    public static class <caret>NestedJava {}
}


text:
<?php

namespace LD2\View;

use Symfony\Component\Routing\Router;
use Twig_Node;

class PathFunction extends \Twig_SimpleFunction  {
    /**
     * @var Router
     */
    protected $router;

}


text:
namespace fractal {
	namespace fcore {
		class HUD : public System, public IDrawable {
		public:
			HUD();
			virtual void update();
			virtual void draw() const;

			virtual bool initialize();
			virtual bool shutdown();

			void beginDraw() const;
			void endDraw() const;
		};
	}
}
#endif // !HUD_H


text:
using System.Collections.Generic;

namespace MMMWrapper.Models
{
    public class Metadata
    {
        public IEnumerable<Field> Field { get; set; }
    }

}


text:
/***********************************************************
 *	Headers
 ***********************************************************/
#include <GL/glut.h>
#include "glutint.h"
#include "glutState.h"

/***********************************************************
 *	Window related callbacks
 ***********************************************************/
void APIENTRY
glutDisplayFunc(GLUTdisplayCB displayFunc)
{
  /* XXX Remove the warning after GLUT 3.0. */
  if (!displayFunc)
    __glutFatalError("NULL display callback not allowed in GLUT 3.0; update your code.");
  gState.currentWindow->display = displayFunc;
}

void APIENTRY
glutKeyboardFunc(GLUTkeyboardCB keyboardFunc)
{
  gState.currentWindow->keyboard = keyboardFunc;
}

void APIENTRY
glutSpecialFunc(GLUTspecialCB specialFunc)
{
  gState.currentWindow->special = specialFunc;
}

void APIENTRY
glutMouseFunc(GLUTmouseCB mouseFunc)
{
  gState.currentWindow->mouse = mouseFunc;
}

void APIENTRY
glutMotionFunc(GLUTmotionCB motionFunc)
{
  gState.currentWindow->motion = motionFunc;
}

void APIENTRY
glutPassiveMotionFunc(GLUTpassiveCB passiveMotionFunc)
{
  gState.currentWindow->passive = passiveMotionFunc;
}

void APIENTRY
glutEntryFunc(GLUTentryCB entryFunc)
{
  gState.currentWindow->entry = entryFunc;
  if (!entryFunc) {
    gState.currentWindow->entryState = -1;
  }
}

void APIENTRY
glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc)
{
  gState.currentWindow->windowStatus = windowStatusFunc;
}

static void
visibilityHelper(int status)
{
  if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED)
    gState.currentWindow->visibility(GLUT_NOT_VISIBLE);
  else
    gState.currentWindow->visibility(GLUT_VISIBLE);
}

void APIENTRY
glutVisibilityFunc(GLUTvisibilityCB visibilityFunc)
{
  gState.currentWindow->visibility = visibilityFunc;
  if (visibilityFunc)
    glutWindowStatusFunc(visibilityHelper);
  else
    glutWindowStatusFunc(NULL);
}

void APIENTRY
glutReshapeFunc(GLUTreshapeCB reshapeFunc)
{
  if (reshapeFunc) {
    gState.currentWindow->reshape = reshapeFunc;
  } else {
    gState.currentWindow->reshape = __glutDefaultReshape;
  }
}

/***********************************************************
 *	General callbacks (timer callback in glutEvent.cpp)
 ***********************************************************/
/* DEPRICATED, use glutMenuStatusFunc instead. */
void APIENTRY
glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
{
  gState.menuStatus = (GLUTmenuStatusCB) menuStateFunc;
}

void APIENTRY
glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
{
  gState.menuStatus = menuStatusFunc;
}

void APIENTRY
glutIdleFunc(GLUTidleCB idleFunc)
{
  gState.idle = idleFunc;
}

/***********************************************************
 *	Unsupported callbacks
 ***********************************************************/
void APIENTRY
glutOverlayDisplayFunc(GLUTdisplayCB displayFunc)
{
}

void APIENTRY
glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc)
{
}

void APIENTRY
glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc)
{
}

void APIENTRY
glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc)
{
}

void APIENTRY
glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc)
{
}

void APIENTRY
glutDialsFunc(GLUTdialsCB dialsFunc)
{
}

void APIENTRY
glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc)
{
}

void APIENTRY
glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc)
{
}