text:
#ifndef _QCC_PLATFORM_H
#define _QCC_PLATFORM_H
/**
 * @file
 *
 * This file just wraps including actual OS and toolchain specific header
 * files depding on the OS group setting.
 */

/******************************************************************************
 * Copyright AllSeen Alliance. All rights reserved.
 *
 *    Permission to use, copy, modify, and/or distribute this software for any
 *    purpose with or without fee is hereby granted, provided that the above
 *    copyright notice and this permission notice appear in all copies.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 ******************************************************************************/

#if defined(QCC_OS_GROUP_POSIX)
#include <qcc/posix/platform_types.h>
#elif defined(QCC_OS_GROUP_WINDOWS)
#include <qcc/windows/platform_types.h>
#include <qcc/windows/mapping.h>

/*
 * This pragma prevents Microsoft compiler warning C4407: cast between different pointer to member representations, compiler may generate incorrect code.
 * This is equivalent to /vmm and /vmg compiler options but without the burden of requiring all apps to specify these non-default options.
 */
#pragma pointers_to_members(full_generality, virtual_inheritance)
#else
#error No OS GROUP defined.
#endif

#if defined(__GNUC__)

#define GCC_VERSION ((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__)
#if (GCC_VERSION < 40700L)
/*
 * Versions of GCC prior to 4.7.0 have an annoying but intentional bug where
 * __cplusplus is set to 1 rather than the appropriate date code so that it
 * would be compatible with Solaris 8.
 */

#if (GCC_VERSION >= 40600L) && defined(__GXX_EXPERIMENTAL_CXX0X__)
/*
 * GCC 4.6.x supports C++11, at least in terms of unordered_map, etc. when the
 * -std=gnu++0x option is passed in.  Thus, fix the value of __cplusplus.
 */
#undef __cplusplus
#define __cplusplus 201100L
#endif  // GCC version >= 4.6 and -std=gnu++0x
#endif  // GCC version < 4.7

#if (__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
#define QCC_DEPRECATED(func) func __attribute__((deprecated)) /**< mark a function as deprecated in gcc. */
#else
#define QCC_DEPRECATED(func) func /**< not all gcc versions support the deprecated attribute. */
#endif

#elif defined(_MSC_VER)

#define QCC_DEPRECATED(func) __declspec(deprecated) func /**< mark a function as deprecated in msvc. */

#else /* Some unknown compiler */

#define QCC_DEPRECATED(func); /**< mark a function as deprecated. */

#endif /* Compiler type */

/**
 * Macro used to avoid unused variable warning in release code.
 * This Macro is only used when a variable is only used in the debug build
 * variant. When building in release mode the compiler will give an unused
 * variable warning.
 *
 * Example usage:
   @code
     String errMsg
     const char* errName = reply->GetErrorName(&errMsg);
     QCC_LogError(status, ("TimedPing returned ERROR_MESSAGE (error=%s, \"%s\")", errName, errMsg.c_str()));
     QCC_UNUSED(errName); // avoid unused variable warning in release build
   @endcode
 *
 * The `QCC_LogError` is an empty macro for release build variants but in debug
 * build variants it is not empty so it uses the errName variable.
 */
#define QCC_UNUSED(x) (void)(x)

#if defined(_MSC_VER)
//disable 'conditional expression is constant' warning to use do{ ... }while(0)
#pragma warning( disable: 4127 )
#endif

/** Boolean type for C */
typedef int32_t QCC_BOOL;
/** Boolean logic true for QCC_BOOL type*/
#define QCC_TRUE 1
/** Boolean logic false for QCC_BOOL type*/
#define QCC_FALSE 0

/** This @#define allows for calling convention redefinition on relevant platforms */
#ifndef AJ_CALL
#  if defined(QCC_OS_GROUP_WINDOWS)
#    define AJ_CALL __stdcall
#  else
#    define AJ_CALL
#  endif
#endif

#endif // _QCC_PLATFORM_H


text:
load("build/jslint.js");

var src = readFile("dist/alloy.js");

JSLINT(src, { evil: true, forin: true });

// All of the following are known issues that we think are 'ok'
// (in contradiction with JSLint) more information here:
// http://docs.jquery.com/JQuery_Core_Style_Guidelines
var ok = {
	"Expected an identifier and instead saw 'undefined' (a reserved word).": true,
	"Use '===' to compare with 'null'.": true,
	"Use '!==' to compare with 'null'.": true,
	"Expected an assignment or function call and instead saw an expression.": true,
	"Expected a 'break' statement before 'case'.": true

};

var e = JSLINT.errors, found = 0, w;

for ( var i = 0; i < e.length; i++ ) {
	w = e[i];

	if ( !ok[ w.reason ] ) {
		found++;
		print( "\n" + w.evidence + "\n" );
		print( "    Problem at line " + w.line + " character " + w.character + ": " + w.reason );
	}
}

if ( found > 0 ) {
	print( "\n" + found + " Error(s) found." );

} else {
	print( "JSLint check passed." );
}

redpajama_set_name: RedPajamaGithub


text:
//  Copyright 2021 Google LLC. All Rights Reserved.
//
//  Licensed 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.

using System.Text;

namespace NtApiDotNet.Win32.Security.Authentication.Kerberos
{
    /// <summary>
    /// Class to represent the AD-AUTH-DATA-TARGET-NAME authorization data.
    /// </summary>
    public sealed class KerberosAuthorizationDataTargetName : KerberosAuthorizationData
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="target_name">The target name.</param>
        public KerberosAuthorizationDataTargetName(string target_name)
            : base(KerberosAuthorizationDataType.AD_AUTH_DATA_TARGET_NAME)
        {
            TargetName = target_name ?? throw new System.ArgumentNullException(nameof(target_name));
        }

        /// <summary>
        /// The target name.
        /// </summary>
        public string TargetName { get; }

        private protected override void FormatData(StringBuilder builder)
        {
            builder.AppendLine($"Target Name     : {TargetName}");
        }

        private protected override byte[] GetData()
        {
            return Encoding.Unicode.GetBytes(TargetName);
        }

        internal static bool Parse(byte[] data, out KerberosAuthorizationDataTargetName entry)
        {
            if ((data.Length % 2) != 0)
            {
                entry = null;
                return false;
            }

            entry = new KerberosAuthorizationDataTargetName(Encoding.Unicode.GetString(data));
            return true;
        }
    }
}


text:
#ifndef MBED_OLD_SLEEP_H
#define MBED_OLD_SLEEP_H

#warning sleep.h has been replaced by mbed_sleep.h, please update to mbed_sleep.h [since mbed-os-5.3]
#include "platform/mbed_sleep.h"

#endif


text:
<?php
/**
 *
 * This file is part of Aura for PHP.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 *
 */
namespace Aura\Dispatcher;

use Closure;

/**
 *
 * A recursive dispatcher.
 *
 * @package Aura.Dispatcher
 *
 */
class Dispatcher implements DispatcherInterface
{
    use InvokeMethodTrait;
    use InvokeClosureTrait;

    /**
     *
     * Dispatchable objects.
     *
     * @var array
     *
     */
    protected $objects = [];

    /**
     *
     * The param indicating the dispatchable object name.
     *
     * @var string
     *
     */
    protected $object_param;

    /**
     *
     * The param indicating the method to invoke on created objects.
     *
     * @var string
     *
     */
    protected $method_param;

    /**
     *
     * Constructor.
     *
     * @param array $objects An array of dispatchable objects keyed by name.
     *
     * @param string $object_param The param indicating the dispatchable
     * object name.
     *
     * @param string $method_param The param indicating the method to invoke
     * on the dispatchable object.
     *
     */
    public function __construct(
        array $objects = [],
        $object_param = null,
        $method_param = null
    ) {
        $this->setObjects($objects);
        $this->setObjectParam($object_param);
        $this->setMethodParam($method_param);
    }

    /**
     *
     * Uses the params to get a dispatchable object, then dispatches it using
     * the params.
     *
     * @param array|ArrayAccess $params Params for the invocation.
     *
     * @param string $object_name Use an explicit object name instead of
     * getting it from the params.
     *
     * @return mixed The return from the invoked object.
     *
     */
    public function __invoke($params = [], $object_name = null)
    {
        if ($object_name) {
            $object = $this->getObject($object_name);
        } else {
            $object = $this->getObjectByParams($params);
        }
        return $this->dispatch($object, $params);
    }

    /**
     *
     * Dispatches to the object with the params; if the result is an object
     * with the dispatchable method, a closure, or an invokable object,
     * recursively to that result with the same params.
     *
     * @param mixed $object Dispatch to this object.
     *
     * @param array|ArrayAccess $params Params for the invocation.
     *
     * @return The first non-dispatchable result.
     *
     */
    protected function dispatch($object, $params = [])
    {
        $method = $this->getMethodByParams($params);
        if (is_callable([$object, $method]) && method_exists($object, $method)) {
            // the object has the specified method
            $result = $this->invokeMethod($object, $method, $params);
        } elseif ($object instanceof Closure) {
            // the object is a closure proper
            $result = $this->invokeClosure($object, $params);
        } elseif (is_object($object) && is_callable($object)) {
            // the object is invokable
            $result = $this->invokeMethod($object, '__invoke', $params);
        } else {
            // cannot dispatch any further; end recursion and return as-is
            return $object;
        }

        // recursively dispatch the result.
        return $this->dispatch($result, $params);
    }

    /**
     *
     * Sets the parameter indicating the dispatchable object name.
     *
     * @param string $object_param The parameter name to use.
     *
     * @return null
     *
     */
    public function setObjectParam($object_param)
    {
        $this->object_param = $object_param;
    }

    /**
     *
     * Gets the parameter indicating the dispatchable object name.
     *
     * @return string
     *
     */
    public function getObjectParam()
    {
        return $this->object_param;
    }

    /**
     *
     * Sets the parameter indicating the method to call on the created object.
     *
     * @param string $method_param The parameter name to use.
     *
     * @return null
     *
     */
    public function setMethodParam($method_param)
    {
        $this->method_param = $method_param;
    }

    /**
     *
     * Gets the parameter indicating the method to call on the created object.
     *
     * @return string
     *
     */
    public function getMethodParam()
    {
        return $this->method_param;
    }

    /**
     *
     * Set the array of dispatchable objects; this clears all existing objects.
     *
     * @param array $objects An array where the key is a name and the value
     * is a dispatchable object.
     *
     * @return null
     *
     */
    public function setObjects(array $objects)
    {
        $this->objects = $objects;
    }

    /**
     *
     * Adds to the array of dispatchable objects; this merges with existing
     * objects.
     *
     * @param array $objects An array where the key is a name and the value
     * is a dispatchable object.
     *
     * @return null
     *
     */
    public function addObjects(array $objects)
    {
        $this->objects = array_merge($this->objects, $objects);
    }

    /**
     *
     * Returns the array of dispatchable objects.
     *
     * @return array
     *
     */
    public function getObjects()
    {
        return $this->objects;
    }

    /**
     *
     * Sets a dispatchable object by name.
     *
     * @param string $name The name.
     *
     * @param object $object The dispatchable object.
     *
     */
    public function setObject($name, $object)
    {
        $this->objects[$name] = $object;
    }

    /**
     *
     * Does a dispatchable object exist?
     *
     * @param string $name The name of the dispatchable object.
     *
     * @return bool
     *
     */
    public function hasObject($name)
    {
        return isset($this->objects[$name]);
    }

    /**
     *
     * Returns a dispatchable object using its name.
     *
     * @param string $name The name of the dispatchable object.
     *
     * @return object
     *
     */
    public function getObject($name)
    {
        if ($this->hasObject($name)) {
            return $this->objects[$name];
        }

        throw new Exception\ObjectNotDefined($name);
    }

    /**
     *
     * Returns a dispatchable object using an array of params; if the
     * `$object_param` is an object, it is returned directly, otherwise it is
     * treated as a dispatchable object name.
     *
     * @param array|ArrayAccess $params Params for the invocation.
     *
     * @return object The dispatchable object.
     *
     */
    public function getObjectByParams($params)
    {
        // do we have an object param available?
        $key = $this->getObjectParam();
        if (! isset($params[$key])) {
            throw new Exception\ObjectNotSpecified;
        }

        // is the object param value already an object?
        $value = $params[$key];
        if (is_object($value)) {
            return $value;
        }

        // get the dispatchable object by name
        if ($this->hasObject($value)) {
            return $this->objects[$value];
        }

        // could not find the dispatchable object by name
        throw new Exception\ObjectNotDefined($value);
    }

    /**
     *
     * Gets the method from the params.
     *
     * @param array|ArrayAccess $params Params for the invocation.
     *
     * @return mixed
     *
     */
    public function getMethodByParams($params)
    {
        if ($this->method_param && isset($params[$this->method_param])) {
            return $params[$this->method_param];
        }
    }
}


text:
import fs from 'fs';
import test from 'tape';
import path from 'path';
import load from 'load-json-file';
import write from 'write-json-file';
import centroid from '@turf/centroid';
import * as chromatism from 'chromatism';
import concaveman from 'concaveman';
import { point, polygon, featureCollection } from '@turf/helpers';
import { clusterReduce, clusterEach } from '@turf/clusters';
import { coordAll, featureEach } from '@turf/meta';
import clustersKmeans from '.';

const directories = {
    in: path.join(__dirname, 'test', 'in') + path.sep,
    out: path.join(__dirname, 'test', 'out') + path.sep
};

const fixtures = fs.readdirSync(directories.in).map(filename => {
    return {
        filename,
        name: path.parse(filename).name,
        geojson: load.sync(directories.in + filename)
    };
});

test('clusters-kmeans', t => {
    fixtures.forEach(fixture => {
        const name = fixture.name;
        const geojson = fixture.geojson;
        const numberOfClusters = (geojson.properties || {}).numberOfClusters;

        const clustered = clustersKmeans(geojson, {numberOfClusters: numberOfClusters});
        const result = styleResult(clustered);

        if (process.env.REGEN) write.sync(directories.out + name + '.geojson', result);
        t.deepEqual(result, load.sync(directories.out + name + '.geojson'), name);
    });

    t.end();
});

const points = featureCollection([
    point([0, 0], {foo: 'bar'}),
    point([2, 4], {foo: 'bar'}),
    point([3, 6], {foo: 'bar'})
]);

test('clusters-kmeans -- prevent input mutation', t => {
    const before = JSON.parse(JSON.stringify(points));
    clustersKmeans(points);
    t.deepEqual(before, points);
    t.end();
});

test('clusters-kmeans -- throws', t => {
    const poly = polygon([[[0, 0], [10, 10], [0, 10], [0, 0]]]);
    t.throws(() => clustersKmeans(poly, {numberOfClusters: 1}), /Input must contain Points/);
    // t.throws(() => clustersKmeans(points, 5), /numberOfClusters can't be greater than the number of points/);
    t.end();
});

test('clusters-kmeans -- translate properties', t => {
    t.equal(clustersKmeans(points, {numberOfClusters: 2}).features[0].properties.foo, 'bar');
    t.end();
});

// style result
function styleResult(clustered) {
    const count = clusterReduce(clustered, 'cluster', i => i + 1, 0);
    const colours = chromatism.adjacent(360 / count, count, '#0000FF').hex;
    const features = [];

    // Add all Point
    featureEach(clustered, function (pt) {
        const clusterId = pt.properties.cluster;
        pt.properties['marker-color'] = colours[clusterId];
        pt.properties['marker-size'] = 'small';
        features.push(pt);
    });

    // Iterate over each Cluster
    clusterEach(clustered, 'cluster', (cluster, clusterValue, clusterId) => {
        const color = chromatism.brightness(-25, colours[clusterId]).hex;

        // Add Centroid
        features.push(centroid(cluster, {
            'marker-color': color,
            'marker-symbol': 'star-stroked',
            'marker-size': 'large'
        }));

        // Add concave polygon
        features.push(polygon([concaveman(coordAll(cluster))], {
            fill: color,
            stroke: color,
            'fill-opacity': 0.3
        }));
    });
    return featureCollection(features);
}


text:
var dispatcher = require('../dispatcher');

module.exports = {
    // called from the PostForm
    addCollection: function(collection) {
        dispatcher.dispatch({
            object: collection,
            type: "resource:addCollection"
        });
    },

    deleteCollection: function(collection) {
        dispatcher.dispatch({
            object: collection,
            type: "resource:deleteCollection"
        });
    },

    editCollection: function(collection) {
        dispatcher.dispatch({
            object: collection,
            type: "resource:editCollection"
        });
    },

    addItem: function(item) {
        dispatcher.dispatch({
            object: item,
            type: 'resource:addItem'
        });
    },

    editItem: function(item) {
        console.log('resourceActions', item.item.edited)
        dispatcher.dispatch({
            object: item,
            type: "resource:editItem"
        });
    },

    deleteItem: function(item) {
        dispatcher.dispatch({
            object: item,
            type: "resource:deleteItem"
        });
    }
}


text:
package org.apach3.commons.io.input;

import java.io.InputStream;

/**
 * Proxy stream that prevents the underlying input stream from being closed.
 * <p>
 * This class is typically used in cases where an input stream needs to be
 * passed to a component that wants to explicitly close the stream even if
 * more input would still be available to other components.
 *
 * @version $Id: CloseShieldInputStream.java 1304052 2012-03-22 20:55:29Z ggregory $
 * @since 1.4
 */
public class CloseShieldInputStream extends ProxyInputStream {

    /**
     * Creates a proxy that shields the given input stream from being
     * closed.
     *
     * @param in underlying input stream
     */
    public CloseShieldInputStream(InputStream in) {
        super(in);
    }

    /**
     * Replaces the underlying input stream with a {@link ClosedInputStream}
     * sentinel. The original input stream will remain open, but this proxy
     * will appear closed.
     */
    @Override
    public void close() {
        in = new ClosedInputStream();
    }

}


text:
flexIEC
===========

HTML UI capable of presenting a never ending series of evolutionary objects.

This UI is meant as a glimpse into automated, partially automated, or manual evolutionary process. The display is meant to be adjustable for most domains (where most HTMl is injected by some other source).

Note that while the UI might be in Javascript/HTML, the actual simulation/evolutionary code can be done in native code. This IEC component is agnostic. Provided API hooks for adding/removing objects, and generating new objects.

See OptimusLime/win for more details.


text:
package com.jetbrains.python.magicLiteral;

import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.refactoring.rename.RenameDialog;
import com.intellij.refactoring.rename.RenameHandler;
import com.jetbrains.python.psi.PyStringLiteralExpression;
import com.jetbrains.python.psi.StringLiteralExpression;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/**
 * @author traff
 */
public class PyMagicLiteralRenameHandler implements RenameHandler {
  @Override
  public boolean isAvailableOnDataContext(final DataContext dataContext) {
    final Editor editor = CommonDataKeys.EDITOR.getData(dataContext);
    if (editor == null) {
      return false;
    }

    final PsiFile file = CommonDataKeys.PSI_FILE.getData(dataContext);
    if (file == null) {
      return false;
    }

    final PsiElement element = getElement(file, editor);

    return !((element == null) || !PyMagicLiteralTools.isMagicLiteral(element));
  }

  @Nullable
  private static PsiElement getElement(PsiFile file, Editor editor) {
    PsiElement element = file.findElementAt(editor.getCaretModel().getCurrentCaret().getOffset());
    if (element instanceof PyStringLiteralExpression) {
      return element;
    }
    return PsiTreeUtil.getParentOfType(element, StringLiteralExpression.class);
  }

  @Override
  public boolean isRenaming(DataContext dataContext) {
    return isAvailableOnDataContext(dataContext);
  }

  @Override
  public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
    PsiElement element = getElement(file, editor);
    if (element == null) {
      return;
    }
    RenameDialog.showRenameDialog(dataContext, new RenameDialog(project, element, null, editor));
  }

  @Override
  public void invoke(@NotNull Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
    throw new UnsupportedOperationException();
  }
}


text:
StringBad & StringBad::operator=(const StringBad & st) {
    if (this == &st)    // object assigned to itself
    return *this;   // all done
    delete [] str;  // free old string
    len = st.len;
    str = new char [len + 1];   // get space for new string
    std::strcpy(str, st.str);   // copy the string
    return *this;   // return reference to invoking object
}

in main() {
    StringBad headline1("Celery Stalks at Midnight");
    StringBad knot = headline1;
    cout << "knot: " << knot << endl;
    cout << "knot: " << knot = headline1 << endl;
}

//https://pt.stackoverflow.com/q/222048/101


text:
module Playsms
  class ClientError < Error
  end
end


text:
using System.Threading.Tasks;
using Luno.Models;
using Luno.Models.Session;

namespace Luno.Interfaces
{
	public interface ISessionClient
	{
		/// <summary>
		/// Create a new session for this user
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="session">The new sessions's details</param>
		/// <param name="expand">The models to expand (fetch details)</param>
		Task<Session<TSession, TUser>> CreateAsync<TSession, TUser>(CreateSession<TSession> session = null, string[] expand = null);

		/// <summary>
		/// Get a list of recently created sessions
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="userId">User ID to filter sessions by, use null to list anonymous sessions</param>
		/// <param name="to">The item ID to stop retrieving the list at</param>
		/// <param name="from">The item ID to retrieve the list from</param>
		/// <param name="limit">The maximum number of items to return. min: 0, max: 200</param>
		/// <param name="expand">The models to expand (fetch details)</param>
		Task<PaginationResponse<Session<TSession, TUser>>> GetAllAsync<TSession, TUser>(string userId = null, string to = null, string from = null, uint limit = 100, string[] expand = null);

		/// <summary>
		/// Get a session
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="id">The session ID</param>
		/// <param name="expand">The models to expand (fetch details)</param>
		Task<Session<TSession, TUser>> GetAsync<TSession, TUser>(string id, string[] expand = null);

		/// <summary>
		/// Get a session
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="session">The session model</param>
		/// <param name="expand">The models to expand (fetch details)</param>
		Task<Session<TSession, TUser>> GetAsync<TSession, TUser>(Session<TSession, TUser> session, string[] expand = null);

		/// <summary>
		/// Set attributes for a session, extending the `details` properties
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="id">The session ID</param>
		/// <param name="session">The updated session model</param>
		/// <param name="destructive">Whether to update existing attributes, or override the model and replace it in it's entirety</param>
		Task<SuccessResponse> UpdateAsync<TSession, TUser>(string id, Session<TSession, TUser> session, bool destructive = false);

		/// <summary>
		/// Set attributes for a session, extending the `details` properties
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="session">The updated session model</param>
		/// <param name="destructive">Whether to update existing attributes, or override the model and replace it in it's entirety</param>
		Task<SuccessResponse> UpdateAsync<TSession, TUser>(Session<TSession, TUser> session, bool destructive = false);

		/// <summary>
		/// Permanently delete a session
		/// </summary>
		/// <param name="id">The session ID</param>
		Task<SuccessResponse> DeleteAsync(string id);

		/// <summary>
		/// Permanently delete a session
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="session">The session model</param>
		Task<SuccessResponse> DeleteAsync<TSession, TUser>(Session<TSession, TUser> session);

		/// <summary>
		/// Validate a session key, incrementing the access count and setting the last access time.
		/// </summary>
		/// <typeparam name="TSession">Any arbitrary data associated with the session model</typeparam>
		/// <typeparam name="TUser">Any arbitrary data associated with the user model</typeparam>
		/// <param name="session">The session model to validate</param>
		/// <param name="expand">The models to expand (fetch details)</param>
		Task<Session<TSession, TUser>> ValidateAsync<TSession, TUser>(Session<TSession, TUser> session, string[] expand = null);
	}
}


text:
var apn = require("../");

describe("Device", function() {
	describe('constructor', function () {

		// Issue #149
		it("should error when given a device string which contains no hex characters and results in 0 length token", function () {
			(function () {
				apn.Device("som string without hx lttrs");
			}).should.throw();
		});

		it("should error when given a device string which contains an odd number of hex characters", function () {
			(function () {
				apn.Device("01234");
			}).should.throw();
		});

		it("should return a Device object containing the correct token when given a hex string", function () {
			apn.Device("<0123 4567 89AB CDEF>").toString().should.equal("0123456789abcdef");
		});

		it("should return a Device object containing the correct token when given a Buffer", function () {
			var buf = new Buffer([1, 35, 69, 103, 137, 171, 205, 239]);
			apn.Device(buf).toString().should.equal("0123456789abcdef");
		});
	});
});


text:
<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">
<ui:UiBinder xmlns:ui="urn:ui:com.google.gwt.uibinder"
	xmlns:g="urn:import:com.google.gwt.user.client.ui" xmlns:b="urn:import:org.gwtbootstrap3.client.ui"
	xmlns:my="urn:import:com.juntosalimos.client.application.home.ui">

	<ui:with type="com.juntosalimos.resource.JSClientBundle" field="res"></ui:with>
	<g:HTMLPanel>

		<g:HTMLPanel
			addStyleNames="{res.style.homePageSection} {res.style.homePageSectionB}">
			<b:Container addStyleNames="{res.style.appContainer}">
				<b:Heading size="3" addStyleNames="{res.style.titlePanel}"> Dinos quién eres para contarte quiénes
					somos</b:Heading>

				<b:Row>
					<b:Column size="MD_4" offset="MD_1">
						<g:HTMLPanel addStyleNames="{res.style.centeredPanel}">
							<b:Button ui:field="leftOptionButton" type="SUCCESS"> Soy un
								"ideador"
							</b:Button>
							<b:Heading size="4"> Quiero ayudar con las ideas</b:Heading>
						</g:HTMLPanel>
					</b:Column>
					<b:Column size="MD_4" offset="MD_2">
						<g:HTMLPanel addStyleNames="{res.style.centeredPanel}">
							<b:Button ui:field="rightOptionButton" type="SUCCESS"> Soy un
								"mini-retista "
							</b:Button>
							<b:Heading size="4"> Necesito ideas que me ayuden</b:Heading>
						</g:HTMLPanel>
					</b:Column>
				</b:Row>

				<b:Row>
					<b:Column size="MD_4" offset="MD_1">
						<g:HTMLPanel addStyleNames="{res.style.centeredPanel}">
							<g:HTMLPanel visible="false" ui:field="leftTriangle"
								addStyleNames="{res.style.triangleUp}" />
						</g:HTMLPanel>
					</b:Column>
					<b:Column size="MD_4" offset="MD_2">
						<g:HTMLPanel addStyleNames="{res.style.centeredPanel}">
							<g:HTMLPanel visible="false" ui:field="rightTriangle"
								addStyleNames="{res.style.triangleUp}" />
						</g:HTMLPanel>
					</b:Column>
				</b:Row>

				<g:HTMLPanel visible="false" ui:field="leftSubPanel"
					addStyleNames="{res.style.homePageSectionA}">

					<g:HTMLPanel height="100px"> TUTORIAL LEFT </g:HTMLPanel>

				</g:HTMLPanel>

				<g:HTMLPanel visible="false" ui:field="rightSubPanel"
					addStyleNames="{res.style.homePageSectionA}">

					<g:HTMLPanel height="100px"> TUTORIAL RIGHT </g:HTMLPanel>

				</g:HTMLPanel>
			</b:Container>
		</g:HTMLPanel>

	</g:HTMLPanel>
</ui:UiBinder>


text:
return {
	metadataFieldsForPhotos = {
		{
			id = 'adjustedLuminance',
			title = LOC "$$$/VideoRenderer/MetadataFieldAdjustedLuminance=Adjusted Luminance",
			dataType = 'string',
			browsable = true,
			searchable = true,
		},
	},
	schemaVersion = 1,
}


text:
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["fp"] = factory();
	else
		root["fp"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	var baseConvert = __webpack_require__(1);

	/**
	 * Converts `lodash` to an immutable auto-curried iteratee-first data-last version.
	 *
	 * @param {Function} lodash The lodash function.
	 * @param {Object} [options] The options object. See `baseConvert` for more details.
	 * @returns {Function} Returns the converted `lodash`.
	 */
	function browserConvert(lodash, options) {
	  return baseConvert(lodash, lodash, options);
	}

	if (typeof _ == 'function') {
	  _ = browserConvert(_.runInContext());
	}
	module.exports = browserConvert;

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	var mapping = __webpack_require__(2),
	    mutateMap = mapping.mutate,
	    placeholder = {};

	/**
	 * The base implementation of `convert` which accepts a `util` object of methods
	 * required to perform conversions.
	 *
	 * @param {Object} util The util object.
	 * @param {string} name The name of the function to wrap.
	 * @param {Function} func The function to wrap.
	 * @param {Object} [options] The options object.
	 * @param {boolean} [options.cap=true] Specify capping iteratee arguments.
	 * @param {boolean} [options.curry=true] Specify currying.
	 * @param {boolean} [options.fixed=true] Specify fixed arity.
	 * @param {boolean} [options.immutable=true] Specify immutable operations.
	 * @param {boolean} [options.rearg=true] Specify rearranging arguments.
	 * @returns {Function|Object} Returns the converted function or object.
	 */
	function baseConvert(util, name, func, options) {
	  var setPlaceholder,
	      isLib = typeof name == 'function',
	      isObj = name === Object(name);

	  if (isObj) {
	    options = func;
	    func = name;
	    name = undefined;
	  }
	  if (func == null) {
	    throw new TypeError;
	  }
	  options || (options = {});

	  var config = {
	    'cap': 'cap' in options ? options.cap : true,
	    'curry': 'curry' in options ? options.curry : true,
	    'fixed': 'fixed' in options ? options.fixed : true,
	    'immutable': 'immutable' in options ? options.immutable : true,
	    'rearg': 'rearg' in options ? options.rearg : true
	  };

	  var forceRearg = ('rearg' in options) && options.rearg;

	  var helpers = isLib ? func : {
	    'ary': util.ary,
	    'clone': util.clone,
	    'curry': util.curry,
	    'forEach': util.forEach,
	    'isArray': util.isArray,
	    'isFunction': util.isFunction,
	    'iteratee': util.iteratee,
	    'keys': util.keys,
	    'rearg': util.rearg,
	    'spread': util.spread,
	    'toPath': util.toPath
	  };

	  var ary = helpers.ary,
	      clone = helpers.clone,
	      curry = helpers.curry,
	      each = helpers.forEach,
	      isArray = helpers.isArray,
	      isFunction = helpers.isFunction,
	      keys = helpers.keys,
	      rearg = helpers.rearg,
	      spread = helpers.spread,
	      toPath = helpers.toPath;

	  var aryMethodKeys = keys(mapping.aryMethod);

	  var baseArity = function(func, n) {
	    return n == 2
	      ? function(a, b) { return func.apply(undefined, arguments); }
	      : function(a) { return func.apply(undefined, arguments); };
	  };

	  var baseAry = function(func, n) {
	    return n == 2
	      ? function(a, b) { return func(a, b); }
	      : function(a) { return func(a); };
	  };

	  var cloneArray = function(array) {
	    var length = array ? array.length : 0,
	        result = Array(length);

	    while (length--) {
	      result[length] = array[length];
	    }
	    return result;
	  };

	  var cloneByPath = function(object, path) {
	    path = toPath(path);

	    var index = -1,
	        length = path.length,
	        result = clone(Object(object)),
	        nested = result;

	    while (nested != null && ++index < length) {
	      var key = path[index],
	          value = nested[key];

	      if (value != null) {
	        nested[key] = clone(Object(value));
	      }
	      nested = nested[key];
	    }
	    return result;
	  };

	  var createCloner = function(func) {
	    return function(object) {
	      return func({}, object);
	    };
	  };

	  var immutWrap = function(func, cloner) {
	    return function() {
	      var length = arguments.length;
	      if (!length) {
	        return result;
	      }
	      var args = Array(length);
	      while (length--) {
	        args[length] = arguments[length];
	      }
	      var result = args[0] = cloner.apply(undefined, args);
	      func.apply(undefined, args);
	      return result;
	    };
	  };

	  var iterateeAry = function(func, n) {
	    return overArg(func, function(func) {
	      return typeof func == 'function' ? baseAry(func, n) : func;
	    });
	  };

	  var iterateeRearg = function(func, indexes) {
	    return overArg(func, function(func) {
	      var n = indexes.length;
	      return baseArity(rearg(baseAry(func, n), indexes), n);
	    });
	  };

	  var overArg = function(func, iteratee, retArg) {
	    return function() {
	      var length = arguments.length;
	      if (!length) {
	        return func();
	      }
	      var args = Array(length);
	      while (length--) {
	        args[length] = arguments[length];
	      }
	      var index = config.rearg ? 0 : (length - 1);
	      args[index] = iteratee(args[index]);
	      return func.apply(undefined, args);
	    };
	  };

	  var wrappers = {
	    'castArray': function(castArray) {
	      return function() {
	        var value = arguments[0];
	        return isArray(value)
	          ? castArray(cloneArray(value))
	          : castArray.apply(undefined, arguments);
	      };
	    },
	    'iteratee': function(iteratee) {
	      return function() {
	        var func = arguments[0],
	            arity = arguments[1],
	            result = iteratee(func, arity),
	            length = result.length;

	        if (config.cap && typeof arity == 'number') {
	          arity = arity > 2 ? (arity - 2) : 1;
	          return (length && length <= arity) ? result : baseAry(result, arity);
	        }
	        return result;
	      };
	    },
	    'mixin': function(mixin) {
	      return function(source) {
	        var func = this;
	        if (!isFunction(func)) {
	          return mixin(func, Object(source));
	        }
	        var methods = [],
	            methodNames = [];

	        each(keys(source), function(key) {
	          var value = source[key];
	          if (isFunction(value)) {
	            methodNames.push(key);
	            methods.push(func.prototype[key]);
	          }
	        });

	        mixin(func, Object(source));

	        each(methodNames, function(methodName, index) {
	          var method = methods[index];
	          if (isFunction(method)) {
	            func.prototype[methodName] = method;
	          } else {
	            delete func.prototype[methodName];
	          }
	        });
	        return func;
	      };
	    },
	    'runInContext': function(runInContext) {
	      return function(context) {
	        return baseConvert(util, runInContext(context), options);
	      };
	    }
	  };

	  var wrap = function(name, func) {
	    name = mapping.aliasToReal[name] || name;
	    var wrapper = wrappers[name];
	    if (wrapper) {
	      return wrapper(func);
	    }
	    var wrapped = func;
	    if (config.immutable) {
	      if (mutateMap.array[name]) {
	        wrapped = immutWrap(func, cloneArray);
	      }
	      else if (mutateMap.object[name]) {
	        wrapped = immutWrap(func, createCloner(func));
	      }
	      else if (mutateMap.set[name]) {
	        wrapped = immutWrap(func, cloneByPath);
	      }
	    }
	    var result;
	    each(aryMethodKeys, function(aryKey) {
	      each(mapping.aryMethod[aryKey], function(otherName) {
	        if (name == otherName) {
	          var aryN = !isLib && mapping.iterateeAry[name],
	              reargIndexes = mapping.iterateeRearg[name],
	              spreadStart = mapping.methodSpread[name];

	          result = wrapped;
	          if (config.fixed) {
	            result = spreadStart === undefined
	              ? ary(result, aryKey)
	              : spread(result, spreadStart);
	          }
	          if (config.rearg && aryKey > 1 && (forceRearg || !mapping.skipRearg[name])) {
	            result = rearg(result, mapping.methodRearg[name] || mapping.aryRearg[aryKey]);
	          }
	          if (config.cap) {
	            if (reargIndexes) {
	              result = iterateeRearg(result, reargIndexes);
	            } else if (aryN) {
	              result = iterateeAry(result, aryN);
	            }
	          }
	          if (config.curry && aryKey > 1) {
	            result = curry(result, aryKey);
	          }
	          return false;
	        }
	      });
	      return !result;
	    });

	    result || (result = wrapped);
	    if (mapping.placeholder[name]) {
	      setPlaceholder = true;
	      func.placeholder = result.placeholder = placeholder;
	    }
	    return result;
	  };

	  if (!isObj) {
	    return wrap(name, func);
	  }
	  var _ = func;

	  // Iterate over methods for the current ary cap.
	  var pairs = [];
	  each(aryMethodKeys, function(aryKey) {
	    each(mapping.aryMethod[aryKey], function(key) {
	      var func = _[mapping.remap[key] || key];
	      if (func) {
	        pairs.push([key, wrap(key, func)]);
	      }
	    });
	  });

	  // Assign to `_` leaving `_.prototype` unchanged to allow chaining.
	  each(pairs, function(pair) {
	    _[pair[0]] = pair[1];
	  });

	  if (setPlaceholder) {
	    _.placeholder = placeholder;
	  }
	  // Wrap the lodash method and its aliases.
	  each(keys(_), function(key) {
	    each(mapping.realToAlias[key] || [], function(alias) {
	      _[alias] = _[key];
	    });
	  });

	  return _;
	}

	module.exports = baseConvert;

/***/ },
/* 2 */
/***/ function(module, exports) {

	/** Used to map aliases to their real names. */
	exports.aliasToReal = {
	  '__': 'placeholder',
	  'all': 'some',
	  'allPass': 'overEvery',
	  'apply': 'spread',
	  'assoc': 'set',
	  'assocPath': 'set',
	  'compose': 'flowRight',
	  'contains': 'includes',
	  'dissoc': 'unset',
	  'dissocPath': 'unset',
	  'each': 'forEach',
	  'eachRight': 'forEachRight',
	  'equals': 'isEqual',
	  'extend': 'assignIn',
	  'extendWith': 'assignInWith',
	  'first': 'head',
	  'init': 'initial',
	  'mapObj': 'mapValues',
	  'omitAll': 'omit',
	  'nAry': 'ary',
	  'path': 'get',
	  'pathEq': 'matchesProperty',
	  'pathOr': 'getOr',
	  'pickAll': 'pick',
	  'pipe': 'flow',
	  'prop': 'get',
	  'propOf': 'propertyOf',
	  'propOr': 'getOr',
	  'somePass': 'overSome',
	  'unapply': 'rest',
	  'unnest': 'flatten',
	  'useWith': 'overArgs',
	  'whereEq': 'filter',
	  'zipObj': 'zipObject'
	};

	/** Used to map ary to method names. */
	exports.aryMethod = {
	  '1': [
	    'attempt', 'castArray', 'ceil', 'create', 'curry', 'curryRight', 'floor',
	    'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'methodOf', 'mixin',
	    'over', 'overEvery', 'overSome', 'rest', 'reverse', 'round', 'runInContext',
	    'spread', 'template', 'trim', 'trimEnd', 'trimStart', 'uniqueId', 'words'
	  ],
	  '2': [
	    'add', 'after', 'ary', 'assign', 'assignIn', 'at', 'before', 'bind', 'bindKey',
	    'chunk', 'cloneDeepWith', 'cloneWith', 'concat', 'countBy', 'curryN',
	    'curryRightN', 'debounce', 'defaults', 'defaultsDeep', 'delay', 'difference',
	    'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq', 'every',
	    'filter', 'find', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
	    'findLastKey', 'flatMap', 'flattenDepth', 'forEach', 'forEachRight', 'forIn',
	    'forInRight', 'forOwn', 'forOwnRight', 'get', 'groupBy', 'gt', 'gte', 'has',
	    'hasIn', 'includes', 'indexOf', 'intersection', 'invertBy', 'invoke', 'invokeMap',
	    'isEqual', 'isMatch', 'join', 'keyBy', 'lastIndexOf', 'lt', 'lte', 'map',
	    'mapKeys', 'mapValues', 'matchesProperty', 'maxBy', 'merge', 'minBy', 'omit',
	    'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt',
	    'partial', 'partialRight', 'partition', 'pick', 'pickBy', 'pull', 'pullAll',
	    'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
	    'repeat', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
	    'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
	    'split', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight', 'takeRightWhile',
	    'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars', 'trimCharsEnd',
	    'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith', 'unset',
	    'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject', 'zipObjectDeep'
	  ],
	  '3': [
	    'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
	    'getOr', 'inRange', 'intersectionBy', 'intersectionWith', 'isEqualWith',
	    'isMatchWith', 'mergeWith', 'orderBy', 'pullAllBy', 'reduce', 'reduceRight',
	    'replace', 'set', 'slice', 'sortedIndexBy', 'sortedLastIndexBy', 'transform',
	    'unionBy', 'unionWith', 'xorBy', 'xorWith', 'zipWith'
	  ],
	  '4': [
	    'fill', 'setWith'
	  ]
	};

	/** Used to map ary to rearg configs. */
	exports.aryRearg = {
	  '2': [1, 0],
	  '3': [2, 0, 1],
	  '4': [3, 2, 0, 1]
	};

	/** Used to map method names to their iteratee ary. */
	exports.iterateeAry = {
	  'assignWith': 2,
	  'assignInWith': 2,
	  'cloneDeepWith': 1,
	  'cloneWith': 1,
	  'dropRightWhile': 1,
	  'dropWhile': 1,
	  'every': 1,
	  'filter': 1,
	  'find': 1,
	  'findIndex': 1,
	  'findKey': 1,
	  'findLast': 1,
	  'findLastIndex': 1,
	  'findLastKey': 1,
	  'flatMap': 1,
	  'forEach': 1,
	  'forEachRight': 1,
	  'forIn': 1,
	  'forInRight': 1,
	  'forOwn': 1,
	  'forOwnRight': 1,
	  'isEqualWith': 2,
	  'isMatchWith': 2,
	  'map': 1,
	  'mapKeys': 1,
	  'mapValues': 1,
	  'partition': 1,
	  'reduce': 2,
	  'reduceRight': 2,
	  'reject': 1,
	  'remove': 1,
	  'some': 1,
	  'takeRightWhile': 1,
	  'takeWhile': 1,
	  'times': 1,
	  'transform': 2
	};

	/** Used to map method names to iteratee rearg configs. */
	exports.iterateeRearg = {
	  'mapKeys': [1]
	};

	/** Used to map method names to rearg configs. */
	exports.methodRearg = {
	  'assignInWith': [1, 2, 0],
	  'assignWith': [1, 2, 0],
	  'getOr': [2, 1, 0],
	  'isMatchWith': [2, 1, 0],
	  'mergeWith': [1, 2, 0],
	  'pullAllBy': [2, 1, 0],
	  'setWith': [3, 1, 2, 0],
	  'sortedIndexBy': [2, 1, 0],
	  'sortedLastIndexBy': [2, 1, 0],
	  'zipWith': [1, 2, 0]
	};

	/** Used to map method names to spread configs. */
	exports.methodSpread = {
	  'partial': 1,
	  'partialRight': 1
	};

	/** Used to identify methods which mutate arrays or objects. */
	exports.mutate = {
	  'array': {
	    'fill': true,
	    'pull': true,
	    'pullAll': true,
	    'pullAllBy': true,
	    'pullAt': true,
	    'remove': true,
	    'reverse': true
	  },
	  'object': {
	    'assign': true,
	    'assignIn': true,
	    'assignInWith': true,
	    'assignWith': true,
	    'defaults': true,
	    'defaultsDeep': true,
	    'merge': true,
	    'mergeWith': true
	  },
	  'set': {
	    'set': true,
	    'setWith': true,
	    'unset': true
	  }
	};

	/** Used to track methods with placeholder support */
	exports.placeholder = {
	  'bind': true,
	  'bindKey': true,
	  'curry': true,
	  'curryRight': true,
	  'partial': true,
	  'partialRight': true
	};

	/** Used to map real names to their aliases. */
	exports.realToAlias = (function() {
	  var hasOwnProperty = Object.prototype.hasOwnProperty,
	      object = exports.aliasToReal,
	      result = {};

	  for (var key in object) {
	    var value = object[key];
	    if (hasOwnProperty.call(result, value)) {
	      result[value].push(key);
	    } else {
	      result[value] = [key];
	    }
	  }
	  return result;
	}());

	/** Used to map method names to other names. */
	exports.remap = {
	  'curryN': 'curry',
	  'curryRightN': 'curryRight',
	  'getOr': 'get',
	  'trimChars': 'trim',
	  'trimCharsEnd': 'trimEnd',
	  'trimCharsStart': 'trimStart'
	};

	/** Used to track methods that skip `_.rearg`. */
	exports.skipRearg = {
	  'add': true,
	  'assign': true,
	  'assignIn': true,
	  'concat': true,
	  'difference': true,
	  'gt': true,
	  'gte': true,
	  'lt': true,
	  'lte': true,
	  'matchesProperty': true,
	  'merge': true,
	  'partial': true,
	  'partialRight': true,
	  'random': true,
	  'range': true,
	  'rangeRight': true,
	  'subtract': true,
	  'zip': true,
	  'zipObject': true
	};

/***/ }
/******/ ])
});
;


text:
require 'rgeo'

module RGeo
  module Tests  # :nodoc:
    module Common  # :nodoc:

      module MultiPointTests  # :nodoc:

        def setup
          @factory = create_factory
          @point1 = @factory.point(0, 0)
          @point2 = @factory.point(1, 0)
          @point3 = @factory.point(-4, 2)
          @point4 = @factory.point(-5, 3)
          @point5 = @factory.point(-5, 3)
        end

        def test_creation_simple
          geom_ = @factory.multi_point([@point1, @point2])
          assert_not_nil(geom_)
          assert(::RGeo::Feature::MultiPoint === geom_)
          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
          assert_equal(2, geom_.num_geometries)
          assert(@point1.eql?(geom_[0]))
          assert(@point2.eql?(geom_[1]))
        end

        def test_creation_empty
          geom_ = @factory.multi_point([])
          assert_not_nil(geom_)
          assert(::RGeo::Feature::MultiPoint === geom_)
          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
          assert_equal(0, geom_.num_geometries)
          assert_equal([], geom_.to_a)
        end

        def test_creation_casting
          mp1_ = @factory.collection([@point3])
          mp2_ = @factory.multi_point([@point4])
          geom_ = @factory.multi_point([@point1, @point2, mp1_, mp2_])
          assert_not_nil(geom_)
          assert_equal(::RGeo::Feature::MultiPoint, geom_.geometry_type)
          assert_equal(4, geom_.num_geometries)
          assert(@point1.eql?(geom_[0]))
          assert(@point2.eql?(geom_[1]))
          assert(@point3.eql?(geom_[2]))
          assert(@point4.eql?(geom_[3]))
        end

        def test_creation_wrong_type
          line_ = @factory.line_string([@point1, @point2])
          geom_ = @factory.multi_point([@point3, line_])
          assert_nil(geom_)
        end

        def test_required_equivalences
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point2])
          assert(geom1_.eql?(geom2_))
          assert(geom1_ == geom2_)
        end

        def test_fully_equal
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point2])
          assert(geom1_.rep_equals?(geom2_))
          assert(geom1_.equals?(geom2_))
        end

        def test_geometrically_equal
          geom1_ = @factory.multi_point([@point1, @point4])
          geom2_ = @factory.multi_point([@point1, @point4, @point5])
          assert(!geom1_.rep_equals?(geom2_))
          assert(geom1_.equals?(geom2_))
        end

        def test_not_equal
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1])
          assert(!geom1_.rep_equals?(geom2_))
          assert(!geom1_.equals?(geom2_))
        end

        def test_hashes_equal_for_representationally_equivalent_objects
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point2])
          assert_equal(geom1_.hash, geom2_.hash)
        end

        def test_wkt_creation_simple
          parsed_geom_ = @factory.parse_wkt('MULTIPOINT((0 0), (-4 2), (-5 3))')
          built_geom_ = @factory.multi_point([@point1, @point3, @point4])
          assert(built_geom_.eql?(parsed_geom_))
        end

        def test_wkt_creation_empty
          parsed_geom_ = @factory.parse_wkt('MULTIPOINT EMPTY')
          assert(::RGeo::Feature::MultiPoint === parsed_geom_)
          assert_equal(0, parsed_geom_.num_geometries)
          assert_equal([], parsed_geom_.to_a)
        end

        def test_clone
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = geom1_.clone
          assert(geom1_.eql?(geom2_))
          assert_equal(::RGeo::Feature::MultiPoint, geom2_.geometry_type)
          assert_equal(2, geom2_.num_geometries)
          assert(@point1.eql?(geom2_[0]))
          assert(@point2.eql?(geom2_[1]))
        end

        def test_type_check
          geom1_ = @factory.multi_point([@point1, @point2])
          assert(::RGeo::Feature::Geometry.check_type(geom1_))
          assert(!::RGeo::Feature::Point.check_type(geom1_))
          assert(::RGeo::Feature::GeometryCollection.check_type(geom1_))
          assert(::RGeo::Feature::MultiPoint.check_type(geom1_))
          assert(!::RGeo::Feature::MultiLineString.check_type(geom1_))
          geom2_ = @factory.multi_point([])
          assert(::RGeo::Feature::Geometry.check_type(geom2_))
          assert(!::RGeo::Feature::Point.check_type(geom2_))
          assert(::RGeo::Feature::GeometryCollection.check_type(geom2_))
          assert(::RGeo::Feature::MultiPoint.check_type(geom2_))
          assert(!::RGeo::Feature::MultiLineString.check_type(geom2_))
        end

        def test_as_text_wkt_round_trip
          geom1_ = @factory.multi_point([@point1, @point2])
          text_ = geom1_.as_text
          geom2_ = @factory.parse_wkt(text_)
          assert(geom1_.eql?(geom2_))
        end

        def test_as_binary_wkb_round_trip
          geom1_ = @factory.multi_point([@point1, @point2])
          binary_ = geom1_.as_binary
          geom2_ = @factory.parse_wkb(binary_)
          assert(geom1_.eql?(geom2_))
        end

        def test_dimension
          geom1_ = @factory.multi_point([@point1, @point2])
          assert_equal(0, geom1_.dimension)
          geom2_ = @factory.multi_point([])
          assert_equal(-1, geom2_.dimension)
        end

        def test_is_empty
          geom1_ = @factory.multi_point([@point1, @point2])
          assert(!geom1_.is_empty?)
          geom2_ = @factory.multi_point([])
          assert(geom2_.is_empty?)
        end

        def test_union
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point3])
          geom3_ = @factory.multi_point([@point1, @point2, @point3])
          assert_equal(geom3_, geom1_.union(geom2_))
          assert_equal(geom3_, geom1_ + geom2_)
        end

        def test_difference
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point3])
          assert_equal(@point2, geom1_.difference(geom2_))
          assert_equal(@point2, geom1_ - geom2_)
        end

        def test_intersection
          geom1_ = @factory.multi_point([@point1, @point2])
          geom2_ = @factory.multi_point([@point1, @point3])
          assert_equal(@point1, geom1_.intersection(geom2_))
          assert_equal(@point1, geom1_ * geom2_)
        end

        def test_zm
          factory_ = create_factory(:has_z_coordinate => true, :has_m_coordinate => true)
          p1_ = factory_.point(1, 2, 3, 4)
          mp_ = factory_.multi_point([p1_])
          assert_equal(p1_, mp_[0])
        end

      end

    end
  end
end


text:
from cssqc.qualityWarning import QualityWarning

def getHelp():
    return """Do not allow "js-" prefixes in selectors."""

class noJSPrefix:
    def __init__(self, data):
        pass

    def on_IDENT(self, i):
        if i.value[0:3] == "js-":
            return [QualityWarning('noJSPrefix', i.lineno, 'Class ".%s" present.' % i.value)]
        else:
            return []

    def on_HASH(self, i):
        if i.value[1:4] == "js-":
            return [QualityWarning('noJSPrefix', i.lineno, 'ID "%s" present.' % i.value)]
        else:
            return []


text:
/*
 * Changes for SnappyData distributed computational and data platform.
 *
 * Portions Copyright (c) 2017-2019 TIBCO Software Inc. All rights reserved.
 *
 * Licensed 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. See accompanying
 * LICENSE file.
 */

package com.gemstone.gemfire.internal.shared.unsafe;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.WritableByteChannel;
import javax.annotation.Nonnull;

import com.gemstone.gemfire.internal.shared.ChannelBufferOutputStream;
import com.gemstone.gemfire.internal.shared.ClientSharedUtils;
import com.gemstone.gemfire.internal.shared.OutputStreamChannel;
import org.apache.spark.unsafe.Platform;

/**
 * A somewhat more efficient implementation of {@link ChannelBufferOutputStream}
 * using internal unsafe class (~30% in raw single byte write calls).
 * Use {@link UnsafeHolder#newChannelBufferOutputStream} method to create
 * either this or {@link ChannelBufferOutputStream} depending on availability.
 *

 * NOTE: THIS CLASS IS NOT THREAD-SAFE BY DESIGN. IF IT IS USED CONCURRENTLY
 * BY MULTIPLE THREADS THEN BAD THINGS CAN HAPPEN DUE TO UNSAFE MEMORY WRITES.
 *

 * Note that the close() method of this class does not close the underlying
 * channel.
 *
 * @author swale
 * @since gfxd 1.1
 */
public class ChannelBufferUnsafeOutputStream extends OutputStreamChannel {

  protected ByteBuffer buffer;
  protected final long baseAddress;
  /**
   * Actual buffer position (+baseAddress) accounting is done by this. Buffer
   * position is adjusted during refill and other places where required using
   * this.
   */
  protected long addrPosition;
  protected long addrLimit;

  /**
   * Some minimum buffer size, particularly for longs and encoding UTF strings
   * efficiently. If reducing this, then consider the logic in
   * {@link ChannelBufferUnsafeDataOutputStream#writeUTF(String)} carefully.
   */
  protected static final int MIN_BUFFER_SIZE = 32;

  public ChannelBufferUnsafeOutputStream(WritableByteChannel channel) {
    this(channel, ChannelBufferOutputStream.DEFAULT_BUFFER_SIZE);
  }

  public ChannelBufferUnsafeOutputStream(WritableByteChannel channel,
      int bufferSize) {
    super(channel);
    this.baseAddress = allocateBuffer(bufferSize);
    resetBufferPositions();
  }

  /**
   * Get handle to the underlying ByteBuffer. ONLY TO BE USED BY TESTS.
   */
  public ByteBuffer getInternalBuffer() {
    // set the current position
    this.buffer.position(position());
    return this.buffer;
  }

  protected final void resetBufferPositions() {
    this.addrPosition = this.baseAddress + this.buffer.position();
    this.addrLimit = this.baseAddress + this.buffer.limit();
  }

  protected long allocateBuffer(int bufferSize) {
    // expect minimum bufferSize of 10 bytes
    if (bufferSize < MIN_BUFFER_SIZE) {
      throw new IllegalArgumentException(
          "ChannelBufferUnsafeDataOutputStream: buffersize=" + bufferSize
              + " too small (minimum " + MIN_BUFFER_SIZE + ')');
    }
    // use allocator which will restrict total allocated size
    final ByteBuffer buffer = DirectBufferAllocator.instance().allocateWithFallback(
        bufferSize, "CHANNELOUTPUT");
    // set the order to native explicitly to skip any byte order conversions
    buffer.order(ByteOrder.nativeOrder());
    this.buffer = buffer;

    try {
      return UnsafeHolder.getDirectBufferAddress(buffer);
    } catch (Exception e) {
      releaseBuffer();
      throw ClientSharedUtils.newRuntimeException(
          "failed in creating an 'unsafe' buffered channel stream", e);
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final void write(int b) throws IOException {
    putByte((byte)(b & 0xff));
  }

  protected final void write_(byte[] b, int off, int len) throws IOException {
    if (len == 1) {
      putByte(b[off]);
      return;
    }

    while (len > 0) {
      final long addrPos = this.addrPosition;
      final int remaining = (int)(this.addrLimit - addrPos);
      if (len <= remaining) {
        Platform.copyMemory(b, Platform.BYTE_ARRAY_OFFSET + off,
            null, addrPos, len);
        this.addrPosition += len;
        return;
      } else {
        // copy b to buffer and flush
        if (remaining > 0) {
          Platform.copyMemory(b, Platform.BYTE_ARRAY_OFFSET + off,
              null, addrPos, remaining);
          this.addrPosition += remaining;
          len -= remaining;
          off += remaining;
        }
        flushBufferBlocking(this.buffer);
      }
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final void write(@Nonnull byte[] b) throws IOException {
    write_(b, 0, b.length);
  }

  protected final void putByte(byte b) throws IOException {
    if (this.addrPosition >= this.addrLimit) {
      flushBufferBlocking(this.buffer);
    }
    Platform.putByte(null, this.addrPosition++, b);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final void write(@Nonnull byte[] b,
      int off, int len) throws IOException {
    UnsafeHolder.checkBounds(b.length, off, len);
    write_(b, off, len);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final int write(ByteBuffer src) throws IOException {
    // We will just use our ByteBuffer for the write. It might be possible
    // to get slight performance advantage in using unsafe instead, but
    // copying from source ByteBuffer will not be efficient without
    // reflection to get src's native address in case it is a direct
    // byte buffer. Avoiding the complication since the benefit will be
    // very small in any case (and reflection cost may well offset that).

    // adjust this buffer position first
    this.buffer.position((int)(this.addrPosition - this.baseAddress));
    // now we are actually set to just call base class method
    try {
      return super.writeBuffered(src, this.buffer);
    } finally {
      // finally reset the raw positions from buffer
      resetBufferPositions();
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final void writeInt(int v) throws IOException {
    long addrPos = this.addrPosition;
    if ((this.addrLimit - addrPos) < 4) {
      flushBufferBlocking(this.buffer);
      addrPos = this.addrPosition;
    }
    this.addrPosition = putInt(addrPos, v);
  }

  public final int position() {
    return (int)(this.addrPosition - this.baseAddress);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void flush() throws IOException {
    final ByteBuffer buffer;
    if (this.addrPosition > this.baseAddress &&
        (buffer = this.buffer) != null) {
      flushBufferBlocking(buffer);
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public final boolean isOpen() {
    return this.channel.isOpen();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void close() throws IOException {
    flush();
    this.addrPosition = this.addrLimit = 0;
    releaseBuffer();
  }

  protected final void releaseBuffer() {
    final ByteBuffer buffer = this.buffer;
    if (buffer != null) {
      this.buffer = null;
      DirectBufferAllocator.instance().release(buffer);
    }
  }

  /**
   * Close the underlying channel in addition to flushing/clearing the buffer.
   */
  public void closeChannel() throws IOException {
    flush();
    this.addrPosition = this.addrLimit = 0;
    this.channel.close();
    releaseBuffer();
  }

  protected void flushBufferBlocking(final ByteBuffer buffer)
      throws IOException {
    buffer.position(position());
    buffer.flip();
    try {
      do {
        writeBuffer(buffer, this.channel);
      } while (buffer.hasRemaining());
    } finally {
      if (buffer.hasRemaining()) {
        buffer.compact();
      } else {
        buffer.clear();
      }
      resetBufferPositions();
    }
  }

  /** Write an integer in big-endian format on given off-heap address. */
  protected static long putInt(long addrPos, final int v) {
    if (UnsafeHolder.littleEndian) {
      Platform.putInt(null, addrPos, Integer.reverseBytes(v));
    } else {
      Platform.putInt(null, addrPos, v);
    }
    return addrPos + 4;
  }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest package="com.guavabot.marshpermissions"
    xmlns:android="http://schemas.android.com/apk/res/android">

    <application
        android:allowBackup="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:name=".AndroidApplication"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".ui.app_list.AppListActivity">
            <intent-filter android:label="@string/app_launcher">
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".ui.settings.SettingsActivity"
            android:label="@string/title_activity_settings"
            android:parentActivityName=".ui.app_list.AppListActivity">
        </activity>
    </application>

</manifest>


text:
var webpack = require('webpack');

module.exports = {
  entry: './modules/index',
  output: {
    filename: 'dist/ReactHotAPI.js',
    libraryTarget: 'umd',
    library: 'ReactHotAPI'
  },
  plugins: [
    new webpack.optimize.OccurenceOrderPlugin()
  ]
};


text:
describe("chorus.pages.InvalidRoutePage", function() {
    beforeEach(function() {
        this.page = new chorus.pages.InvalidRoutePage();
        this.page.render();
    });

    it("has the translations for the title", function() {
        expect(this.page.$('.heading')).toContainTranslation("invalid_route.title");
    });

    it("has the translations for the textbox content", function() {
        expect(this.page.$('.content')).toContainTranslation("invalid_route.text");
    });
});


text:
package pl.project13.janbanery.core.dao;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pl.project13.janbanery.config.Configuration;
import pl.project13.janbanery.config.gson.GsonTypeTokens;
import pl.project13.janbanery.core.flow.*;
import pl.project13.janbanery.core.flow.batch.TasksMoveAllFlow;
import pl.project13.janbanery.core.flow.batch.TasksMoveAllFlowImpl;
import pl.project13.janbanery.core.rest.RestClient;
import pl.project13.janbanery.exceptions.ServerCommunicationException;
import pl.project13.janbanery.resources.*;
import pl.project13.janbanery.resources.additions.TaskLocation;
import pl.project13.janbanery.util.predicates.TaskByOwnerPredicate;
import pl.project13.janbanery.util.predicates.TaskByPriorityPredicate;
import pl.project13.janbanery.util.predicates.TaskByTitleIgnoreCasePredicate;
import pl.project13.janbanery.util.predicates.TaskByTitlePredicate;

import java.util.Collection;
import java.util.List;

import static com.google.common.collect.Collections2.filter;
import static com.google.common.collect.Lists.newArrayList;

/**
 * @author Konrad Malawski
 */
public class TasksImpl implements Tasks {

  private Logger log = LoggerFactory.getLogger(getClass());

  private Configuration conf;
  private RestClient restClient;

  private Columns columns;

  private Workspace currentWorkspace;
  private Project currentProject;

  public TasksImpl(Columns columns, Configuration conf, RestClient restClient) {
    this.conf = conf;
    this.restClient = restClient;
    this.columns = columns;
  }

  @Override
  public TaskFlow create(Task task) {
    String url = getDefaultGetUrl();

    Task newTask = restClient.doPost(url, task, GsonTypeTokens.TASK);

    return new TaskFlowImpl(this, columns, newTask);
  }

  @Override
  public void delete(Task task) {
    String url = getTaskUrl(task);

    restClient.doDelete(url);
  }

  @Override
  public TaskMoveFlow move(Task task) {
    return new TaskMoveFlowImpl(this, columns, task);
  }

  @Override
  public TasksMoveAllFlow moveAllFrom(Column column) {
    List<Task> tasks = allIn(column);
    return new TasksMoveAllFlowImpl(this, tasks);
  }

  @Override
  public void moveAll(Column srcColumn, Column destColumn) {
    List<Task> tasks = allIn(srcColumn);
    for (Task task : tasks) {
      move(task, destColumn);
    }

  }

  @Override
  public TaskFlow move(Task task, TaskLocation location) throws ServerCommunicationException {
    String url = getTaskUrl(task);
    String moveRequest = location.requestBody();

    Task movedTask = restClient.doPut(url, moveRequest, GsonTypeTokens.TASK);

    return new TaskFlowImpl(this, columns, movedTask);
  }

  @Override
  public TaskFlow move(Task task, Column column) {
    String url = getTaskUrl(task);
    Task commandObject = new Task();
    commandObject.setColumnId(column.getId());
    commandObject.setPosition(1); // or else it will throw an exception...

    Task movedTask = restClient.doPut(url, commandObject, GsonTypeTokens.TASK);

    return new TaskFlowImpl(this, columns, movedTask);
  }

  @Override
  public TaskAssignmentFlow assign(Task task) {
    return new TaskAssignmentFlowImpl(this, task);
  }

  @Override
  public TaskFlow assign(Task task, User user) {
    String url = getTaskUrl(task);
    String command = task.getResourceId() + "[owner_id]=%s";

    if (user == null) {
      command = String.format(command, "");
    } else {
      command = String.format(command, user.getId());
    }

    Task assignedTask = restClient.doPut(url, command, GsonTypeTokens.TASK);

    return new TaskFlowImpl(this, columns, assignedTask);
  }

  @Override
  public TaskUpdateFlow update(Task task) {
    return new TaskUpdateFlowImpl(this, columns, task);
  }

  @Override
  public TaskFlow update(Task task, Task newValues) throws ServerCommunicationException {
    String url = getTaskUrl(task);

    Task newTask = restClient.doPut(url, newValues, GsonTypeTokens.TASK);

    return new TaskFlowImpl(this, columns, newTask);
  }

  @Override
  public TaskMarkFlow mark(Task task) {
    return new TaskMarkFlowImpl(this, columns, task);
  }

  @Override
  public TaskFlow markAsReadyToPull(Task task) {
    Task commandObject = new Task();
    commandObject.setReadyToPull(true);

    return update(task, commandObject);
  }

  @Override
  public TaskFlow markAsNotReadyToPull(Task task) {
    Task commandObject = new Task();
    commandObject.setReadyToPull(false);

    return update(task, commandObject);
  }

  @Override
  public List<Task> all() {
    // todo port this to *Flow
    String url = getDefaultGetUrl();

    List<Task> tasks = restClient.doGet(url, GsonTypeTokens.LIST_TASK);

    return tasks;
  }

  @Override
  public List<Task> allIn(Column column) {
    String url = getColumnTasksUrl(column.getId());

    List<Task> tasks = restClient.doGet(url, GsonTypeTokens.LIST_TASK);

    return tasks;
  }

  @Override
  public Task refresh(Task task) {
    return byId(task.getId());
  }

  @Override
  public Task byId(Long taskId) {
    String url = getTaskUrl(taskId);

    Task task = restClient.doGet(url, GsonTypeTokens.TASK);

    return task;
  }

  @Override
  public List<Task> allByTitle(String taskTitle) throws ServerCommunicationException {
    List<Task> tasks = all();
    Collection<Task> filteredTasks = filter(tasks, new TaskByTitlePredicate(taskTitle));
    return newArrayList(filteredTasks);
  }

  @Override
  public List<Task> allByTitleIgnoreCase(String taskTitle) {
    List<Task> tasks = all();
    Collection<Task> filteredTasks = filter(tasks, new TaskByTitleIgnoreCasePredicate(taskTitle));
    return newArrayList(filteredTasks);
  }

  @Override
  public List<Task> allAssignedTo(User user) {
    List<Task> all = all();
    Collection<Task> filteredTasks = filter(all, new TaskByOwnerPredicate(user));
    return newArrayList(filteredTasks);
  }

  @Override
  public List<Task> allWithPriority(Priority priority) {
    List<Task> all = all();
    Collection<Task> filteredTasks = filter(all, new TaskByPriorityPredicate(priority));
    return newArrayList(filteredTasks);
  }

  /**
   * Set this instance to fallback to using the passed in workspace, when none other is passed explicitly.
   * Using this once means you don't have to pass this workspace instance around any longer when performing
   * actions on these tasks.
   *
   * @param currentWorkspace the workspace to be used in all consequent requests
   * @param currentProject   the project to be used in all consequent requests
   * @return the same instance of {@link TasksImpl} as before, but setup to use the currentWorkspace
   */
  public TasksImpl using(Workspace currentWorkspace, Project currentProject) {
    this.currentWorkspace = currentWorkspace;
    this.currentProject = currentProject;
    return this;
  }

  /**
   * The url prepared for most GET requests on this resource,
   * It looks like: https://WORKSPACE.kanbanery.com/api/v1/projects/PROJECT_ID/tasks.json
   *
   * @return url string prepared for querying for data
   */
  private String getDefaultGetUrl() {
    return conf.getApiUrl(currentWorkspace, currentProject.getId()) + "tasks.json";
  }

  private String getTaskUrl(Long taskId) {
    return conf.getApiUrl(currentWorkspace, "tasks", taskId);
  }

  /**
   * Returns a proper url to call API calls for this task on -
   * for PUT/DELETE calls.
   *

   * It looks like: https://WORKSPACE.kanbanery.com/api/v1/tasks/TASK_ID.json
   *
   * @param task the task from which we take the id to work on
   * @return the proper URL for API calls on this task
   */
  private String getTaskUrl(Task task) {
    return getTaskUrl(task.getId());
  }

  /**
   * Returns a proper url to call API calls for this task on -
   * for PUT/DELETE calls.
   *

   * It looks like: https://WORKSPACE.kanbanery.com/api/v1/tasks/TASK_ID.json
   *
   * @param columnId id of the column of which we want the lasts
   * @return the proper URL for API calls on this task
   */
  private String getColumnTasksUrl(Long columnId) {
    return conf.getApiUrl(currentWorkspace) + "columns/" + columnId + "/tasks.json";
  }

}


text:
@implementation VectorHelper

+ (CGPoint)addPoint:(CGPoint)first toPoint:(CGPoint)second {
    return CGPointMake(first.x + second.x, first.y + second.y);
}

+ (CGPoint)subtractPoint:(CGPoint)first fromPoint:(CGPoint)second {
    return CGPointMake(second.x - first.x, second.y - first.y);
}

+ (CGPoint)multiplyPoint:(CGPoint)point byScalar:(double)scalar {
    return CGPointMake(point.x * scalar, point.y * scalar);
}

@end


text:
#ifndef __DAP_CONFIG_H__
#define __DAP_CONFIG_H__

//**************************************************************************************************
/**
\defgroup DAP_Config_Debug_gr CMSIS-DAP Debug Unit Information
\ingroup DAP_ConfigIO_gr
@{
Provides definitions about the hardware and configuration of the Debug Unit.

This information includes:
 - Definition of Cortex-M processor parameters used in CMSIS-DAP Debug Unit.
 - Debug Unit communication packet size.
 - Debug Access Port communication mode (JTAG or SWD).
 - Optional information about a connected Target Device (for Evaluation Boards).
*/

#include "LPC43xx.h"                            // Debug Unit Cortex-M Processor Header File

/// Processor Clock of the Cortex-M MCU used in the Debug Unit.
/// This value is used to calculate the SWD/JTAG clock speed.
#define CPU_CLOCK               180000000U      ///< Specifies the CPU Clock in Hz

/// Number of processor cycles for I/O Port write operations.
/// This value is used to calculate the SWD/JTAG clock speed that is generated with I/O
/// Port write operations in the Debug Unit by a Cortex-M MCU. Most Cortex-M processors
/// require 2 processor cycles for a I/O Port Write operation.  If the Debug Unit uses
/// a Cortex-M0+ processor with high-speed peripheral I/O only 1 processor cycle might be
/// required.
#define IO_PORT_WRITE_CYCLES    2U              ///< I/O Cycles: 2=default, 1=Cortex-M0+ fast I/0

/// Indicate that Serial Wire Debug (SWD) communication mode is available at the Debug Access Port.
/// This information is returned by the command \ref DAP_Info as part of Capabilities.
#define DAP_SWD                 1               ///< SWD Mode:  1 = available, 0 = not available

/// Indicate that JTAG communication mode is available at the Debug Port.
/// This information is returned by the command \ref DAP_Info as part of Capabilities.
#define DAP_JTAG                1               ///< JTAG Mode: 1 = available, 0 = not available.

/// Configure maximum number of JTAG devices on the scan chain connected to the Debug Access Port.
/// This setting impacts the RAM requirements of the Debug Unit. Valid range is 1 .. 255.
#define DAP_JTAG_DEV_CNT        8U              ///< Maximum number of JTAG devices on scan chain

/// Default communication mode on the Debug Access Port.
/// Used for the command \ref DAP_Connect when Port Default mode is selected.
#define DAP_DEFAULT_PORT        1U              ///< Default JTAG/SWJ Port Mode: 1 = SWD, 2 = JTAG.

/// Default communication speed on the Debug Access Port for SWD and JTAG mode.
/// Used to initialize the default SWD/JTAG clock frequency.
/// The command \ref DAP_SWJ_Clock can be used to overwrite this default setting.
#define DAP_DEFAULT_SWJ_CLOCK   1000000U        ///< Default SWD/JTAG clock frequency in Hz.

/// Maximum Package Size for Command and Response data.
/// This configuration settings is used to optimized the communication performance with the
/// debugger and depends on the USB peripheral. Change setting to 1024 for High-Speed USB.
#define DAP_PACKET_SIZE         1024U           ///< USB: 64 = Full-Speed, 1024 = High-Speed.

/// Maximum Package Buffers for Command and Response data.
/// This configuration settings is used to optimized the communication performance with the
/// debugger and depends on the USB peripheral. For devices with limited RAM or USB buffer the
/// setting can be reduced (valid range is 1 .. 255). Change setting to 4 for High-Speed USB.
#define DAP_PACKET_COUNT        4U              ///< Buffers: 64 = Full-Speed, 4 = High-Speed.

/// Indicate that UART Serial Wire Output (SWO) trace is available.
/// This information is returned by the command \ref DAP_Info as part of Capabilities.
#define SWO_UART                1               ///< SWO UART:  1 = available, 0 = not available

/// Maximum SWO UART Baudrate
#define SWO_UART_MAX_BAUDRATE   10000000U       ///< SWO UART Maximum Baudrate in Hz

/// Indicate that Manchester Serial Wire Output (SWO) trace is available.
/// This information is returned by the command \ref DAP_Info as part of Capabilities.
#define SWO_MANCHESTER          0               ///< SWO Manchester:  1 = available, 0 = not available

/// SWO Trace Buffer Size.
#define SWO_BUFFER_SIZE         8192U           ///< SWO Trace Buffer Size in bytes (must be 2^n)

/// Debug Unit is connected to fixed Target Device.
/// The Debug Unit may be part of an evaluation board and always connected to a fixed
/// known device.  In this case a Device Vendor and Device Name string is stored which
/// may be used by the debugger or IDE to configure device parameters.
#define TARGET_DEVICE_FIXED     0               ///< Target Device: 1 = known, 0 = unknown;

#if TARGET_DEVICE_FIXED
#define TARGET_DEVICE_VENDOR    ""              ///< String indicating the Silicon Vendor
#define TARGET_DEVICE_NAME      ""              ///< String indicating the Target Device
#endif

///@}

// LPC43xx peripheral register bit masks (used by macros)
#define CCU_CLK_CFG_RUN         (1U << 0)
#define CCU_CLK_CFG_AUTO        (1U << 1)
#define CCU_CLK_STAT_RUN        (1U << 0)
#define SCU_SFS_EPD             (1U << 3)
#define SCU_SFS_EPUN            (1U << 4)
#define SCU_SFS_EHS             (1U << 5)
#define SCU_SFS_EZI             (1U << 6)
#define SCU_SFS_ZIF             (1U << 7)

// Debug Port I/O Pins

// SWCLK/TCK Pin                P1_17: GPIO0[12]
#define PIN_SWCLK_TCK_PORT      0
#define PIN_SWCLK_TCK_BIT       12

// SWDIO/TMS Pin                P1_6:  GPIO1[9]
#define PIN_SWDIO_TMS_PORT      1
#define PIN_SWDIO_TMS_BIT       9

// SWDIO Output Enable Pin      P1_5:  GPIO1[8]
#define PIN_SWDIO_OE_PORT       1
#define PIN_SWDIO_OE_BIT        8

// TDI Pin                      P1_18: GPIO0[13]
#define PIN_TDI_PORT            0
#define PIN_TDI_BIT             13

// TDO Pin                      P1_14: GPIO1[7]
#define PIN_TDO_PORT            1
#define PIN_TDO_BIT             7

// nTRST Pin                    Not available
#define PIN_nTRST_PORT
#define PIN_nTRST_BIT

// nRESET Pin                   P2_5:  GPIO5[5]
#define PIN_nRESET_PORT         5
#define PIN_nRESET_BIT          5

// nRESET Output Enable Pin     P2_6:  GPIO5[6]
#define PIN_nRESET_OE_PORT      5
#define PIN_nRESET_OE_BIT       6

// Debug Unit LEDs

// Connected LED                P1_1: GPIO0[8]
#define LED_CONNECTED_PORT      0
#define LED_CONNECTED_BIT       8

// Target Running LED           Not available

//**************************************************************************************************
/**
\defgroup DAP_Config_PortIO_gr CMSIS-DAP Hardware I/O Pin Access
\ingroup DAP_ConfigIO_gr
@{

Standard I/O Pins of the CMSIS-DAP Hardware Debug Port support standard JTAG mode
and Serial Wire Debug (SWD) mode. In SWD mode only 2 pins are required to implement the debug
interface of a device. The following I/O Pins are provided:

JTAG I/O Pin                 | SWD I/O Pin          | CMSIS-DAP Hardware pin mode
---------------------------- | -------------------- | ---------------------------------------------
TCK: Test Clock              | SWCLK: Clock         | Output Push/Pull
TMS: Test Mode Select        | SWDIO: Data I/O      | Output Push/Pull; Input (for receiving data)
TDI: Test Data Input         |                      | Output Push/Pull
TDO: Test Data Output        |                      | Input
nTRST: Test Reset (optional) |                      | Output Open Drain with pull-up resistor
nRESET: Device Reset         | nRESET: Device Reset | Output Open Drain with pull-up resistor

DAP Hardware I/O Pin Access Functions
-------------------------------------
The various I/O Pins are accessed by functions that implement the Read, Write, Set, or Clear to
these I/O Pins.

For the SWDIO I/O Pin there are additional functions that are called in SWD I/O mode only.
This functions are provided to achieve faster I/O that is possible with some advanced GPIO
peripherals that can independently write/read a single I/O pin without affecting any other pins
of the same I/O port. The following SWDIO I/O Pin functions are provided:
 - \ref PIN_SWDIO_OUT_ENABLE to enable the output mode from the DAP hardware.
 - \ref PIN_SWDIO_OUT_DISABLE to enable the input mode to the DAP hardware.
 - \ref PIN_SWDIO_IN to read from the SWDIO I/O pin with utmost possible speed.
 - \ref PIN_SWDIO_OUT to write to the SWDIO I/O pin with utmost possible speed.
*/

// Configure DAP I/O pins ------------------------------

//   LPC-Link-II HW uses buffers for debug port pins. Therefore it is not
//   possible to disable outputs SWCLK/TCK, TDI and they are left active.
//   Only SWDIO/TMS output can be disabled but it is also left active.
//   nRESET is configured for open drain mode.

/** Setup JTAG I/O pins: TCK, TMS, TDI, TDO, nTRST, and nRESET.
Configures the DAP Hardware I/O pins for JTAG mode:
 - TCK, TMS, TDI, nTRST, nRESET to output mode and set to high level.
 - TDO to input mode.
*/
static __inline void PORT_JTAG_SETUP (void) {
  LPC_GPIO_PORT->MASK[PIN_SWDIO_TMS_PORT] = 0U;
  LPC_GPIO_PORT->MASK[PIN_TDI_PORT] = ~(1U << PIN_TDI_BIT);
}

/** Setup SWD I/O pins: SWCLK, SWDIO, and nRESET.
Configures the DAP Hardware I/O pins for Serial Wire Debug (SWD) mode:
 - SWCLK, SWDIO, nRESET to output mode and set to default high level.
 - TDI, nTRST to HighZ mode (pins are unused in SWD mode).
*/
static __inline void PORT_SWD_SETUP (void) {
  LPC_GPIO_PORT->MASK[PIN_TDI_PORT] = 0U;
  LPC_GPIO_PORT->MASK[PIN_SWDIO_TMS_PORT] = ~(1U << PIN_SWDIO_TMS_BIT);
}

/** Disable JTAG/SWD I/O Pins.
Disables the DAP Hardware I/O pins which configures:
 - TCK/SWCLK, TMS/SWDIO, TDI, TDO, nTRST, nRESET to High-Z mode.
*/
static __inline void PORT_OFF (void) {
  LPC_GPIO_PORT->SET[PIN_SWCLK_TCK_PORT]  =  (1U << PIN_SWCLK_TCK_BIT);
  LPC_GPIO_PORT->SET[PIN_SWDIO_TMS_PORT]  =  (1U << PIN_SWDIO_TMS_BIT);
  LPC_GPIO_PORT->SET[PIN_SWDIO_OE_PORT]   =  (1U << PIN_SWDIO_OE_BIT);
  LPC_GPIO_PORT->SET[PIN_TDI_PORT]        =  (1U << PIN_TDI_BIT);
  LPC_GPIO_PORT->DIR[PIN_nRESET_PORT]    &= ~(1U << PIN_nRESET_BIT);
  LPC_GPIO_PORT->CLR[PIN_nRESET_OE_PORT]  =  (1U << PIN_nRESET_OE_BIT);
}

// SWCLK/TCK I/O pin -------------------------------------

/** SWCLK/TCK I/O pin: Get Input.
\return Current status of the SWCLK/TCK DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_SWCLK_TCK_IN  (void) {
  return ((LPC_GPIO_PORT->PIN[PIN_SWCLK_TCK_PORT] >> PIN_SWCLK_TCK_BIT) & 1U);
}

/** SWCLK/TCK I/O pin: Set Output to High.
Set the SWCLK/TCK DAP hardware I/O pin to high level.
*/
static __forceinline void     PIN_SWCLK_TCK_SET (void) {
  LPC_GPIO_PORT->SET[PIN_SWCLK_TCK_PORT] = 1U << PIN_SWCLK_TCK_BIT;
}

/** SWCLK/TCK I/O pin: Set Output to Low.
Set the SWCLK/TCK DAP hardware I/O pin to low level.
*/
static __forceinline void     PIN_SWCLK_TCK_CLR (void) {
  LPC_GPIO_PORT->CLR[PIN_SWCLK_TCK_PORT] = 1U << PIN_SWCLK_TCK_BIT;
}

// SWDIO/TMS Pin I/O --------------------------------------

/** SWDIO/TMS I/O pin: Get Input.
\return Current status of the SWDIO/TMS DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_SWDIO_TMS_IN  (void) {
  return ((LPC_GPIO_PORT->PIN[PIN_SWDIO_TMS_PORT] >> PIN_SWDIO_TMS_BIT) & 1U);
}

/** SWDIO/TMS I/O pin: Set Output to High.
Set the SWDIO/TMS DAP hardware I/O pin to high level.
*/
static __forceinline void     PIN_SWDIO_TMS_SET (void) {
  LPC_GPIO_PORT->SET[PIN_SWDIO_TMS_PORT] = 1U << PIN_SWDIO_TMS_BIT;
}

/** SWDIO/TMS I/O pin: Set Output to Low.
Set the SWDIO/TMS DAP hardware I/O pin to low level.
*/
static __forceinline void     PIN_SWDIO_TMS_CLR (void) {
  LPC_GPIO_PORT->CLR[PIN_SWDIO_TMS_PORT] = 1U << PIN_SWDIO_TMS_BIT;
}

/** SWDIO I/O pin: Get Input (used in SWD mode only).
\return Current status of the SWDIO DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_SWDIO_IN      (void) {
  return (LPC_GPIO_PORT->MPIN[PIN_SWDIO_TMS_PORT] >> PIN_SWDIO_TMS_BIT);
}

/** SWDIO I/O pin: Set Output (used in SWD mode only).
\param bit Output value for the SWDIO DAP hardware I/O pin.
*/
static __forceinline void     PIN_SWDIO_OUT     (uint32_t bit) {
  LPC_GPIO_PORT->MPIN[PIN_SWDIO_TMS_PORT] = bit << PIN_SWDIO_TMS_BIT;
}

/** SWDIO I/O pin: Switch to Output mode (used in SWD mode only).
Configure the SWDIO DAP hardware I/O pin to output mode. This function is
called prior \ref PIN_SWDIO_OUT function calls.
*/
static __forceinline void     PIN_SWDIO_OUT_ENABLE  (void) {
  LPC_GPIO_PORT->SET[PIN_SWDIO_OE_PORT] = 1U << PIN_SWDIO_OE_BIT;
}

/** SWDIO I/O pin: Switch to Input mode (used in SWD mode only).
Configure the SWDIO DAP hardware I/O pin to input mode. This function is
called prior \ref PIN_SWDIO_IN function calls.
*/
static __forceinline void     PIN_SWDIO_OUT_DISABLE (void) {
  LPC_GPIO_PORT->CLR[PIN_SWDIO_OE_PORT] = 1U << PIN_SWDIO_OE_BIT;
}

// TDI Pin I/O ---------------------------------------------

/** TDI I/O pin: Get Input.
\return Current status of the TDI DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_TDI_IN  (void) {
  return ((LPC_GPIO_PORT->PIN [PIN_TDI_PORT] >> PIN_TDI_BIT) & 1U);
}

/** TDI I/O pin: Set Output.
\param bit Output value for the TDI DAP hardware I/O pin.
*/
static __forceinline void     PIN_TDI_OUT (uint32_t bit) {
  LPC_GPIO_PORT->MPIN[PIN_TDI_PORT] = bit << PIN_TDI_BIT;
}

// TDO Pin I/O ---------------------------------------------

/** TDO I/O pin: Get Input.
\return Current status of the TDO DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_TDO_IN  (void) {
  return ((LPC_GPIO_PORT->PIN[PIN_TDO_PORT] >> PIN_TDO_BIT) & 1U);
}

// nTRST Pin I/O -------------------------------------------

/** nTRST I/O pin: Get Input.
\return Current status of the nTRST DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_nTRST_IN   (void) {
  return (0U);  // Not available
}

/** nTRST I/O pin: Set Output.
\param bit JTAG TRST Test Reset pin status:
           - 0: issue a JTAG TRST Test Reset.
           - 1: release JTAG TRST Test Reset.
*/
static __forceinline void     PIN_nTRST_OUT  (uint32_t bit) {
  ;             // Not available
}

// nRESET Pin I/O------------------------------------------

/** nRESET I/O pin: Get Input.
\return Current status of the nRESET DAP hardware I/O pin.
*/
static __forceinline uint32_t PIN_nRESET_IN  (void) {
  return ((LPC_GPIO_PORT->PIN[PIN_nRESET_PORT] >> PIN_nRESET_BIT) & 1U);
}

/** nRESET I/O pin: Set Output.
\param bit target device hardware reset pin status:
           - 0: issue a device hardware reset.
           - 1: release device hardware reset.
*/
static __forceinline void     PIN_nRESET_OUT (uint32_t bit) {
  if (bit) {
    LPC_GPIO_PORT->DIR[PIN_nRESET_PORT]    &= ~(1U << PIN_nRESET_BIT);
    LPC_GPIO_PORT->CLR[PIN_nRESET_OE_PORT]  =  (1U << PIN_nRESET_OE_BIT);
  } else {
    LPC_GPIO_PORT->SET[PIN_nRESET_OE_PORT]  =  (1U << PIN_nRESET_OE_BIT);
    LPC_GPIO_PORT->DIR[PIN_nRESET_PORT]    |=  (1U << PIN_nRESET_BIT);
  }
}

///@}

//**************************************************************************************************
/**
\defgroup DAP_Config_LEDs_gr CMSIS-DAP Hardware Status LEDs
\ingroup DAP_ConfigIO_gr
@{

CMSIS-DAP Hardware may provide LEDs that indicate the status of the CMSIS-DAP Debug Unit.

It is recommended to provide the following LEDs for status indication:
 - Connect LED: is active when the DAP hardware is connected to a debugger.
 - Running LED: is active when the debugger has put the target device into running state.
*/

/** Debug Unit: Set status of Connected LED.
\param bit status of the Connect LED.
           - 1: Connect LED ON: debugger is connected to CMSIS-DAP Debug Unit.
           - 0: Connect LED OFF: debugger is not connected to CMSIS-DAP Debug Unit.
*/
static __inline void LED_CONNECTED_OUT (uint32_t bit) {
  LPC_GPIO_PORT->B[32*LED_CONNECTED_PORT + LED_CONNECTED_BIT] = bit;
}

/** Debug Unit: Set status Target Running LED.
\param bit status of the Target Running LED.
           - 1: Target Running LED ON: program execution in target started.
           - 0: Target Running LED OFF: program execution in target stopped.
*/
static __inline void LED_RUNNING_OUT (uint32_t bit) {
  ;             // Not available
}

///@}

//**************************************************************************************************
/**
\defgroup DAP_Config_Initialization_gr CMSIS-DAP Initialization
\ingroup DAP_ConfigIO_gr
@{

CMSIS-DAP Hardware I/O and LED Pins are initialized with the function \ref DAP_SETUP.
*/

/** Setup of the Debug Unit I/O pins and LEDs (called when Debug Unit is initialized).
This function performs the initialization of the CMSIS-DAP Hardware I/O Pins and the
Status LEDs. In detail the operation of Hardware I/O and LED pins are enabled and set:
 - I/O clock system enabled.
 - all I/O pins: input buffer enabled, output pins are set to HighZ mode.
 - for nTRST, nRESET a weak pull-up (if available) is enabled.
 - LED output pins are enabled and LEDs are turned off.
*/
static __inline void DAP_SETUP (void) {

  /* Enable clock and init GPIO outputs */
  LPC_CCU1->CLK_M4_GPIO_CFG = CCU_CLK_CFG_AUTO | CCU_CLK_CFG_RUN;
  while (!(LPC_CCU1->CLK_M4_GPIO_STAT & CCU_CLK_STAT_RUN));

  /* Configure I/O pins: function number, input buffer enabled,  */
  /*                     no pull-up/down except nRESET (pull-up) */
  LPC_SCU->SFSP1_17 = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* SWCLK/TCK: GPIO0[12] */
  LPC_SCU->SFSP1_6  = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* SWDIO/TMS: GPIO1[9]  */
  LPC_SCU->SFSP1_5  = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* SWDIO_OE:  GPIO1[8]  */
  LPC_SCU->SFSP1_18 = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* TDI:       GPIO0[13] */
  LPC_SCU->SFSP1_14 = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* TDO:       GPIO1[7]  */
  LPC_SCU->SFSP2_5  = 4U |              SCU_SFS_EZI;  /* nRESET:    GPIO5[5]  */
  LPC_SCU->SFSP2_6  = 4U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* nRESET_OE: GPIO5[6]  */
  LPC_SCU->SFSP1_1  = 0U | SCU_SFS_EPUN|SCU_SFS_EZI;  /* LED:       GPIO0[8]  */

  /* Configure: SWCLK/TCK, SWDIO/TMS, SWDIO_OE, TDI as outputs (high level)   */
  /*            TDO as input                                                  */
  /*            nRESET as input with output latch set to low level            */
  /*            nRESET_OE as output (low level)                               */
  LPC_GPIO_PORT->SET[PIN_SWCLK_TCK_PORT]  =  (1U << PIN_SWCLK_TCK_BIT);
  LPC_GPIO_PORT->SET[PIN_SWDIO_TMS_PORT]  =  (1U << PIN_SWDIO_TMS_BIT);
  LPC_GPIO_PORT->SET[PIN_SWDIO_OE_PORT]   =  (1U << PIN_SWDIO_OE_BIT);
  LPC_GPIO_PORT->SET[PIN_TDI_PORT]        =  (1U << PIN_TDI_BIT);
  LPC_GPIO_PORT->CLR[PIN_nRESET_PORT]     =  (1U << PIN_nRESET_BIT);
  LPC_GPIO_PORT->CLR[PIN_nRESET_OE_PORT]  =  (1U << PIN_nRESET_OE_BIT);
  LPC_GPIO_PORT->DIR[PIN_SWCLK_TCK_PORT] |=  (1U << PIN_SWCLK_TCK_BIT);
  LPC_GPIO_PORT->DIR[PIN_SWDIO_TMS_PORT] |=  (1U << PIN_SWDIO_TMS_BIT);
  LPC_GPIO_PORT->DIR[PIN_SWDIO_OE_PORT]  |=  (1U << PIN_SWDIO_OE_BIT);
  LPC_GPIO_PORT->DIR[PIN_TDI_PORT]       |=  (1U << PIN_TDI_BIT);
  LPC_GPIO_PORT->DIR[PIN_TDO_PORT]       &= ~(1U << PIN_TDO_BIT);
  LPC_GPIO_PORT->DIR[PIN_nRESET_PORT]    &= ~(1U << PIN_nRESET_BIT);
  LPC_GPIO_PORT->DIR[PIN_nRESET_OE_PORT] |=  (1U << PIN_nRESET_OE_BIT);

  /* Configure: LED as output (turned off) */
  LPC_GPIO_PORT->CLR[LED_CONNECTED_PORT]  =  (1U << LED_CONNECTED_BIT);
  LPC_GPIO_PORT->DIR[LED_CONNECTED_PORT] |=  (1U << LED_CONNECTED_BIT);

  /* Configure Peripheral Interrupt Priorities */
  NVIC_SetPriority(USB0_IRQn, 1U);
}

/** Reset Target Device with custom specific I/O pin or command sequence.
This function allows the optional implementation of a device specific reset sequence.
It is called when the command \ref DAP_ResetTarget and is for example required
when a device needs a time-critical unlock sequence that enables the debug port.
\return 0 = no device specific reset sequence is implemented.\n
        1 = a device specific reset sequence is implemented.
*/
static __inline uint32_t RESET_TARGET (void) {
  return (0);              // change to '1' when a device reset sequence is implemented
}

///@}

#endif /* __DAP_CONFIG_H__ */


text:
[bitcoin](https://bitcoin.org/en/)

## e-commerce

- [OpenBazaar](https://www.openbazaar.org/): OpenBazaar costs nothing to download and use. Unlike sites like Ebay or Amazon there are no fees to list items, and no fees when an item is sold. Because the trade is p2p (peer to peer), it's happening directly between buyers and sellers with no middleman to take a cut from each sale. It's completely free e-commerce.

## Financial

- [corda](https://www.corda.net/index.html): Corda 是一个开源的区块链项目,从最初就是为了商业世界而设计的。只有 Corda 能够允许您创建一个彼此协作的区块链网络来进行交易并且严格地保护你的隐私。Corda 的智能合约技术允许企业之间进行直接的价值交换。
    - [corda中文网](http://cncorda.com/introduction/)
    - [corda | 巴比特资讯](http://www.8btc.com/corda)

## Social Contact

- [Matchpool](https://www.matchpool.com/)

## Fundamental Technology

- [NEO](https://neo.org/)


text:
<?php

namespace Account\Controller;

use Zend\Mvc\Controller\AbstractActionController;

abstract class AbstractAccountController extends AbstractActionController
{

    /**
     * @var AccountTable
     */
    protected $accountTable;

    /**
     * Retrieve the accountTable
     *
     * @return AccountTable
     */
    public function getAccountTable()
    {
        if (!$this->accountTable) {
            $sm                 = $this->getServiceLocator();
            $this->accountTable = $sm->get('Account\Model\AccountTable');
        }

        return $this->accountTable;
    }

}


text: Rails.application.config.session_store :cookie_store, key: '_work-you-could-do_session'


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

namespace AssaultBird2454.VPTU.Networking.Client.UDP
{
    public class UDP_Client
    {
    }
}