text:
/* RaycastResult
 * The result of a raycast query
 */
export declare interface RaycastResult {
    // point of impact in global space
    x: number
    y: number

    // right, left, up or down
    normal: string
    body: Body
}

export declare type QueryResult<X> = X[]

/* Contact
 * Represents a contact between two bodies
 */
export declare class Contact {
    // body that belongs to the entity the contact was taken from
    body: Body
    // other body in the contact (does not belong to the previous entity)
    otherBody: Body

    // right, left, up or down
    side: string
}

/* BodyArgs
 * Interface required for the argument of all bodies
 */
interface BodyArgs {
    // position in relative space of the containing entity
    // default: 0
    x?: number
    // default: 0
    y?: number

    enabled?: boolean
}

/* RectArgs
 * Interface for the argument to provide to the Rect constructor
 */
interface RectArgs extends BodyArgs {
    // default: false
    isSensor?: boolean
    // default: "default"
    layer?: string
    // default: 0
    layerGroup?: number

    width: number
    height: number
}
/* LineArgs
 * Interface for the argument to provide to the Line constructor
 */
interface LineArgs extends BodyArgs {
    // default: false
    isSensor?: boolean
    // default: "default"
    layer?: string
    // default: 0
    layerGroup?: number

    size: number
    isHorizontal: boolean

    // right, left, up or down
    // default: "all"
    side?: string
}
/* GridArgs
 * Interface for the argument to provide to the Grid constructor
 */
interface GridArgs extends BodyArgs {
    // default: "default"
    layer?: string
    // default: 0
    layerGroup?: number

    tiles: TileArgs
    // if set, provides an indication on the size of the grid: it might span from x - width/2 to x + width/2, y - height/2 to y + height/2
    // this is not required as the grid can grow indefinitely
    width?: number
    height?: number
    tileSize?: number
}
// Tiles provided as a list
type TileList = { x: number, y: number, shape: number, data?: any }[]
// Tiles provided as a two dimentional array
type TileGrid = { x: number, y: number, info: ({ shape: number, data?: any } | number)[][] }
type TileArgs = TileList | TileGrid

/* EntityArgs
 * Interface for the argument to provide to the Entity constructor
 */
declare type EntityArgs = {
    // position in world space
    x: number
    y: number
    // default: 0
    level?: number
    type?: string

    body?: (RectArgs | LineArgs | GridArgs)
    bodies?: (RectArgs | LineArgs | GridArgs) | (RectArgs | LineArgs | GridArgs)[]
}
| (RectArgs & { level?: number, type: "rect" })
| (LineArgs & { level?: number, type: "line" })
| (GridArgs & { level?: number, type: "grid" })

/* EntityListener
 * Contract for a class that listens to an entities events
 */
export declare interface EntityListener {
    // called when an entity is put in an invalid "crushed state": can happen
    // when an entity is caught between two other entities of a lower level
    crushStart?()
    crushEnd?()

    // called when an entity is put in contact with an other: the two entities are
    // moving toward one another and they are near each other
    contactStart?(body: Body, otherBody: Body, side: string)
    contactEnd?(body: Body, otherBody: Body, side: string)

    // called when:
    // 1. a body overlaps another and one or both are sensors
    // 2. a body overlaps another and their respective top-entities are of the same level
    overlapStart?(body: Body, otherBody: Body)
    overlapEnd?(body: Body, otherBody: Body)
}

/* Entity
 * The main physical entity of the engine: A world contains a list of entities which itself is defined by its position
 * and the bodies it owns.
 *
 * They are not to be created from a constructor: use the World.createEntity or one of the World.createXXX functions to create
 * an entity.
 */
export declare class Entity {

    // the attached listener, can remain null
    listener: EntityListener

    // true if the entity has been destroyed
    readonly destroyed: boolean

    // HIERARCHY
    // the containing world
    world: World
    /* the parent of the considered entity. Their are two types of
     * parenting:
     * static (0): the entity is attached to its parent and has no independant movement
     * follow (1): the entity inherits its parents speed and add its own. Perfect for moving platforms
     *
     * the parent must be of a higher level (grid.js will not check)
     *
     * null if has no parent
     */
    parent: Entity
    // static (0) or follow (1)
    parentType: string
    readonly children: Entity[]

    // if the entity only has one body, returns it. If not, will return one of them.
    readonly body: Body
    // every bodies of the entity
    readonly bodies: Body[]

    // levels of entities are used to evaluate if an entity can affect the trajectory of another entity:
    // let A and B be entities
    // if A.level > B.level, B will push A but A won't push B
    // if A.level == b.level, A and B cannot collide with one another
    level: number

    // POSITIONNING
    // position in world space
    globalx: number
    globaly: number

    // if the entity has a parent, expresses the position within the space of the parent
    // if the entity has no parent, is the position within world space
    x: number
    y: number

    // speed in world space
    globalvx: number
    globalvy: number

    // if the entity has a parent that is follows, the speed in the parent's space
    // if the entity has no parent, the speed in world space
    vx: number
    vy: number

    // every contact with entities with a strictly lesser level
    readonly contacts: Contact[]
    // one of the left/right/up/down contact or null if there is no contact
    readonly leftContact: Contact
    readonly rightContact: Contact
    readonly upContact: Contact
    readonly downContact: Contact

    // true if their is at least one contact
    readonly hasLeftContact: boolean
    readonly hasRightContact: boolean
    readonly hasUpContact: boolean
    readonly hasDownContact: boolean

    // true if one of the entity's body overlaps an entity it shouldn't
    readonly isCrushed: boolean

    // HIERARCHY
    // adds a Rect to the entity
    createRect(args: RectArgs): Rect
    // adds a Line to the entity
    createLine(args: LineArgs): Line
    // adds a grid to the entity
    createGrid(args: GridArgs): Grid
    // removes a body (the body is destroyed, all reference to it should be removed)
    removeBody(body: Body)
    // iterates through every bodies of the entity
    forBodies(lambda: (b: Body) => void)

    // sets "ent"'s parent to this, removes any previous parenting relation
    addChild(ent: Entity, parentType?: string)
    // removes the parent link between this and ent
    removeChild(ent: Entity)
    // same as addChild, only the other way around
    setParent(parent: Entity, parentType?: string)

    // creates an entity and sets it as a parent
    createChild(args: EntityArgs, parentType?: string): Entity
    // removes child and destroys it (all reference to it should be removed)
    destroyChild(ent: Entity)
    // remove entity from the world (all reference to it should be removed)
    destroy()

    // CONTACTS
    cancelLeftOnewayContact(): boolean
    cancelRightOnewayContact(): boolean
    cancelUpOnewayContact(): boolean
    cancelDownOnewayContact(): boolean

    // simulates the movement of a single entity: does the same as World.simulate but only moves this one
    // entity
    move(dx: number, dy: number)
    // same as move only attemps to move this to x, y in parent local space if this has a parent, world space if this has no parent
    moveToLocal(x: number, y: number)
    // same as move only attemps to move this to x, y in world space
    moveToGlobal(x: number, y: number)

    // calculate referential changes
    localToGlobal(x: number | { x: number, y: number }, y?: number): { x: number, y: number }
    globalToLocal(x: number | { x: number, y: number }, y?: number): { x: number, y: number }
}
export declare enum BodyType { RECT = 0, LINE = 1, GRID = 2 }
/* Body
 * The physical part of an entity, it is the actual object that collides with other Bodies
 * There are currently three types of entities:
 * - Rect: Rectangles
 * - Line
 * - Grid: A grid of blocks
 */
export declare abstract class Body {

    type: BodyType

    // containing entity
    entity: Entity

    // if false, does not collide or overlap with anything
    enabled: boolean

    // position in the containing entity space
    x: number
    y: number

    // position in world space
    globalx: number
    globaly: number

    // contacts of the body
    readonly contacts: Contact[]
    readonly leftContact: Contact
    readonly rightContact: Contact
    readonly upContact: Contact
    readonly downContact: Contact

    // calculate referential changes
    localToGlobal(x: number | { x: number, y: number }, y?: number): { x: number, y: number }
    globalToLocal(x: number | { x: number, y: number }, y?: number): { x: number, y: number }

    // definitely destroy a body
    destroy()
}

export declare abstract class SmallBody extends Body {

    // a sensor can't "collide" with other entity but can overlap. Use EntityListener
    // to listen to overlap with sensors
    isSensor: boolean
    // an id that help specify the rules of collision with other entities, check the layer section in World for more info
    // setting to null will set the layer to "default"
    layer: string
    // adds information as to whether an entity can collide with another, check the layer section in World for more info
    layerGroup: number
}

export declare class Rect extends SmallBody {

    /* dimensions of the Rect:
     * the left of the rectangle is at x - width/2
     * the right at x + width/2
     * the bottom at y - height/2
     * the top at y + height/2
     */
    width: number
    height: number
}

export declare class Line extends SmallBody {

    /* dimension of the Line
     * if isHorizontal is true: goes from [x - size/2; y] to [x + size/2; y]
     * if not: goes from [x; y - size/2] to [x; y + size/2]
     */
    size: number
    // true if the line is horizontal, vertical if not
    readonly isHorizontal: boolean
    /* specifies if the entity points up, down, left or right or is full
     * left: oneway vertical line which only collides with bodies coming from the left
     * right: oneway vertical line which only collides with bodies coming from the right
     * up: oneway horizontal line which only collides with bodies coming from the top
     * down: oneway horizontal line which only collides with bodies coming from the bottom
     * all: collides in every direction, use isHorizontal to specify the direction
     */
    side: string
}

// The IDs of every blocks in a grid
export declare const EMPTY = 0
export declare const BLOCK_TILE = 1
export declare const DOWN_ONEWAY = 2
export declare const LEFT_ONEWAY = 3
export declare const UP_ONEWAY = 4
export declare const RIGHT_ONEWAY = 5

export declare class Grid extends Body {

    // the edges of non empty tiles
    readonly minx: number
    readonly maxx: number
    readonly miny: number
    readonly maxy: number
    readonly tileSize: number

    // The functions are fairly self explanatory. The positions provided in argument represent integer
    // positions with local space of the grid body. For example: the block at [0; 0] corners are at [0; 0], [O; 1], [1, 0] and [1; 1]

    getBlock(x: number, y: number): { shape: number, data: any }
    setBlock(x: number, y: number, shape: number, data: any)
    clearBlock(x: number, y: number)

    setBlocks(arg: any[] | { x: number, y: number, info: { shape: number, data }[][]})
    clearBlocks(args: { x: number, y: number }[] | { x: number, y: number, width: number, height: number })
    forBlocks(x: number, y: number, width: number, height: number, lambda: (x: number, y: number, shape: number, data) => ({ shape: number, data? } | number))

    getBlockShape(x: number, y: number): number
    setBlockShape(x: number, y: number, shape: number)
    clearBlockShape(x: number, y: number)

    setBlockShapes(arg: any[] | { x: number, y: number, shapes: number[][]})
    clearBlockShapes(args: { x: number, y: number }[] | { x: number, y: number, width: number, height: number })

    globalToBlock(x: number, y: number): { x: number, y: number }
}

/* World
 * The top object of the engine: contains every Entities
 */
export declare class World {

    readonly time: number

    readonly layers: string[]

    constructor()

    // LAYER
    // adds a layer, there can be no more than 32 layers
    addLayer(layer: string)
    /* sets the rule, the rules are:
     * "always": always collide
     * "never": never collide
     * "equal_group": collide if the layer group is equal
     * "unequal_group": collide if the layer group is different
     */
    setLayerRule(layer1: string, layer2: string, rule: string)
    getLayerRule(layer1: string, layer2: string): string

    // ENTITIES
    createEntity(args: EntityArgs): Entity
    createRect(args: RectArgs & { level?: number }): Entity
    createLine(args: LineArgs & { level?: number }): Entity
    createGrid(args: GridArgs & { level?: number }): Entity
    removeEntity(entity: Entity)

    // QUERYING
    raycast(x: number, y: number, dx: number, dy: number): RaycastResult
    // finds every body in [x - width/2; x + width/2] * [y - height/2; y + height/2]
    queryRect(x: number, y: number, width: number, height: number): QueryResult<Body>
    queryPoint(x: number, y: number): QueryResult<Body>

    simulate(delta: number)
}

export declare function createWorld(): World


text:
<fa-app style="width: 320px; height: 568px; margin: 0;">
  <!-- <fa-scroll-view fa-pipe-from="handler"> -->
    <fa-modifier
      fa-index="$index"
      ng-repeat="item in items track by item.id"
      fa-translate="[item.transX.get(), $index * 100, 1]"
      fa-size="[undefined, 100]"
      fa-opacity="item.opacity"
      fa-animate-leave="leaveAnimation(item)"
      fa-animate-enter="enterAnimation(item)" >
      <fa-surface
        fa-pipe-to="handler"
        fa-click="remove($index)"
        fa-background-color="item.bgcolor"
        fa-color="item.color"
        fa-padding="'40px'">
        {{item.name}}
      </fa-surface>
    </fa-modifier>
  <!-- </fa-scroll-view> -->
</fa-app>

redpajama_set_name: RedPajamaGithub


text:
package org.apache.jmeter.report.core;

import java.util.regex.Pattern;

/**
 * Simple parser to get a {@link SampleMetadata} instance<br>
 *
 * @since 3.0
 */
public class SampleMetaDataParser {

    private char separator;

    public SampleMetaDataParser(char separator) {
        this.separator = separator;
    }

    public SampleMetadata parse(String headRow) {
        String[] cols = headRow.split(Pattern.quote(Character.toString(separator)));
        return new SampleMetadata(separator, cols);
    }
}


text:
extern "C"
{
#include "../../C/Threads.h"
}

namespace NWindows {

class CThread
{
  ::CThread thread;
public:
  CThread() { Thread_Construct(&thread); }
  ~CThread() { Close(); }
  bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
  WRes Close()  { return Thread_Close(&thread); }
  WRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
    { return Thread_Create(&thread, startAddress, parameter); }
  WRes Wait() { return Thread_Wait(&thread); }

  #ifdef _WIN32
  operator HANDLE() { return thread.handle; }
  void Attach(HANDLE handle) { thread.handle = handle; }
  HANDLE Detach() { HANDLE h = thread.handle; thread.handle = NULL; return h; }
  DWORD Resume() { return ::ResumeThread(thread.handle); }
  DWORD Suspend() { return ::SuspendThread(thread.handle); }
  bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread.handle, exitCode)); }
  int GetPriority() { return ::GetThreadPriority(thread.handle); }
  bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread.handle, priority)); }
  #endif
};

}

#endif


text:
package org.gdg.frisbee.android.api;

import com.google.api.client.http.HttpMethods;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.util.Preconditions;
import com.google.api.client.util.SecurityUtils;
import com.google.api.client.util.SslUtils;
import com.squareup.okhttp.OkHttpClient;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.util.Arrays;

/**
 * GDG Aachen
 * org.gdg.frisbee.android.api
 *

 * User: maui
 * Date: 27.05.13
 * Time: 03:13
 */
public class GapiOkTransport extends HttpTransport {

    /**
     * All valid request methods as specified in {@link HttpURLConnection#setRequestMethod}, sorted in
     * ascending alphabetical order.
     */
    private static final String[] SUPPORTED_METHODS = {HttpMethods.DELETE,
            HttpMethods.GET,
            HttpMethods.HEAD,
            HttpMethods.OPTIONS,
            HttpMethods.POST,
            HttpMethods.PUT,
            HttpMethods.TRACE};
    static {
        Arrays.sort(SUPPORTED_METHODS);
    }

    /**
     * HTTP proxy or {@code null} to use the proxy settings from system
     * properties.
     */
    private final Proxy proxy;

    /** SSL socket factory or {@code null} for the default. */
    private final SSLSocketFactory sslSocketFactory;

    /** Host name verifier or {@code null} for the default. */
    private final HostnameVerifier hostnameVerifier;

    /**
     * Constructor with the default behavior.
     *
     *

     * Instead use {@link Builder} to modify behavior.
     *

     */
    public GapiOkTransport() {
        this(null, null, null);
    }

    /**
     * @param proxy HTTP proxy or {@code null} to use the proxy settings from
     *        system properties
     * @param sslSocketFactory SSL socket factory or {@code null} for the default
     * @param hostnameVerifier host name verifier or {@code null} for the default
     */
    GapiOkTransport(
            Proxy proxy, SSLSocketFactory sslSocketFactory, HostnameVerifier hostnameVerifier) {
        this.proxy = proxy;
        this.sslSocketFactory = sslSocketFactory;
        this.hostnameVerifier = hostnameVerifier;
    }

    @Override
    public boolean supportsMethod(String method) {
        return Arrays.binarySearch(SUPPORTED_METHODS, method) >= 0;
    }

    @Override
    protected GapiOkHttpRequest buildRequest(String method, String url) throws IOException {
        Preconditions.checkArgument(supportsMethod(method), "HTTP method %s not supported", method);
        // connection with proxy settings
        URL connUrl = new URL(url);
        OkHttpClient client = new OkHttpClient();
        SSLContext sslContext;
        try {
            sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, null, null);
        } catch (GeneralSecurityException e) {
            throw new AssertionError(); // The system has no TLS. Just give up.
        }
        client.setSslSocketFactory(sslContext.getSocketFactory());

        if(proxy != null)
            client.setProxy(proxy);

        URLConnection conn = client.open(connUrl);
        HttpURLConnection connection = (HttpURLConnection) conn;
        connection.setRequestMethod(method);

        return new GapiOkHttpRequest(connection);
    }

    /**
     * Builder for {@link GapiOkTransport}.
     *
     *

     * Implementation is not thread-safe.
     *

     *
     * @since 1.13
     */
    public static final class Builder {

        /** SSL socket factory or {@code null} for the default. */
        private SSLSocketFactory sslSocketFactory;

        /** Host name verifier or {@code null} for the default. */
        private HostnameVerifier hostnameVerifier;

        /**
         * HTTP proxy or {@code null} to use the proxy settings from system
         * properties.
         */
        private Proxy proxy;

        /**
         * Sets the HTTP proxy or {@code null} to use the proxy settings from system
         * properties.
         *
         *

         * For example:
         *

         *
         *

         setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("127.0.0.1", 8080)))
         *

         */
        public Builder setProxy(Proxy proxy) {
            this.proxy = proxy;
            return this;
        }

        /**
         * Sets the SSL socket factory based on root certificates in a Java KeyStore.
         *
         *

         * Example usage:
         *

         *
         *

         trustCertificatesFromJavaKeyStore(new FileInputStream("certs.jks"), "password");
         *

         *
         * @param keyStoreStream input stream to the key store (closed at the end of this method in a
         *        finally block)
         * @param storePass password protecting the key store file
         * @since 1.14
         */
        public Builder trustCertificatesFromJavaKeyStore(InputStream keyStoreStream, String storePass)
                throws GeneralSecurityException, IOException {
            KeyStore trustStore = SecurityUtils.getJavaKeyStore();
            SecurityUtils.loadKeyStore(trustStore, keyStoreStream, storePass);
            return trustCertificates(trustStore);
        }

        /**
         * Sets the SSL socket factory based root certificates generated from the specified stream using
         *
         *

         * Example usage:
         *

         *
         *

         trustCertificatesFromStream(new FileInputStream("certs.pem"));
         *

         *
         * @param certificateStream certificate stream
         * @since 1.14
         */
        public Builder trustCertificatesFromStream(InputStream certificateStream)
                throws GeneralSecurityException, IOException {
            KeyStore trustStore = SecurityUtils.getJavaKeyStore();
            trustStore.load(null, null);
            SecurityUtils.loadKeyStoreFromCertificates(
                    trustStore, SecurityUtils.getX509CertificateFactory(), certificateStream);
            return trustCertificates(trustStore);
        }

        /**
         * Sets the SSL socket factory based on a root certificate trust store.
         *
         * @param trustStore certificate trust store (use for example {@link SecurityUtils#loadKeyStore}
         *        or {@link SecurityUtils#loadKeyStoreFromCertificates})
         * @since 1.14
         */
        public Builder trustCertificates(KeyStore trustStore) throws GeneralSecurityException {
            SSLContext sslContext = SslUtils.getTlsSslContext();
            SslUtils.initSslContext(sslContext, trustStore, SslUtils.getPkixTrustManagerFactory());
            return setSslSocketFactory(sslContext.getSocketFactory());
        }

        /**
         * Disables validating server SSL certificates by setting the SSL socket factory using
         * {@link SslUtils#trustAllSSLContext()} for the SSL context and
         * {@link SslUtils#trustAllHostnameVerifier()} for the host name verifier.
         *
         *

         * Be careful! Disabling certificate validation is dangerous and should only be done in testing
         * environments.
         *

         */
        public Builder doNotValidateCertificate() throws GeneralSecurityException {
            hostnameVerifier = SslUtils.trustAllHostnameVerifier();
            sslSocketFactory = SslUtils.trustAllSSLContext().getSocketFactory();
            return this;
        }

        /** Returns the SSL socket factory. */
        public SSLSocketFactory getSslSocketFactory() {
            return sslSocketFactory;
        }

        /** Sets the SSL socket factory or {@code null} for the default. */
        public Builder setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
            this.sslSocketFactory = sslSocketFactory;
            return this;
        }

        /** Returns the host name verifier or {@code null} for the default. */
        public HostnameVerifier getHostnameVerifier() {
            return hostnameVerifier;
        }

        /** Sets the host name verifier or {@code null} for the default. */
        public Builder setHostnameVerifier(HostnameVerifier hostnameVerifier) {
            this.hostnameVerifier = hostnameVerifier;
            return this;
        }

        /** Returns a new instance of {@link GapiOkTransport} based on the options. */
        public GapiOkTransport build() {
            return new GapiOkTransport(proxy, sslSocketFactory, hostnameVerifier);
        }
    }

}


text:
using namespace morda;

nine_patch_button::nine_patch_button(std::shared_ptr<morda::context> c, const treeml::forest& desc) :
		widget(std::move(c), desc),
		button(this->context, desc),
		nine_patch(this->context, desc)
{
	for(const auto& p : desc){
		if(!is_property(p)){
			continue;
		}

		if(p.value == "look"){
			for(const auto& pp : p.children){
				if(!is_property(pp)){
					continue;
				}

				if(pp.value == "unpressed"){
					this->set_unpressed_nine_patch(this->context->loader.load<res::nine_patch>(get_property_value(pp).to_string()));
				}else if(pp.value == "pressed"){
					this->set_pressed_nine_patch(this->context->loader.load<res::nine_patch>(get_property_value(pp).to_string()));
				}
			}
		}
	}
	this->on_press_change();
}

void nine_patch_button::on_press_change(){
	this->set_nine_patch(this->is_pressed() ? this->pressedNinePatch_v : this->unpressedNinePatch_v);
	this->button::on_press_change();
}

void nine_patch_button::set_pressed_nine_patch(std::shared_ptr<const res::nine_patch> np){
	this->pressedNinePatch_v = std::move(np);
}

void nine_patch_button::set_unpressed_nine_patch(std::shared_ptr<const res::nine_patch> np){
	this->unpressedNinePatch_v = std::move(np);
}


text:
export default {
  up: (queryInterface, Sequelize) => {
    queryInterface.bulkInsert('User', [{
      email: 'akugbeode@gmail.com',
      username: 'blaize3',
      password: 'oghogho@ ',
      firstname: 'Akugbe',
      lastname: 'Ode',
      isAuthenticated: false
    }, {
      email: 'trailblaizer34@gmail.com',
      username: 'Don_Ode',
      password: 'mpassword@1',
      firstname: 'Muah',
      lastname: 'Me',
      isAuthenticated: false
    }, {
      email: 'egbeode@yahoo.com',
      username: 'precious4real2017',
      password: 'egbeoode',
      firstname: 'Egbe',
      lastname: 'Ode',
      isAuthenticated: false
    }], {});
  },

  down: (queryInterface, Sequelize) => {
    queryInterface.bulkDelete('User', null, {});
  }
};


text:
import {NgModule} from '@angular/core';
import {DarkModeSupportContainer} from './dark_mode_supporter_container';

@NgModule({
  declarations: [DarkModeSupportContainer],
  exports: [DarkModeSupportContainer],
})
export class DarkModeSupportModule {}


text:
package com.hazelcast.simulator.utils;

/**
 * Exception thrown when a property can't be bound to a test.
 */
public class BindException extends RuntimeException {

    public BindException(String message) {
        super(message);
    }

    public BindException(String message, Throwable cause) {
        super(message, cause);
    }
}


text:
from setuptools import setup

__version__ = None
exec(open('datetime2/version.py').read())

def next_version():
    _v = __version__.split('.')
    _v[-1] = str(int(_v[-1]) + 1)
    return '.'.join(_v)

def read_file(f):
    try:
        with open(f, 'r') as _file:
            return _file.read()
    except Exception as e:
        return ''

setup(
    name='python-datetime2',
    version=__version__,
    url='https://github.com/laco/python-datetime2/',
    download_url='https://github.com/laco/python-datetime2/tarball/' + __version__,
    license='Apache2.0',
    author='László Andrási',
    author_email='mail@laszloandrasi.com',
    description='Python3 Date&Time Best Practices',
    long_description=read_file('README') + '\n\n',
    packages=['datetime2'],
    include_package_data=True,
    zip_safe=False,
    platforms='any',
    install_requires=['pytz', 'parsedatetime', 'delorean', 'Babel', 'Flask-Babel'],
    classifiers=[
        'Development Status :: 4 - Beta',
        'Environment :: Web Environment',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: BSD License',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Topic :: Software Development :: Libraries :: Python Modules'
    ],
)


text:
// Classes reading and writing filebundles for the portable server.

#ifndef GEO_EARTH_ENTERPRISE_SRC_FUSION_PORTABLEGLOBE_SERVERS_FILEUNPACKER_SHARED_PACKETBUNDLE_H_
#define GEO_EARTH_ENTERPRISE_SRC_FUSION_PORTABLEGLOBE_SERVERS_FILEUNPACKER_SHARED_PACKETBUNDLE_H_

#include <fstream>  // NOLINT(readability/streams)
#include <string>
#include <vector>

// We have a similar enum in other places, but I am adding dbroot here.
// Order needs to match the order of the packetbundle writer if
// packet types are mixed within a single bundle.
// Start at 1 so everything is greater than 0 for initial conditions
// of packet order comparison.
enum PacketType {
  kDbRootPacket = 1,
  kDbRoot2Packet,
  kQtpPacket,
  kQtp2Packet,
  kImagePacket,
  kTerrainPacket,
  kVectorPacket,
};

/**
 * Class for index entries that describe location of packets in the
 * packet bundle files.
 */
class IndexItem {
 public:
  // Order matters here. Do NOT cross 64 bit boundaries,
  // or the structure may be laid out differently of 32-bit
  // and 64-bit machines.
  uint32 btree_high;
  uint16 btree_low;
  uint8 level;
  uint8 packet_type;
  // Channel is vector channel or time machine date channel.
  uint16 channel;
  uint16 file_id;
  uint32 packet_size;
  uint64 offset;

  /**
   * Returns whether the given IndexItem points to the same packet.
   */
  bool operator==(const IndexItem& other);

  /**
   * Returns whether the given IndexItem points to a different packet
   * that follows this one with respect to its quadtree address and
   * channel information.
   */
  bool operator<(const IndexItem& other);

  /**
   * Sets the information needed to read the packet from a file.
   * I.e. file_id, offset, and packet_size
   */
  void SetLookupInfo(const IndexItem& other);

  /**
   * Fills in values for an index item.
   */
  void Fill(const std::string& qtpath, uint8 packet_type, uint16 channel);

  // Special value for packet_type indicating channel
  // and type  should be ignored.
  static const uint8 kIgnoreChannelAndType;

  // Maximum level (lod) supported by the indexing system.
  static const uint8 kMaxLevel;
};

/**
 * Class containing constants for the reader and writer. Should not
 * be instantiated directly, but rather derived from a reader or a
 * writer.
 */
class PacketBundle {
 protected:
  /**
   * Returns packetbundle file's name for the given file id.
   */
  std::string PacketBundleFileName(uint16 file_id) const;

  /**
   * Returns index file's name.
   */
  std::string IndexFileName() const;

  PacketBundle() { }
  static const uint64 kMaxFileSize;                 // 0x7fffffffffffffff;
  static const std::string kIndexFile;              // "index"
  static const std::string kPacketbundlePrefix;     // "pbundle_"
  static const std::string kDirectoryDelimiter;     // "/"

  std::string directory_;
};

#endif  // GEO_EARTH_ENTERPRISE_SRC_FUSION_PORTABLEGLOBE_SERVERS_FILEUNPACKER_SHARED_PACKETBUNDLE_H_


text:
Generate some basic boilerplate code for a new Go app

# Installation
```
go get -u github.com/Gufran/bleh
```
bleh!

## Usage
```
bleh
```
bleh!

## WTF?
`bleh` generates a bare minimum skeleton for a Go app. It will create a `Makefile`, `.gitignore`, `.travis.yml`
along with some build specific information about your app, and configure the build step in makefile to populate
that build specific information.
It will also initialise the git repository for you, add a remote and perform an initial commit.
You can instruct `bleh` to not generate that initial commit by including `-no-commit` flag.

That is pretty much all to it, I'm sorry if you were expecting unicorns.

## What is generated by bleh?
`bleh` generates 5 files in total. Generated directory structure looks like this

```
gopath/src/repository/app
        |- .gitignore
        |- .travis.yml
        |- Makefile
        |- main.go
        |- appname
            |- appname.go
```

Where `gopath` is picked up from $GOPATH in shell environment. If $GOPATH has multiple directories you'll be prompted to select your preferred directory.
`repository` is the import path for this application, in a typical scenario this would look similar to `github.com/your-name`, and `app` is the name
of application that you'll be prompted for. Combined this makes up the import name for app i.e. `github.com/your-name/app`.

`.travis.yml` file is configured to build the application against Go v1.5

`appname/appname.go` contains the build information about the app. It includes

 - App name - as defined by you
 - App version - is generated on build, this is the commit hash on which the build is generated
 - App build - is the time of build in UTC
 - App build branch - is the git branch on which the build is generated
 - Go runtime - version is the Golang version which compiled the application
 - App description - is a short description of the application provided by you

 It also defines a function to pretty print all this information.

 `Makefile`, this is the motivator behind `bleh`, Makefile defines a bunch of commands and build configuration.

### Makefile commands

 - build - Build the application
 - test  - Trigger the test suites
 - lint  - Perform linting
 - tools - Install some development related tools
 - mocks - Generate mocks and make them available in `mocks` package
 - clean - Remove generated code, logs, builds and coverage profiles

More commands are available for granular tasks, go through the Makefile to know more about these commands

## Contributing
Although I doubt this tool can accomodate anything else anymore, I'd love to see what you have to offer.
Fork the repository, make your changes and send a pull request.

## License

The MIT License (MIT)

Copyright (c) 2015 Mohammad Gufran

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


text:
/* Code generated by IfcQuery EXPRESS generator, www.ifcquery.com */

#include <sstream>
#include <limits>
#include <map>
#include "ifcpp/reader/ReaderUtil.h"
#include "ifcpp/writer/WriterUtil.h"
#include "ifcpp/model/BasicTypes.h"
#include "ifcpp/model/BuildingException.h"
#include "ifcpp/IFC4/include/IfcFlowInstrumentTypeEnum.h"

// TYPE IfcFlowInstrumentTypeEnum = ENUMERATION OF	(PRESSUREGAUGE	,THERMOMETER	,AMMETER	,FREQUENCYMETER	,POWERFACTORMETER	,PHASEANGLEMETER	,VOLTMETER_PEAK	,VOLTMETER_RMS	,USERDEFINED	,NOTDEFINED);
shared_ptr<BuildingObject> IfcFlowInstrumentTypeEnum::getDeepCopy( BuildingCopyOptions& options )
{
	shared_ptr<IfcFlowInstrumentTypeEnum> copy_self( new IfcFlowInstrumentTypeEnum() );
	copy_self->m_enum = m_enum;
	return copy_self;
}
void IfcFlowInstrumentTypeEnum::getStepParameter( std::stringstream& stream, bool is_select_type ) const
{
	if( is_select_type ) { stream << "IFCFLOWINSTRUMENTTYPEENUM("; }
	switch( m_enum )
	{
		case ENUM_PRESSUREGAUGE:	stream << ".PRESSUREGAUGE."; break;
		case ENUM_THERMOMETER:	stream << ".THERMOMETER."; break;
		case ENUM_AMMETER:	stream << ".AMMETER."; break;
		case ENUM_FREQUENCYMETER:	stream << ".FREQUENCYMETER."; break;
		case ENUM_POWERFACTORMETER:	stream << ".POWERFACTORMETER."; break;
		case ENUM_PHASEANGLEMETER:	stream << ".PHASEANGLEMETER."; break;
		case ENUM_VOLTMETER_PEAK:	stream << ".VOLTMETER_PEAK."; break;
		case ENUM_VOLTMETER_RMS:	stream << ".VOLTMETER_RMS."; break;
		case ENUM_USERDEFINED:	stream << ".USERDEFINED."; break;
		case ENUM_NOTDEFINED:	stream << ".NOTDEFINED."; break;
	}
	if( is_select_type ) { stream << ")"; }
}
const std::wstring IfcFlowInstrumentTypeEnum::toString() const
{
	switch( m_enum )
	{
		case ENUM_PRESSUREGAUGE:	return L"PRESSUREGAUGE";
		case ENUM_THERMOMETER:	return L"THERMOMETER";
		case ENUM_AMMETER:	return L"AMMETER";
		case ENUM_FREQUENCYMETER:	return L"FREQUENCYMETER";
		case ENUM_POWERFACTORMETER:	return L"POWERFACTORMETER";
		case ENUM_PHASEANGLEMETER:	return L"PHASEANGLEMETER";
		case ENUM_VOLTMETER_PEAK:	return L"VOLTMETER_PEAK";
		case ENUM_VOLTMETER_RMS:	return L"VOLTMETER_RMS";
		case ENUM_USERDEFINED:	return L"USERDEFINED";
		case ENUM_NOTDEFINED:	return L"NOTDEFINED";
	}
	return L"";
}
shared_ptr<IfcFlowInstrumentTypeEnum> IfcFlowInstrumentTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
	if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcFlowInstrumentTypeEnum>(); }
	if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcFlowInstrumentTypeEnum>(); }
	shared_ptr<IfcFlowInstrumentTypeEnum> type_object( new IfcFlowInstrumentTypeEnum() );
	if( std_iequal( arg, L".PRESSUREGAUGE." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_PRESSUREGAUGE;
	}
	else if( std_iequal( arg, L".THERMOMETER." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_THERMOMETER;
	}
	else if( std_iequal( arg, L".AMMETER." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_AMMETER;
	}
	else if( std_iequal( arg, L".FREQUENCYMETER." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_FREQUENCYMETER;
	}
	else if( std_iequal( arg, L".POWERFACTORMETER." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_POWERFACTORMETER;
	}
	else if( std_iequal( arg, L".PHASEANGLEMETER." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_PHASEANGLEMETER;
	}
	else if( std_iequal( arg, L".VOLTMETER_PEAK." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_VOLTMETER_PEAK;
	}
	else if( std_iequal( arg, L".VOLTMETER_RMS." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_VOLTMETER_RMS;
	}
	else if( std_iequal( arg, L".USERDEFINED." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_USERDEFINED;
	}
	else if( std_iequal( arg, L".NOTDEFINED." ) )
	{
		type_object->m_enum = IfcFlowInstrumentTypeEnum::ENUM_NOTDEFINED;
	}
	return type_object;
}


text:
<?xml version="1.0" encoding="UTF-8"?>

<rootTag>
  <Award>
    <AwardTitle>NSF East Asia Summer Institutes for US Graduate Students</AwardTitle>
    <AwardEffectiveDate>06/01/2007</AwardEffectiveDate>
    <AwardExpirationDate>05/31/2008</AwardExpirationDate>
    <AwardAmount>4579</AwardAmount>
    <AwardInstrument>
      <Value>Fellowship</Value>
    </AwardInstrument>
    <Organization>
      01090000
      <Directorate>
        <LongName>Office Of The Director</LongName>
      </Directorate>
      <Division>
        <LongName>Office Of Internatl Science &Engineering</LongName>
      </Division>
    </Organization>
    <ProgramOfficer>
      <SignBlockName>Carter Kimsey</SignBlockName>
    </ProgramOfficer>
    <AbstractNarration>EAPSI 2007<br/>This award will support a U.S. graduate student to conduct summer research in East Asia and/or the Pacific Rim. The research project will provide the student with a first hand research experience, an introduction to science and science policy infrastructure, and an orientation to the culture and language of the location. The primary goals of the East Asia Pacific Summer Institute program are to expose students to science and engineering in the context of a research setting, and to initiate early-career professional relationships that foster future research collaborations with foreign counterparts.</AbstractNarration>
    <MinAmdLetterDate>06/18/2007</MinAmdLetterDate>
    <MaxAmdLetterDate>06/18/2007</MaxAmdLetterDate>
    <ARRAAmount/>
    <AwardID>0714458</AwardID>
    <Investigator>
      <FirstName>Paul</FirstName>
      <LastName>Grisham</LastName>
      <EmailAddress/>
      <StartDate>06/18/2007</StartDate>
      <EndDate/>
      <RoleCode>Principal Investigator</RoleCode>
    </Investigator>
    <Institution>
      <Name>Grisham Paul S</Name>
      <CityName>Austin</CityName>
      <ZipCode>787583114</ZipCode>
      <PhoneNumber></PhoneNumber>
      <StreetAddress></StreetAddress>
      <CountryName>United States</CountryName>
      <StateName>Texas</StateName>
      <StateCode>TX</StateCode>
    </Institution>
  </Award>
</rootTag>


text:
layout: page
title: "David Brian Barnett"
comments: true
description: "blanks"
keywords: "David Brian Barnett,CU,Boulder"
---
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
<script src="https://dl.dropboxusercontent.com/s/pc42nxpaw1ea4o9/highcharts.js?dl=0"></script>
<!-- <script src="../assets/js/highcharts.js"></script> -->
<style type="text/css">@font-face {
	font-family: "Bebas Neue";
	src: url(https://www.filehosting.org/file/details/544349/BebasNeue Regular.otf) format("opentype");
	}
	h1.Bebas {
		font-family: "Bebas Neue", Verdana, Tahoma;
	}
</style>
</head>

#### TEACHING INFORMATION

**College**: College of Arts and Sciences

**Classes taught**: PHIL 1000, PHIL 4490

#### PHIL 1000: Introduction to Philosophy

**Terms taught**: Fall 2006, Fall 2006, Fall 2007, Fall 2008, Fall 2008, Spring 2009, Fall 2009, Spring 2010, Fall 2010, Spring 2011, Fall 2011, Fall 2012, Spring 2013, Fall 2013

**Instructor rating**: 5.75

**Standard deviation in instructor rating**: 0.24

**Average grade** (4.0 scale): 2.98

**Standard deviation in grades** (4.0 scale): 0.18

**Average workload** (raw): 2.03

**Standard deviation in workload** (raw): 0.15

#### PHIL 4490: Philosophy of Language

**Terms taught**: Fall 2007, Spring 2010, Fall 2012

**Instructor rating**: 5.7

**Standard deviation in instructor rating**: 0.03

**Average grade** (4.0 scale): 3.33

**Standard deviation in grades** (4.0 scale): 0.1

**Average workload** (raw): 2.44

**Standard deviation in workload** (raw): 0.19


text:
package circumflex.maven;

import org.apache.maven.plugin.MojoExecutionException;
import java.io.File;
import java.io.FileOutputStream;
import java.util.Properties;

public abstract class AbstractConfigureMojo extends AbstractCircumflexMojo {

  public abstract File targetFile();

  public void execute() throws MojoExecutionException {
    try {
      Properties props = collectProps();
      props.setProperty("application.classpath", getApplicationClasspathString());
      getLog().info("Writing Circumflex configuration to " + targetFile());
      FileOutputStream out = new FileOutputStream(targetFile());
      try {
        props.store(out, project.getName() + " Project Properties");
      } finally {
        out.close();
      }
    } catch (Exception e) {
      throw new MojoExecutionException("Could not configure Circumflex.", e);
    }
  }

}


text:
/*
*/
package com.udfv.udf250;

import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import org.apache.xerces.parsers.*;
import org.apache.xerces.dom.*;
import com.udfv.core.*;
import com.udfv.util.*;
import com.udfv.exception.*;
import com.udfv.access.*;
import com.udfv.ecma167.*;

public class UDF_desc2 extends com.udfv.udf201.UDF_desc2
{
    /**
      コンストラクタ

      @param elem 親
      @param prefix ネームスコープ
      @param name 名前
    */
    public UDF_desc2(UDF_Element elem, String prefix, String name){
	super(elem, prefix, name == null ? getUDFClassName() : name);
    }

    public UDF_ErrorList verify() throws UDF_Exception{

	UDF_ErrorList el = new UDF_ErrorList();

	if(env.udf_revision != 0x250)
	    return super.verify();

	el.addError(verifyBase(UDF_Error.C_UDF250, "2.2.3"));

 	el.setRName("Anchor Volume Descriptor Pointer");
	el.addError(super.verify());
	el.setGlobalPoint(getGlobalPoint());

	return el;
    }
}


text:
Installs IUS Repository (http://iuscommunity.org/) for RHEL/CentOS

## Requirements

None.

## Role Variables

None.

## Example Playbook

    - hosts: servers
      roles:
        - { role: repo-ius }

## License

MIT Licence


text:
package unversioned

import (
	api "k8s.io/kubernetes/pkg/api"
	watch "k8s.io/kubernetes/pkg/watch"
)

// PodsGetter has a method to return a PodInterface.
// A group's client should implement this interface.
type PodsGetter interface {
	Pods(namespace string) PodInterface
}

// PodInterface has methods to work with Pod resources.
type PodInterface interface {
	Create(*api.Pod) (*api.Pod, error)
	Update(*api.Pod) (*api.Pod, error)
	UpdateStatus(*api.Pod) (*api.Pod, error)
	Delete(name string, options *api.DeleteOptions) error
	DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error
	Get(name string) (*api.Pod, error)
	List(opts api.ListOptions) (*api.PodList, error)
	Watch(opts api.ListOptions) (watch.Interface, error)
	Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *api.Pod, err error)
	PodExpansion
}

// pods implements PodInterface
type pods struct {
	client *CoreClient
	ns     string
}

// newPods returns a Pods
func newPods(c *CoreClient, namespace string) *pods {
	return &pods{
		client: c,
		ns:     namespace,
	}
}

// Create takes the representation of a pod and creates it.  Returns the server's representation of the pod, and an error, if there is any.
func (c *pods) Create(pod *api.Pod) (result *api.Pod, err error) {
	result = &api.Pod{}
	err = c.client.Post().
		Namespace(c.ns).
		Resource("pods").
		Body(pod).
		Do().
		Into(result)
	return
}

// Update takes the representation of a pod and updates it. Returns the server's representation of the pod, and an error, if there is any.
func (c *pods) Update(pod *api.Pod) (result *api.Pod, err error) {
	result = &api.Pod{}
	err = c.client.Put().
		Namespace(c.ns).
		Resource("pods").
		Name(pod.Name).
		Body(pod).
		Do().
		Into(result)
	return
}

func (c *pods) UpdateStatus(pod *api.Pod) (result *api.Pod, err error) {
	result = &api.Pod{}
	err = c.client.Put().
		Namespace(c.ns).
		Resource("pods").
		Name(pod.Name).
		SubResource("status").
		Body(pod).
		Do().
		Into(result)
	return
}

// Delete takes name of the pod and deletes it. Returns an error if one occurs.
func (c *pods) Delete(name string, options *api.DeleteOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("pods").
		Name(name).
		Body(options).
		Do().
		Error()
}

// DeleteCollection deletes a collection of objects.
func (c *pods) DeleteCollection(options *api.DeleteOptions, listOptions api.ListOptions) error {
	return c.client.Delete().
		Namespace(c.ns).
		Resource("pods").
		VersionedParams(&listOptions, api.ParameterCodec).
		Body(options).
		Do().
		Error()
}

// Get takes name of the pod, and returns the corresponding pod object, and an error if there is any.
func (c *pods) Get(name string) (result *api.Pod, err error) {
	result = &api.Pod{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("pods").
		Name(name).
		Do().
		Into(result)
	return
}

// List takes label and field selectors, and returns the list of Pods that match those selectors.
func (c *pods) List(opts api.ListOptions) (result *api.PodList, err error) {
	result = &api.PodList{}
	err = c.client.Get().
		Namespace(c.ns).
		Resource("pods").
		VersionedParams(&opts, api.ParameterCodec).
		Do().
		Into(result)
	return
}

// Watch returns a watch.Interface that watches the requested pods.
func (c *pods) Watch(opts api.ListOptions) (watch.Interface, error) {
	return c.client.Get().
		Prefix("watch").
		Namespace(c.ns).
		Resource("pods").
		VersionedParams(&opts, api.ParameterCodec).
		Watch()
}

// Patch applies the patch and returns the patched pod.
func (c *pods) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *api.Pod, err error) {
	result = &api.Pod{}
	err = c.client.Patch(pt).
		Namespace(c.ns).
		Resource("pods").
		SubResource(subresources...).
		Name(name).
		Body(data).
		Do().
		Into(result)
	return
}


text:
<?php

class Application_Model_PostMapper extends Application_Model_MapperAbstract
{
    protected $_dbMappableClass = 'Application_Model_Post';

    protected $_columnMap = [
        'id'=>'postId',
        'author'=>'authorId',
    ];
    protected $_dbDefaults = [];

    public function __construct()
    {
        $this->setDbTable('posts');
        $currentTimestamp = new Zend_Db_Expr('CURRENT_TIMESTAMP');
        $this->_dbDefaults = [
            'date'     => $currentTimestamp,
            'isDraft'  => false,
            'created'  => $currentTimestamp,
            'modified' => $currentTimestamp,
        ];
    }

    public function findByDay($day)
    {
        return;
    }

    public function findByDateTitle($date, $title)
    {
        $date = new DateTime($date);
        $select = $this->getDbTable()->select();
        $select->where('date(`date`) = ?', $date->format('Y-m-d'))
               ->where('slugify(title) = slugify(?)', $title);
        return current($this->fetchAll($select));
    }

}


text:
/* headers */
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "returns.h"
#include "debug.h"
#include "myxlib.h"

/* fill in size hints structure */
void
FillSizeHints(x, y, width, height, sizehints)
int x, y, width, height;
XSizeHints *sizehints;
{
	/* set values */
	sizehints->x = x;
	sizehints->y = y;
	sizehints->height = height;
	sizehints->width = width;
	sizehints->min_height = height;
	sizehints->min_width = width;
	sizehints->flags = USPosition | USSize | PMinSize;
#ifdef X11R4
	sizehints->base_width = width;
	sizehints->base_height = height;
	sizehints->flags |= PBaseSize;
#endif

	/* all done */
	return;
}

/* set window size and location hints */
void
SetSizeHints(display, window, x, y, width, height)
Display *display;
Window window;
int x, y, width, height;
{
	XSizeHints sizehints;

	/* get hint sizes */
	FillSizeHints(x, y, width, height, &sizehints);

	/* set size hints */
#ifdef X11R4
	XSetWMNormalHints(display, window, &sizehints);
#else
	XSetNormalHints(display, window, &sizehints);
#endif

	/* all done */
	return;
}


text:
// Serialization / de-serialization of decision trees.

#ifndef YGGDRASIL_DECISION_FORESTS_MODEL_DECISION_TREE_DECISION_TREE_IO_H_
#define YGGDRASIL_DECISION_FORESTS_MODEL_DECISION_TREE_DECISION_TREE_IO_H_

#include <memory>
#include <string>
#include <vector>

#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "yggdrasil_decision_forests/model/decision_tree/decision_tree.h"

namespace yggdrasil_decision_forests {
namespace model {
namespace decision_tree {

// Saves or loads a list of decision trees to drive into a sharded container of
// serialized protos.
//
// The trees and their nodes will be written in
// {directory}/{basename}@{num_shards} while 'num_shards' determined on the fly.
//
// The tree are written sequentially. For each trees, nodes are written
// sequentially, in a depth first transversal, with the <node, negative child,
// positive child> order.
absl::Status SaveTreesToDisk(
    absl::string_view directory, absl::string_view basename,
    const std::vector<std::unique_ptr<DecisionTree>>& trees,
    absl::string_view format, int* num_shards);

absl::Status LoadTreesFromDisk(
    absl::string_view directory, absl::string_view basename, int num_shards,
    int num_trees, absl::string_view format,
    std::vector<std::unique_ptr<DecisionTree>>* trees);

// Gets the recommended format to store decision trees with
// SaveTreesToDisk among the registered ones. At least one
// format should be registered.
absl::StatusOr<std::string> RecommendedSerializationFormat();

}  // namespace decision_tree
}  // namespace model
}  // namespace yggdrasil_decision_forests

#endif  // YGGDRASIL_DECISION_FORESTS_MODEL_DECISION_TREE_DECISION_TREE_IO_H_


text:
.class Landroid/net/INetworkStatsSession$Stub$Proxy;
.super Ljava/lang/Object;
.source "INetworkStatsSession.java"

# interfaces
.implements Landroid/net/INetworkStatsSession;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/net/INetworkStatsSession$Stub;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0xa
    name = "Proxy"
.end annotation

# instance fields
.field private mRemote:Landroid/os/IBinder;

# direct methods
.method constructor <init>(Landroid/os/IBinder;)V
    .locals 0
    .parameter "remote"

    .prologue
    .line 164
    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    .line 165
    iput-object p1, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    .line 166
    return-void
.end method

# virtual methods
.method public asBinder()Landroid/os/IBinder;
    .locals 1

    .prologue
    .line 169
    iget-object v0, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    return-object v0
.end method

.method public close()V
    .locals 5
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 307
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 308
    .local v0, _data:Landroid/os/Parcel;
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v1

    .line 310
    .local v1, _reply:Landroid/os/Parcel;
    :try_start_0
    const-string v2, "android.net.INetworkStatsSession"

    invoke-virtual {v0, v2}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 311
    iget-object v2, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v3, 0x5

    const/4 v4, 0x0

    invoke-interface {v2, v3, v0, v1, v4}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    .line 312
    invoke-virtual {v1}, Landroid/os/Parcel;->readException()V
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 315
    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 316
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 318
    return-void

    .line 315
    :catchall_0
    move-exception v2

    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 316
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v2
.end method

.method public getHistoryForNetwork(Landroid/net/NetworkTemplate;I)Landroid/net/NetworkStatsHistory;
    .locals 6
    .parameter "template"
    .parameter "fields"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 210
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 211
    .local v0, _data:Landroid/os/Parcel;
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v1

    .line 214
    .local v1, _reply:Landroid/os/Parcel;
    :try_start_0
    const-string v3, "android.net.INetworkStatsSession"

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 215
    if-eqz p1, :cond_0

    .line 216
    const/4 v3, 0x1

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V

    .line 217
    const/4 v3, 0x0

    invoke-virtual {p1, v0, v3}, Landroid/net/NetworkTemplate;->writeToParcel(Landroid/os/Parcel;I)V

    .line 222
    :goto_0
    invoke-virtual {v0, p2}, Landroid/os/Parcel;->writeInt(I)V

    .line 223
    iget-object v3, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v4, 0x2

    const/4 v5, 0x0

    invoke-interface {v3, v4, v0, v1, v5}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    .line 224
    invoke-virtual {v1}, Landroid/os/Parcel;->readException()V

    .line 225
    invoke-virtual {v1}, Landroid/os/Parcel;->readInt()I

    move-result v3

    if-eqz v3, :cond_1

    .line 226
    sget-object v3, Landroid/net/NetworkStatsHistory;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v3, v1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v2

    check-cast v2, Landroid/net/NetworkStatsHistory;
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 233
    .local v2, _result:Landroid/net/NetworkStatsHistory;
    :goto_1
    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 234
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 236
    return-object v2

    .line 220
    .end local v2           #_result:Landroid/net/NetworkStatsHistory;
    :cond_0
    const/4 v3, 0x0

    :try_start_1
    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 233
    :catchall_0
    move-exception v3

    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 234
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v3

    .line 229
    :cond_1
    const/4 v2, 0x0

    .restart local v2       #_result:Landroid/net/NetworkStatsHistory;
    goto :goto_1
.end method

.method public getHistoryForUid(Landroid/net/NetworkTemplate;IIII)Landroid/net/NetworkStatsHistory;
    .locals 6
    .parameter "template"
    .parameter "uid"
    .parameter "set"
    .parameter "tag"
    .parameter "fields"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 274
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 275
    .local v0, _data:Landroid/os/Parcel;
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v1

    .line 278
    .local v1, _reply:Landroid/os/Parcel;
    :try_start_0
    const-string v3, "android.net.INetworkStatsSession"

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 279
    if-eqz p1, :cond_0

    .line 280
    const/4 v3, 0x1

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V

    .line 281
    const/4 v3, 0x0

    invoke-virtual {p1, v0, v3}, Landroid/net/NetworkTemplate;->writeToParcel(Landroid/os/Parcel;I)V

    .line 286
    :goto_0
    invoke-virtual {v0, p2}, Landroid/os/Parcel;->writeInt(I)V

    .line 287
    invoke-virtual {v0, p3}, Landroid/os/Parcel;->writeInt(I)V

    .line 288
    invoke-virtual {v0, p4}, Landroid/os/Parcel;->writeInt(I)V

    .line 289
    invoke-virtual {v0, p5}, Landroid/os/Parcel;->writeInt(I)V

    .line 290
    iget-object v3, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v4, 0x4

    const/4 v5, 0x0

    invoke-interface {v3, v4, v0, v1, v5}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    .line 291
    invoke-virtual {v1}, Landroid/os/Parcel;->readException()V

    .line 292
    invoke-virtual {v1}, Landroid/os/Parcel;->readInt()I

    move-result v3

    if-eqz v3, :cond_1

    .line 293
    sget-object v3, Landroid/net/NetworkStatsHistory;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v3, v1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v2

    check-cast v2, Landroid/net/NetworkStatsHistory;
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 300
    .local v2, _result:Landroid/net/NetworkStatsHistory;
    :goto_1
    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 301
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 303
    return-object v2

    .line 284
    .end local v2           #_result:Landroid/net/NetworkStatsHistory;
    :cond_0
    const/4 v3, 0x0

    :try_start_1
    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 300
    :catchall_0
    move-exception v3

    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 301
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v3

    .line 296
    :cond_1
    const/4 v2, 0x0

    .restart local v2       #_result:Landroid/net/NetworkStatsHistory;
    goto :goto_1
.end method

.method public getInterfaceDescriptor()Ljava/lang/String;
    .locals 1

    .prologue
    .line 173
    const-string v0, "android.net.INetworkStatsSession"

    return-object v0
.end method

.method public getSummaryForAllUid(Landroid/net/NetworkTemplate;JJZ)Landroid/net/NetworkStats;
    .locals 6
    .parameter "template"
    .parameter "start"
    .parameter "end"
    .parameter "includeTags"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    const/4 v3, 0x1

    const/4 v4, 0x0

    .line 241
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 242
    .local v0, _data:Landroid/os/Parcel;
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v1

    .line 245
    .local v1, _reply:Landroid/os/Parcel;
    :try_start_0
    const-string v5, "android.net.INetworkStatsSession"

    invoke-virtual {v0, v5}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 246
    if-eqz p1, :cond_0

    .line 247
    const/4 v5, 0x1

    invoke-virtual {v0, v5}, Landroid/os/Parcel;->writeInt(I)V

    .line 248
    const/4 v5, 0x0

    invoke-virtual {p1, v0, v5}, Landroid/net/NetworkTemplate;->writeToParcel(Landroid/os/Parcel;I)V

    .line 253
    :goto_0
    invoke-virtual {v0, p2, p3}, Landroid/os/Parcel;->writeLong(J)V

    .line 254
    invoke-virtual {v0, p4, p5}, Landroid/os/Parcel;->writeLong(J)V

    .line 255
    if-eqz p6, :cond_1

    :goto_1
    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V

    .line 256
    iget-object v3, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v4, 0x3

    const/4 v5, 0x0

    invoke-interface {v3, v4, v0, v1, v5}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    .line 257
    invoke-virtual {v1}, Landroid/os/Parcel;->readException()V

    .line 258
    invoke-virtual {v1}, Landroid/os/Parcel;->readInt()I

    move-result v3

    if-eqz v3, :cond_2

    .line 259
    sget-object v3, Landroid/net/NetworkStats;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v3, v1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v2

    check-cast v2, Landroid/net/NetworkStats;
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 266
    .local v2, _result:Landroid/net/NetworkStats;
    :goto_2
    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 267
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 269
    return-object v2

    .line 251
    .end local v2           #_result:Landroid/net/NetworkStats;
    :cond_0
    const/4 v5, 0x0

    :try_start_1
    invoke-virtual {v0, v5}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 266
    :catchall_0
    move-exception v3

    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 267
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v3

    :cond_1
    move v3, v4

    .line 255
    goto :goto_1

    .line 262
    :cond_2
    const/4 v2, 0x0

    .restart local v2       #_result:Landroid/net/NetworkStats;
    goto :goto_2
.end method

.method public getSummaryForNetwork(Landroid/net/NetworkTemplate;JJ)Landroid/net/NetworkStats;
    .locals 6
    .parameter "template"
    .parameter "start"
    .parameter "end"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Landroid/os/RemoteException;
        }
    .end annotation

    .prologue
    .line 178
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v0

    .line 179
    .local v0, _data:Landroid/os/Parcel;
    invoke-static {}, Landroid/os/Parcel;->obtain()Landroid/os/Parcel;

    move-result-object v1

    .line 182
    .local v1, _reply:Landroid/os/Parcel;
    :try_start_0
    const-string v3, "android.net.INetworkStatsSession"

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInterfaceToken(Ljava/lang/String;)V

    .line 183
    if-eqz p1, :cond_0

    .line 184
    const/4 v3, 0x1

    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V

    .line 185
    const/4 v3, 0x0

    invoke-virtual {p1, v0, v3}, Landroid/net/NetworkTemplate;->writeToParcel(Landroid/os/Parcel;I)V

    .line 190
    :goto_0
    invoke-virtual {v0, p2, p3}, Landroid/os/Parcel;->writeLong(J)V

    .line 191
    invoke-virtual {v0, p4, p5}, Landroid/os/Parcel;->writeLong(J)V

    .line 192
    iget-object v3, p0, Landroid/net/INetworkStatsSession$Stub$Proxy;->mRemote:Landroid/os/IBinder;

    const/4 v4, 0x1

    const/4 v5, 0x0

    invoke-interface {v3, v4, v0, v1, v5}, Landroid/os/IBinder;->transact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    .line 193
    invoke-virtual {v1}, Landroid/os/Parcel;->readException()V

    .line 194
    invoke-virtual {v1}, Landroid/os/Parcel;->readInt()I

    move-result v3

    if-eqz v3, :cond_1

    .line 195
    sget-object v3, Landroid/net/NetworkStats;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v3, v1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v2

    check-cast v2, Landroid/net/NetworkStats;
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 202
    .local v2, _result:Landroid/net/NetworkStats;
    :goto_1
    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 203
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    .line 205
    return-object v2

    .line 188
    .end local v2           #_result:Landroid/net/NetworkStats;
    :cond_0
    const/4 v3, 0x0

    :try_start_1
    invoke-virtual {v0, v3}, Landroid/os/Parcel;->writeInt(I)V
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    goto :goto_0

    .line 202
    :catchall_0
    move-exception v3

    invoke-virtual {v1}, Landroid/os/Parcel;->recycle()V

    .line 203
    invoke-virtual {v0}, Landroid/os/Parcel;->recycle()V

    throw v3

    .line 198
    :cond_1
    const/4 v2, 0x0

    .restart local v2       #_result:Landroid/net/NetworkStats;
    goto :goto_1
.end method


text:
PACKAGE_NAME=isomorphic-form-data
PACKAGE_VERSION=${1:-v2.0.0}
PACKAGE_URL=https://github.com/form-data/isomorphic-form-data

yum install -y nodejs npm git

npm install n -g && n latest && npm install -g npm@latest

HOME_DIR=`pwd`

OS_NAME=$(cat /etc/os-release | grep ^PRETTY_NAME | cut -d= -f2)

if ! git clone $PACKAGE_URL $PACKAGE_NAME; then
	echo "------------------$PACKAGE_NAME:clone_fails---------------------------------------"
	echo "$PACKAGE_URL $PACKAGE_NAME"
	echo "$PACKAGE_NAME  |  $PACKAGE_URL | $PACKAGE_VERSION | $OS_NAME | GitHub | Fail |  Clone_Fails"
	exit 0
fi

cd $HOME_DIR/$PACKAGE_NAME
git checkout $PACKAGE_VERSION

# Only Installation as no Test cases present
if ! npm install; then
	echo "------------------$PACKAGE_NAME:install_fails-------------------------------------"
	echo "$PACKAGE_URL $PACKAGE_NAME"
	echo "$PACKAGE_NAME  |  $PACKAGE_URL | $PACKAGE_VERSION | $OS_NAME | GitHub | Fail |  Install_Fails"
	exit 0
else
	echo "------------------$PACKAGE_NAME:install_success-------------------------"
	echo "$PACKAGE_URL $PACKAGE_NAME"
	echo "$PACKAGE_NAME  |  $PACKAGE_URL | $PACKAGE_VERSION | $OS_NAME | GitHub | Pass |  Install_Success"
	exit 0
fi


text:
<!--
  ~ Copyright 2017 The Bazel Authors. 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.
  -->
<idea-plugin>

  <extensions defaultExtensionNs="com.intellij">
    <coverageEngine implementation="com.google.idea.blaze.java.run.coverage.BlazeCoverageEngine"/>
    <coverageRunner implementation="com.google.idea.blaze.java.run.coverage.BlazeCoverageRunner"/>
    <programRunner implementation="com.google.idea.blaze.java.run.coverage.BlazeCoverageProgramRunner"/>
    <projectService serviceImplementation="com.google.idea.blaze.java.run.coverage.BlazeCoverageAnnotator"/>
    <projectViewNodeDecorator implementation="com.google.idea.blaze.java.run.coverage.BlazeCoverageProjectViewClassDecorator"/>
  </extensions>

</idea-plugin>


text:
<?php

namespace Acme\MeetingBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

class womenRegFormType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('gender', 'hidden')
            ->add('email', 'text')
            ->add('password', 'text')
            ->add('FirstName', 'text')
            ->add('LastName', 'text')
            ->add('country', 'text')
            ->add('city', 'text')
            ->add('city', 'text')
            ->add('BirthDate', 'date')
            ->add('MaritalStatus', 'choice', array(
                'choices' => array('married' => 'married', 'not married' => 'not married'),
                'required' => true,
            ))
            ->add('breast', 'text')
            ->add('waist', 'text')
            ->add('Hips', 'text')
            ->add('file', 'file');
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'Acme\MeetingBundle\Entity\UserWomen'
        ));
    }

    /**
     * @return string
     */
    public function getName()
    {
        return 'form';
    }
}


text:
#include <iostream>
#include <algorithm>
#include <string>
#include <limits>

#include "nkit/detail/config.h"
#include "nkit/test.h"
#include "nkit/dynamic.h"
#include "nkit/dynamic_getter.h"
#include "nkit/logger_brief.h"
#include "nkit/version.h"

#define TABLE_GROW_SIZE 10

namespace nkit_test
{
  using namespace nkit;

  void CreateCases()
  {
    std::string error;

    { // StringVector ctor
      StringVector column_names;
      column_names.push_back("name:STRING");
      column_names.push_back("name1:INTEGER");
      column_names.push_back("name2:BOOL");
      column_names.push_back("name3:INTEGER");
      column_names.push_back("name4:FLOAT");

      for (size_t i = 0; i < TABLE_GROW_SIZE; ++i)
      {
        std::string const v = "name" + string_cast(i) + "STRING";
        column_names.push_back(v);
      }
      Dynamic table = Dynamic::Table(column_names, &error);
      NKIT_TEST_ASSERT_WITH_TEXT(table.width() == column_names.size(), error);
    }

    { // query syntax ctor
      std::string query(
          "name:STRING,name1:INTEGER,name2:BOOL,name3:INTEGER,name4:FLOAT");
      Dynamic table = Dynamic::Table(query, &error);
      NKIT_TEST_ASSERT(table.width() == 5);
    }
  }

  #define TABLE Dynamic::Table("name:STRING,name1:INTEGER,name2:BOOL,name3:INTEGER,name4:FLOAT", &error)

  #define COMMON_TABLE_INIT_(t) \
  do { \
    t = TABLE;\
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A3"), Dynamic(3), Dynamic(false), Dynamic(1), Dynamic(1.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A1"), Dynamic(1), Dynamic(false))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A2"), Dynamic(2))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(1), Dynamic(false), Dynamic(1), Dynamic(99.0))); \
  } while(0)

  #define COMMON_TABLE_INIT_2(t) \
  do { \
    t = TABLE;\
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A3"), Dynamic(10), Dynamic(false), Dynamic(1), Dynamic(100.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A1"), Dynamic(1), Dynamic(false))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A2"), Dynamic(50))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(20), Dynamic(false), Dynamic(1), Dynamic(200.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(20), Dynamic(false), Dynamic(1), Dynamic(200.0))); \
  } while(0)

  #define _COMMON_TABLE_INIT_(t) \
  do { \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A3"), Dynamic(3), Dynamic(false), Dynamic(1), Dynamic(1.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A1"), Dynamic(1), Dynamic(false))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A2"), Dynamic(2))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(1), Dynamic(false), Dynamic(1), Dynamic(99.0))); \
  } while(0)

  #define _COMMON_TABLE_INIT_2(t) \
  do { \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A3"), Dynamic(10), Dynamic(false), Dynamic(1), Dynamic(100.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A1"), Dynamic(1), Dynamic(false))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A2"), Dynamic(50))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(20), Dynamic(false), Dynamic(1), Dynamic(200.0))); \
    NKIT_TEST_ASSERT(t.AppendRow(Dynamic("A"), Dynamic(20), Dynamic(false), Dynamic(1), Dynamic(200.0))); \
  } while(0)

  #define COMMON_TABLE_INIT(t) \
  do { \
    COMMON_TABLE_INIT_(t); \
    NKIT_TEST_ASSERT(t == e); \
  } while(0)

  #define _COMMON_TABLE_INIT(t) \
  do { \
    _COMMON_TABLE_INIT_(t); \
    NKIT_TEST_ASSERT(t == e); \
  } while(0)

  static Dynamic e;

  void EnvInit()
  {
    std::string error;
    COMMON_TABLE_INIT(e);
  }

  void AppendCases()
  {
    std::string error;
    Dynamic table = TABLE;
    nkit::TableIndex::Ptr index;
    nkit::TableIndex::ConstIterator it;

    COMMON_TABLE_INIT(table);

    // Fail cases tests
    for (uint64_t ops = 0; ops < TABLE_GROW_SIZE; ++ops) // wrong type
       NKIT_TEST_ASSERT(table.AppendRow(Dynamic(ops), Dynamic(3), Dynamic(false), Dynamic(1)) ==
          false);

    NKIT_TEST_ASSERT(table == e);

    NKIT_TEST_ASSERT(!table.CreateIndex("", &error));
    NKIT_TEST_ASSERT(!table.CreateIndex("name,name1,name10", &error));

    index = table.CreateIndex("name,name1,name3", &error);
    NKIT_TEST_ASSERT(index);
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic(3), Dynamic(1)) == index->end());
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic("A3"), Dynamic(3)) == index->end());

    // Good cases test
    it = index->GetEqual(Dynamic("A3"), Dynamic(3), Dynamic(1));
    NKIT_TEST_ASSERT(it[4] == Dynamic(1.0));

    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops)
      NKIT_TEST_ASSERT(table.AppendRow(Dynamic("A3"), Dynamic(3),
          Dynamic(false), Dynamic(1), Dynamic(double(2.0 + ops))));

    it = index->GetEqual(Dynamic("A3"), Dynamic(3), Dynamic(1));
    NKIT_TEST_ASSERT(it != index->end());
    for (; it != index->end(); ++it)
    {
  #if defined(MY_TRACE_)
        print(it[4]);
  #endif // MY_TRACE_
    }
  }

  void InsertCases()
  {
    std::string error;
    Dynamic table = TABLE;
    nkit::TableIndex::Ptr index;
    nkit::TableIndex::ConstIterator it;

    COMMON_TABLE_INIT(table);

    // Fail cases tests
    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops) // wrong type
    {
      DynamicVector vargs;
      vargs.push_back(Dynamic(1));
      vargs.push_back(Dynamic(3));
      vargs.push_back(Dynamic(false));
      vargs.push_back(Dynamic(1));
      vargs.push_back(Dynamic("name"));
      NKIT_TEST_ASSERT(table.InsertRow(0, vargs) == false);
    }
    NKIT_TEST_ASSERT(table == e);

    index = table.CreateIndex("name,name1,name3", &error);
    NKIT_TEST_ASSERT(index);
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic(3), Dynamic(1)) == index->end());
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic("A3"), Dynamic(3)) == index->end());

    // Good cases tests
    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops)
    {
      DynamicVector vargs;
      vargs.push_back(Dynamic("A3"));
      vargs.push_back(Dynamic(3));
      vargs.push_back(Dynamic(false));
      vargs.push_back(Dynamic(1));
      vargs.push_back(Dynamic(double(2.0 + ops)));
      NKIT_TEST_ASSERT(table.InsertRow(0, vargs));
    }
    it = index->GetEqual(Dynamic("A3"), Dynamic(3), Dynamic(1));
    NKIT_TEST_ASSERT(it != index->end());
    for (; it != index->end(); ++it)
    {
  #if defined(MY_TRACE_)
        print(it[4]);
  #endif // MY_TRACE_
    }

    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops)
    {
      DynamicVector vargs;
      vargs.push_back(Dynamic("A10"));
      vargs.push_back(Dynamic(3));
      vargs.push_back(Dynamic(false));
      vargs.push_back(Dynamic(1));
      vargs.push_back(Dynamic(double(1.0 + ops)));
      NKIT_TEST_ASSERT(table.InsertRow(table.height() / 2, vargs));
    }

    it = index->GetEqual(Dynamic("A10"), Dynamic(3), Dynamic(1));
    NKIT_TEST_ASSERT(it != index->end());
    for (; it != index->end(); ++it)
    {
  #if defined(MY_TRACE_)
        print(it[4]);
  #endif // MY_TRACE_
    }

    it = index->GetEqual(Dynamic("A"), Dynamic(1), Dynamic(1));
    NKIT_TEST_ASSERT(it != index->end());
    NKIT_TEST_ASSERT(it[4] == Dynamic(99.0));

    it = index->GetEqual(Dynamic("A2"), Dynamic(2), Dynamic::GetDefault(detail::INTEGER));
    NKIT_TEST_ASSERT(it != index->end());

    it = index->GetEqual(Dynamic("A1"), Dynamic(1), Dynamic::GetDefault(detail::INTEGER));
    NKIT_TEST_ASSERT(it != index->end());
  }

  void DeleteCases()
  {
    std::string error;
    Dynamic table = TABLE;
    nkit::TableIndex::Ptr index;
    nkit::TableIndex::ConstIterator it;

    COMMON_TABLE_INIT(table);

    index = table.CreateIndex("name,name1,name3", &error);

    // Fail cases tests
    NKIT_TEST_ASSERT(index);
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic(3), Dynamic(1)) == index->end());
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic("A3"), Dynamic(3)) == index->end());

    // Good cases tests
    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops)
    {
      DynamicVector vargs;
      vargs.push_back(Dynamic("A3"));
      vargs.push_back(Dynamic(3));
      vargs.push_back(Dynamic(false));
      vargs.push_back(Dynamic(1));
      vargs.push_back(Dynamic(double(2.0 + ops)));
      NKIT_TEST_ASSERT(table.InsertRow(0, vargs));
    }

    for (size_t ops = 0; ops < TABLE_GROW_SIZE; ++ops)
      NKIT_TEST_ASSERT(table.DeleteRow(0));

    it = index->GetEqual(Dynamic("A3"), Dynamic(3), Dynamic(1));
    NKIT_TEST_ASSERT(it != index->end());
    for (; it != index->end(); ++it)
    {
  #if defined(MY_TRACE_)
        print(it[4]);
  #endif // MY_TRACE_
    }

    NKIT_TEST_ASSERT(table == e);
  }

  void SetCases()
  {
    std::string error;
    Dynamic table = TABLE;
    nkit::TableIndex::Ptr index;
    nkit::TableIndex::ConstIterator it;

    DynamicVector vargs;
    vargs.push_back(Dynamic("NEW"));
    vargs.push_back(Dynamic(0));
    vargs.push_back(Dynamic(true));
    vargs.push_back(Dynamic(0));
    vargs.push_back(Dynamic(0.0));

    COMMON_TABLE_INIT(table);

    index = table.CreateIndex("name,name1", &error);
    NKIT_TEST_ASSERT_WITH_TEXT(index, error);

    NKIT_TEST_ASSERT(table.SetRow(table.height() / 2, vargs));
    DynamicVector::iterator vit = vargs.begin();
    for (size_t col = 0; vit != vargs.end(); ++vit, ++col)
    {
  #if defined(MY_TRACE_)
    print(*vit, "", false);
    std::cout << " <> ";
    print(table.GetCellValue(table.height() / 2, col));
  #endif // MY_TRACE_
      NKIT_TEST_ASSERT(*vit == table.GetCellValue(table.height() / 2, col));
    } // for
    NKIT_TEST_ASSERT(index->GetEqual(Dynamic("NEW"),Dynamic(0)) != index->end());
  }
/*
#define MY_TRACE_

  void PrintTable(const Dynamic & table)
  {
  #if !defined(MY_TRACE_)
    (void)table;
  #else
    size_t shift_size = 0;
    StringVector cols = table.GetColumnNames();
    StringVector::const_iterator beg = cols.begin();

    for (; beg != cols.end(); ++beg)
    {
      if (beg->size() > shift_size)
        shift_size = beg->size();
    }

    std::string shift;
    beg = cols.begin();
    for (; beg != cols.end(); ++beg)
    {
      std::cout << shift << " | " << *beg;
      shift = std::string(shift_size, ' ');
    }
    std::cout << std::endl;

    std::string shift_;
    const size_t h_size = table.height(), w_size = table.width();
    for (size_t row = 0; row < h_size; ++row)
    {
      for (size_t col = 0; col < w_size; ++col)
      {
        //if (col > 0)
        //  shift_ = std::string(shift_size, ' '); //shift_ = shift.size();
        print(std::cout, table.GetCellValue(row, col), shift_ + " | ", false);
      }
      std::cout << std::endl;
    }
  #endif // MY_TRACE_
  }
*/
  void GroupCases()
  {
    std::string error;
    Dynamic table = TABLE;

    _COMMON_TABLE_INIT(table);
    _COMMON_TABLE_INIT_(table);
    _COMMON_TABLE_INIT_2(table);
    /*
       Error cases
    */
    {
      std::string error;
      Dynamic group_table(table.Group("",
          "COUNT, SUM(name4)", &error));
      NKIT_TEST_ASSERT(!error.empty());
    }
    // --------------------
    {
      std::string error;
      Dynamic group_table(table.Group("name,name1",
          "", &error));
      NKIT_TEST_ASSERT(!error.empty());
    }
    // --------------------
    {
      std::string error;
      Dynamic group_table(table.Group("name,name1,__NOT_EXISTS__",
          "COUNT, SUM(name4)", &error));
      NKIT_TEST_ASSERT(!error.empty());
    }
    // --------------------
    {
      std::string error;
      Dynamic group_table(table.Group("name,name1,name3",
          "COUNT, SUM(name4),__WRONG_AGGREGATOR__(name3)", &error));
      NKIT_TEST_ASSERT(!error.empty());
    }
    // --------------------
    {
      std::string error;
      Dynamic group_table(table.Group("name,name1,name3",
          "COUNT, MAX(name)", &error)); // string -> MAX
      NKIT_TEST_ASSERT(!error.empty());
    }
    /*
       Good cases
     */
    {
      std::string error;
      //CINFO(table);
      Dynamic group_table(table.Group("name3",
        "COUNT, SUM(name4)", &error));
      NKIT_TEST_ASSERT_WITH_TEXT(error.empty(), error);
      //CINFO(group_table);
    }
    {
      std::string error;
      Dynamic group_table(table.Group("name,name3",
        "COUNT, SUM(name4),MAX(name4)", &error));
      NKIT_TEST_ASSERT_WITH_TEXT(error.empty(), error);
      //CINFO(group_table);
    }
    {
      CINFO(table);
      std::string error;
      Dynamic group_table(table.Group("name,name1,name3",
        "  COUNT, SUM(name4),MIN(name1), MAX(name4)   ", &error));
      NKIT_TEST_ASSERT_WITH_TEXT(error.empty(), error);
      //CINFO(group_table);

      // | STRING     | INTEGER     | INTEGER     | INTEGER     | FLOAT     | INTEGER     | FLOAT
      Dynamic et(Dynamic::Table("name:STRING,name1:INTEGER,name2:INTEGER,COUNT:INTEGER,SUM:FLOAT,MIN:INTEGER,MAX:FLOAT", &error));
      // | A3         | 3           | 1           | 2           | 2.000000  | 0           | 1.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A3"), Dynamic(3), Dynamic(1), Dynamic(2), Dynamic(2.0), Dynamic(0), Dynamic(1.0)));
      // | A1         | 1           | 0           | 3           | 0.000000  | 0           | 0.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A1"), Dynamic(1), Dynamic(0), Dynamic(3), Dynamic(0.0), Dynamic(0), Dynamic(0.0)));
      // | A2         | 2           | 0           | 2           | 0.000000  | 0           | 0.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A2"), Dynamic(2), Dynamic(0), Dynamic(2), Dynamic(0.0), Dynamic(0), Dynamic(0.0)));
      // | A | 1 | 1 | 2 | 198.000000 | 0 | 99.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A"), Dynamic(1), Dynamic(1), Dynamic(2), Dynamic(198.0), Dynamic(0), Dynamic(99.0)));
      // | A3 | 10 | 1 | 1 | 100.000000 | 0 | 100.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A3"), Dynamic(10), Dynamic(1), Dynamic(1), Dynamic(100.0), Dynamic(0), Dynamic(100.0)));
      // | A2 | 50 | 0 | 1 | 0.000000 | 0 | 0.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A2"), Dynamic(50), Dynamic(0), Dynamic(1), Dynamic(0.0), Dynamic(0), Dynamic(0.0)));
      // | A | 20 | 1 | 2 | 400.000000 | 0 | 200.000000
      NKIT_TEST_ASSERT(et.AppendRow(Dynamic("A"), Dynamic(20), Dynamic(1), Dynamic(2), Dynamic(400.0), Dynamic(0), Dynamic(200.0)));

      CINFO(group_table);
      CINFO(et);

      NKIT_TEST_ASSERT(group_table == et);
    }
  }

  void TableIteratorCases()
  {
    std::string error;
    Dynamic table = TABLE;
    COMMON_TABLE_INIT(table);
    Dynamic::TableIterator it = table.begin_t();
    Dynamic::TableIterator end = table.end_t();

    for (size_t row = 0; it != end; ++it, ++row)
    {
      for (size_t col = 0; col < table.width(); ++col)
        NKIT_TEST_ASSERT(it[col] == table.GetCellValue(row, col));
    }

    it = table.begin_t();
    for (size_t row = 0; it != end; it++, ++row)
    {
      for (size_t col = 0; col < table.width(); ++col)
        NKIT_TEST_ASSERT(it[col] == table.GetCellValue(row, col));
    }
  }

  NKIT_TEST_CASE(DynamicTable)
  {
    Dynamic etalon_name1("Son");
    Dynamic etalon_age1(38);
    Dynamic etalon_name2("Father");
    Dynamic etalon_age2(56);
    Dynamic tbl = DTBL("name :STRING, age: INTEGER",
        etalon_name1 << etalon_age1 <<
        etalon_name2 << etalon_age2);
    NKIT_TEST_ASSERT(tbl.GetCellValue(0, 0) == etalon_name1);
    NKIT_TEST_ASSERT(tbl.GetCellValue(0, 1) == etalon_age1);
    NKIT_TEST_ASSERT(tbl.GetCellValue(1, 0) == etalon_name2);
    NKIT_TEST_ASSERT(tbl.GetCellValue(1, 1) == etalon_age2);

    Dynamic::TableIterator it = tbl.begin_t(), end = tbl.end_t();
    NKIT_TEST_ASSERT(it != end);
    NKIT_TEST_ASSERT(it[0] == etalon_name1);
    NKIT_TEST_ASSERT(it[1] == etalon_age1);
    NKIT_TEST_ASSERT(++it != end);
    NKIT_TEST_ASSERT(it[0] == etalon_name2);
    NKIT_TEST_ASSERT(it[1] == etalon_age2);
    NKIT_TEST_ASSERT(++it == end);

    Dynamic clone = tbl.Clone();
    NKIT_TEST_ASSERT(clone == tbl);
  }

  NKIT_TEST_CASE(DynamicTableCreateCases)
  {
    EnvInit();
    CreateCases();
  }

  NKIT_TEST_CASE(DynamicTableAppendCases)
  {
    EnvInit();
    AppendCases();
  }

  NKIT_TEST_CASE(DynamicTableInsertCases)
  {
    EnvInit();
    InsertCases();
  }

  NKIT_TEST_CASE(DynamicTableDeleteCases)
  {
    EnvInit();
    DeleteCases();
  }

  NKIT_TEST_CASE(DynamicTableSetCases)
  {
    EnvInit();
    SetCases();
  }

  _NKIT_TEST_CASE(DynamicTableGroupCases)
  {
    EnvInit();
    GroupCases();
  }

  NKIT_TEST_CASE(DynamicTableIterator)
  {
    EnvInit();
    TableIteratorCases();
  }

} // namespace nkit_test


text:
var assert = require('assert'),
    path = require('path'),
    spawn = require('child_process').spawn;

describe('publish', function () {
    var script = path.resolve(__dirname, '..', 'bin', 'publish.js');
    var opts = {
      cwd: path.resolve(__dirname, '..')
    };
    describe('#publishTag', function () {
        it('should use the default config value when not provided', function (done) {
            var testTagDefault = spawn(script, ['--test'], opts),
                output = "";
						testTagDefault.stderr.on('data', function (data) {
                output += data;
            });
            testTagDefault.on('close', function (code) {
								assert.ok(!output.includes('Using tag'), 'The output included "Using tag":\n' + output);
								assert.ifError(code, 'Unexpected error code: ' + code);
                done();
            });
        });
        it('should set the tag provided', function (done) {
            var testTagSet = spawn(script, ['--test', '--tag', 'foo'], opts),
                output = "";
						testTagSet.stderr.on('data', function (data) {
                output += data;
            });
            testTagSet.on('close', function (code) {
								assert.ok(output.includes('Using tag foo'), 'The output did not include "Using tag foo":\n' + output);
								assert.ok(code, 'Unexpected error code: ' + code);
                done();
            });
        });
    });
});

// older versions of node did not support String.includes(), Polyfill from MDN:
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes#Polyfill
if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    if (typeof start !== 'number') {
      start = 0;
    }

    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}


text:
django-debug-toolbar-user-panel
===============================

Documentation: http://code.playfire.com/django-debug-toolbar-user-panel/

.. figure::  http://code.playfire.com/django-debug-toolbar-user-panel/_images/screenshot.png
   :align:   center


text:
import React from 'react'
import Header from './Header'

const DefaultHeader = () => (
	<Header
		title="Chris Aubert"
		name="Chris Aubert"
		description="Developer, gamer, musician and some other stuff. Computer Science student at the University of Portsmouth"
	>
		<meta charSet="utf-8" />
		<meta name="keywords" content="chris, christopher, aubert, geeky, aubergine, geekyaubergine, university, portsmouth, developer, software, web, ui, ux, design" />
		<meta name="author" content="Chris Aubert" />
		<meta name="viewport" content="width=device-width, initial-scale=1" />
		<script type="text/javascript" async="" src="http://www.google-analytics.com/ga.js"></script>
		<script async="" src="//ajax.cloudflare.com/cdn-cgi/nexp/dok3v=f2befc48d1/cloudflare.min.js"></script>
		<script type="text/javascript"></script>
		<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" integrity="sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN" crossOrigin="anonymous" />
		<link rel="dns-prefetch" href="//fonts.gstatic.com" />
		<link rel="stylesheet" href="/css/app.css" />

		<meta name="twitter:card" content="summary" />
		<meta name="twitter:site" content="@geekyaubergine" />
	</Header>
)

export default DefaultHeader


text:
from . import constants
from .assembled_entry_factory import AssembledEntryFactory
from .datacatalog_tag_template_factory import DataCatalogTagTemplateFactory
from .entry_relationship_mapper import EntryRelationshipMapper

__all__ = (
    'constants',
    'AssembledEntryFactory',
    'DataCatalogTagTemplateFactory',
    'EntryRelationshipMapper',
)


text:
package org.rlcommunity.environments.acrobot.messages;

import java.util.StringTokenizer;

import rlVizLib.messaging.AbstractResponse;
import rlVizLib.messaging.GenericMessage;
import rlVizLib.messaging.MessageUser;
import rlVizLib.messaging.MessageValueType;
import rlVizLib.messaging.NotAnRLVizMessageException;
import rlVizLib.messaging.environment.EnvMessageType;

public class StateResponse extends AbstractResponse {

    private double theta1;
    private double theta2;
    private double theta1dot;
    private double theta2dot;
    private int theAction;

    public StateResponse(int action, double theta1, double theta2, double theta1dot, double theta2dot) {
        this.theta1 = theta1;
        this.theta2 = theta2;
        this.theta1dot = theta1dot;
        this.theta2dot = theta2dot;
        this.theAction = action;
    }

    public StateResponse(String responseMessage) throws NotAnRLVizMessageException {

        GenericMessage theGenericResponse = new GenericMessage(responseMessage);

        String thePayLoadString = theGenericResponse.getPayLoad();

        StringTokenizer stateTokenizer = new StringTokenizer(thePayLoadString, ":");

        theAction = Integer.parseInt(stateTokenizer.nextToken());
        theta1 = Double.parseDouble(stateTokenizer.nextToken());
        theta2 = Double.parseDouble(stateTokenizer.nextToken());
        theta1dot = Double.parseDouble(stateTokenizer.nextToken());
        theta2dot = Double.parseDouble(stateTokenizer.nextToken());
    }

    @Override
    public String toString() {
        String theResponse = this.getClass().getName()+": not implemented ";
        return theResponse;
    }

    @Override
    public String makeStringResponse() {
        StringBuffer theResponseBuffer = new StringBuffer();
        theResponseBuffer.append("TO=");
        theResponseBuffer.append(MessageUser.kBenchmark.id());
        theResponseBuffer.append(" FROM=");
        theResponseBuffer.append(MessageUser.kEnv.id());
        theResponseBuffer.append(" CMD=");
        theResponseBuffer.append(EnvMessageType.kEnvResponse.id());
        theResponseBuffer.append(" VALTYPE=");
        theResponseBuffer.append(MessageValueType.kStringList.id());
        theResponseBuffer.append(" VALS=");

        theResponseBuffer.append(theAction);
        theResponseBuffer.append(":");
        theResponseBuffer.append(theta1);
        theResponseBuffer.append(":");
        theResponseBuffer.append(theta2);
        theResponseBuffer.append(":");
        theResponseBuffer.append(theta1dot);
        theResponseBuffer.append(":");
        theResponseBuffer.append(theta2dot);

        return theResponseBuffer.toString();
    }

    public double getTheta1() {
        return theta1;
    }

    public double getTheta2() {
        return theta2;
    }

    public double getTheta1Dot() {
        return theta1dot;
    }

    public int getAction() {
        return theAction;
    }

    public double getTheta2Dot() {
        return theta2dot;
    }
};


text:
/*
** NOTE: This file is generated by Gulp and should not be edited directly!
** Any changes made directly to this file will be overwritten next time its asset group is processed by Gulp.
*/

/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNsb3VkbWVkaWEtYWRtaW4tam9iLmNzcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsQUFMQSIsImZpbGUiOiJjbG91ZG1lZGlhLWFkbWluLWpvYi5jc3MiLCJzb3VyY2VSb290IjoiL3NvdXJjZS8iLCJzb3VyY2VzQ29udGVudCI6W119 */


text:
`goaci` is a simple command-line tool to build go projects into ACIs which confirm to the [app container specification][appc-spec].

[appc-spec]: https://github.com/appc/spec

## Usage

Use goaci as you would `go get`:

	$ goaci github.com/coreos/etcd
	Wrote etcd.aci
	$ actool -debug validate etcd.aci
	etcd.aci: valid app container image

## How it works

`goaci` creates a temporary directory and uses it as a `GOPATH`; it then `go get`s the specified package and compiles it statically.
Then it generates a very basic image manifest (using mostly default values, configurables coming soon) and leverages the [appc/spec](https://github.com/appc/spec) libraries to construct an ACI.

## TODO

Lots, check out the top of [goaci.go](goaci.go)