text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DeadManSwitch.UI
{
    public class ScheduleListModel
    {
        public ScheduleListModel()
            : this (new List<ScheduleViewModel>()) { }
        public ScheduleListModel(IEnumerable<ScheduleViewModel> schedules)
        {
            Schedules = new List<ScheduleViewModel>(schedules);
            NextCheckInText = string.Empty;
        }

        public List<ScheduleViewModel> Schedules { get; private set; }
        public string NextCheckInText { get; set; }
    }
}


text:
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class SpellManager : MonoBehaviour {

	//This script will be our spellDatabase that contains all of our spells.
	public List<Spell> spellList = new List<Spell>();

}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace App\Policies;

use App\Models\Thread;
use App\Models\User;
use Illuminate\Auth\Access\HandlesAuthorization;

class ThreadPolicy
{
    use HandlesAuthorization;

    /**
     * Create a new policy instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    public function before($user, $ability)
    {
        if ($user->is_admin) {
            return true;
        }
    }

    public function update(User $user, Thread $thread)
    {
        return $user->id === $thread->user_id;
    }

    public function edit(User $user, Thread $thread)
    {
        return $user->id === $thread->user_id;
    }

    public function delete(User $user, Thread $thread)
    {
        return $user->id === $thread->user_id;
    }
}


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

<meta http-equiv="Content-Type" content="text/html" charset="utf-8">
<title>NativeLibraryBinarySpec (Gradle API 2.3)</title>
<meta name="date" content="2015-02-16">
<link rel="stylesheet" type="text/css" href="../../../javadoc.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.gradle.nativeplatform

Interface NativeLibraryBinarySpec

All Superinterfaces:

BinarySpec, Buildable, BuildableModelElement, LibraryBinarySpec, Named, NativeBinarySpec

All Known Subinterfaces:

SharedLibraryBinarySpec, StaticLibraryBinarySpec

public interface NativeLibraryBinarySpec
extends NativeBinarySpec, LibraryBinarySpec

Represents a binary artifact that is the result of building a native library component.

Nested Class Summary

Nested classes/interfaces inherited from interface org.gradle.api.Named

Named.Namer

Method Summary

Methods inherited from interface org.gradle.nativeplatform.NativeBinarySpec

getBuildType, getComponent, getFlavor, getLibs, getLinker, getStaticLibArchiver, getTargetPlatform, getToolChain, lib

Methods inherited from interface org.gradle.platform.base.BinarySpec

getDisplayName, getSource, getTasks, isBuildable, source, sources

Methods inherited from interface org.gradle.api.BuildableModelElement

builtBy, getBuildTask, hasBuildDependencies, setBuildTask

Methods inherited from interface org.gradle.api.Buildable

getBuildDependencies

Methods inherited from interface org.gradle.api.Named

getName

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'wriggler'


text: define({title:"Etsi sijaintini"});


text:
/********************************************************************
 * 2014 -
 * open source under Apache License Version 2.0
 ********************************************************************/
/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef _HDFS_LIBHDFS3_CLIENT_HDFS_H_
#define _HDFS_LIBHDFS3_CLIENT_HDFS_H_

#include <errno.h> /* for EINTERNAL, etc. */
#include <fcntl.h> /* for O_RDONLY, O_WRONLY */
#include <stdint.h> /* for uint64_t, etc. */
#include <time.h> /* for time_t */

#ifndef O_RDONLY
#define O_RDONLY 1
#endif

#ifndef O_WRONLY
#define O_WRONLY 2
#endif

#ifndef EINTERNAL
#define EINTERNAL 255
#endif

/** All APIs set errno to meaningful values */

#ifdef __cplusplus
extern "C" {
#endif
/**
 * Some utility decls used in libhdfs.
 */
typedef int32_t tSize; /// size of data for read/write io ops
typedef time_t tTime; /// time type in seconds
typedef int64_t tOffset; /// offset within the file
typedef uint16_t tPort; /// port

typedef enum tObjectKind {
    kObjectKindFile = 'F', kObjectKindDirectory = 'D',
} tObjectKind;

struct HdfsFileSystemInternalWrapper;
typedef struct HdfsFileSystemInternalWrapper * hdfsFS;

struct HdfsFileInternalWrapper;
typedef struct HdfsFileInternalWrapper * hdfsFile;

struct hdfsBuilder;

/**
 * Return error information of last failed operation.
 *
 * @return 			A not NULL const string point of last error information.
 * 					Caller can only read this message and keep it unchanged. No need to free it.
 * 					If last operation finished successfully, the returned message is undefined.
 */
const char * hdfsGetLastError();

/**
 * Determine if a file is open for read.
 *
 * @param file     The HDFS file
 * @return         1 if the file is open for read; 0 otherwise
 */
int hdfsFileIsOpenForRead(hdfsFile file);

/**
 * Determine if a file is open for write.
 *
 * @param file     The HDFS file
 * @return         1 if the file is open for write; 0 otherwise
 */
int hdfsFileIsOpenForWrite(hdfsFile file);

/**
 * hdfsConnectAsUser - Connect to a hdfs file system as a specific user
 * Connect to the hdfs.
 * @param nn   The NameNode.  See hdfsBuilderSetNameNode for details.
 * @param port The port on which the server is listening.
 * @param user the user name (this is hadoop domain user). Or NULL is equivelant to hhdfsConnect(host, port)
 * @return Returns a handle to the filesystem or NULL on error.
 * @deprecated Use hdfsBuilderConnect instead.
 */
hdfsFS hdfsConnectAsUser(const char * nn, tPort port, const char * user);

/**
 * hdfsConnect - Connect to a hdfs file system.
 * Connect to the hdfs.
 * @param nn   The NameNode.  See hdfsBuilderSetNameNode for details.
 * @param port The port on which the server is listening.
 * @return Returns a handle to the filesystem or NULL on error.
 * @deprecated Use hdfsBuilderConnect instead.
 */
hdfsFS hdfsConnect(const char * nn, tPort port);

/**
 * hdfsConnect - Connect to an hdfs file system.
 *
 * Forces a new instance to be created
 *
 * @param nn     The NameNode.  See hdfsBuilderSetNameNode for details.
 * @param port   The port on which the server is listening.
 * @param user   The user name to use when connecting
 * @return       Returns a handle to the filesystem or NULL on error.
 * @deprecated   Use hdfsBuilderConnect instead.
 */
hdfsFS hdfsConnectAsUserNewInstance(const char * nn, tPort port,
                                    const char * user);

/**
 * hdfsConnect - Connect to an hdfs file system.
 *
 * Forces a new instance to be created
 *
 * @param nn     The NameNode.  See hdfsBuilderSetNameNode for details.
 * @param port   The port on which the server is listening.
 * @return       Returns a handle to the filesystem or NULL on error.
 * @deprecated   Use hdfsBuilderConnect instead.
 */
hdfsFS hdfsConnectNewInstance(const char * nn, tPort port);

/**
 * Connect to HDFS using the parameters defined by the builder.
 *
 * The HDFS builder will be freed, whether or not the connection was
 * successful.
 *
 * Every successful call to hdfsBuilderConnect should be matched with a call
 * to hdfsDisconnect, when the hdfsFS is no longer needed.
 *
 * @param bld    The HDFS builder
 * @return       Returns a handle to the filesystem, or NULL on error.
 */
hdfsFS hdfsBuilderConnect(struct hdfsBuilder * bld);

/**
 * Create an HDFS builder.
 *
 * @return The HDFS builder, or NULL on error.
 */
struct hdfsBuilder * hdfsNewBuilder(void);

/**
 * Do nothing, we always create a new instance
 *
 * @param bld The HDFS builder
 */
void hdfsBuilderSetForceNewInstance(struct hdfsBuilder * bld);

/**
 * Set the HDFS NameNode to connect to.
 *
 * @param bld  The HDFS builder
 * @param nn   The NameNode to use.
 *
 *             If the string given is 'default', the default NameNode
 *             configuration will be used (from the XML configuration files)
 *
 *             If NULL is given, a LocalFileSystem will be created.
 *
 *             If the string starts with a protocol type such as file:// or
 *             hdfs://, this protocol type will be used.  If not, the
 *             hdfs:// protocol type will be used.
 *
 *             You may specify a NameNode port in the usual way by
 *             passing a string of the format hdfs://<hostname>:<port>.
 *             Alternately, you may set the port with
 *             hdfsBuilderSetNameNodePort.  However, you must not pass the
 *             port in two different ways.
 */
void hdfsBuilderSetNameNode(struct hdfsBuilder * bld, const char * nn);

/**
 * Set the port of the HDFS NameNode to connect to.
 *
 * @param bld The HDFS builder
 * @param port The port.
 */
void hdfsBuilderSetNameNodePort(struct hdfsBuilder * bld, tPort port);

/**
 * Set the username to use when connecting to the HDFS cluster.
 *
 * @param bld The HDFS builder
 * @param userName The user name.  The string will be shallow-copied.
 */
void hdfsBuilderSetUserName(struct hdfsBuilder * bld, const char * userName);

/**
 * Set the path to the Kerberos ticket cache to use when connecting to
 * the HDFS cluster.
 *
 * @param bld The HDFS builder
 * @param kerbTicketCachePath The Kerberos ticket cache path.  The string
 *                            will be shallow-copied.
 */
void hdfsBuilderSetKerbTicketCachePath(struct hdfsBuilder * bld,
                                       const char * kerbTicketCachePath);

/**
 * Set the token used to authenticate
 *
 * @param bld The HDFS builder
 * @param token The token used to authenticate
 */
void hdfsBuilderSetToken(struct hdfsBuilder * bld, const char * token);

/**
 * Free an HDFS builder.
 *
 * It is normally not necessary to call this function since
 * hdfsBuilderConnect frees the builder.
 *
 * @param bld The HDFS builder
 */
void hdfsFreeBuilder(struct hdfsBuilder * bld);

/**
 * Set a configuration string for an HdfsBuilder.
 *
 * @param key      The key to set.
 * @param val      The value, or NULL to set no value.
 *                 This will be shallow-copied.  You are responsible for
 *                 ensuring that it remains valid until the builder is
 *                 freed.
 *
 * @return         0 on success; nonzero error code otherwise.
 */
int hdfsBuilderConfSetStr(struct hdfsBuilder * bld, const char * key,
                          const char * val);

/**
 * Get a configuration string.
 *
 * @param key      The key to find
 * @param val      (out param) The value.  This will be set to NULL if the
 *                 key isn't found.  You must free this string with
 *                 hdfsConfStrFree.
 *
 * @return         0 on success; nonzero error code otherwise.
 *                 Failure to find the key is not an error.
 */
int hdfsConfGetStr(const char * key, char ** val);

/**
 * Get a configuration integer.
 *
 * @param key      The key to find
 * @param val      (out param) The value.  This will NOT be changed if the
 *                 key isn't found.
 *
 * @return         0 on success; nonzero error code otherwise.
 *                 Failure to find the key is not an error.
 */
int hdfsConfGetInt(const char * key, int32_t * val);

/**
 * Free a configuration string found with hdfsConfGetStr.
 *
 * @param val      A configuration string obtained from hdfsConfGetStr
 */
void hdfsConfStrFree(char * val);

/**
 * hdfsDisconnect - Disconnect from the hdfs file system.
 * Disconnect from hdfs.
 * @param fs The configured filesystem handle.
 * @return Returns 0 on success, -1 on error.
 *         Even if there is an error, the resources associated with the
 *         hdfsFS will be freed.
 */
int hdfsDisconnect(hdfsFS fs);

/**
 * hdfsOpenFile - Open a hdfs file in given mode.
 * @param fs The configured filesystem handle.
 * @param path The full path to the file.
 * @param flags - an | of bits/fcntl.h file flags - supported flags are O_RDONLY, O_WRONLY (meaning create or overwrite i.e., implies O_TRUNCAT),
 * O_WRONLY|O_APPEND and O_SYNC. Other flags are generally ignored other than (O_RDWR || (O_EXCL & O_CREAT)) which return NULL and set errno equal ENOTSUP.
 * @param bufferSize Size of buffer for read/write - pass 0 if you want
 * to use the default configured values.
 * @param replication Block replication - pass 0 if you want to use
 * the default configured values.
 * @param blocksize Size of block - pass 0 if you want to use the
 * default configured values.
 * @return Returns the handle to the open file or NULL on error.
 */
hdfsFile hdfsOpenFile(hdfsFS fs, const char * path, int flags, int bufferSize,
                      short replication, tOffset blocksize);

/**
 * hdfsCloseFile - Close an open file.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @return Returns 0 on success, -1 on error.
 *         On error, errno will be set appropriately.
 *         If the hdfs file was valid, the memory associated with it will
 *         be freed at the end of this call, even if there was an I/O
 *         error.
 */
int hdfsCloseFile(hdfsFS fs, hdfsFile file);

/**
 * hdfsExists - Checks if a given path exsits on the filesystem
 * @param fs The configured filesystem handle.
 * @param path The path to look for
 * @return Returns 0 on success, -1 on error.
 */
int hdfsExists(hdfsFS fs, const char * path);

/**
 * hdfsSeek - Seek to given offset in file.
 * This works only for files opened in read-only mode.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @param desiredPos Offset into the file to seek into.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos);

/**
 * hdfsTell - Get the current offset in the file, in bytes.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @return Current offset, -1 on error.
 */
tOffset hdfsTell(hdfsFS fs, hdfsFile file);

/**
 * hdfsRead - Read data from an open file.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @param buffer The buffer to copy read bytes into.
 * @param length The length of the buffer.
 * @return      On success, a positive number indicating how many bytes
 *              were read.
 *              On end-of-file, 0.
 *              On error, -1.  Errno will be set to the error code.
 *              Just like the POSIX read function, hdfsRead will return -1
 *              and set errno to EINTR if data is temporarily unavailable,
 *              but we are not yet at the end of the file.
 */
tSize hdfsRead(hdfsFS fs, hdfsFile file, void * buffer, tSize length);

/**
 * hdfsWrite - Write data into an open file.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @param buffer The data.
 * @param length The no. of bytes to write.
 * @return Returns the number of bytes written, -1 on error.
 */
tSize hdfsWrite(hdfsFS fs, hdfsFile file, const void * buffer, tSize length);

/**
 * hdfsWrite - Flush the data.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsFlush(hdfsFS fs, hdfsFile file);

/**
 * hdfsHFlush - Flush out the data in client's user buffer. After the
 * return of this call, new readers will see the data.
 * @param fs configured filesystem handle
 * @param file file handle
 * @return 0 on success, -1 on error and sets errno
 */
int hdfsHFlush(hdfsFS fs, hdfsFile file);

/**
 * hdfsSync - Flush out and sync the data in client's user buffer. After the
 * return of this call, new readers will see the data.
 * @param fs configured filesystem handle
 * @param file file handle
 * @return 0 on success, -1 on error and sets errno
 */
int hdfsSync(hdfsFS fs, hdfsFile file);

/**
 * hdfsAvailable - Number of bytes that can be read from this
 * input stream without blocking.
 * @param fs The configured filesystem handle.
 * @param file The file handle.
 * @return Returns available bytes; -1 on error.
 */
int hdfsAvailable(hdfsFS fs, hdfsFile file);

/**
 * hdfsCopy - Copy file from one filesystem to another.
 * @param srcFS The handle to source filesystem.
 * @param src The path of source file.
 * @param dstFS The handle to destination filesystem.
 * @param dst The path of destination file.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsCopy(hdfsFS srcFS, const char * src, hdfsFS dstFS, const char * dst);

/**
 * hdfsMove - Move file from one filesystem to another.
 * @param srcFS The handle to source filesystem.
 * @param src The path of source file.
 * @param dstFS The handle to destination filesystem.
 * @param dst The path of destination file.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsMove(hdfsFS srcFS, const char * src, hdfsFS dstFS, const char * dst);

/**
 * hdfsDelete - Delete file.
 * @param fs The configured filesystem handle.
 * @param path The path of the file.
 * @param recursive if path is a directory and set to
 * non-zero, the directory is deleted else throws an exception. In
 * case of a file the recursive argument is irrelevant.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsDelete(hdfsFS fs, const char * path, int recursive);

/**
 * hdfsRename - Rename file.
 * @param fs The configured filesystem handle.
 * @param oldPath The path of the source file.
 * @param newPath The path of the destination file.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsRename(hdfsFS fs, const char * oldPath, const char * newPath);

/**
 * hdfsGetWorkingDirectory - Get the current working directory for
 * the given filesystem.
 * @param fs The configured filesystem handle.
 * @param buffer The user-buffer to copy path of cwd into.
 * @param bufferSize The length of user-buffer.
 * @return Returns buffer, NULL on error.
 */
char * hdfsGetWorkingDirectory(hdfsFS fs, char * buffer, size_t bufferSize);

/**
 * hdfsSetWorkingDirectory - Set the working directory. All relative
 * paths will be resolved relative to it.
 * @param fs The configured filesystem handle.
 * @param path The path of the new 'cwd'.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsSetWorkingDirectory(hdfsFS fs, const char * path);

/**
 * hdfsCreateDirectory - Make the given file and all non-existent
 * parents into directories.
 * @param fs The configured filesystem handle.
 * @param path The path of the directory.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsCreateDirectory(hdfsFS fs, const char * path);

/**
 * hdfsSetReplication - Set the replication of the specified
 * file to the supplied value
 * @param fs The configured filesystem handle.
 * @param path The path of the file.
 * @return Returns 0 on success, -1 on error.
 */
int hdfsSetReplication(hdfsFS fs, const char * path, int16_t replication);

/**
 * hdfsEncryptionZoneInfo- Information about an encryption zone.
 */
typedef struct {
    int mSuite; /* the suite of encryption zone */
    int mCryptoProtocolVersion; /* the version of crypto protocol */
    int64_t mId; /* the id of encryption zone */
    char * mPath; /* the path of encryption zone */
    char * mKeyName; /* the key name of encryption zone */
} hdfsEncryptionZoneInfo;

/**
 * hdfsEncryptionFileInfo - Information about an encryption file/directory.
 */
typedef struct {
    int mSuite; /* the suite of encryption file/directory */
    int mCryptoProtocolVersion; /* the version of crypto protocol */
    char * mKey; /* the key of encryption file/directory */
    char * mKeyName; /* the key name of encryption file/directory */
    char * mIv; /* the iv of encryption file/directory */
    char * mEzKeyVersionName; /* the version encryption file/directory */
} hdfsEncryptionFileInfo;

/**
 * hdfsFileInfo - Information about a file/directory.
 */
typedef struct {
    tObjectKind mKind; /* file or directory */
    char * mName; /* the name of the file */
    tTime mLastMod; /* the last modification time for the file in seconds */
    tOffset mSize; /* the size of the file in bytes */
    short mReplication; /* the count of replicas */
    tOffset mBlockSize; /* the block size for the file */
    char * mOwner; /* the owner of the file */
    char * mGroup; /* the group associated with the file */
    short mPermissions; /* the permissions associated with the file */
    tTime mLastAccess; /* the last access time for the file in seconds */
    hdfsEncryptionFileInfo * mHdfsEncryptionFileInfo; /* the encryption info of the file/directory */
} hdfsFileInfo;

/**
 * hdfsListDirectory - Get list of files/directories for a given
 * directory-path. hdfsFreeFileInfo should be called to deallocate memory.
 * @param fs The configured filesystem handle.
 * @param path The path of the directory.
 * @param numEntries Set to the number of files/directories in path.
 * @return Returns a dynamically-allocated array of hdfsFileInfo
 * objects; NULL on error.
 */
hdfsFileInfo * hdfsListDirectory(hdfsFS fs, const char * path, int * numEntries);

/**
 * hdfsGetPathInfo - Get information about a path as a (dynamically
 * allocated) single hdfsFileInfo struct. hdfsFreeFileInfo should be
 * called when the pointer is no longer needed.
 * @param fs The configured filesystem handle.
 * @param path The path of the file.
 * @return Returns a dynamically-allocated hdfsFileInfo object;
 * NULL on error.
 */
hdfsFileInfo * hdfsGetPathInfo(hdfsFS fs, const char * path);

/**
 * hdfsFreeFileInfo - Free up the hdfsFileInfo array (including fields)
 * @param infos The array of dynamically-allocated hdfsFileInfo
 * objects.
 * @param numEntries The size of the array.
 */
void hdfsFreeFileInfo(hdfsFileInfo * infos, int numEntries);

/**
 * hdfsFreeEncryptionZoneInfo - Free up the hdfsEncryptionZoneInfo array (including fields)
 * @param infos The array of dynamically-allocated hdfsEncryptionZoneInfo
 * objects.
 * @param numEntries The size of the array.
 */
void hdfsFreeEncryptionZoneInfo(hdfsEncryptionZoneInfo * infos, int numEntries);

/**
 * hdfsGetHosts - Get hostnames where a particular block (determined by
 * pos & blocksize) of a file is stored. The last element in the array
 * is NULL. Due to replication, a single block could be present on
 * multiple hosts.
 * @param fs The configured filesystem handle.
 * @param path The path of the file.
 * @param start The start of the block.
 * @param length The length of the block.
 * @return Returns a dynamically-allocated 2-d array of blocks-hosts;
 * NULL on error.
 */
char ***hdfsGetHosts(hdfsFS fs, const char *path, tOffset start,
                     tOffset length);

/**
 * hdfsFreeHosts - Free up the structure returned by hdfsGetHosts
 * @param hdfsFileInfo The array of dynamically-allocated hdfsFileInfo
 * objects.
 * @param numEntries The size of the array.
 */
void hdfsFreeHosts(char ***blockHosts);

/**
 * hdfsGetDefaultBlockSize - Get the default blocksize.
 *
 * @param fs            The configured filesystem handle.
 * @deprecated          Use hdfsGetDefaultBlockSizeAtPath instead.
 *
 * @return              Returns the default blocksize, or -1 on error.
 */
tOffset hdfsGetDefaultBlockSize(hdfsFS fs);

/**
 * hdfsGetCapacity - Return the raw capacity of the filesystem.
 * @param fs The configured filesystem handle.
 * @return Returns the raw-capacity; -1 on error.
 */
tOffset hdfsGetCapacity(hdfsFS fs);

/**
 * hdfsGetUsed - Return the total raw size of all files in the filesystem.
 * @param fs The configured filesystem handle.
 * @return Returns the total-size; -1 on error.
 */
tOffset hdfsGetUsed(hdfsFS fs);

/**
 * Change the user and/or group of a file or directory.
 *
 * @param fs            The configured filesystem handle.
 * @param path          the path to the file or directory
 * @param owner         User string.  Set to NULL for 'no change'
 * @param group         Group string.  Set to NULL for 'no change'
 * @return              0 on success else -1
 */
int hdfsChown(hdfsFS fs, const char * path, const char * owner,
              const char * group);

/**
 * hdfsChmod
 * @param fs The configured filesystem handle.
 * @param path the path to the file or directory
 * @param mode the bitmask to set it to
 * @return 0 on success else -1
 */
int hdfsChmod(hdfsFS fs, const char * path, short mode);

/**
 * hdfsUtime
 * @param fs The configured filesystem handle.
 * @param path the path to the file or directory
 * @param mtime new modification time or -1 for no change
 * @param atime new access time or -1 for no change
 * @return 0 on success else -1
 */
int hdfsUtime(hdfsFS fs, const char * path, tTime mtime, tTime atime);

/**
 * hdfsTruncate - Truncate the file in the indicated path to the indicated size.
 * @param fs The configured filesystem handle.
 * @param path the path to the file.
 * @param pos the position the file will be truncated to.
 * @param shouldWait output value, true if and client does not need to wait for block recovery,
 * false if client needs to wait for block recovery.
 */
int hdfsTruncate(hdfsFS fs, const char * path, tOffset pos, int * shouldWait);

/**
 * Get a delegation token from namenode.
 * The token should be freed using hdfsFreeDelegationToken after canceling the token or token expired.
 *
 * @param fs The file system
 * @param renewer The user who will renew the token
 *
 * @return Return a delegation token, NULL on error.
 */
char * hdfsGetDelegationToken(hdfsFS fs, const char * renewer);

/**
 * Free a delegation token.
 *
 * @param token The token to be freed.
 */
void hdfsFreeDelegationToken(char * token);

/**
 * Renew a delegation token.
 *
 * @param fs The file system.
 * @param token The token to be renewed.
 *
 * @return the new expiration time
 */
int64_t hdfsRenewDelegationToken(hdfsFS fs, const char * token);

/**
 * Cancel a delegation token.
 *
 * @param fs The file system.
 * @param token The token to be canceled.
 *
 * @return return 0 on success, -1 on error.
 */
int hdfsCancelDelegationToken(hdfsFS fs, const char * token);

typedef struct Namenode {
    char * rpc_addr;    // namenode rpc address and port, such as "host:8020"
    char * http_addr;   // namenode http address and port, such as "host:50070"
} Namenode;

/**
 * If hdfs is configured with HA namenode, return all namenode informations as an array.
 * Else return NULL.
 *
 * Using configure file which is given by environment parameter LIBHDFS3_CONF
 * or "hdfs-client.xml" in working directory.
 *
 * @param nameservice hdfs name service id.
 * @param size output the size of returning array.
 *
 * @return return an array of all namenode information.
 */
Namenode * hdfsGetHANamenodes(const char * nameservice, int * size);

/**
 * If hdfs is configured with HA namenode, return all namenode informations as an array.
 * Else return NULL.
 *
 * @param conf the path of configure file.
 * @param nameservice hdfs name service id.
 * @param size output the size of returning array.
 *
 * @return return an array of all namenode information.
 */
Namenode * hdfsGetHANamenodesWithConfig(const char * conf, const char * nameservice, int * size);

/**
 * Free the array returned by hdfsGetConfiguredNamenodes()
 *
 * @param the array return by hdfsGetConfiguredNamenodes()
 */
void hdfsFreeNamenodeInformation(Namenode * namenodes, int size);

typedef struct BlockLocation {
    int corrupt;            // If the block is corrupt
    int numOfNodes;         // Number of Datanodes which keep the block
    char ** hosts;          // Datanode hostnames
    char ** names;          // Datanode IP:xferPort for accessing the block
    char ** topologyPaths;  // Full path name in network topology
    tOffset length;         // block length, may be 0 for the last block
    tOffset offset;         // Offset of the block in the file
} BlockLocation;

/**
 * Get an array containing hostnames, offset and size of portions of the given file.
 *
 * @param fs The file system
 * @param path The path to the file
 * @param start The start offset into the given file
 * @param length The length for which to get locations for
 * @param numOfBlock Output the number of elements in the returned array
 *
 * @return An array of BlockLocation struct.
 */
BlockLocation * hdfsGetFileBlockLocations(hdfsFS fs, const char * path,
        tOffset start, tOffset length, int * numOfBlock);

/**
 * Free the BlockLocation array returned by hdfsGetFileBlockLocations
 *
 * @param locations The array returned by hdfsGetFileBlockLocations
 * @param numOfBlock The number of elements in the locaitons
 */
void hdfsFreeFileBlockLocations(BlockLocation * locations, int numOfBlock);

/**
 * Create encryption zone for the directory with specific key name
 * @param fs The configured filesystem handle.
 * @param path The path of the directory.
 * @param keyname The key name of the encryption zone
 * @return Returns 0 on success, -1 on error.
 */
int hdfsCreateEncryptionZone(hdfsFS fs, const char * path, const char * keyName);

/**
 * hdfsEncryptionZoneInfo - Get information about a path as a (dynamically
 * allocated) single hdfsEncryptionZoneInfo struct. hdfsEncryptionZoneInfo should be
 * called when the pointer is no longer needed.
 * @param fs The configured filesystem handle.
 * @param path The path of the encryption zone.
 * @return Returns a dynamically-allocated hdfsEncryptionZoneInfo object;
 * NULL on error.
 */
hdfsEncryptionZoneInfo * hdfsGetEZForPath(hdfsFS fs, const char * path);

/**
 * hdfsEncryptionZoneInfo -  Get list of all the encryption zones.
 * hdfsFreeEncryptionZoneInfo should be called to deallocate memory.
 * @param fs The configured filesystem handle.
 * @return Returns a dynamically-allocated array of hdfsEncryptionZoneInfo objects;
 * NULL on error.
 */
hdfsEncryptionZoneInfo * hdfsListEncryptionZones(hdfsFS fs, int * numEntries);

#ifdef __cplusplus
}
#endif

#endif /* _HDFS_LIBHDFS3_CLIENT_HDFS_H_ */


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Hysterostoma brevilobi T.S. Ramakr.

### Remarks
null


text:
struct ci_bridge_platform_data {
	int reset_pin;
	int interrupt_pin;
};

#endif


text:
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using N3P.MVVM.Undo;

namespace N3P.MVVM.Dirty
{
    public class DirtyableService: IInitializationCompleteCallback
    {
        private readonly IServiceProviderProvider _model;

        internal DirtyableService(IServiceProviderProvider model)
        {
            _model = model;
        }

        public bool IsDirty { get; private set; }
        public IExportedState CleanVersion { get; private set; }

        public void MarkDirty()
        {
            MarkDirtyInternal();
        }

        private void MarkDirtyInternal()
        {
            foreach (var parent in _model.Parents)
            {
                var svc = parent.GetService<DirtyableService>();

                if (svc != null)
                {
                    svc.MarkDirtyInternal();
                }
            }

            var s = _model.GetService<DirtyableService>();
            var oldDirty = s.IsDirty;
            s.IsDirty = true;

            if (oldDirty ^ s.IsDirty)
            {
                s.OnDirtyStateChanged();
            }
        }

        private void CleanInternal()
        {
            foreach (var child in _model.Children)
            {
                var svc = child.GetService<DirtyableService>();

                if (svc != null)
                {
                    svc.CleanInternal();
                }
            }

            var s = _model.GetService<DirtyableService>();
            var oldDirty = s.IsDirty;
            s.IsDirty = false;

            if (oldDirty ^ s.IsDirty)
            {
                s.OnDirtyStateChanged();
            }

            SetCleanVersion();
        }

        public void Clean()
        {
            CleanInternal();
        }

        private void OnDirtyStateChanged()
        {
            var handler = DirtyStateChanged;

            if (handler != null)
            {
                handler(this, new EventArgs());
            }
        }

        public event EventHandler DirtyStateChanged;

        internal readonly Dictionary<INotifyCollectionChanged, NotifyCollectionChangedEventHandler> CollectionChangeHandlers = new Dictionary<INotifyCollectionChanged, NotifyCollectionChangedEventHandler>();

        public void OnInitializationComplete()
        {
            Clean();
        }

        internal void SetCleanVersion()
        {
            CleanVersion = ((IExportStateRestorer)_model).ExportState();
        }
    }
}


text:
package car.app.maintain;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import car.domain.maintain.MaintainFacade;
import car.domain.maintain.RegisterExeception;
import car.domain.maintain.RegisterVO;

@Service
public class RegisterAppService {

	@Autowired
	private MaintainFacade maintainFacade;

	@Transactional(readOnly = false)
	public void create(RegisterAppVO register) throws RegisterExeception {
		// ´´½¨Î¬Ð޵Ǽǵ¥
		RegisterVO registerVO = new RegisterVO();
		BeanUtils.copyProperties(register, registerVO);
		maintainFacade.createRegister(registerVO);

	}

	@Transactional(readOnly = true)
	public RegisterAppVO obtain(String registerId) {
		return new RegisterAppVO(maintainFacade.obtainRegister(registerId));
	}

	@Transactional(readOnly = true)
	public RegisterAppVO obtainByVehicleNumber(String vehicleNumber) {
		return new RegisterAppVO(maintainFacade
				.obtainByVehicleNumber(vehicleNumber));
	}

}


text:
using System;
using System.Collections.Generic;
using Hexpoint.Blox.Hosts.World;
using Hexpoint.Blox.GameObjects.Units;
using Hexpoint.Blox.GameActions;
using Hexpoint.Blox;
using Hexpoint.Blox.Hosts;
using OpenTK;
using Hexpoint.Blox.GameObjects.GameItems;

namespace AiKnowledgeEngine
{
    internal class Tasks
    {
        public Tasks ()
        {
            tasks = new List<BaseTaskItem> ();
        }

        internal void Add (BaseTaskItem item)
        {
            tasks.Add (item);
        }

        internal void DoTask (Character chr, FrameEventArgs e)
        {
            if (tasks.Count > 0)
            {
                tasks [tasks.Count - 1].DoTask (chr, e);
            }
        }

        public void Remove (BaseTaskItem item)
        {
            tasks.Remove (item);
        }

        private List<BaseTaskItem> tasks;
    }

    internal abstract class BaseTaskItem
    {
        internal abstract void DoTask (Character chr, FrameEventArgs e);
    }

    internal class GotoTask : BaseTaskItem
    {
        internal GotoTask(Position destination)
        {
            this.destination = destination;
        }

        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Console.WriteLine ("{0}:Finding path to {1}", chr.Id, destination);
            List<Position> route = null;

            route = chr.path.FindPath(chr.Position, destination, chr.knowledge, 10000);
            if (route == null)
            {
                Console.WriteLine ("{0}:Can't find route to target", chr.Id);
                // TODO - what?
                return;
            }
            chr.RemoveTask (this);
            chr.AddTask (new MoveToTask (route));
        }

        private Position destination;
    }

    internal class MoveToTask : BaseTaskItem
    {
        internal MoveToTask (List<Position> route)
        {
            this.route = route;
            index = route.Count - 1;
        }

        private List<Position> route;
        private int index;

        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Position moveTo = route [index];
            if (moveTo.GetBlock().IsSolid)
            {
                Console.WriteLine ("{0}:Route blocked", chr.Id);
                chr.RemoveTask (this);
            }
            else
            {
                //Console.WriteLine ("Moving to {0}", moveTo);
                chr.MoveTo (moveTo, e);

                if (chr.Position == moveTo)
                {
					//Console.WriteLine ("Moved to {0}", moveTo);
                    index--;
                }
                if (index == 0)
                {
                    Console.WriteLine ("{0}:At destination", chr.Id);
                    chr.RemoveTask (this);
				}
            }
        }
    }

//    internal class SearchTask : ITaskItem
//    {
//        internal void DoTask (Character chr)
//        {
//            Console.WriteLine ("Searching");
//
//            List<Position> route = chr.path.FindPathToNearest (chr.Position, loc => loc.Type == Block.BlockType.);
//            if (route.Count <= 1)
//            {
//                Console.WriteLine ("Don't know where to go?");
//                return;
//            }
//
    //            chr.AddTask (new MoveToTask (route));
//        }
//    }

	internal class WaitTask : BaseTaskItem
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="AiKnowledgeEngine.WaitTask"/> class.
		/// </summary>
		/// <param name='waitTime'>
		/// Wait time in seconds.
		/// </param>
		internal WaitTask (double waitTime)
		{
            this.waitTime = waitTime * 1000;
		}

		internal override void DoTask (Character chr, FrameEventArgs e)
		{
			waitTime -= e.Time;
			if (waitTime < 0) {
                chr.RemoveTask (this);
			}
		}

		private double waitTime; // Waittime in ms
	}

    internal class LookAroundTask : BaseTaskItem
    {
        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Console.WriteLine ("{0}:Looking around", chr.Id);
			chr.path.FindPaths(chr.Position, chr.knowledge);
            chr.RemoveTask (this);
        }
    }

    internal class GatherItemTask : BaseTaskItem
    {
        internal GatherItemTask(Block.BlockType blockType)
        {
            this.blockType = blockType;
        }

        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Console.WriteLine ("{0}:Collect item", chr.Id);
            List<Position> route = null;

            route = chr.path.FindPaths(chr.Position, chr.knowledge, blockType, 10000);
            /*
            foreach (Position blockPos in chr.knowledge.GetNearestBlocks(blockType, chr.Position))
            {
                 route = chr.path.FindPath(chr.Position, blockPos);
                 if (route != null)
                 {
                    Console.WriteLine("Found route to nearby item");
                    break;
                 }
            }
            */

            if (route == null)
            {
                Console.WriteLine ("{0}:Can't see any target item, Gather than waiting 10 seconds", chr.Id);

                chr.AddTask (new WaitTask(10));
                chr.AddTask( new LookAroundTask());
                //chr.RemoveTask (this);
				//chr.AddTask (new SearchTask ());
				return;
			}
            chr.AddTask (new ChopBlocksAtPosTask(blockType, route[0]));
            chr.AddTask (new MoveToTask (route));
		}

        private Block.BlockType blockType;
    }

	internal class ChopBlocksAtPosTask : BaseTaskItem
    {
        internal ChopBlocksAtPosTask (Block.BlockType blockType, Position position)
        {
			this.blockType = blockType;
			this.position = position;
        }

		private Block.BlockType blockType;
		private Position position;

        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Console.WriteLine ("{0}:ChopBlocksAtPosTask {1}", chr.Id, position);
            foreach (Position pos in chr.path.NeighbourBlocks(position))
            {
                if (pos.GetBlock().Type == blockType)
			    {
                    chr.AddTask (new ChopBlockTask(blockType, pos));
                }
            }
            chr.RemoveTask (this);
        }
	}

    internal class ChopBlockTask : BaseTaskItem
    {
        internal ChopBlockTask (Block.BlockType blockType, Position position)
        {
            this.blockType = blockType;
            this.position = position;
        }

        private Block.BlockType blockType;
        private Position position;

        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            if (position.GetBlock().Type == blockType)
            {
                Console.WriteLine ("{0}:Chopping {1}", chr.Id, blockType);
                AddOrRemoveBlock(chr, position, Block.BlockType.Air); // replace with air
            }
            chr.RemoveTask (this);
        }

        private void AddOrRemoveBlock(Character chr, Position position, Block.BlockType blockType)
        {
            if (!position.IsValidBlockLocation)
            {
                Console.WriteLine("{0}:Invalid block location", chr.Id);
                return;
            }

            NetworkClient.SendAddOrRemoveBlock(position, blockType);
        }

    }

    internal class BuildConstructionTask : BaseTaskItem
    {
        internal BuildConstructionTask(string blueprint)
        {
            this.blueprint = blueprint;
        }

        private string blueprint;
        private Dictionary<Position, Block.BlockType> blocks;
        internal override void DoTask (Character chr, FrameEventArgs e)
        {
            Console.WriteLine ("{0}:Building {1}", chr.Id, blueprint);
            blocks = Construction.Instance.GetConstruction(blueprint);
            if (blocks == null)
            {
                chr.AddTask (new WaitTask(10));
            }

            // TODO
            chr.RemoveTask (this);
        }
    }
}


text:
package perffmwk;

import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.Collection;
import java.util.Vector;

/**
 * Contains common code used to format reports.
 */
public class Formatter {

  /**
   * The width (in characters) of the report output.
   *
   * @see #center(String, PrintWriter)
   */
  protected static final int WIDTH = 80;

  protected static final String DIVIDER =
      "================================================================================";
  protected static final String SUBDIVIDER =
      "--------------------------------------------------------------------------------";

  /**
   * Centers the given string on the PrintWriter
   *
   * @param s the string to center
   * @param pw the PrintWriter to print with
   */
  public static void center(String s, PrintWriter pw) {
    int indent = (WIDTH / 2) - (s.length() / 2);
    for (int i = 0; i < indent; i++) {
      pw.print(" ");
    }
    pw.println(s);
  }

  /*
   * Returns a collection of decimals based on the given collection but with the doubles formatted
   * according to the pattern. String values are ignored.
   */
  public static Vector formatDecimal(Collection c, String pattern) {
    DecimalFormat f = new DecimalFormat(pattern);
    Vector v = new Vector();
    for (Object o : c) {
      if (o instanceof Double) {
        v.add(f.format(o));
      } else {
        v.add(o);
      }
    }
    return v;
  }

  /*
   * Returns a collection of doubles based on the given collection but with the doubles formatted
   * according to the pattern and all entries, both doubles and string, padded on the left to the
   * length of the longest one.
   */
  public static Vector padLeft(Collection doubles, String pattern) {
    return padLeft(formatDecimal(doubles, pattern));
  }

  /*
   * Returns a collection of doubles based on the given collection but with the doubles formatted
   * according to the pattern and all entries, both doubles and string, padded on the right to the
   * length of the longest one.
   */
  public static Vector padRight(Collection doubles, String pattern) {
    return padRight(formatDecimal(doubles, pattern));
  }

  /*
   * Returns a collection of strings based on the given collection but with all strings padded on
   * the left to the length of the longest one.
   */
  public static Vector padLeft(Collection strings) {
    Vector v = new Vector();
    int length = maxLength(strings);
    for (final Object o : strings) {
      String string = (String) o;
      v.add(padLeft(string, length));
    }
    return v;
  }

  /*
   * Returns a collection of strings based on the given collection but with all strings padded on
   * the right to the length of the longest one.
   */
  public static Vector padRight(Collection strings) {
    Vector v = new Vector();
    int length = maxLength(strings);
    for (final Object o : strings) {
      String string = (String) o;
      v.add(padRight(string, length));
    }
    return v;
  }

  /*
   * Returns a string that is the given string padded on the left to the given length.
   */
  public static String padLeft(String s, int length) {
    if (s.length() > length) {
      throw new RuntimeException(s + " cannot be padded to length " + length + ", it is too long");
    }
    String t = "";
    for (int i = 0; i < length - s.length(); i++) {
      t += " ";
    }
    return t + s;
  }

  /*
   * Returns a string that is the given string padded on the right to the given length.
   */
  public static String padRight(String s, int length) {
    if (s.length() > length) {
      throw new RuntimeException(s + " cannot be padded to length " + length + ", it is too long");
    }
    String t = s;
    for (int i = 0; i < length - s.length(); i++) {
      t += " ";
    }
    return t;
  }

  /*
   * Returns the length of the longest string in the collection (0 if the collection is empty).
   */
  public static int maxLength(Collection strings) {
    int max = 0;
    for (final Object o : strings) {
      String string = (String) o;
      max = Math.max(max, string.length());
    }
    return max;
  }
}


text:
"use strict";

function Game(gameRootSprite) {
    this.rootSprite = gameRootSprite;
    this.activated = false;
    this.inputActivated = false;
    this.level = 0;
    this.score = 0;
    this.earlyWin = false;
}

Game.prototype = Object.create(null);
Game.prototype.constructor = Game;

Object.defineProperties(Game.prototype, {
    showLevel: {
        value: true
    },
    showScore: {
        value: true
    },
    showWinOverlay: {
        value: false
    },

    update: {
        value: function update() {
        }
    },

    init: {
        value: function init(gameDescriptor) {
            this.title = gameDescriptor.title;
            this.help = gameDescriptor.help;
            this.titleImage = gameDescriptor.titleImage;
        }
    },

    activate: {
        value: function activate() {
            this.activated = true;
            this.earlyWin = false;
            this.bonusFrames = 0;
            this.bonusScore = 0;
            // Long running games will likely have additional state controlling where they are in the game.
            // Short running games will want to initialize their next level here.
        }
    },
    inputActivate: {
        value: function inputActivate(activationContext) {
            // Attach event handlers here and start playing the game. Should be called before any updates.
            this.inputActivated = true;
        }
    },
    deactivate: {
        value: function deactivate() {
            this.earlyWin = false;
            this.activated = false;
            this.inputActivated = false;
            this.score += this.bonusScore;

            // Long running games will likely ignore this state.
            // Short running games will clean up any resources they've allocated.

            // Return true for continue playing, return false to say this game has ended
            return true;
        }
    },

    getLeaderboardScore: {
        value: function getLeaderboardScore() {
        }
    }
});

// To Export
function isInView(x, y, border) {
    if (typeof border === 'undefined') border = 0;
    return (x > GlobalRuleSet.GameMinX + border &&
            x < GlobalRuleSet.GameMinX + GlobalRuleSet.GameWidth - border &&
            y > GlobalRuleSet.GameMinY +border &&
            y < GlobalRuleSet.GameMinY + GlobalRuleSet.GameHeight - border);
}


text:
class CorrectionService(object):

    def __init__(self, dictionary):
        self.dictionary = dictionary
        self.n = sum(self.dictionary.values())

    def probability(self, word):
        return self.dictionary[word] / self.n

    def correction(self, word):
        return max(
            self.candidates(word),
            key=lambda x: self.probability(word)
        )

    def candidates(self, word):
        return (
            self.known([word]) or
            self.known(self.edits1(word)) or
            self.known(self.edits2(word)) or
            [word]
        )

    def known(self, words):
        return set(w for w in words if w in self.dictionary)

    def edits1(self, word):
        letters = 'abcdefghijklmnopqrstuvwxyz'
        splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]
        deletes = [L + R[1:] for L, R in splits if R]
        transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R) > 1]
        replaces = [L + c + R[1:] for L, R in splits if R for c in letters]
        inserts = [L + c + R for L, R in splits for c in letters]
        return set(deletes + transposes + replaces + inserts)

    def edits2(self, word):
        return (e2 for e1 in self.edits1(word) for e2 in self.edits1(e1))


text:
layout: category-index
title: Guides
category: guides
---


text:
<?php

namespace Bolt\Storage\Database\Schema\Comparison;

use Doctrine\DBAL\Schema\TableDiff;

/**
 * Comparison handling for Sqlite platforms.
 *
 * @author Gawain Lynch <gawain.lynch@gmail.com>
 */
class Sqlite extends BaseComparator
{
    /** @var string */
    protected $platform = 'sqlite';

    /**
     * {@inheritDoc}
     */
    protected function setIgnoredChanges()
    {
        $this->ignoredChanges[] = new IgnoredChange('changedColumns', 'type', 'date', 'date');
        $this->ignoredChanges[] = new IgnoredChange('changedColumns', 'type', 'datetime', 'datetime');
        $this->ignoredChanges[] = new IgnoredChange('changedColumns', 'type', 'string', 'guid');
        $this->ignoredChanges[] = new IgnoredChange('changedColumns', 'type', 'text', 'json_array');
    }

    /**
     * {@inheritDoc}
     */
    protected function removeIgnoredChanges(TableDiff $diff)
    {
    }
}


text:
/* $Id$ */
/*
 * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
 * See the copyright notice in the ACK home directory, in the file "Copyright".
 */
/* Copy t into s
*/

#include "ack_string.h"

char *
strcpy(s, t)
	register char *s;
	register _CONST char *t;
{
	register char *b = s;

	while (*s++ = *t++)
		;
	return b;
}


text:
package org.assertj.core.util;

import static java.io.File.separator;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.util.Strings.append;

import org.junit.jupiter.api.Test;

/**
 * Tests for <code>{@link Files#temporaryFolderPath()}</code>.
 *
 * @author Alex Ruiz
 * @author Yvonne Wang
 */
class Files_temporaryFolderPath_Test extends Files_TestCase {

  @Test
  void should_find_path_of_temporary_folder() {
    String a = Files.temporaryFolderPath();
    String e = append(separator).to(systemTemporaryFolder());
    assertThat(a).isEqualTo(e);
  }
}


text:
<?php

namespace Princeton\App\Slim;

use League\Container\ReflectionContainer as LeagueContainer;

class ReflectionContainer extends LeagueContainer {
    protected $shared = [];

    public function get($alias, array $args = []) {
        if (isset($this->shared[$alias])) {
            return $this->shared[$alias];
        } else {
            $result = parent::get($alias, $args);

            if (is_string($result)) {
                $result = $this->getContainer()->get($result);
            }

            return $this->shared[$alias] = $result;
        }
    }
}


text:
using System;
using System.Collections;
using System.Threading.Tasks;
using Kentico.Kontent.Delivery.Abstractions;

namespace Kentico.Kontent.Delivery.Tests.DependencyInjectionFrameworks.Helpers
{
    internal class FakeModelProvider : IModelProvider
    {
        public Task<T> GetContentItemModelAsync<T>(object item, IEnumerable modularContent)
            => throw new NotImplementedException();
    }
}


text:
import { AppPage } from './app.po';
import { browser } from 'protractor';

describe('angular-truffle-box meta-sender', () => {
  let page: AppPage;

  beforeEach(() => {
    page = new AppPage();
  });

  it('should transfer money', () => {
    page.navigateTo();
    page.setAddress(0);
    browser.driver.sleep(100);

    expect(page.getBalance()).toBe('10000');

    page.setAmount('50');
    page.setToAddress('0xf17f52151ebef6c7334fad080c5704d77216b732');
    page.clickSend();

    browser.driver.sleep(1000);

    // Auto-refresh is broken in test for some reason
    page.navigateTo();

    expect(page.getBalance()).toBe('9950');
    page.clickSelect();
    page.setAddress(1);
    browser.driver.sleep(100);
    expect(page.getBalance()).toBe('50');
  });
});


text:
package com.gentics.mesh.core.image;

/**
 * Entry for image cache file information.
 */
public class CacheFileInfo {

	public final String path;
	public final boolean exists;

	public CacheFileInfo(String path, boolean exists) {
		this.path = path;
		this.exists = exists;
	}
}


text:
<?php

// Custom post types

/*--------------------------*/
/*  Beers
/*--------------------------*/

function beer_title( $title ){
  $screen = get_current_screen();

  if  ( 'beer' == $screen->post_type ) {
    $title = 'Enter Beer Name';
  }

  return $title;
}

add_filter( 'enter_title_here', 'beer_title' ); //filters title

//Menus Section
add_action( 'init', 'beer' );
function beer() {
  $labels = array(
    'name' => _x('Beers', 'post type general name'),
    'singular_name' => _x('Beer', 'post type singular name'),
    'add_new' => _x('Add New', 'beer'),
    'add_new_item' => __('Add New Beer'),
    'edit_item' => __('Edit Beer'),
    'new_item' => __('New Beer'),
    'all_items' => __('All Beers'),
    'view_item' => __('View Beer'),
    'search_items' => __('Search Beers'),
    'not_found' =>  __('No Beers, womp womp.'),
    'not_found_in_trash' => __('No Beers found in Trash'),
    'parent_item_colon' => '',
    'menu_name' => 'Beers'

    );
  $args = array(
    'labels' => $labels,
    'public' => true,
    'publicly_queryable' => true,
    'show_ui' => true,
    'show_in_menu' => true,
    'show_in_nav_menus' => true,
    'query_var' => true,
    'rewrite' => true,
    'capability_type' => 'post',
    'has_archive' => true,
    'hierarchical' => true,
    'menu_position' => 51,
    'menu_icon' => 'dashicons-visibility',
    'supports' => array( 'title', 'editor', 'thumbnail', 'page-attributes' )
    );
  register_post_type('beer',$args);
}

//add filter to ensure the menu is displayed when user updates a menu
add_filter( 'post_updated_messages', 'codex_beer_updated_messages' );
function codex_beer_updated_messages( $messages ) {
  global $post, $post_ID;

  $messages['beer'] = array(
  0 => '', // Unused. Messages start at index 1.
  1 => sprintf( __('beer updated.'), esc_url( get_permalink($post_ID) ) ),
  2 => __('Custom field updated.'),
  3 => __('Custom field deleted.'),
  4 => __('beer updated.'),
  /* translators: %s: date and time of the revision */
  5 => isset($_GET['revision']) ? sprintf( __('beer restored to revision from %s'), wp_post_revision_title( (int) $_GET['revision'], false ) ) : false,
  6 => sprintf( __('beer added.'), esc_url( get_permalink($post_ID) ) ),
  7 => __('beer saved.'),
  8 => sprintf( __('beer submitted.'), esc_url( add_query_arg( 'preview', 'true', get_permalink($post_ID) ) ) ),
  9 => sprintf( __('beer scheduled for: %1$s.'),
  // translators: Publish box date format, see http://php.net/date
    date_i18n( __( 'M j, Y @ G:i' ), strtotime( $post->post_date ) ), esc_url( get_permalink($post_ID) ) ),
  10 => sprintf( __('beer draft updated.'), esc_url( add_query_arg( 'preview', 'true', get_permalink($post_ID) ) ) ),
  );

return $messages;
}

//display contextual help for beers
add_action( 'contextual_help', 'codex_add_help_text_beer', 10, 3 );

function codex_add_help_text_beer( $contextual_help, $screen_id, $screen ) {
  //$contextual_help .= var_dump( $screen ); // use this to help determine $screen->id
  if ( 'beer' == $screen->id ) {
    $contextual_help =
    '
' . __('Things to remember when adding or editing a beer:') . '
' .
    '
' .
    '
' . __('Give it a short and sweet title.') . '
' .
    '
' .
    '
' . __('If you want to schedule the beer to be published in the future:') . '
' .
    '
' .
    '
' . __('Under the Publish module, click on the Edit link next to Publish.') . '
' .
    '
' . __('Change the date to a future date to publish this beer, then click on OK.') . '
' .
    '
' .
    '
' . __('For more information:') . '
' .
    '
' . __('Email Me') . '
' ;
  }
  return $contextual_help;
}

/*--------------------------*/
/*  Events
/*--------------------------*/

function event_title( $title ){
  $screen = get_current_screen();

  if  ( 'event' == $screen->post_type ) {
    $title = 'Enter Event Title';
  }

  return $title;
}

add_filter( 'enter_title_here', 'event_title' ); //filters title

//Menus Section
add_action( 'init', 'event' );
function event() {
  $labels = array(
    'name' => _x('Events', 'post type general name'),
    'singular_name' => _x('Event', 'post type singular name'),
    'add_new' => _x('Add New', 'event'),
    'add_new_item' => __('Add New Event'),
    'edit_item' => __('Edit Event'),
    'new_item' => __('New Event'),
    'all_items' => __('All Events'),
    'view_item' => __('View Event'),
    'search_items' => __('Search Events'),
    'not_found' =>  __('No Events, womp womp.'),
    'not_found_in_trash' => __('No Events found in Trash'),
    'parent_item_colon' => '',
    'menu_name' => 'Events'

    );
  $args = array(
    'labels' => $labels,
    'public' => true,
    'publicly_queryable' => true,
    'show_ui' => true,
    'show_in_menu' => true,
    'show_in_nav_menus' => true,
    'query_var' => true,
    'rewrite' => true,
    'capability_type' => 'post',
    'has_archive' => true,
    'hierarchical' => true,
    'menu_position' => 52,
    'menu_icon' => 'dashicons-calendar',
    'supports' => array( 'title', 'editor', 'page-attributes' )
    );
  register_post_type('event',$args);
}

//add filter to ensure the menu is displayed when user updates a menu
add_filter( 'post_updated_messages', 'codex_event_updated_messages' );
function codex_event_updated_messages( $messages ) {
  global $post, $post_ID;

  $messages['event'] = array(
  0 => '', // Unused. Messages start at index 1.
  1 => sprintf( __('event updated.'), esc_url( get_permalink($post_ID) ) ),
  2 => __('Custom field updated.'),
  3 => __('Custom field deleted.'),
  4 => __('event updated.'),
  /* translators: %s: date and time of the revision */
  5 => isset($_GET['revision']) ? sprintf( __('event restored to revision from %s'), wp_post_revision_title( (int) $_GET['revision'], false ) ) : false,
  6 => sprintf( __('event added.'), esc_url( get_permalink($post_ID) ) ),
  7 => __('event saved.'),
  8 => sprintf( __('event submitted.'), esc_url( add_query_arg( 'preview', 'true', get_permalink($post_ID) ) ) ),
  9 => sprintf( __('event scheduled for: %1$s.'),
  // translators: Publish box date format, see http://php.net/date
    date_i18n( __( 'M j, Y @ G:i' ), strtotime( $post->post_date ) ), esc_url( get_permalink($post_ID) ) ),
  10 => sprintf( __('event draft updated.'), esc_url( add_query_arg( 'preview', 'true', get_permalink($post_ID) ) ) ),
  );

return $messages;
}

//display contextual help for events
add_action( 'contextual_help', 'codex_add_help_text_event', 10, 3 );

function codex_add_help_text_event( $contextual_help, $screen_id, $screen ) {
  //$contextual_help .= var_dump( $screen ); // use this to help determine $screen->id
  if ( 'event' == $screen->id ) {
    $contextual_help =
    '
' . __('Things to remember when adding or editing a event:') . '
' .
    '
' .
    '
' . __('Give it a short and sweet title.') . '
' .
    '
' .
    '
' . __('If you want to schedule the event to be published in the future:') . '
' .
    '
' .
    '
' . __('Under the Publish module, click on the Edit link next to Publish.') . '
' .
    '
' . __('Change the date to a future date to publish this event, then click on OK.') . '
' .
    '
' .
    '
' . __('For more information:') . '
' .
    '
' . __('Email Me') . '
' ;
  }
  return $contextual_help;
}


text:
<?php

/**
 * Service definition for QPXExpress (v1).
 *
 *

 * Lets you find the least expensive flights between an origin and a
 * destination.

 *
 *

 * For more information about this service, see the API
 * Documentation
 *

 *
 * @author Google, Inc.
 */
class Google_Service_QPXExpress extends Google_Service
{

  public $trips;

  /**
   * Constructs the internal representation of the QPXExpress service.
   *
   * @param Google_Client $client
   */
  public function __construct(Google_Client $client)
  {
    parent::__construct($client);
    $this->rootUrl = 'https://www.googleapis.com/';
    $this->servicePath = 'qpxExpress/v1/trips/';
    $this->version = 'v1';
    $this->serviceName = 'qpxExpress';

    $this->trips = new Google_Service_QPXExpress_Trips_Resource(
        $this,
        $this->serviceName,
        'trips',
        array(
          'methods' => array(
            'search' => array(
              'path' => 'search',
              'httpMethod' => 'POST',
              'parameters' => array(),
            ),
          )
        )
    );
  }
}

/**
 * The "trips" collection of methods.
 * Typical usage is:
 *
 *   $qpxExpressService = new Google_Service_QPXExpress(...);
 *   $trips = $qpxExpressService->trips;
 *
 */
class Google_Service_QPXExpress_Trips_Resource extends Google_Service_Resource
{

  /**
   * Returns a list of flights. (trips.search)
   *
   * @param Google_TripsSearchRequest $postBody
   * @param array $optParams Optional parameters.
   * @return Google_Service_QPXExpress_TripsSearchResponse
   */
  public function search(Google_Service_QPXExpress_TripsSearchRequest $postBody, $optParams = array())
  {
    $params = array('postBody' => $postBody);
    $params = array_merge($params, $optParams);
    return $this->call('search', array($params), "Google_Service_QPXExpress_TripsSearchResponse");
  }
}

class Google_Service_QPXExpress_AircraftData extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $code;
  public $kind;
  public $name;

  public function setCode($code)
  {
    $this->code = $code;
  }
  public function getCode()
  {
    return $this->code;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setName($name)
  {
    $this->name = $name;
  }
  public function getName()
  {
    return $this->name;
  }
}

class Google_Service_QPXExpress_AirportData extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $city;
  public $code;
  public $kind;
  public $name;

  public function setCity($city)
  {
    $this->city = $city;
  }
  public function getCity()
  {
    return $this->city;
  }
  public function setCode($code)
  {
    $this->code = $code;
  }
  public function getCode()
  {
    return $this->code;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setName($name)
  {
    $this->name = $name;
  }
  public function getName()
  {
    return $this->name;
  }
}

class Google_Service_QPXExpress_BagDescriptor extends Google_Collection
{
  protected $collection_key = 'description';
  protected $internal_gapi_mappings = array(
  );
  public $commercialName;
  public $count;
  public $description;
  public $kind;
  public $subcode;

  public function setCommercialName($commercialName)
  {
    $this->commercialName = $commercialName;
  }
  public function getCommercialName()
  {
    return $this->commercialName;
  }
  public function setCount($count)
  {
    $this->count = $count;
  }
  public function getCount()
  {
    return $this->count;
  }
  public function setDescription($description)
  {
    $this->description = $description;
  }
  public function getDescription()
  {
    return $this->description;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setSubcode($subcode)
  {
    $this->subcode = $subcode;
  }
  public function getSubcode()
  {
    return $this->subcode;
  }
}

class Google_Service_QPXExpress_CarrierData extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $code;
  public $kind;
  public $name;

  public function setCode($code)
  {
    $this->code = $code;
  }
  public function getCode()
  {
    return $this->code;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setName($name)
  {
    $this->name = $name;
  }
  public function getName()
  {
    return $this->name;
  }
}

class Google_Service_QPXExpress_CityData extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $code;
  public $country;
  public $kind;
  public $name;

  public function setCode($code)
  {
    $this->code = $code;
  }
  public function getCode()
  {
    return $this->code;
  }
  public function setCountry($country)
  {
    $this->country = $country;
  }
  public function getCountry()
  {
    return $this->country;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setName($name)
  {
    $this->name = $name;
  }
  public function getName()
  {
    return $this->name;
  }
}

class Google_Service_QPXExpress_Data extends Google_Collection
{
  protected $collection_key = 'tax';
  protected $internal_gapi_mappings = array(
  );
  protected $aircraftType = 'Google_Service_QPXExpress_AircraftData';
  protected $aircraftDataType = 'array';
  protected $airportType = 'Google_Service_QPXExpress_AirportData';
  protected $airportDataType = 'array';
  protected $carrierType = 'Google_Service_QPXExpress_CarrierData';
  protected $carrierDataType = 'array';
  protected $cityType = 'Google_Service_QPXExpress_CityData';
  protected $cityDataType = 'array';
  public $kind;
  protected $taxType = 'Google_Service_QPXExpress_TaxData';
  protected $taxDataType = 'array';

  public function setAircraft($aircraft)
  {
    $this->aircraft = $aircraft;
  }
  public function getAircraft()
  {
    return $this->aircraft;
  }
  public function setAirport($airport)
  {
    $this->airport = $airport;
  }
  public function getAirport()
  {
    return $this->airport;
  }
  public function setCarrier($carrier)
  {
    $this->carrier = $carrier;
  }
  public function getCarrier()
  {
    return $this->carrier;
  }
  public function setCity($city)
  {
    $this->city = $city;
  }
  public function getCity()
  {
    return $this->city;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setTax($tax)
  {
    $this->tax = $tax;
  }
  public function getTax()
  {
    return $this->tax;
  }
}

class Google_Service_QPXExpress_FareInfo extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $basisCode;
  public $carrier;
  public $destination;
  public $id;
  public $kind;
  public $origin;
  public $private;

  public function setBasisCode($basisCode)
  {
    $this->basisCode = $basisCode;
  }
  public function getBasisCode()
  {
    return $this->basisCode;
  }
  public function setCarrier($carrier)
  {
    $this->carrier = $carrier;
  }
  public function getCarrier()
  {
    return $this->carrier;
  }
  public function setDestination($destination)
  {
    $this->destination = $destination;
  }
  public function getDestination()
  {
    return $this->destination;
  }
  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setOrigin($origin)
  {
    $this->origin = $origin;
  }
  public function getOrigin()
  {
    return $this->origin;
  }
  public function setPrivate($private)
  {
    $this->private = $private;
  }
  public function getPrivate()
  {
    return $this->private;
  }
}

class Google_Service_QPXExpress_FlightInfo extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $carrier;
  public $number;

  public function setCarrier($carrier)
  {
    $this->carrier = $carrier;
  }
  public function getCarrier()
  {
    return $this->carrier;
  }
  public function setNumber($number)
  {
    $this->number = $number;
  }
  public function getNumber()
  {
    return $this->number;
  }
}

class Google_Service_QPXExpress_FreeBaggageAllowance extends Google_Collection
{
  protected $collection_key = 'bagDescriptor';
  protected $internal_gapi_mappings = array(
  );
  protected $bagDescriptorType = 'Google_Service_QPXExpress_BagDescriptor';
  protected $bagDescriptorDataType = 'array';
  public $kilos;
  public $kilosPerPiece;
  public $kind;
  public $pieces;
  public $pounds;

  public function setBagDescriptor($bagDescriptor)
  {
    $this->bagDescriptor = $bagDescriptor;
  }
  public function getBagDescriptor()
  {
    return $this->bagDescriptor;
  }
  public function setKilos($kilos)
  {
    $this->kilos = $kilos;
  }
  public function getKilos()
  {
    return $this->kilos;
  }
  public function setKilosPerPiece($kilosPerPiece)
  {
    $this->kilosPerPiece = $kilosPerPiece;
  }
  public function getKilosPerPiece()
  {
    return $this->kilosPerPiece;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setPieces($pieces)
  {
    $this->pieces = $pieces;
  }
  public function getPieces()
  {
    return $this->pieces;
  }
  public function setPounds($pounds)
  {
    $this->pounds = $pounds;
  }
  public function getPounds()
  {
    return $this->pounds;
  }
}

class Google_Service_QPXExpress_LegInfo extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $aircraft;
  public $arrivalTime;
  public $changePlane;
  public $connectionDuration;
  public $departureTime;
  public $destination;
  public $destinationTerminal;
  public $duration;
  public $id;
  public $kind;
  public $meal;
  public $mileage;
  public $onTimePerformance;
  public $operatingDisclosure;
  public $origin;
  public $originTerminal;
  public $secure;

  public function setAircraft($aircraft)
  {
    $this->aircraft = $aircraft;
  }
  public function getAircraft()
  {
    return $this->aircraft;
  }
  public function setArrivalTime($arrivalTime)
  {
    $this->arrivalTime = $arrivalTime;
  }
  public function getArrivalTime()
  {
    return $this->arrivalTime;
  }
  public function setChangePlane($changePlane)
  {
    $this->changePlane = $changePlane;
  }
  public function getChangePlane()
  {
    return $this->changePlane;
  }
  public function setConnectionDuration($connectionDuration)
  {
    $this->connectionDuration = $connectionDuration;
  }
  public function getConnectionDuration()
  {
    return $this->connectionDuration;
  }
  public function setDepartureTime($departureTime)
  {
    $this->departureTime = $departureTime;
  }
  public function getDepartureTime()
  {
    return $this->departureTime;
  }
  public function setDestination($destination)
  {
    $this->destination = $destination;
  }
  public function getDestination()
  {
    return $this->destination;
  }
  public function setDestinationTerminal($destinationTerminal)
  {
    $this->destinationTerminal = $destinationTerminal;
  }
  public function getDestinationTerminal()
  {
    return $this->destinationTerminal;
  }
  public function setDuration($duration)
  {
    $this->duration = $duration;
  }
  public function getDuration()
  {
    return $this->duration;
  }
  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setMeal($meal)
  {
    $this->meal = $meal;
  }
  public function getMeal()
  {
    return $this->meal;
  }
  public function setMileage($mileage)
  {
    $this->mileage = $mileage;
  }
  public function getMileage()
  {
    return $this->mileage;
  }
  public function setOnTimePerformance($onTimePerformance)
  {
    $this->onTimePerformance = $onTimePerformance;
  }
  public function getOnTimePerformance()
  {
    return $this->onTimePerformance;
  }
  public function setOperatingDisclosure($operatingDisclosure)
  {
    $this->operatingDisclosure = $operatingDisclosure;
  }
  public function getOperatingDisclosure()
  {
    return $this->operatingDisclosure;
  }
  public function setOrigin($origin)
  {
    $this->origin = $origin;
  }
  public function getOrigin()
  {
    return $this->origin;
  }
  public function setOriginTerminal($originTerminal)
  {
    $this->originTerminal = $originTerminal;
  }
  public function getOriginTerminal()
  {
    return $this->originTerminal;
  }
  public function setSecure($secure)
  {
    $this->secure = $secure;
  }
  public function getSecure()
  {
    return $this->secure;
  }
}

class Google_Service_QPXExpress_PassengerCounts extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $adultCount;
  public $childCount;
  public $infantInLapCount;
  public $infantInSeatCount;
  public $kind;
  public $seniorCount;

  public function setAdultCount($adultCount)
  {
    $this->adultCount = $adultCount;
  }
  public function getAdultCount()
  {
    return $this->adultCount;
  }
  public function setChildCount($childCount)
  {
    $this->childCount = $childCount;
  }
  public function getChildCount()
  {
    return $this->childCount;
  }
  public function setInfantInLapCount($infantInLapCount)
  {
    $this->infantInLapCount = $infantInLapCount;
  }
  public function getInfantInLapCount()
  {
    return $this->infantInLapCount;
  }
  public function setInfantInSeatCount($infantInSeatCount)
  {
    $this->infantInSeatCount = $infantInSeatCount;
  }
  public function getInfantInSeatCount()
  {
    return $this->infantInSeatCount;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setSeniorCount($seniorCount)
  {
    $this->seniorCount = $seniorCount;
  }
  public function getSeniorCount()
  {
    return $this->seniorCount;
  }
}

class Google_Service_QPXExpress_PricingInfo extends Google_Collection
{
  protected $collection_key = 'tax';
  protected $internal_gapi_mappings = array(
  );
  public $baseFareTotal;
  protected $fareType = 'Google_Service_QPXExpress_FareInfo';
  protected $fareDataType = 'array';
  public $fareCalculation;
  public $kind;
  public $latestTicketingTime;
  protected $passengersType = 'Google_Service_QPXExpress_PassengerCounts';
  protected $passengersDataType = '';
  public $ptc;
  public $refundable;
  public $saleFareTotal;
  public $saleTaxTotal;
  public $saleTotal;
  protected $segmentPricingType = 'Google_Service_QPXExpress_SegmentPricing';
  protected $segmentPricingDataType = 'array';
  protected $taxType = 'Google_Service_QPXExpress_TaxInfo';
  protected $taxDataType = 'array';

  public function setBaseFareTotal($baseFareTotal)
  {
    $this->baseFareTotal = $baseFareTotal;
  }
  public function getBaseFareTotal()
  {
    return $this->baseFareTotal;
  }
  public function setFare($fare)
  {
    $this->fare = $fare;
  }
  public function getFare()
  {
    return $this->fare;
  }
  public function setFareCalculation($fareCalculation)
  {
    $this->fareCalculation = $fareCalculation;
  }
  public function getFareCalculation()
  {
    return $this->fareCalculation;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setLatestTicketingTime($latestTicketingTime)
  {
    $this->latestTicketingTime = $latestTicketingTime;
  }
  public function getLatestTicketingTime()
  {
    return $this->latestTicketingTime;
  }
  public function setPassengers(Google_Service_QPXExpress_PassengerCounts $passengers)
  {
    $this->passengers = $passengers;
  }
  public function getPassengers()
  {
    return $this->passengers;
  }
  public function setPtc($ptc)
  {
    $this->ptc = $ptc;
  }
  public function getPtc()
  {
    return $this->ptc;
  }
  public function setRefundable($refundable)
  {
    $this->refundable = $refundable;
  }
  public function getRefundable()
  {
    return $this->refundable;
  }
  public function setSaleFareTotal($saleFareTotal)
  {
    $this->saleFareTotal = $saleFareTotal;
  }
  public function getSaleFareTotal()
  {
    return $this->saleFareTotal;
  }
  public function setSaleTaxTotal($saleTaxTotal)
  {
    $this->saleTaxTotal = $saleTaxTotal;
  }
  public function getSaleTaxTotal()
  {
    return $this->saleTaxTotal;
  }
  public function setSaleTotal($saleTotal)
  {
    $this->saleTotal = $saleTotal;
  }
  public function getSaleTotal()
  {
    return $this->saleTotal;
  }
  public function setSegmentPricing($segmentPricing)
  {
    $this->segmentPricing = $segmentPricing;
  }
  public function getSegmentPricing()
  {
    return $this->segmentPricing;
  }
  public function setTax($tax)
  {
    $this->tax = $tax;
  }
  public function getTax()
  {
    return $this->tax;
  }
}

class Google_Service_QPXExpress_SegmentInfo extends Google_Collection
{
  protected $collection_key = 'leg';
  protected $internal_gapi_mappings = array(
  );
  public $bookingCode;
  public $bookingCodeCount;
  public $cabin;
  public $connectionDuration;
  public $duration;
  protected $flightType = 'Google_Service_QPXExpress_FlightInfo';
  protected $flightDataType = '';
  public $id;
  public $kind;
  protected $legType = 'Google_Service_QPXExpress_LegInfo';
  protected $legDataType = 'array';
  public $marriedSegmentGroup;
  public $subjectToGovernmentApproval;

  public function setBookingCode($bookingCode)
  {
    $this->bookingCode = $bookingCode;
  }
  public function getBookingCode()
  {
    return $this->bookingCode;
  }
  public function setBookingCodeCount($bookingCodeCount)
  {
    $this->bookingCodeCount = $bookingCodeCount;
  }
  public function getBookingCodeCount()
  {
    return $this->bookingCodeCount;
  }
  public function setCabin($cabin)
  {
    $this->cabin = $cabin;
  }
  public function getCabin()
  {
    return $this->cabin;
  }
  public function setConnectionDuration($connectionDuration)
  {
    $this->connectionDuration = $connectionDuration;
  }
  public function getConnectionDuration()
  {
    return $this->connectionDuration;
  }
  public function setDuration($duration)
  {
    $this->duration = $duration;
  }
  public function getDuration()
  {
    return $this->duration;
  }
  public function setFlight(Google_Service_QPXExpress_FlightInfo $flight)
  {
    $this->flight = $flight;
  }
  public function getFlight()
  {
    return $this->flight;
  }
  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setLeg($leg)
  {
    $this->leg = $leg;
  }
  public function getLeg()
  {
    return $this->leg;
  }
  public function setMarriedSegmentGroup($marriedSegmentGroup)
  {
    $this->marriedSegmentGroup = $marriedSegmentGroup;
  }
  public function getMarriedSegmentGroup()
  {
    return $this->marriedSegmentGroup;
  }
  public function setSubjectToGovernmentApproval($subjectToGovernmentApproval)
  {
    $this->subjectToGovernmentApproval = $subjectToGovernmentApproval;
  }
  public function getSubjectToGovernmentApproval()
  {
    return $this->subjectToGovernmentApproval;
  }
}

class Google_Service_QPXExpress_SegmentPricing extends Google_Collection
{
  protected $collection_key = 'freeBaggageOption';
  protected $internal_gapi_mappings = array(
  );
  public $fareId;
  protected $freeBaggageOptionType = 'Google_Service_QPXExpress_FreeBaggageAllowance';
  protected $freeBaggageOptionDataType = 'array';
  public $kind;
  public $segmentId;

  public function setFareId($fareId)
  {
    $this->fareId = $fareId;
  }
  public function getFareId()
  {
    return $this->fareId;
  }
  public function setFreeBaggageOption($freeBaggageOption)
  {
    $this->freeBaggageOption = $freeBaggageOption;
  }
  public function getFreeBaggageOption()
  {
    return $this->freeBaggageOption;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setSegmentId($segmentId)
  {
    $this->segmentId = $segmentId;
  }
  public function getSegmentId()
  {
    return $this->segmentId;
  }
}

class Google_Service_QPXExpress_SliceInfo extends Google_Collection
{
  protected $collection_key = 'segment';
  protected $internal_gapi_mappings = array(
  );
  public $duration;
  public $kind;
  protected $segmentType = 'Google_Service_QPXExpress_SegmentInfo';
  protected $segmentDataType = 'array';

  public function setDuration($duration)
  {
    $this->duration = $duration;
  }
  public function getDuration()
  {
    return $this->duration;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setSegment($segment)
  {
    $this->segment = $segment;
  }
  public function getSegment()
  {
    return $this->segment;
  }
}

class Google_Service_QPXExpress_SliceInput extends Google_Collection
{
  protected $collection_key = 'prohibitedCarrier';
  protected $internal_gapi_mappings = array(
  );
  public $alliance;
  public $date;
  public $destination;
  public $kind;
  public $maxConnectionDuration;
  public $maxStops;
  public $origin;
  public $permittedCarrier;
  protected $permittedDepartureTimeType = 'Google_Service_QPXExpress_TimeOfDayRange';
  protected $permittedDepartureTimeDataType = '';
  public $preferredCabin;
  public $prohibitedCarrier;

  public function setAlliance($alliance)
  {
    $this->alliance = $alliance;
  }
  public function getAlliance()
  {
    return $this->alliance;
  }
  public function setDate($date)
  {
    $this->date = $date;
  }
  public function getDate()
  {
    return $this->date;
  }
  public function setDestination($destination)
  {
    $this->destination = $destination;
  }
  public function getDestination()
  {
    return $this->destination;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setMaxConnectionDuration($maxConnectionDuration)
  {
    $this->maxConnectionDuration = $maxConnectionDuration;
  }
  public function getMaxConnectionDuration()
  {
    return $this->maxConnectionDuration;
  }
  public function setMaxStops($maxStops)
  {
    $this->maxStops = $maxStops;
  }
  public function getMaxStops()
  {
    return $this->maxStops;
  }
  public function setOrigin($origin)
  {
    $this->origin = $origin;
  }
  public function getOrigin()
  {
    return $this->origin;
  }
  public function setPermittedCarrier($permittedCarrier)
  {
    $this->permittedCarrier = $permittedCarrier;
  }
  public function getPermittedCarrier()
  {
    return $this->permittedCarrier;
  }
  public function setPermittedDepartureTime(Google_Service_QPXExpress_TimeOfDayRange $permittedDepartureTime)
  {
    $this->permittedDepartureTime = $permittedDepartureTime;
  }
  public function getPermittedDepartureTime()
  {
    return $this->permittedDepartureTime;
  }
  public function setPreferredCabin($preferredCabin)
  {
    $this->preferredCabin = $preferredCabin;
  }
  public function getPreferredCabin()
  {
    return $this->preferredCabin;
  }
  public function setProhibitedCarrier($prohibitedCarrier)
  {
    $this->prohibitedCarrier = $prohibitedCarrier;
  }
  public function getProhibitedCarrier()
  {
    return $this->prohibitedCarrier;
  }
}

class Google_Service_QPXExpress_TaxData extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $id;
  public $kind;
  public $name;

  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setName($name)
  {
    $this->name = $name;
  }
  public function getName()
  {
    return $this->name;
  }
}

class Google_Service_QPXExpress_TaxInfo extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $chargeType;
  public $code;
  public $country;
  public $id;
  public $kind;
  public $salePrice;

  public function setChargeType($chargeType)
  {
    $this->chargeType = $chargeType;
  }
  public function getChargeType()
  {
    return $this->chargeType;
  }
  public function setCode($code)
  {
    $this->code = $code;
  }
  public function getCode()
  {
    return $this->code;
  }
  public function setCountry($country)
  {
    $this->country = $country;
  }
  public function getCountry()
  {
    return $this->country;
  }
  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setSalePrice($salePrice)
  {
    $this->salePrice = $salePrice;
  }
  public function getSalePrice()
  {
    return $this->salePrice;
  }
}

class Google_Service_QPXExpress_TimeOfDayRange extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $earliestTime;
  public $kind;
  public $latestTime;

  public function setEarliestTime($earliestTime)
  {
    $this->earliestTime = $earliestTime;
  }
  public function getEarliestTime()
  {
    return $this->earliestTime;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setLatestTime($latestTime)
  {
    $this->latestTime = $latestTime;
  }
  public function getLatestTime()
  {
    return $this->latestTime;
  }
}

class Google_Service_QPXExpress_TripOption extends Google_Collection
{
  protected $collection_key = 'slice';
  protected $internal_gapi_mappings = array(
  );
  public $id;
  public $kind;
  protected $pricingType = 'Google_Service_QPXExpress_PricingInfo';
  protected $pricingDataType = 'array';
  public $saleTotal;
  protected $sliceType = 'Google_Service_QPXExpress_SliceInfo';
  protected $sliceDataType = 'array';

  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setPricing($pricing)
  {
    $this->pricing = $pricing;
  }
  public function getPricing()
  {
    return $this->pricing;
  }
  public function setSaleTotal($saleTotal)
  {
    $this->saleTotal = $saleTotal;
  }
  public function getSaleTotal()
  {
    return $this->saleTotal;
  }
  public function setSlice($slice)
  {
    $this->slice = $slice;
  }
  public function getSlice()
  {
    return $this->slice;
  }
}

class Google_Service_QPXExpress_TripOptionsRequest extends Google_Collection
{
  protected $collection_key = 'slice';
  protected $internal_gapi_mappings = array(
  );
  public $maxPrice;
  protected $passengersType = 'Google_Service_QPXExpress_PassengerCounts';
  protected $passengersDataType = '';
  public $refundable;
  public $saleCountry;
  protected $sliceType = 'Google_Service_QPXExpress_SliceInput';
  protected $sliceDataType = 'array';
  public $solutions;

  public function setMaxPrice($maxPrice)
  {
    $this->maxPrice = $maxPrice;
  }
  public function getMaxPrice()
  {
    return $this->maxPrice;
  }
  public function setPassengers(Google_Service_QPXExpress_PassengerCounts $passengers)
  {
    $this->passengers = $passengers;
  }
  public function getPassengers()
  {
    return $this->passengers;
  }
  public function setRefundable($refundable)
  {
    $this->refundable = $refundable;
  }
  public function getRefundable()
  {
    return $this->refundable;
  }
  public function setSaleCountry($saleCountry)
  {
    $this->saleCountry = $saleCountry;
  }
  public function getSaleCountry()
  {
    return $this->saleCountry;
  }
  public function setSlice($slice)
  {
    $this->slice = $slice;
  }
  public function getSlice()
  {
    return $this->slice;
  }
  public function setSolutions($solutions)
  {
    $this->solutions = $solutions;
  }
  public function getSolutions()
  {
    return $this->solutions;
  }
}

class Google_Service_QPXExpress_TripOptionsResponse extends Google_Collection
{
  protected $collection_key = 'tripOption';
  protected $internal_gapi_mappings = array(
  );
  protected $dataType = 'Google_Service_QPXExpress_Data';
  protected $dataDataType = '';
  public $kind;
  public $requestId;
  protected $tripOptionType = 'Google_Service_QPXExpress_TripOption';
  protected $tripOptionDataType = 'array';

  public function setData(Google_Service_QPXExpress_Data $data)
  {
    $this->data = $data;
  }
  public function getData()
  {
    return $this->data;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setRequestId($requestId)
  {
    $this->requestId = $requestId;
  }
  public function getRequestId()
  {
    return $this->requestId;
  }
  public function setTripOption($tripOption)
  {
    $this->tripOption = $tripOption;
  }
  public function getTripOption()
  {
    return $this->tripOption;
  }
}

class Google_Service_QPXExpress_TripsSearchRequest extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  protected $requestType = 'Google_Service_QPXExpress_TripOptionsRequest';
  protected $requestDataType = '';

  public function setRequest(Google_Service_QPXExpress_TripOptionsRequest $request)
  {
    $this->request = $request;
  }
  public function getRequest()
  {
    return $this->request;
  }
}

class Google_Service_QPXExpress_TripsSearchResponse extends Google_Model
{
  protected $internal_gapi_mappings = array(
  );
  public $kind;
  protected $tripsType = 'Google_Service_QPXExpress_TripOptionsResponse';
  protected $tripsDataType = '';

  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setTrips(Google_Service_QPXExpress_TripOptionsResponse $trips)
  {
    $this->trips = $trips;
  }
  public function getTrips()
  {
    return $this->trips;
  }
}


text:
{% load static %}

<!DOCTYPE html>

{% include "base_header.html" %}
{% block extra-header %}
{% endblock %}

          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar-collapse-1" aria-expanded="false">
            Toggle navigation

          </button>

          {% block nav-left %}{% endblock %}

<input type="text" value="0" class="pgs" >

          {% block nav-right %}{% endblock %}

{% block main-body %}

{% endblock %}


text:
namespace Rcpp{
namespace sugar{

template <int RTYPE,
    bool NA_1, typename T_1,
    bool NA_2, typename T_2,
    typename Function
>
class Mapply_2 : public VectorBase<
	Rcpp::traits::r_sexptype_traits<
		typename ::Rcpp::traits::result_of<Function>::type
	>::rtype ,
	true ,
	Mapply_2<RTYPE,NA_1,T_1,NA_2,T_2,Function>
> {
public:
	typedef typename ::Rcpp::traits::result_of<Function>::type result_type ;

	Mapply_2( const T_1& vec_1_, const T_2& vec_2_, Function fun_ ) :
		vec_1(vec_1_), vec_2(vec_2_), fun(fun_){}

        inline result_type operator[]( R_xlen_t i ) const {
		return fun( vec_1[i], vec_2[i] );
	}
        inline R_xlen_t size() const { return vec_1.size() ; }

private:
	const T_1& vec_1 ;
	const T_2& vec_2 ;
	Function fun ;
} ;

template <int RTYPE,
    bool NA_1, typename T_1,
    typename PRIM_2 ,
    typename Function
>
class Mapply_2_Vector_Primitive : public
    VectorBase<
	    Rcpp::traits::r_sexptype_traits<
	    	typename ::Rcpp::traits::result_of<Function>::type
	    >::rtype ,
	    true ,
	    Mapply_2_Vector_Primitive<RTYPE,NA_1,T_1,PRIM_2,Function>
    >
{
public:
	typedef typename ::Rcpp::traits::result_of<Function>::type result_type ;

	Mapply_2_Vector_Primitive( const T_1& vec_1_, PRIM_2 prim_2_, Function fun_ ) :
		vec_1(vec_1_), prim_2(prim_2_), fun(fun_){}

        inline result_type operator[]( R_xlen_t i ) const {
		return fun( vec_1[i], prim_2 );
	}
        inline R_xlen_t size() const { return vec_1.size() ; }

private:
	const T_1& vec_1 ;
	PRIM_2 prim_2 ;
	Function fun ;
} ;

template <int RTYPE,
    typename PRIM_1,
    bool NA_2, typename T_2,
    typename Function
>
class Mapply_2_Primitive_Vector : public
    VectorBase<
	    Rcpp::traits::r_sexptype_traits<
	    	typename ::Rcpp::traits::result_of<Function>::type
	    >::rtype ,
	    true ,
	    Mapply_2_Primitive_Vector<RTYPE,PRIM_1,NA_2,T_2,Function>
    >
{
public:
	typedef typename ::Rcpp::traits::result_of<Function>::type result_type ;

	Mapply_2_Primitive_Vector( PRIM_1 prim_1_, const T_2& vec_2_, Function fun_ ) :
		prim_1(prim_1_), vec_2(vec_2_), fun(fun_){}

        inline result_type operator[]( R_xlen_t i ) const {
		return fun( prim_1, vec_2[i] );
	}
        inline R_xlen_t size() const { return vec_2.size() ; }

private:
	PRIM_1 prim_1 ;
    const T_2& vec_2 ;
	Function fun ;
} ;

} // sugar

template <int RTYPE, bool NA_1, typename T_1, bool NA_2, typename T_2, typename Function >
inline sugar::Mapply_2<RTYPE,NA_1,T_1,NA_2,T_2,Function>
mapply( const Rcpp::VectorBase<RTYPE,NA_1,T_1>& t1, const Rcpp::VectorBase<RTYPE,NA_2,T_2>& t2, Function fun ){
	return sugar::Mapply_2<RTYPE,NA_1,T_1,NA_2,T_2,Function>( t1.get_ref(), t2.get_ref(), fun ) ;
}

template <int RTYPE, bool NA_1, typename T_1, typename Function >
inline sugar::Mapply_2_Vector_Primitive<RTYPE,NA_1,T_1,double,Function>
mapply( const Rcpp::VectorBase<RTYPE,NA_1,T_1>& t1, double t2, Function fun ){
	return sugar::Mapply_2_Vector_Primitive<RTYPE,NA_1,T_1,double,Function>( t1.get_ref(), t2, fun ) ;
}

template <int RTYPE, bool NA_2, typename T_2, typename Function >
inline sugar::Mapply_2_Primitive_Vector<RTYPE,double, NA_2,T_2,Function>
mapply( double t1, const Rcpp::VectorBase<RTYPE,NA_2,T_2>& t2, Function fun ){
	return sugar::Mapply_2_Primitive_Vector<RTYPE,double, NA_2,T_2,Function>( t1, t2.get_ref(), fun ) ;
}

} // Rcpp

#endif


text:
import { isPlainObject, isArray } from 'is-what'

type PlainObject = { [key in string | symbol]: any }

function assignProp (
  carry: PlainObject,
  key: string | symbol,
  newVal: any,
  originalObject: PlainObject,
  includeNonenumerable: boolean
): void {
  const propType = {}.propertyIsEnumerable.call(originalObject, key)
    ? 'enumerable'
    : 'nonenumerable'
  if (propType === 'enumerable') carry[key as any] = newVal
  if (includeNonenumerable && propType === 'nonenumerable') {
    Object.defineProperty(carry, key, {
      value: newVal,
      enumerable: false,
      writable: true,
      configurable: true,
    })
  }
}

export type Options = { props?: (string | symbol)[]; nonenumerable?: boolean }

/**
 * Copy (clone) an object and all its props recursively to get rid of any prop referenced of the original object. Arrays are also cloned, however objects inside arrays are still linked.
 *
 * @export
 * @template T
 * @param {T} target Target can be anything
 * @param {Options} [options = {}] Options can be `props` or `nonenumerable`
 * @returns {T} the target with replaced values
 * @export
 */
export function copy<T extends any> (target: T, options: Options = {}): T {
  if (isArray(target)) return target.map((item) => copy(item, options)) as T
  if (!isPlainObject(target)) return target
  const props = Object.getOwnPropertyNames(target)
  const symbols = Object.getOwnPropertySymbols(target)
  return [...props, ...symbols].reduce((carry, key) => {
    if (isArray(options.props) && !options.props.includes(key)) {
      return carry
    }
    const val = target[key]
    const newVal = copy(val, options)
    assignProp(carry, key, newVal, target, options.nonenumerable)
    return carry
  }, {} as T)
}


text:
<?php
$pageTitle = "ag-Grid Examples: Plain JavaScript";
$pageDescription = "ag-Grid is a feature-rich datagrid available in Free or Enterprise versions. This page shows Plain JavaScript examples.";
$pageKeywords = "ag-Grid JavaScript examples";
$pageGroup = "examples";
include '../documentation-main/documentation_header.php';
?>

Plain JavaScript Examples

        Here we show some examples in plain JavaScript combining different features of the grid.

        File Browser

        File Browser changes the look and feel of the grid to make it behave like a Microsoft Windows
        file browser. We don't expect you to re-create Windows File Browser, however it demonstrates
        the flexibility of the grid's styling.

        Styled Report

        The Styled Report shows how the grid doesn't need to look like a typical grid. This report
        looks like something out of a presentation.

        Expressions and Context

        This example is similar to what finance departments might build. It shows how to use value getters
        to build expressions.

        Excel Import

        Illustrates how you might utilise a third-party library to import an Excel spreadsheet into ag-Grid.

<?php include '../documentation-main/documentation_footer.php'; ?>