text:
package com.apptentive.android.sdk.tests.model;

import androidx.test.runner.AndroidJUnit4;

import com.apptentive.android.sdk.ApptentiveLog;
import com.apptentive.android.sdk.model.CommerceExtendedData;
import com.apptentive.android.sdk.model.EventPayload;
import com.apptentive.android.sdk.model.LocationExtendedData;
import com.apptentive.android.sdk.model.TimeExtendedData;
import com.apptentive.android.sdk.tests.ApptentiveTestCaseBase;
import com.apptentive.android.sdk.util.JsonDiffer;
import com.apptentive.android.sdk.util.Util;

import org.json.JSONException;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

@RunWith(AndroidJUnit4.class)
public class EventTests extends ApptentiveTestCaseBase {

	private static final String TEST_DATA_DIR = "model" + File.separator;

	@Test
	public void extendedDataEvents() {
		ApptentiveLog.e("testExtendedDataEvents()");
		try {
			EventPayload expected = new EventPayload(loadTextAssetAsString(TEST_DATA_DIR + "testExtendedDataEvents.json"));
			// Change the expected output to use the same timezone as the test machine.
			expected.setClientCreatedAtUtcOffset(Util.getUtcOffset());

			String data = "{\"data_key\":\"data_value\"}";

			Map<String, Object> customData = new HashMap<>();
			customData.put("string_key", "string_value");
			customData.put("number_key", 12345.6789f);

			CommerceExtendedData commerce = null;
			try {
				commerce = new CommerceExtendedData()
						.setId("commerce_id")
						.setAffiliation("1111111111")
						.setRevenue(100d)
						.setShipping(5L)
						.setTax(4.38f)
						.setCurrency("USD");
				CommerceExtendedData.Item item = new CommerceExtendedData.Item(22222222, "Item Name", "Category", 20, 5.0d, "USD");
				commerce.addItem(item);
			} catch (JSONException e) {
				ApptentiveLog.e(e, "Error: ");
			}
			assertNotNull(commerce);

			TimeExtendedData time = new TimeExtendedData(1.406316991957E9);

			LocationExtendedData location = new LocationExtendedData(-122.34569190000002d, 47.6288591d);

			EventPayload actual = new EventPayload("event_label", null, data, customData, commerce, time, location);
			actual.setClientCreatedAt(1.406316991967E9);
			actual.setNonce("4579c403-e8c5-4e6b-8826-f3d61e6ebb98");

			boolean equal = JsonDiffer.areObjectsEqual(expected.getJsonObject(), actual.getJsonObject());
			ApptentiveLog.e("Events are equal: %b", equal);
			assertTrue(equal);
		} catch (JSONException e) {
			throw new RuntimeException(e);
		}
	}
}


text:
/* eslint-disable react-hooks/exhaustive-deps */
import {useDocumentOperation} from '@sanity/react-hooks'
import React, {useCallback, useContext, useMemo, useState} from 'react'
import {unstable_useDocumentPairPermissions as useDocumentPairPermissions} from '@sanity/base/hooks'
import {Box, Stack, Button, Grid, Text, useClickOutside} from '@sanity/ui'
import {useConditionalReadOnly} from '@sanity/base/_internal'
import {undoChange} from '../changes/undoChange'
import {isFieldChange} from '../helpers'
import {isPTSchemaType} from '../../types/portableText/diff'
import {GroupChangeNode, OperationsAPI} from '../../types'
import {useHover} from '../../utils/useHover'
import {pathsAreEqual} from '../../paths'
import {DiffContext} from '../contexts/DiffContext'
import {ChangeBreadcrumb} from './ChangeBreadcrumb'
import {ChangeResolver} from './ChangeResolver'
import {DocumentChangeContext} from './DocumentChangeContext'
import {RevertChangesButton} from './RevertChangesButton'
import {ChangeListWrapper, GroupChangeContainer, PopoverWrapper} from './GroupChange.styled'

export function GroupChange({
  change: group,
  readOnly,
  hidden,
  ...restProps
}: {change: GroupChangeNode; readOnly?: boolean; hidden?: boolean} & React.HTMLAttributes<
  HTMLDivElement
>): React.ReactElement | null {
  const {titlePath, changes, path: groupPath} = group
  const {path: diffPath} = useContext(DiffContext)
  const {documentId, schemaType, FieldWrapper, rootDiff, isComparingCurrent} = useContext(
    DocumentChangeContext
  )
  const conditionalReadOnly = useConditionalReadOnly() ?? readOnly

  const isPortableText = changes.every(
    (change) => isFieldChange(change) && isPTSchemaType(change.schemaType)
  )

  const isNestedInDiff = pathsAreEqual(diffPath, groupPath)
  const [hoverRef, isHoveringRevert] = useHover<HTMLDivElement>()
  const docOperations = useDocumentOperation(documentId, schemaType.name) as OperationsAPI
  const [confirmRevertOpen, setConfirmRevertOpen] = useState(false)
  const [revertButtonElement, setRevertButtonElement] = useState<HTMLDivElement | null>(null)

  const [permissions, isPermissionsLoading] = useDocumentPairPermissions({
    id: documentId,
    type: schemaType.name,
    permission: 'update',
  })

  const handleRevertChanges = useCallback(() => undoChange(group, rootDiff, docOperations), [
    group,
    rootDiff,
    docOperations,
  ])

  const handleRevertChangesConfirm = useCallback(() => {
    setConfirmRevertOpen(true)
  }, [])

  const closeRevertChangesConfirmDialog = useCallback(() => {
    setConfirmRevertOpen(false)
  }, [])

  useClickOutside(() => setConfirmRevertOpen(false), [revertButtonElement])

  const setRevertButtonRef = useCallback(
    (el: HTMLDivElement | null) => {
      hoverRef.current = el
      setRevertButtonElement(el)
    },
    [hoverRef]
  )

  const content = useMemo(
    () => (
      <Stack
        space={1}
        as={GroupChangeContainer}
        data-revert-group-hover={isHoveringRevert ? '' : undefined}
        data-portable-text={isPortableText ? '' : undefined}
        data-revert-all-groups-hover={
          restProps['data-revert-all-changes-hover'] === '' ? '' : undefined
        }
      >
        <Stack as={ChangeListWrapper} space={5}>
          {changes.map((change) => (
            <ChangeResolver
              key={change.key}
              change={change}
              readOnly={conditionalReadOnly}
              hidden={hidden}
            />
          ))}
        </Stack>
        {isComparingCurrent && !isPermissionsLoading && permissions?.granted && (
          <PopoverWrapper
            content={
              <Box>
                Are you sure you want to revert the changes?
                <Grid columns={2} gap={2} marginTop={2}>
                  <Button mode="ghost" onClick={closeRevertChangesConfirmDialog}>
                    <Text align="center">Cancel</Text>
                  </Button>
                  <Button tone="critical" onClick={handleRevertChanges}>
                    <Text align="center">Revert change</Text>
                  </Button>
                </Grid>
              </Box>
            }
            portal
            padding={4}
            placement={'left'}
            open={confirmRevertOpen}
            ref={setRevertButtonElement}
          >
            <Box>
              <RevertChangesButton
                onClick={handleRevertChangesConfirm}
                ref={setRevertButtonRef}
                selected={confirmRevertOpen}
                disabled={conditionalReadOnly}
                data-testid={`group-change-revert-button-${group.fieldsetName}`}
              />
            </Box>
          </PopoverWrapper>
        )}
      </Stack>
    ),
    [conditionalReadOnly, hidden, confirmRevertOpen, isPermissionsLoading, permissions]
  )

  return hidden ? null : (
    <Stack space={1} {...restProps}>
      <ChangeBreadcrumb titlePath={titlePath} />
      {isNestedInDiff || !FieldWrapper ? (
        content
      ) : (
        <FieldWrapper path={group.path} hasHover={isHoveringRevert}>
          {content}
        </FieldWrapper>
      )}
    </Stack>
  )
}

redpajama_set_name: RedPajamaGithub


text:
<?php

$update_start_time = time();

/**
* @ignore
*/
define('IN_PHPBB', true);
define('IN_INSTALL', true);
$phpbb_root_path = (defined('PHPBB_ROOT_PATH')) ? PHPBB_ROOT_PATH : './../';
$phpEx = substr(strrchr(__FILE__, '.'), 1);

function phpbb_end_update($cache, $config)
{
	$cache->purge();

	$config->increment('assets_version', 1);

?>

				Powered by phpBB® Forum Software © phpBB Limited

<?php

	garbage_collection();
	exit_handler();
}

require($phpbb_root_path . 'includes/startup.' . $phpEx);
require($phpbb_root_path . 'phpbb/class_loader.' . $phpEx);

$phpbb_class_loader = new \phpbb\class_loader('phpbb\\', "{$phpbb_root_path}phpbb/", $phpEx);
$phpbb_class_loader->register();

$phpbb_config_php_file = new \phpbb\config_php_file($phpbb_root_path, $phpEx);
extract($phpbb_config_php_file->get_all());

if (!defined('PHPBB_INSTALLED') || empty($dbms) || empty($acm_type))
{
	die("Please read: INSTALL.html before attempting to update.");
}

// In case $phpbb_adm_relative_path is not set (in case of an update), use the default.
$phpbb_adm_relative_path = (isset($phpbb_adm_relative_path)) ? $phpbb_adm_relative_path : 'adm/';
$phpbb_admin_path = (defined('PHPBB_ADMIN_PATH')) ? PHPBB_ADMIN_PATH : $phpbb_root_path . $phpbb_adm_relative_path;

// Include files
require($phpbb_root_path . 'includes/functions.' . $phpEx);
require($phpbb_root_path . 'includes/functions_content.' . $phpEx);

require($phpbb_root_path . 'includes/constants.' . $phpEx);
include($phpbb_root_path . 'includes/utf/utf_normalizer.' . $phpEx);
require($phpbb_root_path . 'includes/utf/utf_tools.' . $phpEx);

// Set PHP error handler to ours
set_error_handler(defined('PHPBB_MSG_HANDLER') ? PHPBB_MSG_HANDLER : 'msg_handler');

// Set up container (must be done here because extensions table may not exist)
$phpbb_container_builder = new \phpbb\di\container_builder($phpbb_config_php_file, $phpbb_root_path, $phpEx);
$phpbb_container_builder->set_use_extensions(false);
$phpbb_container_builder->set_use_kernel_pass(false);
$phpbb_container_builder->set_dump_container(false);
$phpbb_container = $phpbb_container_builder->get_container();

// set up caching
$cache = $phpbb_container->get('cache');

// Instantiate some basic classes
$phpbb_dispatcher = $phpbb_container->get('dispatcher');
$request	= $phpbb_container->get('request');
$user		= $phpbb_container->get('user');
$auth		= $phpbb_container->get('auth');
$db			= $phpbb_container->get('dbal.conn');
$phpbb_log	= $phpbb_container->get('log');

// make sure request_var uses this request instance
request_var('', 0, false, false, $request); // "dependency injection" for a function

// Grab global variables, re-cache if necessary
$config = $phpbb_container->get('config');
set_config(null, null, null, $config);
set_config_count(null, null, null, $config);

if (!isset($config['version_update_from']))
{
	$config->set('version_update_from', $config['version']);
}

$orig_version = $config['version_update_from'];

$user->add_lang(array('common', 'acp/common', 'install', 'migrator'));

// Add own hook handler, if present. :o
if (file_exists($phpbb_root_path . 'includes/hooks/index.' . $phpEx))
{
	require($phpbb_root_path . 'includes/hooks/index.' . $phpEx);
	$phpbb_hook = new phpbb_hook(array('exit_handler', 'phpbb_user_session_handler', 'append_sid', array('template', 'display')));

	$phpbb_hook_finder = $phpbb_container->get('hook_finder');
	foreach ($phpbb_hook_finder->find() as $hook)
	{
		@include($phpbb_root_path . 'includes/hooks/' . $hook . '.' . $phpEx);
	}
}
else
{
	$phpbb_hook = false;
}

header('Content-type: text/html; charset=UTF-8');
?>
<!DOCTYPE html>
<html dir="<?php echo $user->lang['DIRECTION']; ?>" lang="<?php echo $user->lang['USER_LANG']; ?>">

<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">

<title><?php echo $user->lang['UPDATING_TO_LATEST_STABLE']; ?></title>

<link href="<?php echo htmlspecialchars($phpbb_admin_path); ?>style/admin.css" rel="stylesheet" type="text/css" media="screen" />

<?php echo $user->lang['UPDATING_TO_LATEST_STABLE']; ?>

<?php echo $user->lang['DATABASE_TYPE']; ?> :: <?php echo $db->get_sql_layer(); ?>

								<?php echo $user->lang['PREVIOUS_VERSION']; ?> :: <?php echo $config['version']; ?>

<?php

define('IN_DB_UPDATE', true);

/**
* @todo mysql update?
*/

// End startup code

$migrator = $phpbb_container->get('migrator');
$migrator->set_output_handler(new \phpbb\db\log_wrapper_migrator_output_handler($user, new \phpbb\db\html_migrator_output_handler($user), $phpbb_root_path . 'store/migrations_' . time() . '.log'));

$migrator->create_migrations_table();

$phpbb_extension_manager = $phpbb_container->get('ext.manager');

$migrations = $phpbb_extension_manager
	->get_finder()
	->core_path('phpbb/db/migration/data/')
	->extension_directory('/migrations')
	->get_classes();

$migrator->set_migrations($migrations);

// What is a safe limit of execution time? Half the max execution time should be safe.
//  No more than 15 seconds so the user isn't sitting and waiting for a very long time
$phpbb_ini = new \phpbb\php\ini();
$safe_time_limit = min(15, ($phpbb_ini->get_int('max_execution_time') / 2));

// While we're going to try limit this to half the max execution time,
//  we want to try and take additional measures to prevent hitting the
//  max execution time (if, say, one migration step takes much longer
//  than the max execution time)
@set_time_limit(0);

while (!$migrator->finished())
{
	try
	{
		$migrator->update();
	}
	catch (\phpbb\db\migration\exception $e)
	{
		echo $e->getLocalisedMessage($user);

		phpbb_end_update($cache, $config);
	}

	$state = array_merge(array(
			'migration_schema_done' => false,
			'migration_data_done'	=> false,
		),
		$migrator->last_run_migration['state']
	);

	// Are we approaching the time limit? If so we want to pause the update and continue after refreshing
	if ((time() - $update_start_time) >= $safe_time_limit)
	{
		echo '
' . $user->lang['DATABASE_UPDATE_NOT_COMPLETED'] . '

';
		echo 'variable('type', 0) . '&language=' . $request->variable('language', 'en')) . '" class="button1">' . $user->lang['DATABASE_UPDATE_CONTINUE'] . '';

		phpbb_end_update($cache, $config);
	}
}

if ($orig_version != $config['version'])
{
	add_log('admin', 'LOG_UPDATE_DATABASE', $orig_version, $config['version']);
}

echo $user->lang['DATABASE_UPDATE_COMPLETE'] . '
';

if ($request->variable('type', 0))
{
	echo $user->lang['INLINE_UPDATE_SUCCESSFUL'] . '

';
	echo 'variable('language', 'en')) . '" class="button1">' . $user->lang['CONTINUE_UPDATE_NOW'] . '';
}
else
{
	echo '
' . $user->lang['UPDATE_FILES_NOTICE'] . '
';
	echo $user->lang['COMPLETE_LOGIN_TO_BOARD'];
}

$config->delete('version_update_from');

phpbb_end_update($cache, $config);


text:
@interface ForumCell : UITableViewCell
@property (weak, nonatomic) IBOutlet UILabel *titleLabel1;
@property (weak, nonatomic) IBOutlet UILabel *desLabel1;
@property (weak, nonatomic) IBOutlet UIImageView *imageView1;
@property (weak, nonatomic) IBOutlet UILabel *titleLabel2;
@property (weak, nonatomic) IBOutlet UILabel *desLabel2;
@property (weak, nonatomic) IBOutlet UIImageView *imageView2;
@property (strong, nonatomic) NSArray *forumArray;
@property (weak, nonatomic) IBOutlet UIView *view1;
@property (weak, nonatomic) IBOutlet UIView *view2;

@end


text:
{-# LANGUAGE Safe #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Text.ParserCombinators.Parsec.Expr
-- Copyright   :  (c) Paolo Martini 2007
-- License     :  BSD-style (see the LICENSE file)
--
-- Maintainer  :  derek.a.elkins@gmail.com
-- Stability   :  provisional
-- Portability :  portable
--
-- Parsec compatibility module
--
-----------------------------------------------------------------------------

module Text.ParserCombinators.Parsec.Expr
    ( Assoc (AssocNone,AssocLeft,AssocRight),
      Operator(..),
      OperatorTable,
      buildExpressionParser
    ) where

import Text.Parsec.Expr(Assoc(..))
import qualified Text.Parsec.Expr as N
import Text.ParserCombinators.Parsec(GenParser)

import Control.Monad.Identity

data Operator tok st a   = Infix  (GenParser tok st (a -> a -> a)) Assoc
                         | Prefix (GenParser tok st (a -> a))
                         | Postfix (GenParser tok st (a -> a))

type OperatorTable tok st a = [[Operator tok st a]]

convert :: Operator tok st a -> N.Operator [tok] st Identity a
convert (Infix p a) = N.Infix p a
convert (Prefix p)  = N.Prefix p
convert (Postfix p)  = N.Postfix p

buildExpressionParser :: OperatorTable tok st a
                      -> GenParser tok st a
                      -> GenParser tok st a
buildExpressionParser = N.buildExpressionParser . map (map convert)


text:
package org.apache.pdfbox.filter;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.pdfbox.cos.COSDictionary;

/**
 * Decompresses data encoded using a byte-oriented run-length encoding algorithm,
 * reproducing the original text or binary data
 *
 * @author Ben Litchfield
 * @author Tilman Hausherr
 */
final class RunLengthDecodeFilter extends Filter
{
    private static final int RUN_LENGTH_EOD = 128;

    @Override
    public DecodeResult decode(InputStream encoded, OutputStream decoded,
                                         COSDictionary parameters, int index) throws IOException
    {
        int dupAmount;
        byte[] buffer = new byte[128];
        while ((dupAmount = encoded.read()) != -1 && dupAmount != RUN_LENGTH_EOD)
        {
            if (dupAmount <= 127)
            {
                int amountToCopy = dupAmount + 1;
                int compressedRead;
                while (amountToCopy > 0)
                {
                    compressedRead = encoded.read(buffer, 0, amountToCopy);
                    // EOF reached?
                    if (compressedRead == -1)
                    {
                        break;
                    }
                    decoded.write(buffer, 0, compressedRead);
                    amountToCopy -= compressedRead;
                }
            }
            else
            {
                int dupByte = encoded.read();
                // EOF reached?
                if (dupByte == -1)
                {
                    break;
                }
                for (int i = 0; i < 257 - dupAmount; i++)
                {
                    decoded.write(dupByte);
                }
            }
        }
        return new DecodeResult(parameters);
    }

    @Override
    protected void encode(InputStream input, OutputStream encoded, COSDictionary parameters)
            throws IOException
    {
        // Not used in PDFBox except for testing the decoder.
        int lastVal = -1;
        int byt;
        int count = 0;
        boolean equality = false;

        // buffer for "unequal" runs, size between 2 and 128
        byte[] buf = new byte[128];

        while ((byt = input.read()) != -1)
        {
            if (lastVal == -1)
            {
                // first time
                lastVal = byt;
                count = 1;
            }
            else
            {
                if (count == 128)
                {
                    if (equality)
                    {
                        // max length of equals
                        encoded.write(129); // = 257 - 128
                        encoded.write(lastVal);
                    }
                    else
                    {
                        // max length of unequals
                        encoded.write(127);
                        encoded.write(buf, 0, 128);
                    }
                    equality = false;
                    lastVal = byt;
                    count = 1;
                }
                else if (count == 1)
                {
                    if (byt == lastVal)
                    {
                        equality = true;
                    }
                    else
                    {
                        buf[0] = (byte) lastVal;
                        buf[1] = (byte) byt;
                        lastVal = byt;
                    }
                    count = 2;
                }
                else
                {
                    // 1 < count < 128
                    if (byt == lastVal)
                    {
                        if (equality)
                        {
                            ++count;
                        }
                        else
                        {
                            // write all we got except the last
                            encoded.write(count - 2);
                            encoded.write(buf, 0, count - 1);
                            count = 2;
                            equality = true;
                        }
                    }
                    else
                    {
                        if (equality)
                        {
                            // equality ends here
                            encoded.write(257 - count);
                            encoded.write(lastVal);
                            equality = false;
                            count = 1;
                        }
                        else
                        {
                            buf[count] = (byte) byt;
                            ++count;
                        }
                        lastVal = byt;
                    }
                }
            }
        }
        if (count > 0)
        {
            if (count == 1)
            {
                encoded.write(0);
                encoded.write(lastVal);
            }
            else if (equality)
            {
                encoded.write(257 - count);
                encoded.write(lastVal);
            }
            else
            {
                encoded.write(count - 1);
                encoded.write(buf, 0, count);
            }
        }
        encoded.write(RUN_LENGTH_EOD);
    }
}


text:
import React, { PropTypes } from 'react';

const propTypes = {
  name: PropTypes.string,
  username: PropTypes.string
};

const FriendThumbnail = ({ name, username }) => (

{name} {username}

);

FriendThumbnail.propTypes = propTypes;
export default FriendThumbnail;


text:
package ru.stesting.jtraining.mantis.appmanager;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.remote.BrowserType;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

/**
 * Created by DBorisov on 24.04.2016.
 */
public class ApplicationManager {
  private final Properties properties;
  private WebDriver wd;

  private String browser;
  private RegistrationHelper registrationHelper;
  private FtpHelper ftp;
  private MailHelper mailHelper;
  private SessionHelper sessionHelper;
  private NavigationHelper navigationHelper;
  private UserHelper userHelper;
  private DbHelper dbHelper;
  private JamesHelper jamesHelper;
  private SoapHelper soapHelper;

  public ApplicationManager(String browser) {
    this.browser = browser;
    properties = new Properties();
  }

  public void init() throws IOException {
    String target = System.getProperty("target", "local");
    properties.load(new FileReader(new File(String.format("src/test/resources/%s.properties", target))));
  }

  public void stop() {
    if (wd != null) {
      wd.quit();
    }
  }

  public HttpSession newSession() {
    return new HttpSession(this);
  }

  public String getProperty(String key) {
    return properties.getProperty(key);
  }

  public RegistrationHelper registration() {
    if (registrationHelper == null) {
      registrationHelper = new RegistrationHelper(this);
    }
    return registrationHelper;
  }

  public FtpHelper ftp() {
    if (ftp == null) {
      ftp = new FtpHelper(this);
    }
    return ftp;
  }

  public WebDriver getDriver() {
    if (wd == null) {
      if (browser.equals(BrowserType.FIREFOX)) {
        wd = new FirefoxDriver();
      } else if (browser.equals(BrowserType.CHROME)) {
        wd = new ChromeDriver();
      } else if (browser.equals(BrowserType.IE)) {
        wd = new InternetExplorerDriver();
      }
      wd.manage().timeouts().implicitlyWait(1, TimeUnit.SECONDS);
      wd.get(properties.getProperty("web.baseUrl"));
    }
    return wd;
  }

  public MailHelper mail() {
    if (mailHelper == null) {
      mailHelper = new MailHelper(this);
    }
    return mailHelper;
  }

  public SessionHelper webSession() {
    if (sessionHelper == null) {
      sessionHelper = new SessionHelper(this);
    }
    return sessionHelper;
  }

  public NavigationHelper goTo() {
    if (navigationHelper == null) {
      navigationHelper = new NavigationHelper(this);
    }
    return navigationHelper;
  }

  public UserHelper users() {
    if (userHelper == null) {
      userHelper = new UserHelper(this);
    }
    return userHelper;
  }

  public DbHelper db() {
    if (dbHelper == null) {
      dbHelper = new DbHelper();
    }
    return dbHelper;
  }

  public JamesHelper james() {
    if (jamesHelper == null) {
      jamesHelper = new JamesHelper(this);
    }
    return jamesHelper;
  }

  public SoapHelper soap() {
    if (soapHelper == null) {
      soapHelper = new SoapHelper(this);
    }
    return soapHelper;
  }

}


text:
layout: base
title:  'Statistics of Gender in UD_Western_Sierra_Puebla_Nahuatl-ITML'
udver: '2'
---

## Treebank Statistics: UD_Western_Sierra_Puebla_Nahuatl-ITML: Features: `Gender`

This feature is universal.
It occurs with 1 different values: `Masc`.

9 tokens (0%) have a non-empty value of `Gender`.
6 types (0%) occur at least once with a non-empty value of `Gender`.
5 lemmas (0%) occur at least once with a non-empty value of `Gender`.
The feature is used with 4 part-of-speech tags: <tt>ADJ</tt> (3; 0% instances), <tt>NOUN</tt> (3; 0% instances), <tt>PROPN</tt> (2; 0% instances), <tt>PRON</tt> (1; 0% instances).

### `ADJ`

3 <tt>ADJ</tt> tokens (2% of all `ADJ` tokens) have a non-empty value of `Gender`.

The most frequent other feature values with which `ADJ` and `Gender` co-occurred: <tt>Foreign</tt><tt>=Yes</tt> (3; 100%), <tt>Number</tt><tt>=Sing</tt> (3; 100%).

`ADJ` tokens may have the following values of `Gender`:

* `Masc` (3; 100% of non-empty `Gender`): mexicano, chistoso
* `EMPTY` (133): cualli, kwale, kwaltsih, weyi, igual, kwali, Nuevo, atrasado, chihchikichih, chikawak

### `NOUN`

3 <tt>NOUN</tt> tokens (0% of all `NOUN` tokens) have a non-empty value of `Gender`.

The most frequent other feature values with which `NOUN` and `Gender` co-occurred: <tt>Case</tt><tt>=EMPTY</tt> (3; 100%), <tt>Foreign</tt><tt>=Yes</tt> (3; 100%), <tt>NounType</tt><tt>=EMPTY</tt> (3; 100%), <tt>Number</tt><tt>=Plur</tt> (3; 100%), <tt>Number[psor]</tt><tt>=EMPTY</tt> (3; 100%), <tt>Person[psor]</tt><tt>=EMPTY</tt> (3; 100%).

`NOUN` tokens may have the following values of `Gender`:

* `Masc` (3; 100% of non-empty `Gender`): mexicanos
* `EMPTY` (1474): ich, itich, atl, ica, ika, itzcuintli, pueblo, telpukatl, topueblo, tonal

### `PROPN`

2 <tt>PROPN</tt> tokens (1% of all `PROPN` tokens) have a non-empty value of `Gender`.

`PROPN` tokens may have the following values of `Gender`:

* `Masc` (2; 100% of non-empty `Gender`): estados, unidos
* `EMPTY` (209): Ticpintzin, Ticpinitos, Lupita, San, dios, Pedro, Francisco, Lencho, Mexico, Luis

### `PRON`

1 <tt>PRON</tt> tokens (0% of all `PRON` tokens) have a non-empty value of `Gender`.

The most frequent other feature values with which `PRON` and `Gender` co-occurred: <tt>Number</tt><tt>=Sing</tt> (1; 100%), <tt>Person</tt><tt>=3</tt> (1; 100%), <tt>PronType</tt><tt>=Prs</tt> (1; 100%).

`PRON` tokens may have the following values of `Gender`:

* `Masc` (1; 100% of non-empty `Gender`): lo
* `EMPTY` (505): neh, yeh, tlen, non, nochi, teh, yej, tehwah, ye, tlenoh

## Relations with Agreement in `Gender`

The 10 most frequent relations where parent and child node agree in `Gender`:
<tt>PROPN --[<tt>flat</tt>]--> PROPN</tt> (1; 100%).


text:
export default /* glsl */ `varying float vPixelSize;

float getGenericHollowAlpha(float mask) {
  return vPixelSize * (0.5 - 2.0 * abs(mask - .75));
}
`;


text:
#ifndef __AUTO_RPC_H
#define __AUTO_RPC_H

class RakPeerInterface;
class NetworkIDManager;
#include "PluginInterface.h"
#include "DS_Map.h"
#include "PacketPriority.h"
#include "RakNetTypes.h"
#include "BitStream.h"
#include "Gen_RPC8.h"
#include "RakString.h"

#ifdef _MSC_VER
#pragma warning( push )
#endif

/// \defgroup AUTO_RPC_GROUP AutoRPC
/// \ingroup PLUGINS_GROUP

namespace RakNet
{

/// Maximum amount of data that can be passed on the stack in a function call
#define ARPC_MAX_STACK_SIZE 65536

#if defined (_WIN32)
/// Easier way to get a pointer to a function member of a C++ class
/// \note Recommended you use ARPC_REGISTER_CPP_FUNCTION0 to ARPC_REGISTER_CPP_FUNCTION9 (below)
/// \note ARPC_REGISTER_CPP_FUNCTION is not Linux compatible, and cannot validate the number of parameters is correctly passed.
/// \param[in] autoRPCInstance A pointer to an instance of AutoRPC
/// \param[in] _IDENTIFIER_ C string identifier to use on the remote system to call the function
/// \param[in] _RETURN_ Return value of the function
/// \param[in] _CLASS_ Base-most class of the containing class that contains your function
/// \param[in] _FUNCTION_ Name of the function
/// \param[in] _PARAMS_ Parameter list, include parenthesis
#define ARPC_REGISTER_CPP_FUNCTION(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS_) \
{ \
union \
{ \
	_RETURN_ (AUTO_RPC_CALLSPEC _CLASS_::*__memberFunctionPtr)_PARAMS_; \
	void* __voidFunc; \
}; \
	__memberFunctionPtr=&_CLASS_::_FUNCTION_; \
	(autoRPCInstance)->RegisterFunction(_IDENTIFIER_, __voidFunc, true, -1); \
}

/// \internal Used by ARPC_REGISTER_CPP_FUNCTION0 to ARPC_REGISTER_CPP_FUNCTION9
#define ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS_, _PARAM_COUNT_) \
	{ \
	union \
	{ \
	_RETURN_ (AUTO_RPC_CALLSPEC _CLASS_::*__memberFunctionPtr)_PARAMS_; \
	void* __voidFunc; \
}; \
	__memberFunctionPtr=&_CLASS_::_FUNCTION_; \
	(autoRPCInstance)->RegisterFunction(_IDENTIFIER_, __voidFunc, true, _PARAM_COUNT_); \
}

/// Same as ARPC_REGISTER_CPP_FUNCTION, but specifies how many parameters the function has
#define ARPC_REGISTER_CPP_FUNCTION0(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_) (autoRPCInstance)->RegisterFunction(_IDENTIFIER_, __voidFunc, true, 0);
#define ARPC_REGISTER_CPP_FUNCTION1(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_), 0)
#define ARPC_REGISTER_CPP_FUNCTION2(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_), 1)
#define ARPC_REGISTER_CPP_FUNCTION3(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_), 2)
#define ARPC_REGISTER_CPP_FUNCTION4(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_), 3)
#define ARPC_REGISTER_CPP_FUNCTION5(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_,_PARAMS5_), 4)
#define ARPC_REGISTER_CPP_FUNCTION6(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_,_PARAMS5_,_PARAMS6_), 5)
#define ARPC_REGISTER_CPP_FUNCTION7(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_,_PARAMS5_,_PARAMS6_,_PARAMS7_), 6)
#define ARPC_REGISTER_CPP_FUNCTION8(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_,_PARAMS5_,_PARAMS6_,_PARAMS7_,_PARAMS8_), 7)
#define ARPC_REGISTER_CPP_FUNCTION9(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_, _PARAMS9_) ARPC_REGISTER_CPP_FUNCTIONX(autoRPCInstance,_IDENTIFIER_,_RETURN_,_CLASS_,_FUNCTION_,(_PARAMS1_,_PARAMS2_,_PARAMS3_,_PARAMS4_,_PARAMS5_,_PARAMS6_,_PARAMS7_,_PARAMS8_,_PARAMS9_), 8)

#else

#define ARPC_REGISTER_CPP_FUNCTION0(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*)) &_CLASS_::_FUNCTION_, true, 0 );

#define ARPC_REGISTER_CPP_FUNCTION1(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_ )) &_CLASS_::_FUNCTION_, true, 0 );

#define ARPC_REGISTER_CPP_FUNCTION2(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_ )) &_CLASS_::_FUNCTION_, true, 1 );

#define ARPC_REGISTER_CPP_FUNCTION3(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_ )) &_CLASS_::_FUNCTION_, true, 2 );

#define ARPC_REGISTER_CPP_FUNCTION4(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_ )) &_CLASS_::_FUNCTION_, true, 3 );

#define ARPC_REGISTER_CPP_FUNCTION5(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_ )) &_CLASS_::_FUNCTION_, true, 4 );

#define ARPC_REGISTER_CPP_FUNCTION6(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_ )) &_CLASS_::_FUNCTION_, true, 5 );

#define ARPC_REGISTER_CPP_FUNCTION7(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_ )) &_CLASS_::_FUNCTION_, true, 6 );

#define ARPC_REGISTER_CPP_FUNCTION8(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_ )) &_CLASS_::_FUNCTION_, true, 7 );

#define ARPC_REGISTER_CPP_FUNCTION9(autoRPCInstance, _IDENTIFIER_, _RETURN_, _CLASS_, _FUNCTION_, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_, _PARAMS9_) \
	(autoRPCInstance)->RegisterFunction((_IDENTIFIER_), (void*)(_RETURN_ (*) (_CLASS_*, _PARAMS1_, _PARAMS2_, _PARAMS3_, _PARAMS4_, _PARAMS5_, _PARAMS6_, _PARAMS7_, _PARAMS8_, _PARAMS9_ )) &_CLASS_::_FUNCTION_, true, 8 );

#endif

/// Error codes returned by a remote system as to why an RPC function call cannot execute
/// Follows packet ID ID_RPC_REMOTE_ERROR
/// Name of the function will be appended, if available. Read as follows:
/// char outputBuff[256];
/// stringCompressor->DecodeString(outputBuff,256,&RakNet::BitStream(p->data+sizeof(MessageID)+1,p->length-sizeof(MessageID)-1,false),0);
/// printf("Function: %s\n", outputBuff);
enum RPCErrorCodes
{
	/// AutoRPC::SetNetworkIDManager() was not called, and it must be called to call a C++ object member
	RPC_ERROR_NETWORK_ID_MANAGER_UNAVAILABLE,

	/// Cannot execute C++ object member call because the object specified by SetRecipientObject() does not exist on this system
	RPC_ERROR_OBJECT_DOES_NOT_EXIST,

	/// Internal error, index optimization for function lookup does not exist
	RPC_ERROR_FUNCTION_INDEX_OUT_OF_RANGE,

	/// Named function was not registered with RegisterFunction(). Check your spelling.
	RPC_ERROR_FUNCTION_NOT_REGISTERED,

	/// Named function was registered, but later unregistered with UnregisterFunction() and can no longer be called.
	RPC_ERROR_FUNCTION_NO_LONGER_REGISTERED,

	/// SetRecipientObject() was not called before Call(), but RegisterFunction() was called with isObjectMember=true
	/// If you intended to call a CPP function, call SetRecipientObject() with a valid object first.
	RPC_ERROR_CALLING_CPP_AS_C,

	/// SetRecipientObject() was called before Call(), but RegisterFunction() was called with isObjectMember=false
	/// If you intended to call a C function, call SetRecipientObject(UNASSIGNED_NETWORK_ID) first.
	RPC_ERROR_CALLING_C_AS_CPP,

	/// Internal error, passed stack is bigger than current stack. Check that the version is the same on both systems.
	RPC_ERROR_STACK_TOO_SMALL,

	/// Internal error, formatting error with how the stack was serialized
	RPC_ERROR_STACK_DESERIALIZATION_FAILED,

	/// The \a parameterCount parameter passed to RegisterFunction() on this system does not match the \a parameterCount parameter passed to SendCall() on the remote system.
	RPC_ERROR_INCORRECT_NUMBER_OF_PARAMETERS,
};

/// The AutoRPC plugin allows you to call remote functions as if they were local functions, using the standard function call syntax
/// No serialization or deserialization is needed.
/// Advantages are that this is easier to use than regular RPC system.
/// Disadvantages is that all parameters must be passable on the stack using memcpy (shallow copy). For other types of parameters, use SetOutgoingExtraData() and GetIncomingExtraData()
/// Pointers are automatically dereferenced and the contents copied with memcpy
/// Use the old system, or regular message passing, if you need greater flexibility
/// \ingroup AUTO_RPC_GROUP
class AutoRPC : public PluginInterface
{
public:
	/// Constructor
	AutoRPC();

	/// Destructor
	virtual ~AutoRPC();

	/// Sets the network ID manager to use for object lookup
	/// Required to call C++ object member functions via SetRecipientObject()
	/// \param[in] idMan Pointer to the network ID manager to use
	void SetNetworkIDManager(NetworkIDManager *idMan);

	/// Registers a function pointer to be callable given an identifier for the pointer
	/// \param[in] uniqueIdentifier String identifying the function. Recommended that this is the name of the function
	/// \param[in] functionPtr Pointer to the function. For C, just pass the name of the function. For C++, use ARPC_REGISTER_CPP_FUNCTION
	/// \param[in] isObjectMember false if a C function. True if a member function of an object (C++)
	/// \param[in] parameterCount Optional parameter to tell the system how many parameters this function has. If specified, and the wrong number of parameters are called by the remote system, the call is rejected. -1 indicates undefined
	/// \return True on success, false on uniqueIdentifier already used
	bool RegisterFunction(const char *uniqueIdentifier, void *functionPtr, bool isObjectMember, char parameterCount=-1);

	/// Unregisters a function pointer to be callable given an identifier for the pointer
	/// \note This is not safe to call while connected
	/// \param[in] uniqueIdentifier String identifying the function.
	/// \param[in] isObjectMember false if a C function. True if a member function of an object (C++)
	/// \return True on success, false on function was not previously or is not currently registered.
	bool UnregisterFunction(const char *uniqueIdentifier, bool isObjectMember);

	/// Send or stop sending a timestamp with all following calls to Call()
	/// Use GetLastSenderTimestamp() to read the timestamp.
	/// \param[in] timeStamp Non-zero to pass this timestamp using the ID_TIMESTAMP system. 0 to clear passing a timestamp.
	void SetTimestamp(RakNetTime timeStamp);

	/// Set parameters to pass to RakPeer::Send() for all following calls to Call()
	/// Deafults to HIGH_PRIORITY, RELIABLE_ORDERED, ordering channel 0
	/// \param[in] priority See RakPeer::Send()
	/// \param[in] reliability See RakPeer::Send()
	/// \param[in] orderingChannel See RakPeer::Send()
	void SetSendParams(PacketPriority priority, PacketReliability reliability, char orderingChannel);

	/// Set system to send to for all following calls to Call()
	/// Defaults to UNASSIGNED_SYSTEM_ADDRESS, broadcast=true
	/// \param[in] systemAddress See RakPeer::Send()
	/// \param[in] broadcast See RakPeer::Send()
	void SetRecipientAddress(SystemAddress systemAddress, bool broadcast);

	/// Set the NetworkID to pass for all following calls to Call()
	/// Defaults to UNASSIGNED_NETWORK_ID (none)
	/// If set, the remote function will be considered a C++ function, e.g. an object member function
	/// If set to UNASSIGNED_NETWORK_ID (none), the remote function will be considered a C function
	/// If this is set incorrectly, you will get back either RPC_ERROR_CALLING_C_AS_CPP or RPC_ERROR_CALLING_CPP_AS_C
	/// \sa NetworkIDManager
	/// \param[in] networkID Returned from NetworkIDObject::GetNetworkID()
	void SetRecipientObject(NetworkID networkID);

	/// Write extra data to pass for all following calls to Call()
	/// Use BitStream::Reset to clear extra data. Don't forget to do this or you will waste bandwidth.
	/// \return A bitstream you can write to to send extra data with each following call to Call()
	RakNet::BitStream *SetOutgoingExtraData(void);

	/// If the last received function call has a timestamp included, it is stored and can be retrieved with this function.
	/// \return 0 if the last call did not have a timestamp, else non-zero
	RakNetTime GetLastSenderTimestamp(void) const;

	/// Returns the system address of the last system to send us a received function call
	/// Equivalent to the old system RPCParameters::sender
	/// \return Last system to send an RPC call using this system
	SystemAddress GetLastSenderAddress(void) const;

	/// Returns the instance of RakPeer this plugin was attached to
	RakPeerInterface *GetRakPeer(void) const;

	/// Returns the currently running RPC call identifier, set from RegisterFunction::uniqueIdentifier
	/// Returns an empty string "" if none
	/// \Return which RPC call is currently running
	const char *GetCurrentExecution(void) const;

	/// Gets the bitstream written to via SetOutgoingExtraData().
	/// Data is updated with each incoming function call
	/// \return A bitstream you can read from with extra data that was written with SetOutgoingExtraData();
	RakNet::BitStream *GetIncomingExtraData(void);

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	bool Call(const char *uniqueIdentifier){
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 0);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1>
	bool Call(const char *uniqueIdentifier, P1 p1)	{
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 1);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2)	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 2);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3 )	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 3);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3, class P4>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3, P4 p4 )	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, true, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 4);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3, class P4, class P5>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, true, true, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 5);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3, class P4, class P5, class P6>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, true, true, true, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 6);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3, class P4, class P5, class P6, class P7>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )	{
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, p7, true, true, true, true, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 7);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	template <class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
	bool Call(const char *uniqueIdentifier, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 ) {
			char stack[ARPC_MAX_STACK_SIZE];
			unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, p7, p8, true, true, true, true, true, true, true, true);
			return SendCall(uniqueIdentifier, stack, bytesOnStack, 8);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID){
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 0);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1)	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 1);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2)	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 2);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3 )	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 3);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3, class P4>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3, P4 p4 )	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, true, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 4);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3, class P4, class P5>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, true, true, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 5);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3, class P4, class P5, class P6>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, true, true, true, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 6);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3, class P4, class P5, class P6, class P7>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )	{
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, p7, true, true, true, true, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 7);
	}

	/// Calls a remote function, using whatever was last passed to SetTimestamp(), SetSendParams(), SetRecipientAddress(), and SetRecipientObject()
	/// Passed parameter(s), if any, are passed via memcpy and pushed on the stack for the remote function
	/// \note This ONLY works with variables that are passable via memcpy! If you need more flexibility, use SetOutgoingExtraData() and GetIncomingExtraData()
	/// \note The this pointer, for this instance of AutoRPC, is pushed as the last parameter on the stack. See AutoRPCSample.ccp for an example of this
	/// \param[in] uniqueIdentifier parameter of the same name passed to RegisterFunction() on the remote system
	/// \param[in] timeStamp See SetTimestamp()
	/// \param[in] priority See SetSendParams()
	/// \param[in] reliability See SetSendParams()
	/// \param[in] orderingChannel See SetSendParams()
	/// \param[in] systemAddress See SetRecipientAddress()
	/// \param[in] broadcast See SetRecipientAddress()
	/// \param[in] networkID See SetRecipientObject()
	template <class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
	bool CallExplicit(const char *uniqueIdentifier, RakNetTime timeStamp, PacketPriority priority, PacketReliability reliability, char orderingChannel, SystemAddress systemAddress, bool broadcast, NetworkID networkID, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 ) {
		SetTimestamp(timeStamp);
		SetSendParams(priority, reliability, orderingChannel);
		SetRecipientAddress(systemAddress, broadcast);
		SetRecipientObject(networkID);
		char stack[ARPC_MAX_STACK_SIZE];
		unsigned int bytesOnStack = GenRPC::BuildStack(stack, p1, p2, p3, p4, p5, p6, p7, p8, true, true, true, true, true, true, true, true);
		return SendCall(uniqueIdentifier, stack, bytesOnStack, 8);
	}

	// If you need more than 8 parameters, just add it here...

	// ---------------------------- ALL INTERNAL AFTER HERE ----------------------------

	/// \internal
	/// Identifies an RPC function, by string identifier and if it is a C or C++ function
	struct RPCIdentifier
	{
		char *uniqueIdentifier;
		bool isObjectMember;
	};

	/// \internal
	/// The RPC identifier, and a pointer to the function
	struct LocalRPCFunction
	{
		RPCIdentifier identifier;
		void *functionPtr;
		char parameterCount;
	};

	/// \internal
	/// The RPC identifier, and the index of the function on a remote system
	struct RemoteRPCFunction
	{
		RPCIdentifier identifier;
		unsigned int functionIndex;
	};

	/// \internal
	static int RemoteRPCFunctionComp( const RPCIdentifier &key, const RemoteRPCFunction &data );

	/// \internal
	/// Sends the RPC call, with a given serialized stack
	bool SendCall(const char *uniqueIdentifier, const char *stack, unsigned int bytesOnStack, char parameterCount);

protected:

	// --------------------------------------------------------------------------------------------
	// Packet handling functions
	// --------------------------------------------------------------------------------------------
	void OnAttach(RakPeerInterface *peer);
	virtual PluginReceiveResult OnReceive(RakPeerInterface *peer, Packet *packet);
	virtual void OnAutoRPCCall(SystemAddress systemAddress, unsigned char *data, unsigned int lengthInBytes);
	virtual void OnRPCRemoteIndex(SystemAddress systemAddress, unsigned char *data, unsigned int lengthInBytes);
	virtual void OnRPCUnknownRemoteIndex(SystemAddress systemAddress, unsigned char *data, unsigned int lengthInBytes, RakNetTime timestamp);
	virtual void OnCloseConnection(RakPeerInterface *peer, SystemAddress systemAddress);
	virtual void OnShutdown(RakPeerInterface *peer);

	void Clear(void);

	void SendError(SystemAddress target, unsigned char errorCode, const char *functionName);
	unsigned GetLocalFunctionIndex(RPCIdentifier identifier);
	bool GetRemoteFunctionIndex(SystemAddress systemAddress, RPCIdentifier identifier, unsigned int *outerIndex, unsigned int *innerIndex);

	DataStructures::List<LocalRPCFunction> localFunctions;
	DataStructures::Map<SystemAddress, DataStructures::OrderedList<RPCIdentifier, RemoteRPCFunction, AutoRPC::RemoteRPCFunctionComp> *> remoteFunctions;

	RakNetTime outgoingTimestamp;
	PacketPriority outgoingPriority;
	PacketReliability outgoingReliability;
	char outgoingOrderingChannel;
	SystemAddress outgoingSystemAddress;
	bool outgoingBroadcast;
	NetworkID outgoingNetworkID;
	RakNet::BitStream outgoingExtraData;

	RakNetTime incomingTimeStamp;
	SystemAddress incomingSystemAddress;
	RakNet::BitStream incomingExtraData;

	RakPeerInterface *rakPeer;
	NetworkIDManager *networkIdManager;
	char currentExecution[512];
};

} // End namespace

#endif

#ifdef _MSC_VER
#pragma warning( pop )
#endif


text:
class Application : public gloperate_qt::Application
{
public:
    Application(int & argc, char ** argv)
    : gloperate_qt::Application(argc, argv)
    {
        const QFileInfo fi(QCoreApplication::applicationFilePath());

        QApplication::setApplicationDisplayName(fi.baseName());

        QApplication::setApplicationName("glexamples");
        QApplication::setApplicationVersion("1.0.0");

        QApplication::setOrganizationName("HPI Computer Graphics Systems Group");
        QApplication::setOrganizationDomain("https://github.com/hpicgs");
    }

    virtual ~Application() = default;
};

int main(int argc, char * argv[])
{
    Application app(argc, argv);

    widgetzeug::enableDarkFusionStyle();

    gloperate_qt::Viewer viewer;
    viewer.show();

    return app.exec();
}


text:
package bixie.boogie.ast.expression;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

import bixie.boogie.ast.location.ILocation;
import bixie.boogie.type.BoogieType;

/**
 * Represents a bit vector access expression which is a special form of a
 * expression.
 */
public class BitVectorAccessExpression extends Expression {
	/**
	 * The serial version UID.
	 */
	// private static final long serialVersionUID = 1L;
	/**
	 * The sub expression representing the bit-vector.
	 */
	Expression bitvec;

	/**
	 * The end index of this bit-vector access.
	 */
	int end;

	/**
	 * The start index of this bit-vector access.
	 */
	int start;

	/**
	 * The constructor taking initial values.
	 *
	 * @param loc
	 *            the node's location
	 * @param bitvec
	 *            the sub expression representing the bit-vector.
	 * @param end
	 *            the end index of this bit-vector access.
	 * @param start
	 *            the start index of this bit-vector access.
	 */
	public BitVectorAccessExpression(ILocation loc, Expression bitvec, int end,
			int start) {
		super(loc);
		this.bitvec = bitvec;
		this.end = end;
		this.start = start;
	}

	/**
	 * The constructor taking initial values.
	 *
	 * @param loc
	 *            the node's location
	 * @param type
	 *            the type of this expression.
	 * @param bitvec
	 *            the sub expression representing the bit-vector.
	 * @param end
	 *            the end index of this bit-vector access.
	 * @param start
	 *            the start index of this bit-vector access.
	 */
	public BitVectorAccessExpression(ILocation loc, BoogieType type,
			Expression bitvec, int end, int start) {
		super(loc, type);
		this.bitvec = bitvec;
		this.end = end;
		this.start = start;
	}

	/**
	 * Returns a textual description of this object.
	 */
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("BitVectorAccessExpression").append('[');
		sb.append(bitvec);
		sb.append(',').append(end);
		sb.append(',').append(start);
		return sb.append(']').toString();
	}

	/**
	 * Gets the sub expression representing the bit-vector.
	 *
	 * @return the sub expression representing the bit-vector.
	 */
	public Expression getBitvec() {
		return bitvec;
	}

	/**
	 * Gets the end index of this bit-vector access.
	 *
	 * @return the end index of this bit-vector access.
	 */
	public int getEnd() {
		return end;
	}

	/**
	 * Gets the start index of this bit-vector access.
	 *
	 * @return the start index of this bit-vector access.
	 */
	public int getStart() {
		return start;
	}

	public List<Object> getChildren() {
		List<Object> children = super.getChildren();
		children.add(bitvec);
		children.add(end);
		children.add(start);
		return children;
	}

	@Override
	public Expression substitute(HashMap<String, Expression> s) {
		return new BitVectorAccessExpression(this.getLocation(),
				this.getType(),
				this.bitvec.substitute(s), this.end, this.start);
	}

	@Override
	public HashSet<IdentifierExpression> getFreeVariables() {
		HashSet<IdentifierExpression> ret = new HashSet<IdentifierExpression>();
		ret.addAll(this.bitvec.getFreeVariables());
		return ret;
	}

}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:id="@+id/vehicle_view"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent">
    <LinearLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:visibility="gone"
            >
        <EditText
                android:id="@+id/commandText"
                android:layout_width="200dp"
                android:layout_height="wrap_content"
                android:inputType="text"
                />
        <Button
                android:id="@+id/sendButton"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="发 送"
                />
    </LinearLayout>
    <LinearLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:visibility="gone"
            >
        <TextView
                android:id="@+id/resultText"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:text="--"
                />
    </LinearLayout>
    <TableLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:stretchColumns="1,3"
            android:background="#dddddd">
        <TableRow
                android:layout_margin="2dip"
                android:background="#000000">
            <ImageView
                    android:src="@drawable/mpg"
                    android:layout_gravity="top|left"/>
            <TextView
                    android:text="0"
                    android:id="@+id/fuel_econ_text"
                    android:textSize="115px"
                    android:gravity="bottom|right"/>
            <TextView
                    android:text="l/100km"
                    android:id="@+id/avg_fuel_econ_lbl"
                    android:gravity="bottom|left"/>
            <TextView
                    android:id="@+id/compass_text"
                    android:text="N"
                    android:gravity="center"
                    android:layout_marginRight="10px"
                    android:textSize="115px"/>
        </TableRow>
    </TableLayout>
    <TableLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:background="#dddddd">
        <TableRow
                android:layout_margin="2dip"
                android:background="#000000">
            <eu.lighthouselabs.obd.reader.drawable.CoolantGaugeView
                    android:layout_width="330px"
                    android:id="@+id/coolant_gauge"
                    android:layout_height="50px"
                    android:layout_margin="7px"/>
            <ImageView
                    android:src="@drawable/temp"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center_vertical|center_horizontal"
                    android:paddingLeft="10px"/>
            <TextView
                    android:id="@+id/air_temp_text"
                    android:text=""
                    android:layout_marginLeft="15px"
                    android:layout_gravity="center_vertical|center_horizontal"/>
        </TableRow>
        <!--
        <TableRow
            android:layout_margin="2dip"
          android:background="#000000">
          <TextView
            android:id="@+id/accel_text"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
          <eu.lighthouselabs.MyCommand.reader.drawable.AccelGaugeView
            android:id="@+id/accel_gauge"
            android:layout_width="330px"
            android:layout_height="50px"
            android:layout_margin="7px"/>
        </TableRow>
        -->
    </TableLayout>
    <TableLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:stretchColumns="*"
            android:background="#dddddd">
        <TableRow
                android:layout_margin="2dip"
                android:background="#000000">
            <TextView
                    android:id="@+id/inst_fuel_econ_text"
                    android:text="0l/100km"/>
            <TextView
                    android:id="@+id/run_time_text"
                    android:text="00:00:00"/>
            <TextView
                    android:id="@+id/rpm_text"
                    android:text=""/>
            <TextView
                    android:id="@+id/spd_text"
                    android:text=""/>
        </TableRow>
    </TableLayout>
    <ScrollView
            android:id="@+id/data_scroll"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content">
        <TableLayout
                android:id="@+id/data_table"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:stretchColumns="*"
                android:background="#dddddd">
        </TableLayout>
    </ScrollView>
</LinearLayout>


text:
<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

namespace Larium\Http;

class Cookie
{

    protected $name;
    protected $value;
    protected $expire;
    protected $path;
    protected $domain;
    protected $secure;
    protected $httponly;

    public function __construct(
        $name,
        $value=null,
        $expire=0,
        $path='/',
        $domain=null,
        $secure=false,
        $httponly=false
    ) {

        // Validate cookie name and value.
        // https://github.com/php/php-src/blob/php-5.4.16/ext/standard/head.c#L84
        $invalid_name = "=,; \t\r\n\013\014";
        if (preg_match("/[$invalid_name]/", $name)) {
            throw new \InvalidArgumentException(sprintf("Invalid cookie name %s. Cookie names cannot contain any of the following '%s'",$name, $invalid_name));
        }
        $invalid_value = ",; \t\r\n\013\014";
        if (preg_match("/[$invalid_value]/", $value)) {
            throw new \InvalidArgumentException(sprintf("Invalid cookie value %s. Cookie values cannot contain any of the following '%s'",$name, $invalid_value));
        }

        $this->name     = $name;
        $this->value    = $value;
        $this->expire   = $expire;
        $this->path     = $path;
        $this->domain   = $domain;
        $this->secure   = $secure;
        $this->httponly = $httponly;

    }

    public function getName()
    {
        return $this->name;
    }

    public function getValue()
    {
        return $this->value;
    }

    public function getExpire()
    {
        return $this->expire;
    }

    public function getPath()
    {
        return $this->path;
    }

    public function getDomain()
    {
        return $this->domain;
    }

    public function isSecure()
    {
        return $this->secure;
    }

    public function httpOnly()
    {
        return $this->httponly;
    }
}


text:
<?php

namespace Symfony\Component\Translation;

use Symfony\Component\Translation\Loader\LoaderInterface;

/*
 * This file is part of the Symfony framework.
 *
 * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

/**
 * Translator.
 *
 * @author Fabien Potencier <fabien.potencier@symfony-project.com>
 */
class Translator implements TranslatorInterface
{
    protected $catalogues;
    protected $locale;
    protected $fallbackLocale;
    protected $loaders;
    protected $resources;
    protected $selector;

    /**
     * Constructor.
     *
     * @param string          $locale   The locale
     * @param MessageSelector $selector The message selector for pluralization
     */
    public function __construct($locale = null, MessageSelector $selector)
    {
        $this->locale = $locale;
        $this->selector = $selector;
        $this->loaders = array();
        $this->resources = array();
        $this->catalogues = array();
    }

    /**
     * Adds a Loader.
     *
     * @param string          $format The name of the loader (@see addResource())
     * @param LoaderInterface $loader A LoaderInterface instance
     */
    public function addLoader($format, LoaderInterface $loader)
    {
        $this->loaders[$format] = $loader;
    }

    /**
     * Adds a Resource.
     *
     * @param string $format   The name of the loader (@see addLoader())
     * @param mixed  $resource The resource name
     * @param string $locale   The locale
     * @param string $domain   The domain
     */
    public function addResource($format, $resource, $locale, $domain = 'messages')
    {
        if (!isset($this->resources[$locale])) {
            $this->resources[$locale] = array();
        }

        $this->resources[$locale][] = array($format, $resource, $domain);
    }

    /**
     * {@inheritdoc}
     */
    public function setLocale($locale)
    {
        $this->locale = $locale;
    }

    /**
     * {@inheritdoc}
     */
    public function getLocale()
    {
        return $this->locale;
    }

    /**
     * Sets the fallback locale.
     *
     * @param string $locale The fallback locale
     */
    public function setFallbackLocale($locale)
    {
        // needed as the fallback locale is used to fill-in non-yet translated messages
        $this->catalogues = array();

        $this->fallbackLocale = $locale;
    }

    /**
     * {@inheritdoc}
     */
    public function trans($id, array $parameters = array(), $domain = 'messages', $locale = null)
    {
        if (!isset($locale)) {
            $locale = $this->getLocale();
        }

        if (!isset($this->catalogues[$locale])) {
            $this->loadCatalogue($locale);
        }

        return strtr($this->catalogues[$locale]->get($id, $domain), $parameters);
    }

    /**
     * {@inheritdoc}
     */
    public function transChoice($id, $number, array $parameters = array(), $domain = 'messages', $locale = null)
    {
        if (!isset($locale)) {
            $locale = $this->getLocale();
        }

        if (!isset($this->catalogues[$locale])) {
            $this->loadCatalogue($locale);
        }

        return strtr($this->selector->choose($this->catalogues[$locale]->get($id, $domain), (int) $number, $locale), $parameters);
    }

    protected function loadCatalogue($locale)
    {
        $this->catalogues[$locale] = new MessageCatalogue($locale);
        if (!isset($this->resources[$locale])) {
            return;
        }

        foreach ($this->resources[$locale] as $resource) {
            if (!isset($this->loaders[$resource[0]])) {
                throw new \RuntimeException(sprintf('The "%s" translation loader is not registered.', $resource[0]));
            }
            $this->catalogues[$locale]->addCatalogue($this->loaders[$resource[0]]->load($resource[1], $locale, $resource[2]));
        }

        $this->optimizeCatalogue($locale);
    }

    protected function optimizeCatalogue($locale)
    {
        if (strlen($locale) > 3) {
            $fallback = substr($locale, 0, -strlen(strrchr($locale, '_')));
        } else {
            $fallback = $this->fallbackLocale;
        }

        if (!$fallback) {
            return;
        }

        if (!isset($this->catalogues[$fallback])) {
            $this->loadCatalogue($fallback);
        }

        $this->catalogues[$locale]->addFallbackCatalogue($this->catalogues[$fallback]);
    }
}


text:
using System.IO;

using Hyena;

namespace FSpot.Utils
{
	public static class HashUtils
	{
		public static string GenerateMD5 (SafeUri uri)
		{
			string hash = string.Empty;

			using (var stream = new FileStream (uri.AbsolutePath, FileMode.Open, FileAccess.Read)) {
				hash = CryptoUtil.Md5EncodeStream (stream);
			}

			return hash;
		}
	}
}


text:
package com.hazelcast.map.impl.querycache.subscriber;

import com.hazelcast.config.Config;
import com.hazelcast.config.MapConfig;
import com.hazelcast.config.QueryCacheConfig;
import com.hazelcast.internal.config.ConfigUtils;
import com.hazelcast.map.impl.querycache.QueryCacheConfigurator;
import com.hazelcast.map.impl.querycache.QueryCacheEventService;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Node side implementation of {@link QueryCacheConfigurator}.
 *
 * @see QueryCacheConfigurator
 */
public class NodeQueryCacheConfigurator extends AbstractQueryCacheConfigurator {

    private final Config config;

    public NodeQueryCacheConfigurator(Config config, ClassLoader configClassLoader,
                                      QueryCacheEventService eventService) {
        super(configClassLoader, eventService);
        this.config = config;
    }

    @Override
    public QueryCacheConfig getOrCreateConfiguration(String mapName, String cacheName, String cacheId) {
        MapConfig mapConfig = config.getMapConfig(mapName);

        QueryCacheConfig queryCacheConfig = findQueryCacheConfigFromMapConfig(mapConfig, cacheName);

        if (queryCacheConfig != null) {
            setPredicateImpl(queryCacheConfig);
            setEntryListener(mapName, cacheId, queryCacheConfig);
            return queryCacheConfig;
        }

        QueryCacheConfig newConfig = new QueryCacheConfig(cacheName);
        mapConfig.getQueryCacheConfigs().add(newConfig);
        return newConfig;
    }

    @Override
    public QueryCacheConfig getOrNull(String mapName, String cacheName, String cacheId) {
        MapConfig mapConfig = config.getMapConfigOrNull(mapName);
        if (mapConfig == null) {
            return null;
        }

        QueryCacheConfig queryCacheConfig = findQueryCacheConfigFromMapConfig(mapConfig, cacheName);
        if (queryCacheConfig != null) {
            setPredicateImpl(queryCacheConfig);
            setEntryListener(mapName, cacheId, queryCacheConfig);
            return queryCacheConfig;
        }

        return queryCacheConfig;
    }

    private QueryCacheConfig findQueryCacheConfigFromMapConfig(MapConfig mapConfig, String cacheName) {
        List<QueryCacheConfig> queryCacheConfigs = mapConfig.getQueryCacheConfigs();
        Map<String, QueryCacheConfig> allQueryCacheConfigs = new HashMap<String, QueryCacheConfig>(queryCacheConfigs.size());
        for (QueryCacheConfig queryCacheConfig : queryCacheConfigs) {
            allQueryCacheConfigs.put(queryCacheConfig.getName(), queryCacheConfig);
        }

        return ConfigUtils.lookupByPattern(config.getConfigPatternMatcher(), allQueryCacheConfigs, cacheName);
    }

    @Override
    public void removeConfiguration(String mapName, String cacheName) {
        MapConfig mapConfig = config.getMapConfig(mapName);
        List<QueryCacheConfig> queryCacheConfigs = mapConfig.getQueryCacheConfigs();
        if (queryCacheConfigs == null || queryCacheConfigs.isEmpty()) {
            return;
        }
        Iterator<QueryCacheConfig> iterator = queryCacheConfigs.iterator();
        while (iterator.hasNext()) {
            QueryCacheConfig config = iterator.next();
            if (config.getName().equals(cacheName)) {
                iterator.remove();
            }
        }
    }
}


text:
/**
 *
 */
package io.pratik.metricscapture.models;

import java.util.List;

import lombok.Builder;

/**
 * @author pratikdas
 *
 */
@Builder
public class Order {
	private List<Product> products;

	private String orderDate;

}


text:
class Transformation < ActiveRecord::Base
  belongs_to :renderer, :class_name => 'FileRenderer'
  has_many :typescripts, dependent: :nullify

  def full_path
    renderer.path.sub(/:transformation/, path)
  end
end


text:
export const INPUT_CHANGE_WEBCAM_IMAGE = 'INPUT_CHANGE_WEBCAM_IMAGE'
export const INPUT_CHANGE_NEW_FACE_IMAGE = 'INPUT_CHANGE_NEW_FACE_IMAGE'
export const INPUT_CHANGE_WEBCAM_IDENTIFY_IMAGE = 'INPUT_CHANGE_WEBCAM_IDENTIFY_IMAGE'
// Add Action String Constant Here (do not delete this line)

export const inputChangeWebcamImage = (data) => ({
  type: INPUT_CHANGE_WEBCAM_IMAGE,
  data
})

export const inputChangeNewFaceImage = (data) => ({
  type: INPUT_CHANGE_NEW_FACE_IMAGE,
  data
})

export const inputChangeWebcamIdentifyImage = (data) => ({
  type: INPUT_CHANGE_WEBCAM_IDENTIFY_IMAGE,
  data
})

// Add Action Creator Here (do not delete this line)


text:
require_relative '../spec_helper'

describe Omx::Player do

  describe 'default options' do
    it 'should set hdmi and start position zero by default' do
      opts = Omx::Player.new.send :default_options
      opts[:audio_out].should == 'hdmi'
      opts[:start_pos].should == 0
    end
  end

  describe 'building the pipe' do

    before :each do
      @pipe = Omx::Player::PIPE
      @player = Omx::Player.new
    end

    it 'will not create pipe if none exists' do
      File.expects(:exists?).with(@pipe).returns(true)
      @player.expects(:system).never
    end

    it 'will create pipe if does not exist' do
      File.expects(:exists?).with(@pipe).returns(false)
      @player.expects(:system)
    end

    after :each do
      @player.send :mkfifo
    end

  end

  describe 'building the unix command' do

    before :each do
      @player = Omx::Player.new
      opts = {filename: 'none.mp4', audio_out: 'hdmi', start_pos: 0}
      @cmd = @player.send :unix_command_with, opts
      @pipe = Omx::Player::PIPE
    end

    it 'should start with omxplayer' do
      @cmd.should match /^omxplayer/
    end

    it 'should generate the args' do
      @cmd.should match /--adev hdmi/
      @cmd.should match /--pos 0/
    end

    it 'should put quotes around the filename' do
      @cmd.should match /"none.mp4"/
    end

    it 'should end with a pipe ampersand' do
      @cmd.should match /< #{@pipe} &$/
    end

    it 'must match this sequence of tokens' do
      # command --args+ filename pipe ampersand
      r = /(?<command>omxplayer) (?<arg>--\w+ \S+\s?){2,} (?<file>"\S+") < (?<pipe>\S+) &/
      @cmd.should match r
    end

  end

  describe 'sending commands to pipe' do
    it 'should send the command as a background process' do
      p = Omx::Player.new
      p.expects(:system).with do |command|
        command =~ /^echo -n . > \S+ &$/
      end
      p.send :send_to_pipe, "."
    end
  end

  describe 'opening a file' do
    it 'should send the start command' do
      p = Omx::Player.new
      p.expects(:start).once
      p.send :open
    end
  end

end