text:
RIOT SUPPORTS CODERDOJO
=======================

Required plugins
----------------

* pods
* timber
* simple-facebook-open-graph-tags

Configure pods
--------------

Pods has to be configured to extend Post / Page with certain custom fields that
are used by the Company Header and People twig templates.

For company header:

* Company Name (company_name, text)
* Company Logo (company_logo, image)
* Company Bio (company_bio, WYSISYG)
* Company URL (company_url, URL)

For people:

* Person Name (people_name, text)
* Person Avatar (people_image, image)
* Person Title (people_tag, text)
* Person Bio (people_bio, WYSISYG)

Configure Facebook OG
---------------------

* https://www.dropbox.com/s/0glsw61bvmf5qqx/Screenshot%202016-05-26%2021.59.41.png?dl=0
* https://www.dropbox.com/s/qdg6embf3hqu60h/Screenshot%202016-05-26%2022.00.29.png?dl=0
* https://www.dropbox.com/s/tv1vp46m148ipgr/Screenshot%202016-05-26%2022.00.49.png?dl=0
* https://www.dropbox.com/s/y4wu1fx3v25s3x1/Screenshot%202016-05-26%2022.01.05.png?dl=0
* https://www.dropbox.com/s/t4l2ettjm3fs0ff/Screenshot%202016-05-26%2022.01.22.png?dl=0

Using the CTA twig template
---------------------------

```
{% include 'cta.twig' with {'buttontext': 'Call to Action', 'target': 'http://www.google.com', 'class': 'foo' } %}
```

Using the Company Header twig template
--------------------------------------

Create a post and fill in the Company related custom fields created in pods.

Using the People twig template
------------------------------

Create a post and fill in the People related custom fields created in pods.

Managing the menus
------------------

The main navigation menu is completely handled via the wordpress menu system.
Just create a menu called `main` and start adding links.

Getting specific pages
----------------------

There are specific pages that need to be added (in wordpress) that have their own twig view (/views), these (can) include other twig files.

To be able to see these pages, create the following pages within the Wordpress Admin:

```
Page                  slug name
----                  ---------
About                 about
Attend a Dojo         attend-a-dojo
Community             community
-Badges               badges
-Community Committee  community-committee
-Forum                forum
Create a Dojo         create-a-dojo
Volunteer             volunteer
What we do            what-we-do
Donate                donate
User Details          user-details
Register              register
Resources             resources
Foundation            foundation
Supporters            supporters
Movement              movement
News                  news
Regional Bodies       regional-bodies
```

> The menu does not support more than 7 pages.

Adding media within articles
------------------------

Using POD Admin you need to extend posts and add two new fields, with the following labels and filetypes:
* video (File / video / image)
* video-poster (File / video / image)
* article_desc (Text)

*Video* should accept video file types and be used to host the video directly.
 > Upload both an mp4, and a ogg file.

With the *Video-poster* item you should accept images and this will host the Video's poster (image shown before the video plays).

If neither of this fields are field in a horizontal rule is shown instead to show.

*post_banner* A required image for posts. This image needs to be large and high quality. It will be injected into a carousel on page-news.


text:
THEOS_DEVICE_IP = 192.168.199.164
ARCHS = armv7 arm64
TARGET = iphone:latest:8.0

include theos/makefiles/common.mk

TWEAK_NAME = alipaywalletchatvoicesaver
alipaywalletchatvoicesaver_FILES = Tweak.xm
alipaywalletchatvoicesaver_FRAMEWORKS = UIKit

include $(THEOS_MAKE_PATH)/tweak.mk

after-install::
	install.exec "killall -9 AlipayWallet"

redpajama_set_name: RedPajamaGithub


text:
using base::android::AttachCurrentThread;
using base::android::ConvertUTF8ToJavaString;
using base::android::JavaParamRef;
using base::android::JavaRef;
using base::android::ScopedJavaGlobalRef;
using base::android::ScopedJavaLocalRef;

namespace send_tab_to_self {

ScopedJavaLocalRef<jobject> CreateJavaSendTabToSelfEntry(
    JNIEnv* env,
    const SendTabToSelfEntry* entry) {
  return Java_SendTabToSelfEntry_createSendTabToSelfEntry(
      env, ConvertUTF8ToJavaString(env, entry->GetGUID()),
      ConvertUTF8ToJavaString(env, entry->GetURL().spec()),
      ConvertUTF8ToJavaString(env, entry->GetTitle()),
      entry->GetSharedTime().ToJavaTime(),
      entry->GetOriginalNavigationTime().ToJavaTime(),
      ConvertUTF8ToJavaString(env, entry->GetDeviceName()),
      ConvertUTF8ToJavaString(env, entry->GetTargetDeviceSyncCacheGuid()));
}

}  // namespace send_tab_to_self


text:
package kill.me.later;

import static org.testng.Assert.assertTrue;

import org.testng.annotations.Test;

public class SomeTest {

	private int id = 0;
	private String account = "";

	public SomeTest(int id, String account) {
		this.id = id;
		this.account = account;
	}

	@Test
	public void firstTest() {
		System.out.println("Test #1 with data: "+id+". "+account);
		assertTrue(true);
	}

	@Test
	public void secondTest() {
		System.out.println("Test #2 with data: "+id+". "+account);
		assertTrue(true);
	}

	@Test
	public void thirdTest() {
		System.out.println("Test #3 with data: "+id+". "+account);
		assertTrue(true);
	}

}


text:
package iso20022

// Specifies prices related to a corporate action option.
type CorporateActionPrice31 struct {

	// Indicates whether the price is an indicative price or a market price.
	IndicativeOrMarketPrice *IndicativeOrMarketPrice5Choice `xml:"IndctvOrMktPric,omitempty"`

	// Cash disbursement in lieu of equities; usually in lieu of fractional quantity.
	CashInLieuOfSharePrice *PriceFormat19Choice `xml:"CshInLieuOfShrPric,omitempty"`

	// Cash value of resulting securities proceeds for tax calculation and/or reporting.
	CashValueForTax *PriceFormat29Choice `xml:"CshValForTax,omitempty"`

	// Generic cash price paid per product by the underlying security holder either as a percentage or an amount, for example, reinvestment price.
	GenericCashPricePaidPerProduct *PriceFormat23Choice `xml:"GncCshPricPdPerPdct,omitempty"`

	// Generic cash price received per product by the underlying security holder either as a percentage or an amount, for example, redemption price.
	GenericCashPriceReceivedPerProduct *PriceFormat20Choice `xml:"GncCshPricRcvdPerPdct,omitempty"`
}

func (c *CorporateActionPrice31) AddIndicativeOrMarketPrice() *IndicativeOrMarketPrice5Choice {
	c.IndicativeOrMarketPrice = new(IndicativeOrMarketPrice5Choice)
	return c.IndicativeOrMarketPrice
}

func (c *CorporateActionPrice31) AddCashInLieuOfSharePrice() *PriceFormat19Choice {
	c.CashInLieuOfSharePrice = new(PriceFormat19Choice)
	return c.CashInLieuOfSharePrice
}

func (c *CorporateActionPrice31) AddCashValueForTax() *PriceFormat29Choice {
	c.CashValueForTax = new(PriceFormat29Choice)
	return c.CashValueForTax
}

func (c *CorporateActionPrice31) AddGenericCashPricePaidPerProduct() *PriceFormat23Choice {
	c.GenericCashPricePaidPerProduct = new(PriceFormat23Choice)
	return c.GenericCashPricePaidPerProduct
}

func (c *CorporateActionPrice31) AddGenericCashPriceReceivedPerProduct() *PriceFormat20Choice {
	c.GenericCashPriceReceivedPerProduct = new(PriceFormat20Choice)
	return c.GenericCashPriceReceivedPerProduct
}


text:
/* Liux/gcc implementation of the call_stack class. */
#ifdef __GNUC__

#include <stdio.h>
#include <execinfo.h>
#include <cxxabi.h>
#include <dlfcn.h>
#include <stdlib.h>
#include "call_stack.hpp"

#define MAX_DEPTH 32

namespace stacktrace {

call_stack::call_stack (const size_t num_discard /*= 0*/) {
    using namespace abi;

    // retrieve call-stack
    void * trace[MAX_DEPTH];
    int stack_depth = backtrace(trace, MAX_DEPTH);

    for (int i = num_discard+1; i < stack_depth; i++) {
        Dl_info dlinfo;
        if(!dladdr(trace[i], &dlinfo))
            break;

        const char * symname = dlinfo.dli_sname;

        int    status;
        char * demangled = abi::__cxa_demangle(symname, NULL, 0, &status);
        if(status == 0 && demangled)
            symname = demangled;

        //printf("entry: %s, %s\n", dlinfo.dli_fname, symname);

        // store entry to stack
        if (dlinfo.dli_fname && symname) {
            entry e;
            e.file     = dlinfo.dli_fname;
            e.line     = 0; // unsupported
            e.function = symname;
            stack.push_back(e);
        } else {
            break; // skip last entries below main
        }

        if (demangled)
            free(demangled);
    }
}

call_stack::~call_stack () throw() {
    // automatic cleanup
}

} // namespace stacktrace

#endif // __GNUC__


text:
package graphql.schema.idl.errors;

import graphql.Internal;
import graphql.language.OperationTypeDefinition;

import static java.lang.String.format;

@Internal
public class OperationTypesMustBeObjects extends BaseError {

    public OperationTypesMustBeObjects(OperationTypeDefinition op) {
        super(op, format("The operation type '%s' MUST have a object type as its definition %s",
                op.getName(), lineCol(op)));
    }
}


text: //= require modal-dialog


text:
import Vue from 'vue';

import 'minireset.css';

import VueScroller from 'vue-scroller';
import VueCookies from 'vue-cookies';
import Vant from 'vant';
import 'vant/lib/index.less';
import '@/assets/css/vant.scss';

import axios from 'axios';

import Flexible from '@/common/lib/flexible';
import Debugger from '@/common/lib/debugger';
import config from '@/config';
import Components from '@/components';
import lib from '@/common/lib';

Vue.prototype.$axios = axios;
Vue.prototype.$config = config;
Vue.prototype.$tools = Object.keys(lib).reduce(
  (p, c) => Object.assign(p, lib[c]),
  {}
);

Vue.use(Flexible);
Vue.use(Vant);
Vue.use(VueScroller);
Vue.use(VueCookies);
Vue.use(Components);

if (config.env === 'test') {
  Vue.use(Debugger);
}


text:
// X3BEGIN_CLASS_DECLARE(Cls, clsid)
// X3BEGIN_CLASS_DECLARE0(Cls)
//     X3DEFINE_INTERFACE_ENTRY(_Interface)
//     X3USE_INTERFACE_ENTRY(_BaseClass)
// X3END_CLASS_DECLARE()

namespace x3 {
LOCALAPI HMODULE getModuleHandle();
LOCALAPI HMODULE getManagerModule();
}

#define X3BEGIN_CLASS_DECLARE0(Cls) \
public: \
    static bool _queryObject(const Cls* self, long iid, x3::IObject** p)  \
    {

#define X3BEGIN_CLASS_DECLARE(Cls, clsid)  \
public: \
    static const char* _getClassID() { return clsid; }   \
    static const char* _getClassName() { return #Cls; }   \
    static bool _queryObject(const Cls* self, long iid, x3::IObject** p)  \
    {

#define X3DEFINE_INTERFACE_ENTRY(_Interface)    \
        if (iid == _Interface::getIID())        \
        {   \
            if (self) {     \
                *p = (x3::IObject*)(_Interface*)(self); \
                (*p)->retainObject(); \
            }   \
            return true;    \
        }

#define X3USE_INTERFACE_ENTRY(_BaseClass)   \
        if (_BaseClass::_queryObject(self, iid, p))   \
        {   \
            return true;    \
        }

#define X3END_CLASS_DECLARE() \
        return false; \
    }   \
protected:  // Ensure the following constructor is protected.

#endif


text:
using System;
using System.Collections;
using System.Data;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Web.SessionState;
using System.IO;
using TravelAgent.Web.UI;

namespace TravelAgent.Web.Tools
{
    /// <summary>
    /// $codebehindclassname$ 的摘要说明
    /// </summary>
    public class SingleUpload1 : IHttpHandler, IRequiresSessionState
    {

        public void ProcessRequest(HttpContext context)
        {
            //检查是否登录后上传操作
            //if (context.Session["AdminNo"] == null)
            //{
            //    context.Response.Write("{\"msg\": 0, \"msbox\": \"请登录后再进行上传文件!\"}");
            //    return;
            //}
            HttpPostedFile _upfile = context.Request.Files["FileUpload1"];
            string _delfile = context.Request.Params["txtImgUrl1"];
            if (_upfile == null)
            {
                context.Response.Write("{\"msg\": 0, \"msbox\": \"请选择要上传文件!\"}");
                return;
            }
            UpLoad upFiles = new UpLoad();
            string msg = upFiles.fileSaveAs(_upfile, 0);
            //删除已存在的旧文件
            if (!string.IsNullOrEmpty(_delfile))
            {
                string _filename = HttpContext.Current.Server.MapPath(_delfile);
                if (File.Exists(_filename))
                {
                    File.Delete(_filename);
                }
            }
            //返回成功信息
            context.Response.Write(msg);
        }

        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }
}


text:
// Copyright (c) Christophe Gondouin (CGO Conseils). All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DefinitionManager
{
    [AttributeUsage(AttributeTargets.Property)]
    internal class ColumnAttribute : MergeableAttribute
    {
        public string DisplayName { get; set; }

        public int Order { get; set; }

        public int Width { get; set; }

        public ColumnAttribute(string displayName, int order, int width = 145)
        {
            DisplayName = displayName;
            Order = order;
            Width = width;
        }
    }
}


text:
<?php

namespace SPF\DatabaseDumpProvider\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class CacheClearCommand extends Command
{
    protected function configure()
    {
        $this
            ->setName('data:clear-caches')
            ->setDescription('Clears the cache')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $output->writeln('<info>Clearing cache...</info>');
        passthru(sprintf('rm -rf %s', __DIR__ . '/../../../../var/cache/*'));
        $output->writeln('<info>Done</info>');
    }

}


text:
import os, sys
import Image
from utils import tic, toc

##################################
# Parameter checking
#################################
if len(sys.argv) < 3:
  print 'Use: benchmark.py imageList imgsDir outputFile'
  print '     localMachine: /home/caicedo/software/decaf-release-master/pretrained/'
  print '     cluster:      /projects/VisionLanguage/caicedo/data/decaf/'
  sys.exit()

images  = [x.replace('\n','') for x in open(sys.argv[1])]
imgsDir = sys.argv[2]
outFile = sys.argv[3]

import numpy as np
from skimage import io
#from decaf.scripts.imagenet import DecafNet
from decaf.util import transform
#net = DecafNet(pretrainedModel+'/imagenet.decafnet.epoch90', pretrainedModel+'/imagenet.decafnet.meta')

from caffe import imagenet
MODEL_FILE = '/home/caicedo/software/caffe-master/examples/imagenet_deploy.prototxt'
PRETRAINED = '/home/caicedo/Downloads/caffe_reference_imagenet_model'
net = imagenet.ImageNetClassifier(MODEL_FILE, PRETRAINED)
net.caffenet.set_phase_test()
#net.caffenet.set_mode_cpu()
net.caffenet.set_mode_gpu()

# From: https://github.com/zachrahan/scikits-image/blob/master/skimage/io/tests/test_freeimage.py?source=cc
try:
    import skimage.io._plugins.freeimage_plugin as fi
    FI_available = True
    io.use_plugin('freeimage')
except RuntimeError:
    FI_available = False

# Prevent Hitting Memory Limits
r = os.popen('cat /proc/meminfo | grep MemTotal').read()
mem = int(r.split()[1])
if mem < 18282710:
  batch = 100
else:
  batch = 500

##################################
# Functions
#################################

def loadImageNetWords():
  words = [w.split(',')[0] for w in open('/home/caicedo/software/caffe-master/python/caffe/imagenet/ilsvrc_2012_synset_words.txt')]
  words = [' '.join(w.split()[1:]) for w in words]
  return words

#################################
# Classify Images
#################################
totalItems = len(images)
words = loadImageNetWords()
print 'Classifying',totalItems,'total images'
result = open(outFile,'w')
for name in images:
  #img = io.imread(imgsDir+'/'+name)
  # Extract and store CNN Features
  print name
  #scores = net.classify(img, center_only=False)
  prediction = net.predict(imgsDir+'/'+name)
  top1 = words[ np.argmax(prediction) ]
  result.write(name + ' ' + top1 + '\n')


text:
using System.Collections;
using nHydrate.Generator.Common.GeneratorFramework;
using nHydrate.Generator.Common.Util;

namespace nHydrate.Generator.Common.EventArgs
{
	public class ProjectItemGeneratedErrorEventArgs : System.EventArgs
	{
		#region Constructors

		#endregion

		#region Property Implementations

		public string Text { get; set; }

		public bool ShowError { get; set; }

		#endregion

	}
}


text:
import React from 'react';
import assign from 'object-assign';

let MentionHighlighter = () => {
  return {
    highlight(srcText, highlightText, options = {}) {
      if(typeof srcText !== 'string') return srcText;
      if(!srcText || !highlightText) return srcText;
      if(highlightText === '' || srcText === '') return srcText;

      const result = srcText.split(' ').map(word => {
          let match = word.startsWith(highlightText)
                  || word.startsWith(highlightText + ":")
                  || word.startsWith("@" + highlightText)
                  || word.startsWith(highlightText + ",");
          if (match) {
            return React.createElement(
              'span',
              assign({className: options.highlightClassName}, options),
              word + " "
            );
          } else {
            return word + " ";
          }
        });

      let r = [];
      let s = '';
      result.forEach((e) => {
        if(typeof e === 'string') {
          s += e;
        } else {
          r.push(s);
          r.push(e);
          s = '';
        }
      });
      r.push(s);

      return r;
    }
  };
};

export default MentionHighlighter();


text:
import fs from 'fs';
import os from 'os';
import path from 'path';
import repl from 'repl';

export function setupHistory(replServer: repl.REPLServer, historyFile: string, historySize: number): void {
  fs.mkdirSync(path.join(os.homedir(), '.rinore'), { mode: 0o755, recursive: true });

  if (historyFile.startsWith('.rinore/')) {
    // no change
  } else if (historyFile.startsWith('.')) {
    // move old style history file to new path (~/.rinore)
    const newHistoryFile = '.rinore/' + historyFile.replace(/^\./, '');
    if (
      fs.existsSync(path.join(os.homedir(), historyFile)) &&
      !fs.existsSync(path.join(os.homedir(), newHistoryFile))
    ) {
      fs.renameSync(path.join(os.homedir(), historyFile), path.join(os.homedir(), newHistoryFile));
    }
    historyFile = newHistoryFile;
  } else {
    historyFile = '.rinore/' + historyFile;
  }

  historyFile = path.join(os.homedir(), historyFile);
  try {
    const data = fs.readFileSync(historyFile, 'utf8');
    if (data) {
      const histories = data.split(/[\n\r]+/);
      if (histories[histories.length - 1] === '') {
        histories.pop();
      }
      if (histories.length > historySize) {
        histories.splice(0, histories.length - historySize);
        fs.writeFileSync(historyFile, histories.join(os.EOL) + os.EOL, 'utf8');
      }
      histories.reverse();
      (replServer as any).history = histories;
    }
  } catch (error) {
    // can not read historyFile, just skip
  }

  const fd = fs.openSync(historyFile, 'a');
  replServer.on('line', (line: string) => {
    fs.writeSync(fd, line + os.EOL, null, 'utf8');
  });
  replServer.on('exit', () => {
    fs.closeSync(fd);
  });
}


text:
package com.heisenbugdev.heisenui.api.view;

public interface IButton
{

    public String text();
    public void setText(String text);
    public boolean enabled();
    public void setEnabled(boolean enabled);
    public int buttonId();
    public void setButtonId(int buttonId);
}


text:
using StructureMap;

namespace WhoWhat.Core.Configuration
{
    public class TestConfig : IConfigurator
    {
        public void Configure(IContainer container)
        {
            new CoreConfigurator().RegisterSettings(container)
                                  .RegisterGuidIdGenerator(container)
                                  .RegisterFakePusher(container)
                                  .RegisterFakeImageStorage(container);

            new EventStoreConfigurator().RegisterInMemoryEventStore(container)
                                        .RegisterAggregateRepository(container);

            new LoggingConfigurator().RegisterMongoDomainLogger(container);

            new UserCacheConfigurator().RegisterInMemoryUserCache(container);

            new UniformConfigurator().RegisterInMemoryUniform(container)
                                     .RegisterDocuments(container)
                                     .RegisterDocumentStores(container)
                                     .RegisterViewContext(container);

            new TransportConfigurator().RegisterDispatcher(container, enableLogs: false)
                                       .RegisterServiceBus(container)
                                       .RegisterDomainBuses(container);
        }
    }
}


text:
"use strict"

var path = require('path')
  , fs = require('fs-extra')
  , util = require('util')
  , marked = require('marked')

class Toc {

  /**
   *
   * @param {GWC} gwc
   */
  constructor(ld) {
    this.ld = ld
    this.computeTocParts()
  }

  getMarkdown() {
    return this.toc.tocMd
  }

  getHtml() {
    return this.toc.tocHtml
  }

  getItems() {
    return this.toc.tocItems
  }

  /**
   * @private
   */
  computeTocParts() {
    this.toc = {}
    this.toc.tocMd = this.getTocFileContents()

    let convertedToc = this.ld.getMarkdownConverter().convertTocMarkdownString(this.toc.tocMd)
    this.toc.tocHtml = convertedToc.tocHtml
    this.toc.tocItems = convertedToc.tocItems
  }

  /**
   * @private
   * @returns {String}
   */
  getTocFileContents() {
    var tocFile = this.ld.getTocFile()
    if (tocFile) {
      return fs.readFileSync(tocFile, {encoding: 'utf8'})
    }
    // if no toc file, generate contents from files
    return this.genTocFileContents()
  }

  /**
   * @private
   * @returns {string}
   */
  genTocFileContents() {
    return Object.keys(this.ld.getMarkdownFiles()).map(filename => {
      var basename = path.basename(filename)
      return util.format('- [%s](%s)', basename, basename)
    }).join('\n')
  }
}

module.exports = Toc


text:
import { Attr } from "./Attr";
import { Node } from "./Node";

export function getAttribute(node: Node, name: string): Attr {
    for (let i = 0; i < node.attributes.length; i++) {
        const attribute = node.attributes[i];
        if (attribute.nodeName === name) {
            return attribute;
        }
    }
    return null;
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<TITLE>
org.apache.hadoop.hbase.ipc (HBase 0.94.16 API)
</TITLE>

<META NAME="date" CONTENT="2014-01-10">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../stylesheet.css" TITLE="Style">

org.apache.hadoop.hbase.ipc

Interfaces

CoprocessorProtocol

Delayable

HBaseRPCErrorHandler

HMasterInterface

HMasterRegionInterface

HRegionInterface

RpcCallContext

RpcEngine

RpcServer

VersionedProtocol

Classes

ExecRPCInvoker

HBaseClient

HBaseClient.ConnectionId

HBaseClient.ParallelResults

HBaseRPC

HBaseRpcMetrics

HBaseRPCStatistics

HBaseServer

Invocation

MasterExecRPCInvoker

ProtocolSignature

RequestContext

Exceptions

CallerDisconnectedException

HBaseClient.CallTimeoutException

HBaseClient.FailedServerException

HBaseRPC.UnknownProtocolException

HBaseRPC.VersionMismatch

ServerNotRunningYetException


text:
try:
    import uasyncio as asyncio
except ImportError:
    try:
        import asyncio
    except ImportError:
        print("SKIP")
        raise SystemExit

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print("Task {}: Compute factorial({})...".format(name, i))
        await asyncio.sleep(0.01)
        f *= i
    print("Task {}: factorial({}) = {}".format(name, number, f))
    return f

async def task(id):
    print("start", id)
    await asyncio.sleep(0.2)
    print("end", id)

async def gather_task():
    print("gather_task")
    await asyncio.gather(task(1), task(2))
    print("gather_task2")

async def main():
    # Simple gather with return values
    print(await asyncio.gather(factorial("A", 2), factorial("B", 3), factorial("C", 4),))

    # Cancel a multi gather
    # TODO doesn't work, Task should not forward cancellation from gather to sub-task
    # but rather CancelledError should cancel the gather directly, which will then cancel
    # all sub-tasks explicitly
    # t = asyncio.create_task(gather_task())
    # await asyncio.sleep(0.1)
    # t.cancel()
    # await asyncio.sleep(0.01)

asyncio.run(main())


text:
ActiveRecord::Base.send :include, ActiveRecord::HasManyComments
ActionController::Base.send :include, ActionController::ActsAsCommentable

# wtf ...
ActiveSupport::Dependencies.autoloaded_constants -= %w(ActionController::ActsAsCommentable ActiveRecord::HasManyComments)

require 'format'

register_javascript_expansion :default   => %w( adva_comments/jquery.comments )
register_stylesheet_expansion :default => %w( adva_comments/comments ),
                              :admin   => %w( adva_comments/admin/comments )


text:
Package.describe({
	name: 'rocketchat:favico',
	version: '0.0.1',
	summary: 'Favico.js for Rocket.Chat',
});

Package.onUse(function(api) {
	api.addFiles('client/favico.js', 'client');
});


text:
A full-featured markdown parser and compiler, written in javascript.
Built for speed.

## Benchmarks

node v0.4.x

``` bash
$ node test --bench
marked completed in 12071ms.
showdown (reuse converter) completed in 27387ms.
showdown (new converter) completed in 75617ms.
markdown-js completed in 70069ms.
```

node v0.6.x

``` bash
$ node test --bench
marked completed in 6448ms.
marked (gfm) completed in 7357ms.
marked (pedantic) completed in 6092ms.
discount completed in 7314ms.
showdown (reuse converter) completed in 16018ms.
showdown (new converter) completed in 18234ms.
markdown-js completed in 24270ms.
```

__Marked is now faster than Discount, which is written in C.__

For those feeling skeptical: These benchmarks run the entire markdown test suite
1000 times. The test suite tests every feature. It doesn't cater to specific
aspects.

node v0.8.x

``` bash
$ node test --bench
marked completed in 3411ms.
marked (gfm) completed in 3727ms.
marked (pedantic) completed in 3201ms.
robotskirt completed in 808ms.
showdown (reuse converter) completed in 11954ms.
showdown (new converter) completed in 17774ms.
markdown-js completed in 17191ms.
```

## Install

``` bash
$ npm install marked
```

## Another Javascript Markdown Parser

The point of marked was to create a markdown compiler where it was possible to
frequently parse huge chunks of markdown without having to worry about
caching the compiled output somehow...or blocking for an unnecesarily long time.

marked is very concise and still implements all markdown features. It is also
now fully compatible with the client-side.

marked more or less passes the official markdown test suite in its
entirety. This is important because a surprising number of markdown compilers
cannot pass more than a few tests. It was very difficult to get marked as
compliant as it is. It could have cut corners in several areas for the sake
of performance, but did not in order to be exactly what you expect in terms
of a markdown rendering. In fact, this is why marked could be considered at a
disadvantage in the benchmarks above.

Along with implementing every markdown feature, marked also implements
[GFM features](http://github.github.com/github-flavored-markdown/).

## Options

marked has a few different switches which change behavior.

- __pedantic__: Conform to obscure parts of `markdown.pl` as much as possible.
  Don't fix any of the original markdown bugs or poor behavior.
- __gfm__: Enable github flavored markdown (enabled by default).
- __sanitize__: Sanitize the output. Ignore any HTML that has been input.
- __highlight__: A callback to highlight code blocks.
- __tables__: Enable GFM tables. This is enabled by default. (Requires the
  `gfm` option in order to be enabled).
- __breaks__: Enable GFM line breaks. Disabled by default.
- __smartLists__: Use smarter list behavior than the original markdown.
  Disabled by default. May eventually be default with the old behavior
  moved into `pedantic`.
- __langPrefix__: Set the prefix for code block classes. Defaults to `lang-`.

## Usage

``` js
// Set default options
marked.setOptions({
  gfm: true,
  tables: true,
  breaks: false,
  pedantic: false,
  sanitize: true,
  smartLists: true,
  langPrefix: 'language-',
  highlight: function(code, lang) {
    if (lang === 'js') {
      return highlighter.javascript(code);
    }
    return code;
  }
});
console.log(marked('i am using __markdown__.'));
```

You also have direct access to the lexer and parser if you so desire.

``` js
var tokens = marked.lexer(text, options);
console.log(marked.parser(tokens));
```

``` js
var lexer = new marked.Lexer(options);
var tokens = lexer.lex(text);
console.log(tokens);
console.log(lexer.rules);
```

``` bash
$ node
> require('marked').lexer('> i am using marked.')
[ { type: 'blockquote_start' },
  { type: 'paragraph',
    text: 'i am using marked.' },
  { type: 'blockquote_end' },
  links: {} ]
```

## CLI

``` bash
$ marked -o hello.html
hello world
^D
$ cat hello.html
<p>hello world</p>
```

## License

Copyright (c) 2011-2013, Christopher Jeffrey. (MIT License)

See LICENSE for more info.


text:
                    <button type="button" class="btn btn-default btn-sm dropdown-toggle"
                        data-toggle="dropdown" aria-expanded="false">
                    {%= __("Menu") %}

                    </button>

                <button class="btn btn-secondary btn-default btn-sm hide"></button>

                    <button type="button" class="btn btn-primary btn-sm dropdown-toggle"
                        data-toggle="dropdown" aria-expanded="false">
                    {%= __("Actions") %}
                    </button>

                <button class="btn btn-primary btn-sm hide primary-action"></button>


text:
import django.db.models.deletion
import taggit.managers
from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ("utils", "0012_tag_ordering"),
        ("devices", "0003_configuration"),
        ("peering", "0083_move_email_to_messaging"),
    ]

    def move_router_configuration_templates(apps, schema_editor):
        db_alias = schema_editor.connection.alias
        Configuration = apps.get_model("peering.Configuration")
        Router = apps.get_model("peering.Router")
        NewConfiguration = apps.get_model("devices.Configuration")

        mapping = {}
        for c in Configuration.objects.using(db_alias).all():
            n = NewConfiguration.objects.using(db_alias).create(
                name=c.name,
                template=c.template,
                jinja2_trim=c.jinja2_trim,
                jinja2_lstrip=c.jinja2_lstrip,
                comments=c.comments,
            )
            mapping[c.pk] = n.pk

        for r in Router.objects.using(db_alias).filter(
            configuration_template__isnull=False
        ):
            r.configuration_id = mapping[r.configuration_template.pk]
            r.save()

    operations = [
        migrations.AddField(
            model_name="router",
            name="configuration",
            field=models.ForeignKey(
                blank=True,
                null=True,
                on_delete=django.db.models.deletion.SET_NULL,
                to="devices.configuration",
            ),
        ),
        migrations.AlterField(
            model_name="configuration",
            name="tags",
            field=taggit.managers.TaggableManager(
                help_text="A comma-separated list of tags.",
                related_name="old_config_field_tags",
                through="utils.TaggedItem",
                to="utils.Tag",
                verbose_name="Tags",
            ),
        ),
        migrations.RunPython(move_router_configuration_templates),
    ]


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<title>Best Practices</title>

Best Practices

      It is best to register Components and Controllers as high up the Context tree as possible (i.e. Application
      prefered over Session;  Session prefered over Request). This will reduce the number of Objects that need to be
      created and reduce introspection on classes.

use "final" on instance variable dependencies whenever possible.

An ActionMethod that returns null will act exactly like an ActionMethod with a return type
      of void.  Generally it is not a good practice to have null returned, take a look at how Exceptions are
      handled when produced from an ActionMethod.

More to come ....


text:
#include "tensorflow/compiler/xla/python/ifrt/client.h"
#include "tensorflow/compiler/xla/python/ifrt/test_util.h"
#include "tensorflow/tsl/platform/test.h"

namespace xla {
namespace ifrt {
namespace {

using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::NotNull;
using ::testing::SizeIs;

TEST(ClientImplTest, RuntimeTypeAndPlatform) {
  TF_ASSERT_OK_AND_ASSIGN(auto client, test_util::GetClient());

  EXPECT_THAT(client->runtime_type(), Not(IsEmpty()));
  EXPECT_THAT(client->platform_name(), Not(IsEmpty()));
  EXPECT_THAT(client->platform_version(), Not(IsEmpty()));
  client->platform_id();
}

TEST(ClientImplTest, Devices) {
  TF_ASSERT_OK_AND_ASSIGN(auto client, test_util::GetClient());

  ASSERT_GE(client->device_count(), 0);
  EXPECT_THAT(client->devices(), SizeIs(client->device_count()));

  ASSERT_GE(client->addressable_device_count(), 0);
  EXPECT_THAT(client->addressable_devices(),
              SizeIs(client->addressable_device_count()));

  for (Device* device : client->devices()) {
    TF_ASSERT_OK_AND_ASSIGN(auto* looked_up_device,
                            client->LookupDevice(device->id()));
    EXPECT_EQ(device, looked_up_device);
  }

  EXPECT_GE(client->process_index(), 0);
}

TEST(ClientImplTest, DefaultCompiler) {
  TF_ASSERT_OK_AND_ASSIGN(auto client, test_util::GetClient());
  EXPECT_THAT(client->GetDefaultCompiler(), NotNull());
}

}  // namespace
}  // namespace ifrt
}  // namespace xla


text:
/* */
var baseClone = require('./_baseClone');
function cloneDeep(value) {
  return baseClone(value, true, true);
}
module.exports = cloneDeep;


text:
module.exports = {
  apiKey: '3813ef95a069ab1cfd0be781216ff62869311c34',       // Get you API key from your user dashboard : htts://my.overlay.live
  ingest: 'ingest.epeakgears.com',
  deviceKey: 'd_4111'                                       // To get a device key, add a manual device to your account.
}


text:
using System;
using System.Threading;
using System.Threading.Tasks;

namespace DevoidTalk.Server
{
    public interface IClientAcceptor
    {
        event EventHandler<ClientConnection> ClientAccepted;
        Task Listen(CancellationToken cancellation);
    }
}


text:
describe :queue_clear, shared: true do
  it "removes all objects from the queue" do
    queue = @object.call
    queue << Object.new
    queue << 1
    queue.empty?.should be_false
    queue.clear
    queue.empty?.should be_true
  end

  # TODO: test for atomicity of Queue#clear
end


text:
 - list/search jobs
 - create new jobs from command line
 - create new jobs from a pattern directory
 - create new jobs from another job
 - delete jobs
 - disable jobs
 - add an email report to a job, list of jobs
 - update execution patterns for jobs
 - fetch qa stats from jobs
 - ....

### Github

 - list of repositories into an organization.
 - create a new repository
 - fetch qa stats from the repositories

### Shared

 - Check projects in one system but not in another


text:
<?php
namespace Phalcon
{

    /**
     * Phalcon\Registry
     *
     * A registry is a container for storing objects and values in the application space.
     * By storing the value in a registry, the same object is always available throughout
     * your application.
     *
     * <code>
     * $registry = new \Phalcon\Registry();
     *
     * // Set value
     * $registry->something = 'something';
     * // or
     * $registry['something'] = 'something';
     *
     * // Get value
     * $value = $registry->something;
     * // or
     * $value = $registry['something'];
     *
     * // Check if the key exists
     * $exists = isset($registry->something);
     * // or
     * $exists = isset($registry['something']);
     *
     * // Unset
     * unset($registry->something);
     * // or
     * unset($registry['something']);
     * </code>
     *
     * In addition to ArrayAccess, Phalcon\Registry also implements Countable
     * (count($registry) will return the number of elements in the registry),
     * Serializable and Iterator (you can iterate over the registry
     * using a foreach loop) interfaces. For PHP 5.4 and higher, JsonSerializable
     * interface is implemented.
     *
     * Phalcon\Registry is very fast (it is typically faster than any userspace
     * implementation of the registry); however, this comes at a price:
     * Phalcon\Registry is a final class and cannot be inherited from.
     *
     * Though Phalcon\Registry exposes methods like __get(), offsetGet(), count() etc,
     * it is not recommended to invoke them manually (these methods exist mainly to
     * match the interfaces the registry implements): $registry->__get('property')
     * is several times slower than $registry->property.
     *
     * Internally all the magic methods (and interfaces except JsonSerializable)
     * are implemented using object handlers or similar techniques: this allows
     * to bypass relatively slow method calls.
     */
    final class Registry implements \ArrayAccess, \Countable, \Iterator, \Traversable
    {

        protected $_data;

        /**
         * Registry constructor
         */
        final public function __construct()
        {
            $this->_data = array();
        }

        /**
         * Checks if the element is present in the registry
         *
         * @param
         *            string offset
         */
        final public function offsetExists($offset)
        {
            return isset($this->_data[$offset]);
        }

        /**
         * Returns an index in the registry
         *
         * @param
         *            string offset
         */
        final public function offsetGet($offset)
        {
            return $this->_data[$offset];
        }

        /**
         * Sets an element in the registry
         *
         * @param
         *            string offset
         * @param
         *            mixed value
         */
        final public function offsetSet($offset, $value)
        {
            return $this->_data[$offset] = $value;
        }

        /**
         * Unsets an element in the registry
         *
         * @param
         *            string offset
         */
        final public function offsetUnset($offset)
        {
            unset($this->_data[$offset]);
        }

        /**
         * Sets an element in the registry
         *
         * @param
         *            string offset
         * @param
         *            mixed value
         */
        final public function __set($offset, $value)
        {
            return $this->_data[$offset] = $value;
        }

        /**
         * Returns an index in the registry
         *
         * @param
         *            string offset
         */
        final public function __get($offset)
        {
            return $this->_data[$offset];
        }

        /**
         * Checks how many elements are in the register
         *
         * @return int
         */
        final public function count()
        {
            return count($this->_data);
        }

        /**
         * Moves cursor to next row in the registry
         */
        final public function next()
        {
            next($this->_data);
        }

        /**
         * Gets pointer number of active row in the registry
         *
         * @return int
         */
        final public function key()
        {
            return key($this->_data);
        }

        /**
         * Rewinds the registry cursor to its beginning
         */
        final public function rewind()
        {
            reset($this->_data);
        }

        public function valid()
        {
            return key($this->_data) !== null;
        }

        public function current()
        {
            return current($this->_data);
        }
    }
}


text:
@attributes mutable struct AlgAssAbsOrd{S, T} <: Ring
  algebra::S                       # Algebra containing the order
  dim::Int
  basis#::Vector{AlgAssAbsOrdElem{S, T}}
  basis_alg::Vector{T}             # Basis as array of elements of the algebra
  basis_matrix::FakeFmpqMat           # Basis matrix of order wrt basis of the algebra
  basis_mat_inv::FakeFmpqMat       # Inverse of basis matrix
  gen_index::fmpq                  # The det of basis_mat_inv as fmpq
  index::fmpz                      # The det of basis_mat_inv
                                   # (this is the index of the equation order
                                   #  in the given order)
  det_basis_matrix::fmpq
  disc::fmpz                       # Discriminant

  is_maximal::Int                   # 0 Not known
                                   # 1 Known to be maximal
                                   # 2 Known to not be maximal

  #trace_mat::fmpz_mat              # The reduced trace matrix (if known)
  trred_matrix::fmpz_mat

  picard_group#::MapPicardGrp

  tcontain::FakeFmpqMat

  isnice::Bool
  nice_order#Tuple{AlgAssAbsOrd, T}
  nice_order_ideal::fmpz

  function AlgAssAbsOrd{S, T}(A::S) where {S, T}
    # "Default" constructor with default values.
    O = new{S, T}(A, dim(A))
    O.is_maximal = 0
    O.isnice = false
    O.tcontain = FakeFmpqMat(zero_matrix(FlintZZ, 1, dim(A)))
    return O
  end

  function AlgAssAbsOrd{S, T}(A::S, M::FakeFmpqMat, Minv::FakeFmpqMat, B::Vector{T}, cached::Bool = false) where {S, T}
    return get_cached!(AlgAssAbsOrdID, (A, M), cached) do
      O = AlgAssAbsOrd{S, T}(A)
      O.basis_alg = B
      O.basis_matrix = M
      O.basis_mat_inv = Minv
      return O
    end::AlgAssAbsOrd{S, T}
  end

  function AlgAssAbsOrd{S, T}(A::S, M::FakeFmpqMat, cached::Bool = false) where {S, T}
    return get_cached!(AlgAssAbsOrdID, (A, M), cached) do
      O = AlgAssAbsOrd{S, T}(A)
      d = dim(A)
      O.basis_matrix = M
      O.basis_alg = Vector{T}(undef, d)
      for i in 1:d
        O.basis_alg[i] = elem_from_mat_row(A, M.num, i, M.den)
      end
      return O
    end::AlgAssAbsOrd{S, T}
  end

  function AlgAssAbsOrd{S, T}(A::S, B::Vector{T}, cached::Bool = false) where {S, T}
    M = basis_matrix(B, FakeFmpqMat)
    return get_cached!(AlgAssAbsOrdID, (A, M), cached) do
      O = AlgAssAbsOrd{S, T}(A)
      O.basis_alg = B
      O.basis_matrix = M
      return O
    end::AlgAssAbsOrd{S, T}
  end
end

const AlgAssAbsOrdID = Dict{Tuple{AbsAlgAss, FakeFmpqMat}, AlgAssAbsOrd}()

@attributes mutable struct AlgAssAbsOrdElem{S, T} <: RingElem
  elem_in_algebra::T
  coordinates::Vector{fmpz}
  has_coord::Bool # needed for mul!
  parent::AlgAssAbsOrd{S, T}

  function AlgAssAbsOrdElem{S, T}(O::AlgAssAbsOrd{S, T}) where {S, T}
    z = new{S, T}()
    z.parent = O
    z.elem_in_algebra = algebra(O)()
    z.coordinates = Vector{fmpz}(undef, degree(O))
    z.has_coord = false
    return z
  end

  function AlgAssAbsOrdElem{S, T}(O::AlgAssAbsOrd{S, T}, a::T) where {S, T}
    z = new{S, T}()
    z.elem_in_algebra = a
    z.parent = O
    z.coordinates = Vector{fmpz}(undef, degree(O))
    z.has_coord = false
    return z
  end

  function AlgAssAbsOrdElem{S, T}(O::AlgAssAbsOrd{S, T}, arr::Vector{fmpz}) where {S, T}
    z = new{S, T}()
    z.elem_in_algebra = dot(O.basis_alg, arr)
    z.coordinates = arr
    z.parent = O
    z.has_coord = true
    return z
  end

  function AlgAssAbsOrdElem{S, T}(O::AlgAssAbsOrd{S, T}, a::T, arr::Vector{fmpz}) where {S, T}
    z = new{S, T}()
    z.parent = O
    z.elem_in_algebra = a
    z.coordinates = arr
    z.has_coord = true
    return z
  end
end

################################################################################
#
#  AlgAssAbsOrdIdl
#
################################################################################

@attributes mutable struct AlgAssAbsOrdIdl{S, T}
  algebra::S

  basis::Vector{T} # Basis of the ideal as array of elements of the algebra
  # The basis matrix is in the BASIS of the ALGEBRA!
  basis_matrix::FakeFmpqMat
  basis_mat_inv::FakeFmpqMat
  det_basis_matrix::fmpq

  # Store whether the ideal has full rank
  # -1 no, 0 don't know, 1 yes
  full_rank::Int
  # rank
  rank::Int

  # In case the ideal has full rank, store a multiple of the largest elementary
  # divisor of the numerator of the basis matrix
  eldiv_mul::fmpz

  # Basis matrices with respect to orders
  basis_matrix_wrt::Dict{AlgAssAbsOrd{S, T}, FakeFmpqMat}

  # Left and right order:
  # The largest orders of which the ideal is a left resp. right ideal.
  left_order::AlgAssAbsOrd{S, T}
  right_order::AlgAssAbsOrd{S, T}

  # Any order contained in the left or right order, that is, an order of which
  # the ideal is a (possibly fractional) ideal.
  order::AlgAssAbsOrd{S, T}
  gens::Vector{T}    # Generators of the ideal w. r. t. order

  # isleft and isright with respect to `order`
  isleft::Int                      # 0 Not known
                                   # 1 Known to be a left ideal
                                   # 2 Known not to be a left ideal
  isright::Int                     # as for isleft

  iszero::Int                      # 0: don't know, 1: known to be zero, 2: known to be not zero

  norm::Dict{AlgAssAbsOrd{S, T}, fmpq} # The ideal has different norms with respect
                                       # to different orders
  normred::Dict{AlgAssAbsOrd{S, T}, fmpq}

  function AlgAssAbsOrdIdl{S, T}(A::S) where { S <: AbsAlgAss, T <: AbsAlgAssElem }
    r = new{S, T}()
    r.algebra = A
    r.isleft = 0
    r.isright = 0
    r.iszero = 0
    r.basis_matrix_wrt = Dict{AlgAssAbsOrd{S, T}, FakeFmpqMat}()
    r.norm = Dict{AlgAssAbsOrd{S, T}, fmpq}()
    r.normred = Dict{AlgAssAbsOrd{S, T}, fmpq}()
    r.full_rank = 0
    r.rank = -1
    return r
  end

  function AlgAssAbsOrdIdl{S, T}(A::S, M::FakeFmpqMat) where { S <: AbsAlgAss, T <: AbsAlgAssElem }
    r = AlgAssAbsOrdIdl{S, T}(A)
    r.basis_matrix = M
    n = nrows(M)
    if is_lower_triangular(M)
      i = 0
      while i < n && is_zero_row(M, i + 1)
        i += 1
      end
      r.full_rank = (i == 0) ? 1 : -1
      r.rank = n - i
      if r.full_rank == 1
        r.eldiv_mul = reduce(lcm, diagonal(numerator(M, copy = false)), init = one(ZZ))
      else
        r.eldiv_mul = zero(ZZ)
      end
    elseif is_upper_triangular(M)
      i = n + 1
      while i > 0 && is_zero_row(M, i - 1)
        i -= 1
      end
      r.rank = i - 1
      r.full_rank = (i == n + 1) ? 1 : -1
      if r.full_rank == 1
        r.eldiv_mul = reduce(lcm, diagonal(numerator(M, copy = false)), init = one(ZZ))
      else
        r.eldiv_mul = zero(ZZ)
      end
    else
      error("basis matrix not triangular matrix")
    end

    return r
  end
end

@attributes mutable struct AlgAssAbsOrdIdlSet{S, T}
  order::AlgAssAbsOrd{S, T}

  function AlgAssAbsOrdIdlSet{S, T}(O::AlgAssAbsOrd{S, T}) where {S, T}
    z = new{S, T}(O)
    return z
  end
end

function AlgAssAbsOrdIdlSet(O::AlgAssAbsOrd{S, T}) where {S, T}
  return AlgAssAbsOrdIdlSet{S, T}(O)
end

################################################################################
#
#  AlgAssAbsOrdQuoRing / AlgAssAbsOrdQuoRingElem
#
################################################################################

const AlgAssAbsOrdQuoRing{S, T} = AbsOrdQuoRing{AlgAssAbsOrd{S, T}, AlgAssAbsOrdIdl{S, T}} where {S, T}

const AlgAssAbsOrdQuoRingElem{S, T} = AbsOrdQuoRingElem{AlgAssAbsOrd{S, T}, AlgAssAbsOrdIdl{S, T}, AlgAssAbsOrdElem{S, T}} where {S, T}


text:
[![view on npm](http://img.shields.io/npm/v/command-line-tool.svg)](https://www.npmjs.org/package/command-line-tool)
[![npm module downloads](http://img.shields.io/npm/dt/command-line-tool.svg)](https://www.npmjs.org/package/command-line-tool)
[![Build Status](https://travis-ci.org/75lb/command-line-tool.svg?branch=master)](https://travis-ci.org/75lb/command-line-tool)
[![Dependency Status](https://david-dm.org/75lb/command-line-tool.svg)](https://david-dm.org/75lb/command-line-tool)
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](https://github.com/feross/standard)

## command-line-tool
Some conventional operations used in command-line tools.

**Example**
```js
const tool = require('command-line-tool')
```

* [command-line-tool](#module_command-line-tool)
    * [.stop([message])](#module_command-line-tool.stop)
    * [.printError(message)](#module_command-line-tool.printError)
    * [.printOutput(message)](#module_command-line-tool.printOutput)
    * [.halt([err], [options])](#module_command-line-tool.halt)
    * [.getCli(definitions, [usageSections], [argv])](#module_command-line-tool.getCli) ⇒ object

### tool.stop([message])
Print the supplied messages then stop the process (no exit code).

**Kind**: static method of [command-line-tool](#module_command-line-tool)

| Param | Type | Description |
| --- | --- | --- |
| [message] | string | Array.<string> | One or more messages to be written to stderr before exiting. May contain `ansi.format` markup. |

### tool.printError(message)
Prints one or more strings in red to stderr.

**Kind**: static method of [command-line-tool](#module_command-line-tool)

| Param | Type | Description |
| --- | --- | --- |
| message | string | Array.<string> | input message(s) |

### tool.printOutput(message)
Prints one or more strings to stdout. Catches unwanted EPIPE error.

**Kind**: static method of [command-line-tool](#module_command-line-tool)

| Param | Type | Description |
| --- | --- | --- |
| message | string | Array.<string> | input message(s) |

### tool.halt([err], [options])
Stop the process with an error message.

**Kind**: static method of [command-line-tool](#module_command-line-tool)

| Param | Type | Description |
| --- | --- | --- |
| [err] | Error | the error instance |
| [options] | object |  |
| [options.exitCode] | number | defaults to 1 |
| [options.stack] | boolean | defaults to false |

### tool.getCli(definitions, [usageSections], [argv]) ⇒ object
Parse the command-line options.

**Kind**: static method of [command-line-tool](#module_command-line-tool)

| Param | Type | Description |
| --- | --- | --- |
| definitions | Array.<OptionDefinitions> | to be passed to command-line-args |
| [usageSections] | Array.<section> | to be passed to command-line-usage |
| [argv] | Array.<string> | If supplied, this `argv` array is parsed instead of `process.argv`. |

* * *

© 2015-18 Lloyd Brookes \<75pound@gmail.com\>. Documented by [jsdoc-to-markdown](https://github.com/jsdoc2md/jsdoc-to-markdown).


text:
package fairqueuing

import (
	"context"
	"time"

	"k8s.io/apiserver/pkg/util/flowcontrol/debug"
	"k8s.io/apiserver/pkg/util/flowcontrol/metrics"
)

// QueueSetFactory is used to create QueueSet objects.  Creation, like
// config update, is done in two phases: the first phase consumes the
// QueuingConfig and the second consumes the DispatchingConfig.  They
// are separated so that errors from the first phase can be found
// before committing to a concurrency allotment for the second.
type QueueSetFactory interface {
	// BeginConstruction does the first phase of creating a QueueSet
	BeginConstruction(QueuingConfig, metrics.TimedObserverPair) (QueueSetCompleter, error)
}

// QueueSetCompleter finishes the two-step process of creating or
// reconfiguring a QueueSet
type QueueSetCompleter interface {
	// Complete returns a QueueSet configured by the given
	// dispatching configuration.
	Complete(DispatchingConfig) QueueSet
}

// QueueSet is the abstraction for the queuing and dispatching
// functionality of one non-exempt priority level.  It covers the
// functionality described in the "Assignment to a Queue", "Queuing",
// and "Dispatching" sections of
// https://github.com/kubernetes/enhancements/blob/master/keps/sig-api-machinery/20190228-priority-and-fairness.md
// .  Some day we may have connections between priority levels, but
// today is not that day.
type QueueSet interface {
	// BeginConfigChange starts the two-step process of updating the
	// configuration.  No change is made until Complete is called.  If
	// `C := X.BeginConstruction(q)` then `C.Complete(d)` returns the
	// same value `X`.  If the QueuingConfig's DesiredNumQueues field
	// is zero then the other queuing-specific config parameters are
	// not changed, so that the queues continue draining as before.
	// In any case, reconfiguration does not discard any queue unless
	// and until it is undesired and empty.
	BeginConfigChange(QueuingConfig) (QueueSetCompleter, error)

	// IsIdle returns a bool indicating whether the QueueSet was idle
	// at the moment of the return.  Idle means the QueueSet has zero
	// requests queued and zero executing.  This bit can change only
	// (1) during a call to StartRequest and (2) during a call to
	// Request::Finish.  In the latter case idleness can only change
	// from false to true.
	IsIdle() bool

	// StartRequest begins the process of handling a request.  If the
	// request gets queued and the number of queues is greater than 1
	// then StartRequest uses the given hashValue as the source of
	// entropy as it shuffle-shards the request into a queue.  The
	// descr1 and descr2 values play no role in the logic but appear
	// in log messages.  This method always returns quickly (without
	// waiting for the request to be dequeued).  If this method
	// returns a nil Request value then caller should reject the
	// request and the returned bool indicates whether the QueueSet
	// was idle at the moment of the return.  Otherwise idle==false
	// and the client must call the Finish method of the Request
	// exactly once.
	StartRequest(ctx context.Context, hashValue uint64, flowDistinguisher, fsName string, descr1, descr2 interface{}, queueNoteFn QueueNoteFn) (req Request, idle bool)

	// Dump saves and returns the instant internal state of the queue-set.
	// Note that dumping process will stop the queue-set from proceeding
	// any requests.
	// For debugging only.
	Dump(includeRequestDetails bool) debug.QueueSetDump
}

// QueueNoteFn is called when a request enters and leaves a queue
type QueueNoteFn func(inQueue bool)

// Request represents the remainder of the handling of one request
type Request interface {
	// Finish determines whether to execute or reject the request and
	// invokes `execute` if the decision is to execute the request.
	// The returned `idle bool` value indicates whether the QueueSet
	// was idle when the value was calculated, but might no longer be
	// accurate by the time the client examines that value.
	Finish(execute func()) (idle bool)
}

// QueuingConfig defines the configuration of the queuing aspect of a QueueSet.
type QueuingConfig struct {
	// Name is used to identify a queue set, allowing for descriptive information about its intended use
	Name string

	// DesiredNumQueues is the number of queues that the API says
	// should exist now.  This may be zero, in which case
	// QueueLengthLimit, HandSize, and RequestWaitLimit are ignored.
	DesiredNumQueues int

	// QueueLengthLimit is the maximum number of requests that may be waiting in a given queue at a time
	QueueLengthLimit int

	// HandSize is a parameter of shuffle sharding.  Upon arrival of a request, a queue is chosen by randomly
	// dealing a "hand" of this many queues and then picking one of minimum length.
	HandSize int

	// RequestWaitLimit is the maximum amount of time that a request may wait in a queue.
	// If, by the end of that time, the request has not been dispatched then it is rejected.
	RequestWaitLimit time.Duration
}

// DispatchingConfig defines the configuration of the dispatching aspect of a QueueSet.
type DispatchingConfig struct {
	// ConcurrencyLimit is the maximum number of requests of this QueueSet that may be executing at a time
	ConcurrencyLimit int
}


text:
<?php

namespace mageekguy\atoum;

if (defined(__NAMESPACE__ . '\running') === false)
{
    define(__NAMESPACE__ . '\running',  true);
    define(__NAMESPACE__ . '\directory', __DIR__);
    define(__NAMESPACE__ . '\version', preg_replace('/\$Rev: ([^ ]+) \$/', '$1', '$Rev: DEVELOPMENT-0.0.1 $'));
    define(__NAMESPACE__ . '\author', 'Frédéric Hardy');
    define(__NAMESPACE__ . '\mail', 'support@atoum.org');
    define(__NAMESPACE__ . '\repository',  'http://www.atoum.org/atoum');
}


text:
FactoryGirl.define do
  factory :user do
    email 'hello@invisiblelines.com'
    password 'authed'
    image_authentication_enabled true
  end
end


text:
module Fastlane
  module Actions
    class PodPushAction < Action
      def self.run(params)
        if params[:repo]
          repo = params[:repo]
          command = "pod repo push #{repo}"
        else
          command = 'pod trunk push'
        end

        if params[:path]
          command << " '#{params[:path]}'"
        end

        if params[:sources]
          sources = params[:sources].join(",")
          command << " --sources='#{sources}'"
        end

        if params[:swift_version]
          swift_version = params[:swift_version]
          command << " --swift-version=#{swift_version}"
        end

        if params[:allow_warnings]
          command << " --allow-warnings"
        end

        if params[:use_libraries]
          command << " --use-libraries"
        end

        if params[:verbose]
          command << " --verbose"
        end

        result = Actions.sh(command.to_s)
        UI.success("Successfully pushed Podspec ⬆ ")
        return result
      end

      #####################################################
      # @!group Documentation
      #####################################################

      def self.description
        "Push a Podspec to Trunk or a private repository"
      end

      def self.details
        ""
      end

      def self.available_options
        [
          FastlaneCore::ConfigItem.new(key: :path,
                                       description: "The Podspec you want to push",
                                       optional: true,
                                       verify_block: proc do |value|
                                         UI.user_error!("Couldn't find file at path '#{value}'") unless File.exist?(value)
                                         UI.user_error!("File must be a `.podspec` or `.podspec.json`") unless value.end_with?(".podspec", ".podspec.json")
                                       end),
          FastlaneCore::ConfigItem.new(key: :repo,
                                       description: "The repo you want to push. Pushes to Trunk by default",
                                       optional: true),
          FastlaneCore::ConfigItem.new(key: :allow_warnings,
                                       description: "Allow warnings during pod push",
                                       optional: true,
                                       is_string: false),
          FastlaneCore::ConfigItem.new(key: :use_libraries,
                                       description: "Allow lint to use static libraries to install the spec",
                                       optional: true,
                                       is_string: false),
          FastlaneCore::ConfigItem.new(key: :sources,
                                       description: "The sources of repos you want the pod spec to lint with, separated by commas",
                                       optional: true,
                                       is_string: false,
                                       verify_block: proc do |value|
                                         UI.user_error!("Sources must be an array.") unless value.kind_of?(Array)
                                       end),
          FastlaneCore::ConfigItem.new(key: :swift_version,
                                       description: "The SWIFT_VERSION that should be used to lint the spec. This takes precedence over a .swift-version file",
                                       optional: true,
                                       is_string: false),
          FastlaneCore::ConfigItem.new(key: :verbose,
                                       description: "Show more debugging information",
                                       optional: true,
                                       is_string: false,
                                       default_value: false)
        ]
      end

      def self.return_value
        nil
      end

      def self.authors
        ["squarefrog"]
      end

      def self.is_supported?(platform)
        [:ios, :mac].include?(platform)
      end

      def self.example_code
        [
          '# If no path is supplied then Trunk will attempt to find the first Podspec in the current directory.
          pod_push',
          '# Alternatively, supply the Podspec file path
          pod_push(path: "TSMessages.podspec")',
          '# You may also push to a private repo instead of Trunk
          pod_push(path: "TSMessages.podspec", repo: "MyRepo")',
          '# If the podspec has a dependency on another private pod, then you will have to supply the sources you want the podspec to lint with for pod_push to succeed. Read more here - https://github.com/CocoaPods/CocoaPods/issues/2543.
          pod_push(path: "TMessages.podspec", repo: "MyRepo", sources: ["https://github.com/username/Specs", "https://github.com/CocoaPods/Specs"])'
        ]
      end

      def self.category
        :misc
      end
    end
  end
end


text:
<?php

namespace Drupal\Tests\rest\Functional\EntityResource\View;

use Drupal\Tests\views\Functional\Rest\ViewResourceTestBase as ViewResourceTestBaseReal;

/**
 * Class for backward compatibility. It is deprecated in Drupal 8.6.x.
 *
 * @see https://www.drupal.org/node/2971931
 */
abstract class ViewResourceTestBase extends ViewResourceTestBaseReal {
}


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Nova Hedwigia 3: 69 (1961)

#### Original name
Mortierella macrocystis W. Gams, 1961

### Remarks
null


text:
angular.module('<%= title %>', ['ionic',<%= modules %>])

.run(function($ionicPlatform) {
  $ionicPlatform.ready(function() {
    // Hide the accessory bar by default (remove this to show the accessory bar above the keyboard
    // for form inputs)
    if(window.cordova && window.cordova.plugins.Keyboard) {
      cordova.plugins.Keyboard.hideKeyboardAccessoryBar(true);
    }
    if(window.StatusBar) {
      StatusBar.styleDefault();
    }
  });
})

.config(function($stateProvider, $urlRouterProvider) {

  $stateProvider
    .state('app', {
      url: '/app',
      abstract: true,
      templateUrl: 'sections/menu.html',

    });

  $urlRouterProvider.otherwise('app/<%= homeSection %>')

});


text:
using System;
using System.Threading.Tasks;
using NServiceBus;
using NServiceBus.Extensibility;
using NServiceBus.Persistence;

partial class SagaPersister
{
    public Task Complete(IContainSagaData sagaData, SynchronizedStorageSession session, ContextBag context)
    {
        return Complete(sagaData, session, GetConcurrency(context));
    }

    internal async Task Complete(IContainSagaData sagaData, SynchronizedStorageSession session, int concurrency)
    {
        var sagaInfo = sagaInfoCache.GetInfo(sagaData.GetType());
        var sqlSession = session.SqlPersistenceSession();

        using (var command = sqlDialect.CreateCommand(sqlSession.Connection))
        {
            command.CommandText = sagaInfo.CompleteCommand;
            command.Transaction = sqlSession.Transaction;
            command.AddParameter("Id", sagaData.Id);
            command.AddParameter("Concurrency", concurrency);
            var affected = await command.ExecuteNonQueryAsync().ConfigureAwait(false);
            if (affected != 1)
            {
                throw new Exception($"Optimistic concurrency violation when trying to complete saga {sagaInfo.SagaType.FullName} {sagaData.Id}. Expected version {concurrency}.");
            }
        }
    }
}


text:
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#ifndef ULOCIMP_H
#define ULOCIMP_H

#include "unicode/bytestream.h"
#include "unicode/uloc.h"

/**
 * Create an iterator over the specified keywords list
 * @param keywordList double-null terminated list. Will be copied.
 * @param keywordListSize size in bytes of keywordList
 * @param status err code
 * @return enumeration (owned by caller) of the keyword list.
 * @internal ICU 3.0
 */
U_CAPI UEnumeration* U_EXPORT2
uloc_openKeywordList(const char *keywordList, int32_t keywordListSize, UErrorCode* status);

/**
 * Look up a resource bundle table item with fallback on the table level.
 * This is accessible so it can be called by C++ code.
 */
U_CAPI const UChar * U_EXPORT2
uloc_getTableStringWithFallback(
    const char *path,
    const char *locale,
    const char *tableKey,
    const char *subTableKey,
    const char *itemKey,
    int32_t *pLength,
    UErrorCode *pErrorCode);

/*returns TRUE if a is an ID separator FALSE otherwise*/
#define _isIDSeparator(a) (a == '_' || a == '-')

U_CFUNC const char*
uloc_getCurrentCountryID(const char* oldID);

U_CFUNC const char*
uloc_getCurrentLanguageID(const char* oldID);

U_CFUNC int32_t
ulocimp_getLanguage(const char *localeID,
                    char *language, int32_t languageCapacity,
                    const char **pEnd);

U_CFUNC int32_t
ulocimp_getScript(const char *localeID,
                   char *script, int32_t scriptCapacity,
                   const char **pEnd);

U_CFUNC int32_t
ulocimp_getCountry(const char *localeID,
                   char *country, int32_t countryCapacity,
                   const char **pEnd);

U_STABLE void U_EXPORT2
ulocimp_getName(const char* localeID,
                icu::ByteSink& sink,
                UErrorCode* err);

U_STABLE void U_EXPORT2
ulocimp_getBaseName(const char* localeID,
                    icu::ByteSink& sink,
                    UErrorCode* err);

U_STABLE void U_EXPORT2
ulocimp_canonicalize(const char* localeID,
                     icu::ByteSink& sink,
                     UErrorCode* err);

/**
 * Writes a well-formed language tag for this locale ID.
 *
 * **Note**: When `strict` is FALSE, any locale fields which do not satisfy the
 * BCP47 syntax requirement will be omitted from the result.  When `strict` is
 * TRUE, this function sets U_ILLEGAL_ARGUMENT_ERROR to the `err` if any locale
 * fields do not satisfy the BCP47 syntax requirement.
 *
 * @param localeID  the input locale ID
 * @param sink      the output sink receiving the BCP47 language
 *                  tag for this Locale.
 * @param strict    boolean value indicating if the function returns
 *                  an error for an ill-formed input locale ID.
 * @param err       error information if receiving the language
 *                  tag failed.
 * @return          The length of the BCP47 language tag.
 *
 * @internal ICU 64
 */
U_STABLE void U_EXPORT2
ulocimp_toLanguageTag(const char* localeID,
                      icu::ByteSink& sink,
                      UBool strict,
                      UErrorCode* err);

/**
 * Returns a locale ID for the specified BCP47 language tag string.
 * If the specified language tag contains any ill-formed subtags,
 * the first such subtag and all following subtags are ignored.
 * <p>
 * This implements the 'Language-Tag' production of BCP47, and so
 * supports grandfathered (regular and irregular) as well as private
 * use language tags.  Private use tags are represented as 'x-whatever',
 * and grandfathered tags are converted to their canonical replacements
 * where they exist.  Note that a few grandfathered tags have no modern
 * replacement, these will be converted using the fallback described in
 * the first paragraph, so some information might be lost.
 * @param langtag   the input BCP47 language tag.
 * @param tagLen    the length of langtag, or -1 to call uprv_strlen().
 * @param sink      the output sink receiving a locale ID for the
 *                  specified BCP47 language tag.
 * @param parsedLength  if not NULL, successfully parsed length
 *                      for the input language tag is set.
 * @param err       error information if receiving the locald ID
 *                  failed.
 * @internal ICU 63
 */
U_CAPI void U_EXPORT2
ulocimp_forLanguageTag(const char* langtag,
                       int32_t tagLen,
                       icu::ByteSink& sink,
                       int32_t* parsedLength,
                       UErrorCode* err);

/**
 * Get the region to use for supplemental data lookup. Uses
 * (1) any region specified by locale tag "rg"; if none then
 * (2) any unicode_region_tag in the locale ID; if none then
 * (3) if inferRegion is TRUE, the region suggested by
 * getLikelySubtags on the localeID.
 * If no region is found, returns length 0.
 *
 * @param localeID
 *     The complete locale ID (with keywords) from which
 *     to get the region to use for supplemental data.
 * @param inferRegion
 *     If TRUE, will try to infer region from localeID if
 *     no other region is found.
 * @param region
 *     Buffer in which to put the region ID found; should
 *     have a capacity at least ULOC_COUNTRY_CAPACITY.
 * @param regionCapacity
 *     The actual capacity of the region buffer.
 * @param status
 *     Pointer to in/out UErrorCode value for latest status.
 * @return
 *     The length of any region code found, or 0 if none.
 * @internal ICU 57
 */
U_CAPI int32_t U_EXPORT2
ulocimp_getRegionForSupplementalData(const char *localeID, UBool inferRegion,
                                     char *region, int32_t regionCapacity, UErrorCode* status);

/**
 * Add the likely subtags for a provided locale ID, per the algorithm described
 * in the following CLDR technical report:
 *
 *   http://www.unicode.org/reports/tr35/#Likely_Subtags
 *
 * If localeID is already in the maximal form, or there is no data available
 * for maximization, it will be copied to the output buffer.  For example,
 * "und-Zzzz" cannot be maximized, since there is no reasonable maximization.
 *
 * Examples:
 *
 * "en" maximizes to "en_Latn_US"
 *
 * "de" maximizes to "de_Latn_US"
 *
 * "sr" maximizes to "sr_Cyrl_RS"
 *
 * "sh" maximizes to "sr_Latn_RS" (Note this will not reverse.)
 *
 * "zh_Hani" maximizes to "zh_Hans_CN" (Note this will not reverse.)
 *
 * @param localeID The locale to maximize
 * @param sink The output sink receiving the maximized locale
 * @param err Error information if maximizing the locale failed.  If the length
 * of the localeID and the null-terminator is greater than the maximum allowed size,
 * or the localeId is not well-formed, the error code is U_ILLEGAL_ARGUMENT_ERROR.
 * @internal ICU 64
 */
U_STABLE void U_EXPORT2
ulocimp_addLikelySubtags(const char* localeID,
                         icu::ByteSink& sink,
                         UErrorCode* err);

/**
 * Minimize the subtags for a provided locale ID, per the algorithm described
 * in the following CLDR technical report:
 *
 *   http://www.unicode.org/reports/tr35/#Likely_Subtags
 *
 * If localeID is already in the minimal form, or there is no data available
 * for minimization, it will be copied to the output buffer.  Since the
 * minimization algorithm relies on proper maximization, see the comments
 * for ulocimp_addLikelySubtags for reasons why there might not be any data.
 *
 * Examples:
 *
 * "en_Latn_US" minimizes to "en"
 *
 * "de_Latn_US" minimizes to "de"
 *
 * "sr_Cyrl_RS" minimizes to "sr"
 *
 * "zh_Hant_TW" minimizes to "zh_TW" (The region is preferred to the
 * script, and minimizing to "zh" would imply "zh_Hans_CN".)
 *
 * @param localeID The locale to minimize
 * @param sink The output sink receiving the maximized locale
 * @param err Error information if minimizing the locale failed.  If the length
 * of the localeID and the null-terminator is greater than the maximum allowed size,
 * or the localeId is not well-formed, the error code is U_ILLEGAL_ARGUMENT_ERROR.
 * @internal ICU 64
 */
U_STABLE void U_EXPORT2
ulocimp_minimizeSubtags(const char* localeID,
                        icu::ByteSink& sink,
                        UErrorCode* err);

U_CAPI const char * U_EXPORT2
locale_getKeywordsStart(const char *localeID);

U_CFUNC UBool
ultag_isExtensionSubtags(const char* s, int32_t len);

U_CFUNC UBool
ultag_isLanguageSubtag(const char* s, int32_t len);

U_CFUNC UBool
ultag_isPrivateuseValueSubtags(const char* s, int32_t len);

U_CFUNC UBool
ultag_isRegionSubtag(const char* s, int32_t len);

U_CFUNC UBool
ultag_isScriptSubtag(const char* s, int32_t len);

U_CFUNC UBool
ultag_isTransformedExtensionSubtags(const char* s, int32_t len);

U_CFUNC UBool
ultag_isUnicodeExtensionSubtags(const char* s, int32_t len);

U_CFUNC UBool
ultag_isUnicodeLocaleAttribute(const char* s, int32_t len);

U_CFUNC UBool
ultag_isUnicodeLocaleAttributes(const char* s, int32_t len);

U_CFUNC UBool
ultag_isUnicodeLocaleKey(const char* s, int32_t len);

U_CFUNC UBool
ultag_isUnicodeLocaleType(const char* s, int32_t len);

U_CFUNC UBool
ultag_isVariantSubtags(const char* s, int32_t len);

U_CFUNC const char*
ulocimp_toBcpKey(const char* key);

U_CFUNC const char*
ulocimp_toLegacyKey(const char* key);

U_CFUNC const char*
ulocimp_toBcpType(const char* key, const char* type, UBool* isKnownKey, UBool* isSpecialType);

U_CFUNC const char*
ulocimp_toLegacyType(const char* key, const char* type, UBool* isKnownKey, UBool* isSpecialType);

#endif


text:
import { StyleSheet } from 'react-native'
import { Metrics, ApplicationStyles } from '../../Themes/'

export default StyleSheet.create({
    ...ApplicationStyles.screen,
    logo: {
        height: Metrics.images.logo,
        width: Metrics.images.logo,
        resizeMode: 'contain'
    },
    centered: {
        alignItems: 'center'
    }
})


text:
package uk.co.threeonefour.ifictionary.engine.client.resty;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.fusesource.restygwt.client.MethodCallback;
import org.fusesource.restygwt.client.Resource;
import org.fusesource.restygwt.client.RestService;
import org.fusesource.restygwt.client.RestServiceProxy;

import uk.co.threeonefour.ifictionary.api.game.Base64EncodedStr;
import uk.co.threeonefour.ifictionary.api.game.GameInfo;

import com.google.gwt.core.client.GWT;

@Path("/game")
public interface GameService extends RestService {

	public static class Util {
		private static GameService instance;
		public static GameService getService() {
			if (instance == null) {
				instance = GWT.create(GameService.class);
			}
			Resource resource = new Resource(GWT.getModuleBaseURL() + "game");
	        ((RestServiceProxy) instance).setResource(resource);

			return instance;
		}
	}

	@GET
	@Path("/{gameId}/info")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public void getGame(@PathParam("gameId") String gameId, MethodCallback<GameInfo> callback);

    @GET
    @Path("/{gameId}/file")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public void getFile(@PathParam("gameId") String gameId, MethodCallback<Base64EncodedStr> callback);

}