text:
package rx.observables;

import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Observable.Operator;
import rx.Subscriber;
import rx.Subscription;
import rx.functions.Func0;
import rx.functions.Func1;
import rx.functions.Func2;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.util.Arrays;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Pattern;

public class StringObservable {
    /**
     * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
     * {@code byte[]}s
     *

     *
     *
     * @param i
     *            Source {@link InputStream}
     * @return the Observable containing read byte arrays from the input
     */
    public static Observable<byte[]> from(final InputStream i) {
        return from(i, 8 * 1024);
    }

    private static class CloseableResource<S extends Closeable> implements Subscription {
        private final AtomicBoolean unsubscribed = new AtomicBoolean();
        private S closable;

        public CloseableResource(S closeable) {
            this.closable = closeable;
        }

        @Override
        public void unsubscribe() {
            if (unsubscribed.compareAndSet(false, true)) {
                try {
                    closable.close();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }

        @Override
        public boolean isUnsubscribed() {
            return unsubscribed.get();
        }
    }

    /**
     * Func0 that allows throwing an {@link IOException}s commonly thrown during IO operations.
     * @see StringObservable#from(UnsafeFunc0, UnsafeFunc1)
     *
     * @param <R>
     */
    public static interface UnsafeFunc0<R> extends Callable<R> {
        public R call() throws Exception;
    }

    /**
     * Helps in creating an Observable that automatically calls {@link Closeable#close()} on completion, error or unsubscribe.
     *
     *

     * StringObservable.using(() -> new FileReader(file), (reader) -> StringObservable.from(reader))
     *

     *
     * @param resourceFactory
     *            Generates a new {@link Closeable} resource for each new subscription to the returned Observable
     * @param observableFactory
     *            Converts the {@link Closeable} resource into a {@link Observable} with {@link #from(InputStream)} or {@link #from(Reader)}
     * @return
     */
    public static <R, S extends Closeable> Observable<R> using(final UnsafeFunc0<S> resourceFactory,
            final Func1<S, Observable<R>> observableFactory) {
        return Observable.using(new Func0<CloseableResource<S>>() {
            @Override
            public CloseableResource<S> call() {
                try {
                    return new CloseableResource<S>(resourceFactory.call());
                } catch (Throwable e) {
                    throw new RuntimeException(e);
                }
            }
        }, new Func1<CloseableResource<S>, Observable<R>>() {
            @Override
            public Observable<R> call(CloseableResource<S> t1) {
                return observableFactory.call(t1.closable);
            }
        });
    }

    /**
     * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
     * {@code byte[]}s
     *

     *
     *
     * @param i
     *            Source {@link InputStream}
     * @param size
     *            internal buffer size
     * @return the Observable containing read byte arrays from the input
     */
    public static Observable<byte[]> from(final InputStream i, final int size) {
        return Observable.create(new OnSubscribe<byte[]>() {
            @Override
            public void call(Subscriber<? super byte[]> o) {
                byte[] buffer = new byte[size];
                try {
                    if (o.isUnsubscribed())
                        return;
                    int n = i.read(buffer);
                    while (n != -1 && !o.isUnsubscribed()) {
                        o.onNext(Arrays.copyOf(buffer, n));
                        if (!o.isUnsubscribed())
                            n = i.read(buffer);
                    }
                } catch (IOException e) {
                    o.onError(e);
                }
                if (o.isUnsubscribed())
                    return;
                o.onCompleted();
            }
        });
    }

    /**
     * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
     * {@link String}s
     *

     *
     *
     * @param i
     *            Source {@link Reader}
     * @return the Observable of Strings read from the source
     */
    public static Observable<String> from(final Reader i) {
        return from(i, 8 * 1024);
    }

    /**
     * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
     * {@link String}s
     *

     *
     *
     * @param i
     *            Source {@link Reader}
     * @param size
     *            internal buffer size
     * @return the Observable of Strings read from the source
     */
    public static Observable<String> from(final Reader i, final int size) {
        return Observable.create(new OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> o) {
                char[] buffer = new char[size];
                try {
                    if (o.isUnsubscribed())
                        return;
                    int n = 0;
                    n = i.read(buffer);
                    while (n != -1 && !o.isUnsubscribed()) {
                        o.onNext(new String(buffer, 0, n));
                        n = i.read(buffer);
                    }
                } catch (IOException e) {
                    o.onError(e);
                }
                if (o.isUnsubscribed())
                    return;
                o.onCompleted();
            }
        });
    }

    /**
     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
     * and where handles when a multibyte character spans two chunks.
     *

     *
     *
     * @param src
     * @param charsetName
     * @return the Observable returning a stream of decoded strings
     */
    public static Observable<String> decode(Observable<byte[]> src, String charsetName) {
        return decode(src, Charset.forName(charsetName));
    }

    /**
     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
     * and where handles when a multibyte character spans two chunks.
     *

     *
     *
     * @param src
     * @param charset
     * @return the Observable returning a stream of decoded strings
     */
    public static Observable<String> decode(Observable<byte[]> src, Charset charset) {
        return decode(src, charset.newDecoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE));
    }

    /**
     * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
     * and where it handles when a multibyte character spans two chunks.
     * This method allows for more control over how malformed and unmappable characters are handled.
     *

     *
     *
     * @param src
     * @param charsetDecoder
     * @return the Observable returning a stream of decoded strings
     */
    public static Observable<String> decode(final Observable<byte[]> src, final CharsetDecoder charsetDecoder) {
        return src.lift(new Operator<String, byte[]>() {
            @Override
            public Subscriber<? super byte[]> call(final Subscriber<? super String> o) {
                return new Subscriber<byte[]>(o) {
                    private ByteBuffer leftOver = null;

                    @Override
                    public void onCompleted() {
                        if (process(null, leftOver, true))
                            o.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        if (process(null, leftOver, true))
                            o.onError(e);
                    }

                    @Override
                    public void onNext(byte[] bytes) {
                        process(bytes, leftOver, false);
                    }

                    public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
                        if (o.isUnsubscribed())
                            return false;

                        ByteBuffer bb;
                        if (last != null) {
                            if (next != null) {
                                // merge leftover in front of the next bytes
                                bb = ByteBuffer.allocate(last.remaining() + next.length);
                                bb.put(last);
                                bb.put(next);
                                bb.flip();
                            }
                            else { // next == null
                                bb = last;
                            }
                        }
                        else { // last == null
                            if (next != null) {
                                bb = ByteBuffer.wrap(next);
                            }
                            else { // next == null
                                return true;
                            }
                        }

                        CharBuffer cb = CharBuffer.allocate((int) (bb.limit() * charsetDecoder.averageCharsPerByte()));
                        CoderResult cr = charsetDecoder.decode(bb, cb, endOfInput);
                        cb.flip();

                        if (cr.isError()) {
                            try {
                                cr.throwException();
                            }
                            catch (CharacterCodingException e) {
                                o.onError(e);
                                return false;
                            }
                        }

                        if (bb.remaining() > 0) {
                            leftOver = bb;
                        }
                        else {
                            leftOver = null;
                        }

                        String string = cb.toString();
                        if (!string.isEmpty())
                            o.onNext(string);

                        return true;
                    }
                };
            }
        });
    }

    /**
     * Encodes a possible infinite stream of strings into a Observable of byte arrays.
     *

     *
     *
     * @param src
     * @param charsetName
     * @return the Observable with a stream of encoded byte arrays
     */
    public static Observable<byte[]> encode(Observable<String> src, String charsetName) {
        return encode(src, Charset.forName(charsetName));
    }

    /**
     * Encodes a possible infinite stream of strings into a Observable of byte arrays.
     *

     *
     *
     * @param src
     * @param charset
     * @return the Observable with a stream of encoded byte arrays
     */
    public static Observable<byte[]> encode(Observable<String> src, Charset charset) {
        return encode(src, charset.newEncoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE));
    }

    /**
     * Encodes a possible infinite stream of strings into a Observable of byte arrays.
     * This method allows for more control over how malformed and unmappable characters are handled.
     *

     *
     *
     * @param src
     * @param charsetEncoder
     * @return the Observable with a stream of encoded byte arrays
     */
    public static Observable<byte[]> encode(Observable<String> src, final CharsetEncoder charsetEncoder) {
        return src.map(new Func1<String, byte[]>() {
            @Override
            public byte[] call(String str) {
                CharBuffer cb = CharBuffer.wrap(str);
                ByteBuffer bb;
                try {
                    bb = charsetEncoder.encode(cb);
                } catch (CharacterCodingException e) {
                    throw new RuntimeException(e);
                }
                return Arrays.copyOfRange(bb.array(), bb.position(), bb.limit());
            }
        });
    }

    /**
     * Gather up all of the strings in to one string to be able to use it as one message. Don't use
     * this on infinite streams.
     *

     *
     *
     * @param src
     * @return the Observable returing all strings concatenated as a single string
     */
    public static Observable<String> stringConcat(Observable<String> src) {
        return toString(src.reduce(new StringBuilder(), new Func2<StringBuilder, String, StringBuilder>() {
            @Override
            public StringBuilder call(StringBuilder a, String b) {
                return a.append(b);
            }
        }));
    }

    /**
     * Maps {@link Observable}<{@link Object}> to {@link Observable}<{@link String}> by using {@link String#valueOf(Object)}
     * @param src
     * @return
     */
    public static Observable<String> toString(Observable<?> src) {
        return src.map(new Func1<Object, String>() {
            @Override
            public String call(Object obj) {
                return String.valueOf(obj);
            }
        });
    }

    /**
     * Rechunks the strings based on a regex pattern and works on infinite stream.
     *
     *

     * split(["boo:an", "d:foo"], ":") --> ["boo", "and", "foo"]
     * split(["boo:an", "d:foo"], "o") --> ["b", "", ":and:f", "", ""]
     *

     *
     * See {@link Pattern}
     *

     *
     *
     * @param src
     * @param regex
     * @return the Observable streaming the split values
     */
    public static Observable<String> split(final Observable<String> src, String regex) {
        final Pattern pattern = Pattern.compile(regex);

        return src.lift(new Operator<String, String>() {
            @Override
            public Subscriber<? super String> call(final Subscriber<? super String> o) {
                return new Subscriber<String>(o) {
                    private String leftOver = null;

                    @Override
                    public void onCompleted() {
                        if (leftOver!=null)
                            output(leftOver);
                        if (!o.isUnsubscribed())
                            o.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        if (leftOver!=null)
                            output(leftOver);
                        if (!o.isUnsubscribed())
                            o.onError(e);
                    }

                    @Override
                    public void onNext(String segment) {
                        String[] parts = pattern.split(segment, -1);

                        if (leftOver != null)
                            parts[0] = leftOver + parts[0];
                        for (int i = 0; i < parts.length - 1; i++) {
                            String part = parts[i];
                            output(part);
                        }
                        leftOver = parts[parts.length - 1];
                    }

                    private int emptyPartCount = 0;

                    /**
                     * when limit == 0 trailing empty parts are not emitted.
                     *
                     * @param part
                     */
                    private void output(String part) {
                        if (part.isEmpty()) {
                            emptyPartCount++;
                        }
                        else {
                            for (; emptyPartCount > 0; emptyPartCount--)
                                if (!o.isUnsubscribed())
                                    o.onNext("");
                            if (!o.isUnsubscribed())
                                o.onNext(part);
                        }
                    }
                };
            }
        });
    }

    /**
     * Concatenates the sequence of values by adding a separator
     * between them and emitting the result once the source completes.
     *

     *
     *

     * The conversion from the value type to String is performed via
     * {@link java.lang.String#valueOf(java.lang.Object)} calls.
     *

     * For example:
     *
     *

     * Observable<Object> source = Observable.from("a", 1, "c");
     * Observable<String> result = join(source, ", ");
     *

     *
     * will yield a single element equal to "a, 1, c".
     *
     * @param source
     *            the source sequence of CharSequence values
     * @param separator
     *            the separator to a
     * @return an Observable which emits a single String value having the concatenated
     *         values of the source observable with the separator between elements
     */
    public static Observable<String> join(final Observable<String> source, final CharSequence separator) {
        return source.lift(new Operator<String, String>() {
            @Override
            public Subscriber<String> call(final Subscriber<? super String> o) {
                return new Subscriber<String>(o) {
                    boolean mayAddSeparator;
                    StringBuilder b = new StringBuilder();

                    @Override
                    public void onCompleted() {
                        String str = b.toString();
                        b = null;
                        if (!o.isUnsubscribed())
                            o.onNext(str);
                        if (!o.isUnsubscribed())
                            o.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        b = null;
                        if (!o.isUnsubscribed())
                            o.onError(e);
                    }

                    @Override
                    public void onNext(String t) {
                        if (mayAddSeparator) {
                            b.append(separator);
                        }
                        mayAddSeparator = true;
                        b.append(t);
                    }
                };
            }
        });
    }

    public final static class Line {
        private final int number;
        private final String text;

        public Line(int number, String text) {
            this.number = number;
            this.text = text;
        }

        public int getNumber() {
            return number;
        }

        public String getText() {
            return text;
        }

        @Override
        public int hashCode() {
            int result = 31 + number;
            result = 31 * result + (text == null ? 0 : text.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof Line))
                return false;
            Line other = (Line) obj;
            if (number != other.number)
                return false;
            if (other.text == text)
                return true;
            if (text == null)
                return false;
            return text.equals(other.text);
        }

        @Override
        public String toString() {
            return number + ":" + text;
        }
    }

    /**
     * Splits the {@link Observable} of Strings by lines and numbers them (zero based index)
     *

     *
     *
     * @param source
     * @return the Observable conaining the split lines of the source
     */
    public static Observable<Line> byLine(Observable<String> source) {
        return split(source, System.getProperty("line.separator")).map(new Func1<String, Line>() {
            int lineNumber = 0;

            @Override
            public Line call(String text) {
                return new Line(lineNumber++, text);
            }
        });
    }
}


text:
General purpose communication and synchronization layer for distributed applications / Microservices / events, semaphores, locks and messages for JavaScript, Java, Python and PHP

<!-- MarkdownTOC -->

- [Overview](#overview)
- [Install](#install)

<!-- /MarkdownTOC -->

# Overview
This __Python__ module implements a full featured client for the __GEPARD__ middleware for general purpose distributed applications.

In order to use this __Python__ client you must have installed the __GEPARD__ middleware.
This is simply done by executing the command:

```bash
	npm install gepard
```

Prerequisite for this command is the installation of node and npm.
For more information see [gepard on npm](https://www.npmjs.com/package/gepard) and [gessinger-hj/gepard on github](https://github.com/gessinger-hj/gepard).

If you are interested in the __PHP__ client see [gepard-python on pypi](https://pypi.python.org/pypi?name=gepard-python&:action=display) and [gepard-python on github](https://github.com/gessinger-hj/gepard-python)

# Install

Installation is done from __pypi__ with:

```sh
pip install gepard-python
```

redpajama_set_name: RedPajamaGithub


text:
package net.smart_json_database;

import java.util.Arrays;

public class Order {

	private static String[] databaseFields = {"json_uid", "createDate", "updateDate"};

	private String field = "json_uid";
	private String direction = "DESC";

	public Order(String field) {
		super();
		this.field = field;
	}

	public Order(String field, String direction) {
		super();
		this.field = field;
		this.direction = direction;
	}

	public String sql() {
		return " ORDER BY " + field + " " + direction;

	}

	public boolean sortDatabaseField() {
		if( Arrays.asList(databaseFields).contains(field)){
			return true;
		} else {
			return false;
		}
	}

	public boolean sortDataField() {
		if( Arrays.asList(databaseFields).contains(field)){
			return false;
		} else {
			return true;
		}
	}

	public String collation() {
		return field;
	}
}


text:
//Copyright © 2014 Sony Computer Entertainment America LLC. See License.txt.

namespace LevelEditorCore
{
    /// <summary>
    /// Client code can implement this interface
    /// to filter out objects that can't be used as a snap target.</summary>
    /// <remarks>The snap operation is performed when
    /// drag/dropping objects onto designView or when moving objects
    /// using translate manipulator in both case snapping have to
    /// activated using shortcut keys</remarks>
    public interface ISnapFilter
    {
        /// <summary>
        /// Can dragObj snaps to snapObj.
        /// </summary>
        /// <param name="dragObj">object that is being dragged</param>
        /// <param name="snapObj">object that the dragged object is trying to snap to</param>
        /// <returns>True if dragObj can be snapped to snapObject.</returns>
        bool CanSnapTo(object dragObj, object snapObj);
    }
}


text:
extern crate internal_unstable;

thread_local!(static FOO: () = ());
thread_local!(static BAR: () = internal_unstable::unstable()); //~ WARN use of unstable

#[rustc_error]
fn main() {} //~ ERROR


text:
package org.apache.manifoldcf.agents.output.kafka;

import java.util.Properties;
import org.junit.After;
import static org.junit.Assert.fail;
import org.junit.Before;

public class BaseITHSQLDB extends org.apache.manifoldcf.crawler.tests.BaseITHSQLDB {

  static KafkaLocal kafka;

  protected String[] getConnectorNames() {
    return new String[]{"CMIS"};
  }

  protected String[] getConnectorClasses() {
    return new String[]{"org.apache.manifoldcf.crawler.tests.TestingRepositoryConnector"};
  }

  protected String[] getOutputNames() {
    return new String[]{"Kafka"};
  }

  protected String[] getOutputClasses() {
    return new String[]{"org.apache.manifoldcf.agents.output.kafka.KafkaOutputConnector"};
  }

  @Before
  public void setupKafka()
          throws Exception {
    Properties kafkaProperties = new Properties();
    Properties zkProperties = new Properties();

    try {
      //load properties
      kafkaProperties.put("broker.id", "0");
      kafkaProperties.put("port", "9092");
      kafkaProperties.put("num.network.threads", "3");
      kafkaProperties.put("num.io.threads", "8");
      kafkaProperties.put("socket.send.buffer.bytes", "102400");
      kafkaProperties.put("socket.receive.buffer.bytes", "102400");
      kafkaProperties.put("socket.request.max.bytes", "104857600");
      kafkaProperties.put("log.dirs", "/tmp/kafka-logs");
      kafkaProperties.put("num.partitions", "1");
      kafkaProperties.put("num.recovery.threads.per.data.dir", "1");
      kafkaProperties.put("log.retention.hours", "168");
      kafkaProperties.put("log.segment.bytes", "1073741824");
      kafkaProperties.put("log.retention.check.interval.ms", "300000");
      kafkaProperties.put("log.cleaner.enable", "false");
      kafkaProperties.put("zookeeper.connect", "localhost:2181");
      kafkaProperties.put("zookeeper.connection.timeout.ms", "6000");

      zkProperties.put("dataDir", "/tmp/zookeeper");
      zkProperties.put("clientPort", "2181");
      zkProperties.put("maxClientCnxns", "0");

      //kafkaProperties.load(Class.class.getResourceAsStream("/kafkalocal.properties"));
      //zkProperties.load(Class.class.getResourceAsStream("/zklocal.properties"));
      System.out.println("Kafka is starting...");

      //start kafka
      kafka = new KafkaLocal(kafkaProperties, zkProperties);
      Thread.sleep(5000);
    } catch (Exception e) {
      e.printStackTrace(System.out);
      fail("Error running local Kafka broker");
      e.printStackTrace(System.out);
    }
  }

  @After
  public void cleanUpKafka() {
    kafka.stop();
  }

}


text: BOOL AWSMTLEqualObjects(id obj1, id obj2);


text: A JSON lexer written in Dart.


text:
package aQute.launcher.constants;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;

public class LauncherConstants {

	public final static String	LAUNCHER_PROPERTIES			= "launcher.properties";
	public final static String	DEFAULT_LAUNCHER_PROPERTIES	= "launcher.properties";
	public final static String	LAUNCHER_ARGUMENTS			= "launcher.arguments";
	public final static String	LAUNCHER_READY				= "launcher.ready";

	// MUST BE ALIGNED WITH ProjectLauncher! Donot want to create coupling
	// so cannot refer.
	public final static int		OK							= 0;
	public final static int		ERROR						= -2;
	public final static int		WARNING						= -1;
	public final static int		TIMEDOUT					= -3;
	public final static int		UPDATE_NEEDED				= -4;
	public final static int		CANCELED					= -5;
	public final static int		DUPLICATE_BUNDLE			= -6;
	public final static int		RESOLVE_ERROR				= -7;
	public final static int		ACTIVATOR_ERROR				= -8;
	public static final int		STOPPED						= -9;

	// Start custom errors from here
	public final static int		CUSTOM_LAUNCHER				= -128;

	// Local names
	final static String			LAUNCH_SERVICES				= "launch.services";
	final static String			LAUNCH_STORAGE_DIR			= "launch.storage.dir";
	final static String			LAUNCH_KEEP					= "launch.keep";
	final static String			LAUNCH_RUNBUNDLES			= "launch.bundles";
	final static String			LAUNCH_SYSTEMPACKAGES		= "launch.system.packages";
	final static String			LAUNCH_SYSTEMCAPABILITIES	= "launch.system.capabilities";
	final static String			LAUNCH_TRACE				= "launch.trace";
	final static String			LAUNCH_TIMEOUT				= "launch.timeout";
	final static String			LAUNCH_ACTIVATORS			= "launch.activators";
	final static String			LAUNCH_EMBEDDED				= "launch.embedded";
	final static String			LAUNCH_NAME					= "launch.name";
	final static String			LAUNCH_NOREFERENCES			= "launch.noreferences";
	final static String			LAUNCH_NOTIFICATION_PORT	= "launch.notificationPort";
	/**
	 * The command line arguments of the launcher. Launcher are not supposed to
	 * eat any arguments, they should use -D VM arguments so that applications
	 * can leverage the command line. The launcher must register itself as a
	 * service under its impl. class with this property set to a String[].
	 */

	public boolean				services;
	public boolean				noreferences;
	public File					storageDir;
	public boolean				keep;
	public final List<String>	runbundles					= new ArrayList<String>();
	public String				systemPackages;
	public String				systemCapabilities;
	public boolean				trace;
	public long					timeout;
	public final List<String>	activators					= new ArrayList<String>();
	public Map<String,String>	runProperties				= new HashMap<String,String>();
	public boolean				embedded					= false;
	public String				name;
	public int					notificationPort			= -1;

	/**
	 * Translate a constants to properties.
	 *
	 * @return
	 */
	public Properties getProperties(Properties p) {
		p.setProperty(LAUNCH_NOREFERENCES, noreferences + "");
		p.setProperty(LAUNCH_SERVICES, services + "");
		if (storageDir != null)
			p.setProperty(LAUNCH_STORAGE_DIR, storageDir.getAbsolutePath());
		p.setProperty(LAUNCH_KEEP, keep + "");
		p.setProperty(LAUNCH_RUNBUNDLES, join(runbundles, ","));
		if (systemPackages != null)
			p.setProperty(LAUNCH_SYSTEMPACKAGES, systemPackages + "");
		if (systemCapabilities != null)
			p.setProperty(LAUNCH_SYSTEMCAPABILITIES, systemCapabilities + "");
		p.setProperty(LAUNCH_TRACE, trace + "");
		p.setProperty(LAUNCH_TIMEOUT, timeout + "");
		p.setProperty(LAUNCH_ACTIVATORS, join(activators, ","));
		p.setProperty(LAUNCH_EMBEDDED, embedded + "");
		if (name != null)
			p.setProperty(LAUNCH_NAME, name);

		p.setProperty(LAUNCH_NOTIFICATION_PORT, String.valueOf(notificationPort));

		for (Map.Entry<String,String> entry : runProperties.entrySet()) {
			if (entry.getValue() == null) {
				if (entry.getKey() != null)
					p.remove(entry.getKey());
			} else {
				p.put(entry.getKey(), entry.getValue());
			}

		}
		return p;
	}

	/**
	 * Empty constructor for the plugin
	 */

	public LauncherConstants() {}

	/**
	 * Create a constants from properties.
	 *
	 * @param p
	 */
	public LauncherConstants(Properties p) {
		services = Boolean.valueOf(p.getProperty(LAUNCH_SERVICES));
		if (p.getProperty(LAUNCH_STORAGE_DIR) != null)
			storageDir = new File(p.getProperty(LAUNCH_STORAGE_DIR));
		noreferences = Boolean.valueOf(p.getProperty(LAUNCH_NOREFERENCES));
		keep = Boolean.valueOf(p.getProperty(LAUNCH_KEEP));
		runbundles.addAll(split(p.getProperty(LAUNCH_RUNBUNDLES), ","));
		systemPackages = p.getProperty(LAUNCH_SYSTEMPACKAGES);
		systemCapabilities = p.getProperty(LAUNCH_SYSTEMCAPABILITIES);
		trace = Boolean.valueOf(p.getProperty(LAUNCH_TRACE));
		timeout = Long.parseLong(p.getProperty(LAUNCH_TIMEOUT));
		activators.addAll(split(p.getProperty(LAUNCH_ACTIVATORS), " ,"));
		String s = p.getProperty(LAUNCH_EMBEDDED);
		embedded = s != null && Boolean.parseBoolean(s);
		name = p.getProperty(LAUNCH_NAME);
		notificationPort = Integer.valueOf(p.getProperty(LAUNCH_NOTIFICATION_PORT, "-1"));
		@SuppressWarnings({
				"unchecked", "rawtypes"
		})
		Map<String,String> map = (Map) p;
		runProperties.putAll(map);
	}

	private Collection< ? extends String> split(String property, String string) {
		List<String> result = new ArrayList<String>();
		StringTokenizer st = new StringTokenizer(property, string);
		while (st.hasMoreTokens()) {
			result.add(st.nextToken());
		}

		return result;
	}

	private static String join(List< ? > runbundles2, String string) {
		StringBuilder sb = new StringBuilder();
		String del = "";
		for (Object r : runbundles2) {
			sb.append(del);
			sb.append(r);
			del = string;
		}
		return sb.toString();
	}
}


text:
package org.hisp.dhis.android.sdk.fragments.dataentry;

import org.hisp.dhis.android.sdk.utils.ui.adapters.rows.dataentry.DataEntryRow;

import java.util.List;

public final class DataEntryFragmentSection {
    private final String label;
    private final String id;
    private final List<DataEntryRow> rows;
    private boolean hidden = false;

    public DataEntryFragmentSection(String label, String id,
                                    List<DataEntryRow> rows) {
        this.label = label;
        this.id = id;
        this.rows = rows;
    }

    public String getLabel() {
        return label;
    }

    public List<DataEntryRow> getRows() {
        return rows;
    }

    public boolean isHidden() {
        return hidden;
    }

    public void setHidden(boolean hidden) {
        this.hidden = hidden;
    }

    public String getId() {
        return id;
    }
}


text:
package doobie.free

import scalaz.{ Catchable, Coyoneda, Free => F, Kleisli, Monad, ~>, \/ }
import scalaz.concurrent.Task

import doobie.util.capture._

import java.io.InputStream
import java.io.OutputStream
import java.sql.Blob
import java.sql.CallableStatement
import java.sql.Clob
import java.sql.Connection
import java.sql.DatabaseMetaData
import java.sql.Driver
import java.sql.NClob
import java.sql.PreparedStatement
import java.sql.Ref
import java.sql.ResultSet
import java.sql.SQLData
import java.sql.SQLInput
import java.sql.SQLOutput
import java.sql.Statement

import nclob.NClobIO
import blob.BlobIO
import clob.ClobIO
import databasemetadata.DatabaseMetaDataIO
import driver.DriverIO
import ref.RefIO
import sqldata.SQLDataIO
import sqlinput.SQLInputIO
import sqloutput.SQLOutputIO
import connection.ConnectionIO
import statement.StatementIO
import preparedstatement.PreparedStatementIO
import callablestatement.CallableStatementIO
import resultset.ResultSetIO

/**
 * Algebra and free monad for primitive operations over a `java.sql.Blob`. This is
 * a low-level API that exposes lifecycle-managed JDBC objects directly and is intended mainly
 * for library developers. End users will prefer a safer, higher-level API such as that provided
 * in the `doobie.hi` package.
 *
 * `BlobIO` is a free monad that must be run via an interpreter, most commonly via
 * natural transformation of its underlying algebra `BlobOp` to another monad via
 * `Free.runFC`.
 *
 * The library provides a natural transformation to `Kleisli[M, Blob, A]` for any
 * exception-trapping (`Catchable`) and effect-capturing (`Capture`) monad `M`. Such evidence is
 * provided for `Task`, `IO`, and stdlib `Future`; and `transK[M]` is provided as syntax.
 *
 * {{{
 * // An action to run
 * val a: BlobIO[Foo] = ...
 *
 * // A JDBC object
 * val s: Blob = ...
 *
 * // Unfolding into a Task
 * val ta: Task[A] = a.transK[Task].run(s)
 * }}}
 *
 * @group Modules
 */
object blob {

  /**
   * Sum type of primitive operations over a `java.sql.Blob`.
   * @group Algebra
   */
  sealed trait BlobOp[A] {
    protected def primitive[M[_]: Monad: Capture](f: Blob => A): Kleisli[M, Blob, A] =
      Kleisli((s: Blob) => Capture[M].apply(f(s)))
    def defaultTransK[M[_]: Monad: Catchable: Capture]: Kleisli[M, Blob, A]
  }

  /**
   * Module of constructors for `BlobOp`. These are rarely useful outside of the implementation;
   * prefer the smart constructors provided by the `blob` module.
   * @group Algebra
   */
  object BlobOp {

    // Lifting
    case class LiftCallableStatementIO[A](s: CallableStatement, action: CallableStatementIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftClobIO[A](s: Clob, action: ClobIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftConnectionIO[A](s: Connection, action: ConnectionIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftDatabaseMetaDataIO[A](s: DatabaseMetaData, action: DatabaseMetaDataIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftDriverIO[A](s: Driver, action: DriverIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftNClobIO[A](s: NClob, action: NClobIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftPreparedStatementIO[A](s: PreparedStatement, action: PreparedStatementIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftRefIO[A](s: Ref, action: RefIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftResultSetIO[A](s: ResultSet, action: ResultSetIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftSQLDataIO[A](s: SQLData, action: SQLDataIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftSQLInputIO[A](s: SQLInput, action: SQLInputIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftSQLOutputIO[A](s: SQLOutput, action: SQLOutputIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }
    case class LiftStatementIO[A](s: Statement, action: StatementIO[A]) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = Kleisli(_ => action.transK[M].run(s))
    }

    // Combinators
    case class Attempt[A](action: BlobIO[A]) extends BlobOp[Throwable \/ A] {
      import scalaz._, Scalaz._
      def defaultTransK[M[_]: Monad: Catchable: Capture] =
        Predef.implicitly[Catchable[Kleisli[M, Blob, ?]]].attempt(action.transK[M])
    }
    case class Pure[A](a: () => A) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_ => a())
    }
    case class Raw[A](f: Blob => A) extends BlobOp[A] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(f)
    }

    // Primitive Operations
    case object Free extends BlobOp[Unit] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.free())
    }
    case class  GetBinaryStream(a: Long, b: Long) extends BlobOp[InputStream] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.getBinaryStream(a, b))
    }
    case object GetBinaryStream1 extends BlobOp[InputStream] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.getBinaryStream())
    }
    case class  GetBytes(a: Long, b: Int) extends BlobOp[Array[Byte]] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.getBytes(a, b))
    }
    case object Length extends BlobOp[Long] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.length())
    }
    case class  Position(a: Array[Byte], b: Long) extends BlobOp[Long] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.position(a, b))
    }
    case class  Position1(a: Blob, b: Long) extends BlobOp[Long] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.position(a, b))
    }
    case class  SetBinaryStream(a: Long) extends BlobOp[OutputStream] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.setBinaryStream(a))
    }
    case class  SetBytes(a: Long, b: Array[Byte]) extends BlobOp[Int] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.setBytes(a, b))
    }
    case class  SetBytes1(a: Long, b: Array[Byte], c: Int, d: Int) extends BlobOp[Int] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.setBytes(a, b, c, d))
    }
    case class  Truncate(a: Long) extends BlobOp[Unit] {
      def defaultTransK[M[_]: Monad: Catchable: Capture] = primitive(_.truncate(a))
    }

  }
  import BlobOp._ // We use these immediately

  /**
   * Free monad over a free functor of [[BlobOp]]; abstractly, a computation that consumes
   * a `java.sql.Blob` and produces a value of type `A`.
   * @group Algebra
   */
  type BlobIO[A] = F.FreeC[BlobOp, A]

  /**
   * Monad instance for [[BlobIO]] (can't be inferred).
   * @group Typeclass Instances
   */
  implicit val MonadBlobIO: Monad[BlobIO] =
    F.freeMonad[({type λ[α] = Coyoneda[BlobOp, α]})#λ]

  /**
   * Catchable instance for [[BlobIO]].
   * @group Typeclass Instances
   */
  implicit val CatchableBlobIO: Catchable[BlobIO] =
    new Catchable[BlobIO] {
      def attempt[A](f: BlobIO[A]): BlobIO[Throwable \/ A] = blob.attempt(f)
      def fail[A](err: Throwable): BlobIO[A] = blob.delay(throw err)
    }

  /**
   * Capture instance for [[BlobIO]].
   * @group Typeclass Instances
   */
  implicit val CaptureBlobIO: Capture[BlobIO] =
    new Capture[BlobIO] {
      def apply[A](a: => A): BlobIO[A] = blob.delay(a)
    }

  /**
   * @group Constructors (Lifting)
   */
  def liftCallableStatement[A](s: CallableStatement, k: CallableStatementIO[A]): BlobIO[A] =
    F.liftFC(LiftCallableStatementIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftClob[A](s: Clob, k: ClobIO[A]): BlobIO[A] =
    F.liftFC(LiftClobIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftConnection[A](s: Connection, k: ConnectionIO[A]): BlobIO[A] =
    F.liftFC(LiftConnectionIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftDatabaseMetaData[A](s: DatabaseMetaData, k: DatabaseMetaDataIO[A]): BlobIO[A] =
    F.liftFC(LiftDatabaseMetaDataIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftDriver[A](s: Driver, k: DriverIO[A]): BlobIO[A] =
    F.liftFC(LiftDriverIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftNClob[A](s: NClob, k: NClobIO[A]): BlobIO[A] =
    F.liftFC(LiftNClobIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftPreparedStatement[A](s: PreparedStatement, k: PreparedStatementIO[A]): BlobIO[A] =
    F.liftFC(LiftPreparedStatementIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftRef[A](s: Ref, k: RefIO[A]): BlobIO[A] =
    F.liftFC(LiftRefIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftResultSet[A](s: ResultSet, k: ResultSetIO[A]): BlobIO[A] =
    F.liftFC(LiftResultSetIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftSQLData[A](s: SQLData, k: SQLDataIO[A]): BlobIO[A] =
    F.liftFC(LiftSQLDataIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftSQLInput[A](s: SQLInput, k: SQLInputIO[A]): BlobIO[A] =
    F.liftFC(LiftSQLInputIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftSQLOutput[A](s: SQLOutput, k: SQLOutputIO[A]): BlobIO[A] =
    F.liftFC(LiftSQLOutputIO(s, k))

  /**
   * @group Constructors (Lifting)
   */
  def liftStatement[A](s: Statement, k: StatementIO[A]): BlobIO[A] =
    F.liftFC(LiftStatementIO(s, k))

  /**
   * Lift a BlobIO[A] into an exception-capturing BlobIO[Throwable \/ A].
   * @group Constructors (Lifting)
   */
  def attempt[A](a: BlobIO[A]): BlobIO[Throwable \/ A] =
    F.liftFC[BlobOp, Throwable \/ A](Attempt(a))

  /**
   * Non-strict unit for capturing effects.
   * @group Constructors (Lifting)
   */
  def delay[A](a: => A): BlobIO[A] =
    F.liftFC(Pure(a _))

  /**
   * Backdoor for arbitrary computations on the underlying Blob.
   * @group Constructors (Lifting)
   */
  def raw[A](f: Blob => A): BlobIO[A] =
    F.liftFC(Raw(f))

  /**
   * @group Constructors (Primitives)
   */
  val free: BlobIO[Unit] =
    F.liftFC(Free)

  /**
   * @group Constructors (Primitives)
   */
  def getBinaryStream(a: Long, b: Long): BlobIO[InputStream] =
    F.liftFC(GetBinaryStream(a, b))

  /**
   * @group Constructors (Primitives)
   */
  val getBinaryStream: BlobIO[InputStream] =
    F.liftFC(GetBinaryStream1)

  /**
   * @group Constructors (Primitives)
   */
  def getBytes(a: Long, b: Int): BlobIO[Array[Byte]] =
    F.liftFC(GetBytes(a, b))

  /**
   * @group Constructors (Primitives)
   */
  val length: BlobIO[Long] =
    F.liftFC(Length)

  /**
   * @group Constructors (Primitives)
   */
  def position(a: Array[Byte], b: Long): BlobIO[Long] =
    F.liftFC(Position(a, b))

  /**
   * @group Constructors (Primitives)
   */
  def position(a: Blob, b: Long): BlobIO[Long] =
    F.liftFC(Position1(a, b))

  /**
   * @group Constructors (Primitives)
   */
  def setBinaryStream(a: Long): BlobIO[OutputStream] =
    F.liftFC(SetBinaryStream(a))

  /**
   * @group Constructors (Primitives)
   */
  def setBytes(a: Long, b: Array[Byte]): BlobIO[Int] =
    F.liftFC(SetBytes(a, b))

  /**
   * @group Constructors (Primitives)
   */
  def setBytes(a: Long, b: Array[Byte], c: Int, d: Int): BlobIO[Int] =
    F.liftFC(SetBytes1(a, b, c, d))

  /**
   * @group Constructors (Primitives)
   */
  def truncate(a: Long): BlobIO[Unit] =
    F.liftFC(Truncate(a))

 /**
  * Natural transformation from `BlobOp` to `Kleisli` for the given `M`, consuming a `java.sql.Blob`.
  * @group Algebra
  */
  def interpK[M[_]: Monad: Catchable: Capture]: BlobOp ~> Kleisli[M, Blob, ?] =
    new (BlobOp ~> Kleisli[M, Blob, ?]) {
      def apply[A](op: BlobOp[A]): Kleisli[M, Blob, A] =
        op.defaultTransK[M]
    }

 /**
  * Natural transformation from `BlobIO` to `Kleisli` for the given `M`, consuming a `java.sql.Blob`.
  * @group Algebra
  */
  def transK[M[_]: Monad: Catchable: Capture]: BlobIO ~> Kleisli[M, Blob, ?] =
    new (BlobIO ~> Kleisli[M, Blob, ?]) {
      def apply[A](ma: BlobIO[A]): Kleisli[M, Blob, A] =
        F.runFC[BlobOp, Kleisli[M, Blob, ?], A](ma)(interpK[M])
    }

 /**
  * Natural transformation from `BlobIO` to `M`, given a `java.sql.Blob`.
  * @group Algebra
  */
 def trans[M[_]: Monad: Catchable: Capture](c: Blob): BlobIO ~> M =
   new (BlobIO ~> M) {
     def apply[A](ma: BlobIO[A]): M[A] =
       transK[M].apply(ma).run(c)
   }

  /**
   * Syntax for `BlobIO`.
   * @group Algebra
   */
  implicit class BlobIOOps[A](ma: BlobIO[A]) {
    def transK[M[_]: Monad: Catchable: Capture]: Kleisli[M, Blob, A] =
      blob.transK[M].apply(ma)
  }

}


text:
/*!
 * Back2Front
 * Route helper
 *   为了避免把过多的属性和方法挂载到Express的res对象,
 *   把这些属性和方法放到RouteHelper类,
 *   这样就可以只挂载一个RouteHelper对象到res对象了。
 */

'use strict';

var util = require('../lib/util');

/**
 * 路由辅助器基类
 * @class BasicRouteHelper
 * @constructor
 * @param {String} template 页面模板路径
 */
var BasicRouteHelper = util.createClass(function(template) {
	this._viewData = { };
	this.setTemplate(template);
	this._type = 'basic';
}, {
	/**
	 * 获取路由辅助器类型
	 * @method type
	 * @for BasicRouteHelper
	 * @return {String} 路由辅助器类型
	 */
	type: function() { return this._type; },

	/**
	 * 设置页面模板
	 * @method setTemplate
	 * @for BasicRouteHelper
	 * @param {String} template 模板路径
	 */
	setTemplate: function(template) { this._template = template; },

	/**
	 * 获取视图数据
	 * @method viewData
	 * @for BasicRouteHelper
	 * @param {String} key 键
	 * @return {Any} 值
	 */
	/**
	 * 设置视图数据
	 * @method viewData
	 * @for BasicRouteHelper
	 * @param {String} key 键
	 * @param {Any} value 值
	 */
	/**
	 * 设置视图数据
	 * @method viewData
	 * @for BasicRouteHelper
	 * @param {Object} map 键值对
	 */
	viewData: function(key, value) {
		var viewData = this._viewData;
		if (arguments.length === 1 && typeof key === 'string') {
			return viewData[key];
		} else {
			if (typeof key === 'object') {
				util.extend(viewData, key);
			} else {
				viewData[key] = value;
			}
		}
	},

	/**
	 * 映射数据到viewData
	 * @method mapToViewData
	 * @for BasicRouteHelper
	 * @param {Array} dataSource 源数据
	 * @param {String|Function} mapWay 映射方式:为字符串时,即为映射的key;为函数时,返回map
	 */
	mapToViewData: function(dataSource, config) {
		var t = this;

		config.forEach(function(mapWay, i) {
			switch (typeof mapWay) {
				case 'string':
					t.viewData(mapWay, dataSource[i]);
					break;

				case 'function':
					var map = mapWay(dataSource[i]);
					if (typeof map === 'object') {
						util.each(map, function(key, value) {
							t.viewData(key, value);
						});
					}
					break;
			}
		});
	},

	/**
	 * 渲染视图
	 * @method render
	 * @for BasicRouteHelper
	 * @param {Object} res Response对象
	 */
	render: function(res) {
		this._rendered = true;
		res.end();
	},

	/**
	 * 渲染提示信息
	 * @method renderInfo
	 * @for BasicRouteHelper
	 * @param {Object} res Response对象
	 * @param {Object} info 提示信息
	 */
	renderInfo: function(res, info) { this.render(res); },

	/**
	 * 获取是否已渲染视图
	 * @method rendered
	 * @for BasicRouteHelper
	 * @return {Boolean} 是否已渲染视图
	 */
	rendered: function() { return !!this._rendered; }
});

/**
 * HTML路由辅助器
 * @class HTMLRouteHelper
 * @constructor
 * @extends BasicRouteHelper
 * @param {String} template 页面模板路径
 */
exports.HTMLRouteHelper = util.createClass(function(template) {
	this._type = 'html';
}, {
	render: function(res) {
		res.render(this._template, this._viewData);
		this._rendered = true;
	},

	renderInfo: function(res, info) {
		info = util.extend({
			backURL: res.req.get('Referer'),
			status: 1
		}, info);
		this.viewData('info', info);
		this.setTemplate('pages/_info/_info.page');
		this.render(res);
	}
}, BasicRouteHelper);

/**
 * JSON路由辅助器
 * @class JSONRouteHelper
 * @constructor
 * @extends BasicRouteHelper
 */
exports.JSONRouteHelper = util.createClass(function() {
	this._viewDataWrap = { status: 1 };
	this._type = 'json';
}, {
	render: function(res) {
		var viewDataWrap = this._viewDataWrap;
		viewDataWrap.data = this._viewData;
		res.json(viewDataWrap);
		this._rendered = true;
	},

	renderInfo: function(res, info) {
		util.extend(this._viewDataWrap, info);
		this._viewData = null;
		this.render(res);
	}
}, BasicRouteHelper);


text:
#ifndef PPAPI_C_PPP_GRAPHICS_3D_H_
#define PPAPI_C_PPP_GRAPHICS_3D_H_

#include "ppapi/c/pp_instance.h"

#define PPP_GRAPHICS_3D_INTERFACE "PPP_Graphics_3D;1.0"

struct PPP_Graphics3D {
  /**
   * Called when the OpenGL ES window is invalidated and needs to be repainted.
   */
  void (*Graphics3DContextLost)(PP_Instance instance);
};

#endif  /* PPAPI_C_PPP_GRAPHICS_3D_H_ */


text:
package ir.pegahtech.saas.client.shared.models;

import java.util.List;

/**
 * Created by hamidreza on 3/16/2015.
 */
public class UpdateResponse {
    private List<QueryOutput> updateIDOutputList;

    public List<QueryOutput> getUpdateIDOutputList() {
        return updateIDOutputList;
    }
    public void setUpdateIDOutputList(List<QueryOutput> updateIDOutputList) {
        this.updateIDOutputList = updateIDOutputList;
    }

}


text:
module Puppet::Parser::Functions
	newfunction(:basename, :type => :rvalue) do |args|
		if args[0].is_a?(Array)
			args.collect do |a| File.basename(a) end
		else
			File.basename(args[0])
		end
	end
end


text:
""" Test of the generic wrapper library capabilities.

This actually needs ctypes to make sense but it affects all wrappers.

"""
from __future__ import (division, unicode_literals, print_function,
                        absolute_import)

import os
import _ctypes_test
import ctypes
from pytest import yield_fixture, mark

from pyclibrary.utils import (add_library_locations, add_header_locations,
                              LIBRARY_DIRS, HEADER_DIRS)
from pyclibrary.c_library import CLibrary

HEADERS_DIR = os.path.dirname(__file__)
BACKUPS = ()

def setup_module():
    global BACKUPS
    BACKUPS = HEADER_DIRS[:]
    add_header_locations([os.path.join(os.path.dirname(__file__),
                                       'headers')])

def teardown_module():
    global HEADER_DIRS
    if BACKUPS:
        HEADER_DIRS = BACKUPS

@yield_fixture
def library_location_fixture():
    old = LIBRARY_DIRS[:]
    add_library_locations([os.path.dirname(_ctypes_test.__file__)])
    yield
    global LIBRARY_DIRS
    LIBRARY_DIRS = old

class TestCLibrary(object):
    """Test the basic CLibrary object functionalities.

    """
    def test_accessing_library_by_name(self, library_location_fixture):

        library = CLibrary(os.path.basename(_ctypes_test.__file__),
                           ['ctypes_test.h'])
        assert library._lib_

    def test_accessing_library_by_path(self):

        library = CLibrary(_ctypes_test.__file__, ['ctypes_test.h'])
        assert library._lib_

    def test_accessing_library_by_object(self):

        lib = ctypes.CDLL(_ctypes_test.__file__)
        library = CLibrary(lib, ['ctypes_test.h'])
        assert library._lib_ is lib

    # This works on both windows and python locally but fails on Travis
    @mark.no_travis
    def test_already_opened_library(self):

        lib = ctypes.CDLL(_ctypes_test.__file__)
        library = CLibrary(lib, ['ctypes_test.h'])
        assert library is CLibrary(_ctypes_test.__file__, ['ctypes_test.h'])

    def test_accessing_prefixed_value(self):
        pass


text:
require 'formula'
require File.join(File.dirname(__FILE__), "../Requirements/php-meta-requirement")
require File.join(File.dirname(__FILE__), "../Requirements/phar-requirement")

class AbstractPhpPhar < Formula
  def initialize(*)
    super
  end

  def self.init
    depends_on PhpMetaRequirement
    depends_on PharRequirement
  end

  def phar_file
    class_name = self.class.name.split("::").last
    class_name.downcase + ".phar"
  end

  def phar_bin
    class_name = self.class.name.split("::").last
    class_name.downcase
  end

  def phar_wrapper
    <<-EOS.undent
      #!/usr/bin/env bash
      /usr/bin/env php -d allow_url_fopen=On -d detect_unicode=Off #{libexec}/#{@real_phar_file} "$@"
    EOS
  end

  def install
    if phar_file == phar_bin
      @real_phar_file = phar_file + ".phar"
      File.rename(phar_file, @real_phar_file)
    else
      @real_phar_file = phar_file
    end

    libexec.install @real_phar_file
    (libexec/phar_bin).write phar_wrapper
    chmod 0755, (libexec/phar_bin)
    bin.install_symlink (libexec/phar_bin)
  end

  test do
    which phar_bin
  end
end


text:
call tools\deploy_www.bat
call tools\start-node.bat


text:
<?xml version='1.0' encoding='utf-8'?>
<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://192.168.2.50/test</property>
        <property name="connection.username">james</property>
        <property name="connection.password">password</>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">create</property>

        <mapping class="com.equippedcoding.libgdx.mydialog.database.UserDetails"/>

    </session-factory>

</hibernate-configuration>


text:
package uk.ac.cam.cl.dtg.teaching.models;

public class Fruit {

	private String type;

	public Fruit() {}

	public Fruit(String type) {
		super();
		this.type = type;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

}


text:
<!doctype html>

    <title>Code coverage report for master/plugins/markdown.js</title>
    <meta charset="utf-8">
    <link rel="stylesheet" href="../../prettify.css">
    <link rel="stylesheet" href="../../base.css">

Code coverage report for master/plugins/markdown.js

        Statements: 94.29% (33 / 35)
        Branches: 84% (21 / 25)
        Functions: 100% (6 / 6)
        Lines: 94.29% (33 / 35)
        Ignored: none

All files » master/plugins/ » markdown.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

1

1
1

1
1
1
1

1
10

10
1

10

1
16
128
104

24
9

15
10
8
8
8
8

5
5

1

1

1
8
8

1

3

/**
 * @overview Translate doclet descriptions from MarkDown into HTML.
 * @module plugins/markdown
 * @author Michael Mathews <micmath@gmail.com>
 * @author Ben Blank <ben.blank@gmail.com>
 */
'use strict';

var env = require('jsdoc/env');

var config = env.conf.markdown || {};
var defaultTags = [
    'author',
    'classdesc',
    'description',
    'exceptions',
    'params',
    'properties',
    'returns',
    'see'
];
var hasOwnProp = Object.prototype.hasOwnProperty;
var parse = require('jsdoc/util/markdown').getParser();
var tags = [];
var excludeTags = [];

function shouldProcessString(tagName, text) {
    var shouldProcess = true;

    // we only want to process `@author` and `@see` tags that contain Markdown links
    if ( (tagName === 'author' || tagName === 'see') && text.indexOf('[') === -1 ) {
        shouldProcess = false;
    }

    return shouldProcess;
}

/**
 * Process the markdown source in a doclet. The properties that should be
 * processed are configurable, but always include "classdesc", "description",
 * "params", "properties", and "returns".  Handled properties can be bare
 * strings, objects, or arrays of objects.
 */
function process(doclet) {
    tags.forEach(function(tag) {
        if ( !hasOwnProp.call(doclet, tag) ) {
            return;
        }

        if (typeof doclet[tag] === 'string' && shouldProcessString(tag, doclet[tag]) ) {
            doclet[tag] = parse(doclet[tag]);
        }
        else if ( Array.isArray(doclet[tag]) ) {
            doclet[tag].forEach(function(value, index, original) {
                var inner = {};
                inner[tag] = value;
                process(inner);
                original[index] = inner[tag];
            });
        }
        else Eif (doclet[tag]) {
            process(doclet[tag]);
        }
    });
}

// set up the list of "tags" (properties) to process
Iif (config.tags) {
    tags = config.tags.slice();
}
// set up the list of default tags to exclude from processing
Iif (config.excludeTags) {
    excludeTags = config.excludeTags.slice();
}
defaultTags.forEach(function(tag) {
    Eif (excludeTags.indexOf(tag) === -1 && tags.indexOf(tag) === -1) {
        tags.push(tag);
    }
});

exports.handlers = {
    /**
     * Translate markdown syntax in a new doclet's description into HTML. Is run
     * by JSDoc 3 whenever a "newDoclet" event fires.
     */
    newDoclet: function(e) {
        process(e.doclet);
    }
};

Generated by istanbul at Wed Jul 29 2015 16:27:33 GMT-0700 (PDT)


text:
package utils

import scala.reflect.macros.Context
import scala.language.experimental.macros

object Templates {

  def byName(rootPackage: String) = macro Macros.byName

  object Macros {

    def byName(c: Context)(rootPackage: c.Expr[String]) = {
      import c.universe._

      val pkg = rootPackage.tree match {
        case Literal(Constant(name: String)) => c.mirror.staticPackage(name)
      }

      val templates = for {
        member <- pkg.typeSignature.members
        if member.typeSignature <:< typeOf[play.twirl.api.BaseScalaTemplate[_, _]]
      } yield q"${member.name.decoded} -> $member"

      // TODO return a value which has page names as members
      c.Expr[Any](q"Map(..$templates)")
    }

  }

}


text:
package  ejb_generated;
import adapt.exceptions.InvariantException;

public class CfProj_EventConstraints extends CfProj_Event{

	private String objectName;

	public String getObjectName() {
		return objectName;
	}

	public void setObjectName(String objectName) {
		this.objectName = objectName;
	}
}


text:
<!DOCTYPE html>

点击按钮就可以执行 displayDate() 函数。

<button id="myBtn">点击这里</button>


text:
#ifndef __tags_h__
#define __tags_h__

#include <Python.h>
#undef HAVE_STAT
#include "../rfxswf.h"

PyMethodDef* tags_getMethods();

#endif


text:
Download the example [or clone the repo](https://github.com/zeit/next.js):

```bash
curl https://codeload.github.com/zeit/next.js/tar.gz/master | tar -xz --strip=2 next.js-master/examples/only-client-render-external-dependencies
cd only-client-render-external-dependencies
```

Install it and run:

```bash
npm install
npm run dev
```

Deploy it to the cloud with [now](https://zeit.co/now) ([download](https://zeit.co/download))

```bash
now
```

## The idea behind the example

This example shows how to use an external dependency that only allows client-render.


text:
__doc__="""
Reports highest and lowest glyphs for each master in the Macro Window.
"""

thisFont = Glyphs.font
exportingGlyphs = [g for g in thisFont.glyphs if g.export]

Glyphs.clearLog()
Glyphs.showMacroWindow()

print "Highest and lowest glyphs for %s\n" % thisFont.familyName
for thisMaster in thisFont.masters:
	masterID = thisMaster.id
	glyphsBottomsAndTops = [[g.name, g.layers[masterID].bounds.origin.y, g.layers[masterID].bounds.origin.y + g.layers[masterID].bounds.size.height] for g in exportingGlyphs]
	lowest = sorted( glyphsBottomsAndTops, key=lambda x: x[1] )[0]
	highest = sorted( glyphsBottomsAndTops, key=lambda x: -x[2] )[0]
	print "Master: %s" % thisMaster.name
	print "   Highest: %s (top y: %.1f)" % ( highest[0], highest[2] )
	print "   Lowest: %s (bottom y: %.1f)" % ( lowest[0], lowest[1] )
	print


text:
/*	$NetBSD: linux_sig_notalpha.c,v 1.18 1998/10/07 23:05:09 erh Exp $	*/

/*-
 * Copyright (c) 1995, 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Frank van der Linden and Eric Haszlakiewicz.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the NetBSD
 *	Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * heavily from: svr4_signal.c,v 1.7 1995/01/09 01:04:21 christos Exp
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/filedesc.h>
#include <sys/mount.h>
#include <sys/kernel.h>
#include <sys/signal.h>
#include <sys/signalvar.h>

#include <sys/syscallargs.h>

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_util.h>

#include <compat/linux/linux_syscallargs.h>

/* Used on: arm, i386, m68k, mips, sparc, sparc64 */
/* Not used on: alpha */

/*
 * The Linux signal() system call. I think that the signal() in the C
 * library actually calls sigaction, so I doubt this one is ever used.
 * But hey, it can't hurt having it here. The same restrictions as for
 * sigaction() apply.
 */
int
linux_sys_signal(p, v, retval)
	register struct proc *p;
	void *v;
	register_t *retval;
{
	struct linux_sys_signal_args /* {
		syscallarg(int) sig;
		syscallarg(linux_handler_t) handler;
	} */ *uap = v;
	struct sigaction nbsa, obsa;
	int error;

	nbsa.sa_handler = SCARG(uap, handler);
	sigemptyset(&nbsa.sa_mask);
	nbsa.sa_flags = SA_RESETHAND | SA_NODEFER;
	error = sigaction1(p, linux_to_native_sig[SCARG(uap, sig)],
	    &nbsa, &obsa);
	if (error)
		return (error);
	*retval = (int)obsa.sa_handler;
	return (0);
}

/* ARGSUSED */
int
linux_sys_siggetmask(p, v, retval)
	register struct proc *p;
	void *v;
	register_t *retval;
{
	sigset_t bss;
	linux_old_sigset_t lss;
	int error;

	error = sigprocmask1(p, SIG_SETMASK, 0, &bss);
	if (error)
		return (error);
	native_to_linux_old_sigset(&bss, &lss);
	return (0);
}

/*
 * The following three functions fiddle with a process' signal mask.
 * Convert the signal masks because of the different signal
 * values for Linux. The need for this is the reason why
 * they are here, and have not been mapped directly.
 */
int
linux_sys_sigsetmask(p, v, retval)
	register struct proc *p;
	void *v;
	register_t *retval;
{
	struct linux_sys_sigsetmask_args /* {
		syscallarg(linux_old_sigset_t) mask;
	} */ *uap = v;
	sigset_t nbss, obss;
	linux_old_sigset_t nlss, olss;
	int error;

	nlss = SCARG(uap, mask);
	linux_old_to_native_sigset(&nlss, &nbss);
	error = sigprocmask1(p, SIG_SETMASK, &nbss, &obss);
	if (error)
		return (error);
	native_to_linux_old_sigset(&obss, &olss);
	*retval = olss;
	return (0);
}

int
linux_sys_sigprocmask(p, v, retval)
	register struct proc *p;
	void *v;
	register_t *retval;
{
	struct linux_sys_sigprocmask_args /* {
		syscallarg(int) how;
		syscallarg(const linux_old_sigset_t *) set;
		syscallarg(linux_old_sigset_t *) oset;
	} */ *uap = v;

	return(linux_sigprocmask1(p, SCARG(uap, how),
				SCARG(uap, set), SCARG(uap, oset)));
}

/*
 * The deprecated pause(2), which is really just an instance
 * of sigsuspend(2).
 */
int
linux_sys_pause(p, v, retval)
	register struct proc *p;
	void *v;
	register_t *retval;
{

	return (sigsuspend1(p, 0));
}


text:
package eus.ixa.ixa.pipe.ml.sequence;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;

import opennlp.tools.util.BaseToolFactory;
import opennlp.tools.util.InvalidFormatException;
import opennlp.tools.util.ext.ExtensionLoader;
import opennlp.tools.util.featuregen.AdaptiveFeatureGenerator;
import opennlp.tools.util.featuregen.AggregatedFeatureGenerator;
import opennlp.tools.util.featuregen.FeatureGeneratorResourceProvider;
import opennlp.tools.util.featuregen.GeneratorFactory;

/**
 * Based on opennlp.tools.namefind.TokenNameFinderFactory.
 *
 * @author ragerri
 * @version 2016-11-11
 */
public class SequenceLabelerFactory extends BaseToolFactory {

  private byte[] featureGeneratorBytes;
  private Map<String, Object> resources;
  private SequenceLabelerCodec<String> seqCodec;

  /**
   * Creates a {@link SequenceLabelerFactory} that provides the default
   * implementation of the resources.
   */
  public SequenceLabelerFactory() {
    this.seqCodec = new BioCodec();
  }

  public SequenceLabelerFactory(final byte[] featureGeneratorBytes,
      final Map<String, Object> resources,
      final SequenceLabelerCodec<String> seqCodec) {
    init(featureGeneratorBytes, resources, seqCodec);
  }

  void init(final byte[] featureGeneratorBytes,
      final Map<String, Object> resources,
      final SequenceLabelerCodec<String> seqCodec) {
    this.featureGeneratorBytes = featureGeneratorBytes;
    this.resources = resources;
    this.seqCodec = seqCodec;
  }

  //TODO call this method for default feature generation
  private static byte[] loadDefaultFeatureGeneratorBytes() {

    final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try (InputStream in = SequenceLabelerFactory.class.getResourceAsStream(
        "/sequenceLabeler/default-feature-descriptor.xml")) {

      if (in == null) {
        throw new IllegalStateException(
            "Classpath must contain default-feature-descriptor.xml file!");
      }

      final byte buf[] = new byte[1024];
      int len;
      while ((len = in.read(buf)) > 0) {
        bytes.write(buf, 0, len);
      }
    } catch (final IOException e) {
      throw new IllegalStateException(
          "Failed reading from default-feature-descriptor.xml file on classpath!");
    }

    return bytes.toByteArray();
  }

  protected SequenceLabelerCodec<String> getSequenceCodec() {
    return this.seqCodec;
  }

  protected Map<String, Object> getResources() {
    return this.resources;
  }

  protected byte[] getFeatureGenerator() {
    return this.featureGeneratorBytes;
  }

  public static SequenceLabelerFactory create(final String subclassName,
      final byte[] featureGeneratorBytes, final Map<String, Object> resources,
      final SequenceLabelerCodec<String> seqCodec)
      throws InvalidFormatException {
    SequenceLabelerFactory theFactory;
    if (subclassName == null) {
      // will create the default factory
      theFactory = new SequenceLabelerFactory();
    } else {
      try {
        theFactory = ExtensionLoader
            .instantiateExtension(SequenceLabelerFactory.class, subclassName);
      } catch (final Exception e) {
        final String msg = "Could not instantiate the " + subclassName
            + ". The initialization throw an exception.";
        System.err.println(msg);
        e.printStackTrace();
        throw new InvalidFormatException(msg, e);
      }
    }
    theFactory.init(featureGeneratorBytes, resources, seqCodec);
    return theFactory;
  }

  @Override
  public void validateArtifactMap() throws InvalidFormatException {
    // no additional artifacts
  }

  public SequenceLabelerCodec<String> createSequenceCodec() {

    if (this.artifactProvider != null) {
      final String sequeceCodecImplName = this.artifactProvider
          .getManifestProperty(
              SequenceLabelerModel.SEQUENCE_CODEC_CLASS_NAME_PARAMETER);
      return instantiateSequenceCodec(sequeceCodecImplName);
    } else {
      return this.seqCodec;
    }
  }

  public SequenceLabelerContextGenerator createContextGenerator() {

    final AdaptiveFeatureGenerator featureGenerator = createFeatureGenerators();
    if (featureGenerator == null) {
      throw new NullPointerException("featureGenerator must not be null");
    }

    return new DefaultSequenceLabelerContextGenerator(featureGenerator);
  }

  /**
   * Creates the {@link AdaptiveFeatureGenerator}. Usually this is a set of
   * generators contained in the {@link AggregatedFeatureGenerator}.
   *
   * Note: The generators are created on every call to this method.
   *
   * @return the feature generator or null if there is no descriptor in the
   *         model
   */
  public AdaptiveFeatureGenerator createFeatureGenerators() {

    if (this.featureGeneratorBytes == null && this.artifactProvider != null) {
      this.featureGeneratorBytes = (byte[]) this.artifactProvider
          .getArtifact(SequenceLabelerModel.GENERATOR_DESCRIPTOR_ENTRY_NAME);
    }
    if (this.featureGeneratorBytes == null) {
      System.err.println(
          "WARNING: loading the default feature generator descriptor!!");
      this.featureGeneratorBytes = loadDefaultFeatureGeneratorBytes();
    }

    final InputStream descriptorIn = new ByteArrayInputStream(
        this.featureGeneratorBytes);
    AdaptiveFeatureGenerator generator = null;
    try {
      generator = GeneratorFactory.create(descriptorIn,
          new FeatureGeneratorResourceProvider() {

            @Override
            public Object getResource(final String key) {
              if (SequenceLabelerFactory.this.artifactProvider != null) {
                return SequenceLabelerFactory.this.artifactProvider
                    .getArtifact(key);
              } else {
                return SequenceLabelerFactory.this.resources.get(key);
              }
            }
          });
    } catch (final InvalidFormatException e) {
      // It is assumed that the creation of the feature generation does not
      // fail after it succeeded once during model loading.

      // But it might still be possible that such an exception is thrown,
      // in this case the caller should not be forced to handle the exception
      // and a Runtime Exception is thrown instead.

      // If the re-creation of the feature generation fails it is assumed
      // that this can only be caused by a programming mistake and therefore
      // throwing a Runtime Exception is reasonable

      throw new SequenceLabelerModel.FeatureGeneratorCreationError(e);
    } catch (final IOException e) {
      throw new IllegalStateException(
          "Reading from mem cannot result in an I/O error", e);
    }

    return generator;
  }

  @SuppressWarnings("unchecked")
  public static SequenceLabelerCodec<String> instantiateSequenceCodec(
      final String sequenceCodecImplName) {

    if (sequenceCodecImplName != null) {
      return ExtensionLoader.instantiateExtension(SequenceLabelerCodec.class,
          sequenceCodecImplName);
    } else {
      // If nothing is specified return old default!
      return new BioCodec();
    }
  }
}


text:
@interface LeoLoadingView : UIView

-(void)showView:(BOOL)show;

@end


text:
Gowiki is a single-file single-executable wiki which runs its own webserver.

Writing it was an experiment in determining the cowpaths of small but non-trivial web application development using
[gorilla](http://gorillatoolkit.org), [sqlx](http://github.com/jmoiron/sqlx), and
[modl](http://github.com/jmoiron/modl).

## Features

Gowiki is a simple markdown wiki with the following features:

* markdown syntax w/ github style codeblocks
* distributable as a single binary which runs its own http server
* online customizable styles and page markup
* users and online user signup
* open or closed wikis, user page ownership
* ... by default it looks like [my website](http://jmoiron.net)

Gowiki does not:

* attempt to prevent multiple simultaneous edits
* auto-link WikiWeb style PageNames or require WikiCase urls

TODO:

* keep a revision history
* keep track of page references or interlinking
* add export options mentioned in `/config/files`

## Installing

```
go get github.com/jmoiron/gowiki
```

## Deployment

If your `$GOPATH/bin` is in your `PATH`, you can simply:

```
$ gowiki
Running in deployment mode with bundled resources.
Listening on :2222
```

`GOWIKI_PORT` controls the port to run on and `GOWIKI_PATH` controls the destination of the sqlite database.

Front this with nginx or whatever reverse proxy you like.

### Updating

Gowiki will create static files for things like style sheets and page templates in its database which
you can then edit online to modify the look and behavior of the wiki.  This means that old wikis
which run newer versions of gowiki might not look right.  Gowiki will automatically re-seed these if
they aren't there, so to refresh them, clear out the cache:

```sql
$ sqlite3 wiki.db
...
sqlite> delete from file;
sqlite>
```

## Development

```sh
$ ./gowiki -h
Usage of ./gowiki:
  -db="./wiki.db": path for wiki db
  -debug=false: run with debug mode
  -del-static=false: delete db-cached static files
  -load-static=false: reload db-cached static files
  -port="2222": port to run on
```

If no options are chosen, static files are loaded as necessary and the wiki is run in deploy mode.


text:
package fi.helsinki.cs.iot.hub.api.handlers.applications;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.HttpClientBuilder;

import fi.helsinki.cs.iot.hub.api.handlers.basic.IotHubApiRequestHandler;
import fi.helsinki.cs.iot.hub.api.request.IotHubRequest;
import fi.helsinki.cs.iot.hub.jsengine.DuktapeJavascriptEngineWrapper;
import fi.helsinki.cs.iot.hub.utils.Log;
import fi.helsinki.cs.iot.hub.webserver.NanoHTTPD.Method;
import fi.helsinki.cs.iot.hub.webserver.NanoHTTPD.Response;

/**
 *
 * @author Julien Mineraud <julien.mineraud@cs.helsinki.fi>
 *
 */
public class ApplicationGetRequestHandler extends IotHubApiRequestHandler {

	private static final String TAG = "ApplicationGetRequestHandler";
	private Path libdir;
	private List<Method> methods;

	public ApplicationGetRequestHandler(Path libdir) {
		this.libdir = libdir;
		this.methods = new ArrayList<>();
		this.methods.add(Method.GET);
	}

	@Override
	public Response handleRequest(IotHubRequest uri) {
		Log.d(TAG, "Got a request");
		// Case where we just want to list the libraires
		if (uri.getIdentifiers().size() == 0) {
			//Quick try for executing javascript code
			HttpClient httpclient = HttpClientBuilder.create().build();
			// Prepare a request object
			HttpGet httpget = new HttpGet("http://localhost:8080/libraries/test_jsoo.js");
			// Execute the request
			HttpResponse response;
			try {
				response = httpclient.execute(httpget);
				// Get hold of the response entity
				HttpEntity entity = response.getEntity();
				// If the response does not enclose an entity, there is no need
				// to worry about connection release
				if (entity != null) {
					// A Simple JSON Response Read
					InputStream instream = entity.getContent();
					String result= convertStreamToString(instream);
					DuktapeJavascriptEngineWrapper wrapper = new DuktapeJavascriptEngineWrapper(libdir);
					wrapper.runScript(result);
					instream.close();
				}
			} catch (Exception e) {
				getResponseKo("TODO", e.getMessage());
			}
			return getResponseOk("");
		}
		else if (uri.getIdentifiers().size() == 1) {
			//Quick try for executing javascript code
			HttpClient httpclient = HttpClientBuilder.create().build();
			// Prepare a request object
			HttpGet httpget = new HttpGet("http://localhost:8080/libraries/" + uri.getIdentifiers().get(0));
			// Execute the request
			HttpResponse response;
			try {
				response = httpclient.execute(httpget);
				// Get hold of the response entity
				HttpEntity entity = response.getEntity();
				// If the response does not enclose an entity, there is no need
				// to worry about connection release
				if (entity != null) {
					// A Simple JSON Response Read
					InputStream instream = entity.getContent();
					String result= convertStreamToString(instream);
					DuktapeJavascriptEngineWrapper wrapper = new DuktapeJavascriptEngineWrapper(libdir);
					wrapper.runScript(result);
					instream.close();
				}
			} catch (Exception e) {
				getResponseKo("TODO", e.getMessage());
			}
			return getResponseOk("Run is finished");
		}
		else {
			return getResponseKo(STATUS_NOT_YET_IMPLEMENTED, STATUS_NOT_YET_IMPLEMENTED);
		}
	}

	@Override
	public List<Method> getSupportedMethods() {
		return methods;
	}

	//http://www.vogella.com/code/com.vogella.android.webservice.rest/src/com/vogella/android/webservice/rest/RestClient.html
	private static String convertStreamToString(InputStream is) {
		/*
		 * To convert the InputStream to String we use the BufferedReader.readLine()
		 * method. We iterate until the BufferedReader return null which means
		 * there's no more data to read. Each line will appended to a StringBuilder
		 * and returned as String.
		 */
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder sb = new StringBuilder();

		String line = null;
		try {
			while ((line = reader.readLine()) != null) {
				sb.append(line + "\n");
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sb.toString();
	}

}


text:
namespace chromecast {
namespace media {
namespace {

std::unique_ptr<MediaPipelineBackend> CreateMediaPipelineBackend(
    const media::MediaPipelineDeviceParams& params) {
  LOG(INFO) << "Beginning creation of MediaPipelineBackend...";
  auto backend = base::WrapUnique(
      media::CastMediaShlib::CreateMediaPipelineBackend(params));
  LOG(INFO) << "Completed creation of MediaPipelineBackend!";
  return backend;
}

}  // namespace

using DecoderType = MediaPipelineBackendManager::DecoderType;

// DecoderCreatorCmaBackend transfers the ownership of the created Decoders.
class DecoderCreatorCmaBackend : public CmaBackend {
 public:
  virtual std::unique_ptr<AudioDecoderWrapper> CreateAudioDecoderWrapper() = 0;
  virtual std::unique_ptr<VideoDecoderWrapper> CreateVideoDecoderWrapper() = 0;
};

namespace {

class RevokedMediaPipelineBackendWrapper : public DecoderCreatorCmaBackend {
 public:
  RevokedMediaPipelineBackendWrapper(const AudioContentType& content_type,
                                     int64_t current_pts)
      : content_type_(content_type), current_pts_(current_pts) {}

  RevokedMediaPipelineBackendWrapper(
      const RevokedMediaPipelineBackendWrapper&) = delete;
  RevokedMediaPipelineBackendWrapper& operator=(
      const RevokedMediaPipelineBackendWrapper&) = delete;

  ~RevokedMediaPipelineBackendWrapper() override = default;

  std::unique_ptr<AudioDecoderWrapper> CreateAudioDecoderWrapper() override {
    return std::make_unique<AudioDecoderWrapper>(content_type_);
  }

  std::unique_ptr<VideoDecoderWrapper> CreateVideoDecoderWrapper() override {
    return std::make_unique<VideoDecoderWrapper>();
  }

  // CmaBackend implementation:
  CmaBackend::AudioDecoder* CreateAudioDecoder() override {
    NOTREACHED();
    return nullptr;
  }

  CmaBackend::VideoDecoder* CreateVideoDecoder() override {
    NOTREACHED();
    return nullptr;
  }

  bool Initialize() override { return true; }
  bool Start(int64_t start_pts) override { return true; }
  void Stop() override {}
  bool Pause() override { return true; }
  bool Resume() override { return true; }
  int64_t GetCurrentPts() override { return current_pts_; }
  bool SetPlaybackRate(float rate) override { return true; }
  void LogicalPause() override {}
  void LogicalResume() override {}

 private:
  const AudioContentType content_type_;
  const int64_t current_pts_;
};

}  // namespace

class ActiveMediaPipelineBackendWrapper : public DecoderCreatorCmaBackend {
 public:
  ActiveMediaPipelineBackendWrapper(
      const media::MediaPipelineDeviceParams& params,
      MediaPipelineBackendWrapper* wrapping_backend,
      MediaPipelineBackendManager* backend_manager,
      MediaResourceTracker* media_resource_tracker);

  ActiveMediaPipelineBackendWrapper(const ActiveMediaPipelineBackendWrapper&) =
      delete;
  ActiveMediaPipelineBackendWrapper& operator=(
      const ActiveMediaPipelineBackendWrapper&) = delete;

  ~ActiveMediaPipelineBackendWrapper() override;

  // DecoderCreatorCmaBackend implementation:
  // Audio/VideoDecoders are owned by the MediaPipelineBackendWrapper.
  std::unique_ptr<AudioDecoderWrapper> CreateAudioDecoderWrapper() override;
  std::unique_ptr<VideoDecoderWrapper> CreateVideoDecoderWrapper() override;

  // CmaBackend implementation:
  AudioDecoder* CreateAudioDecoder() override;
  VideoDecoder* CreateVideoDecoder() override;
  bool Initialize() override;
  bool Start(int64_t start_pts) override;
  void Stop() override;
  bool Pause() override;
  bool Resume() override;
  int64_t GetCurrentPts() override;
  bool SetPlaybackRate(float rate) override;
  void LogicalPause() override;
  void LogicalResume() override;

 private:
  void SetPlaying(bool playing);

  bool IsSfx() {
    return audio_stream_type_ ==
           media::MediaPipelineDeviceParams::kAudioStreamSoundEffects;
  }

  AudioDecoderWrapper* audio_decoder_ptr_;
  bool video_decoder_created_;
  const std::unique_ptr<MediaPipelineBackend> backend_;
  MediaPipelineBackendWrapper* const wrapping_backend_;
  MediaPipelineBackendManager* const backend_manager_;
  const MediaPipelineDeviceParams::AudioStreamType audio_stream_type_;
  const AudioContentType content_type_;

  // Acquire the media resource at construction. The resource will be released
  // when this class is destructed.
  MediaResourceTracker::ScopedUsage media_resource_usage_;

  bool playing_;
};

ActiveMediaPipelineBackendWrapper::ActiveMediaPipelineBackendWrapper(
    const media::MediaPipelineDeviceParams& params,
    MediaPipelineBackendWrapper* wrapping_backend,
    MediaPipelineBackendManager* backend_manager,
    MediaResourceTracker* media_resource_tracker)
    : audio_decoder_ptr_(nullptr),
      video_decoder_created_(false),
      backend_(CreateMediaPipelineBackend(params)),
      wrapping_backend_(wrapping_backend),
      backend_manager_(backend_manager),
      audio_stream_type_(params.audio_type),
      content_type_(params.content_type),
      media_resource_usage_(media_resource_tracker),
      playing_(false) {
  DCHECK(backend_);
  DCHECK(backend_manager_);
}

ActiveMediaPipelineBackendWrapper::~ActiveMediaPipelineBackendWrapper() {
  // When the backend is revoked,  the video/audio_decoder should be considered
  // gone to |backend_manager_|. The reason is that the replacement of the
  // Audio/VideoDecoderWrapper are dummy ones that are not actually playing.
  if (audio_decoder_ptr_) {
    backend_manager_->DecrementDecoderCount(
        IsSfx() ? DecoderType::SFX_DECODER : DecoderType::AUDIO_DECODER);
    if (playing_) {
      backend_manager_->UpdatePlayingAudioCount(IsSfx(), content_type_, -1);
    }
  }
  if (video_decoder_created_) {
    backend_manager_->DecrementDecoderCount(DecoderType::VIDEO_DECODER);
  }
}

CmaBackend::AudioDecoder*
ActiveMediaPipelineBackendWrapper::CreateAudioDecoder() {
  NOTREACHED();
  return nullptr;
}

CmaBackend::VideoDecoder*
ActiveMediaPipelineBackendWrapper::CreateVideoDecoder() {
  NOTREACHED();
  return nullptr;
}

void ActiveMediaPipelineBackendWrapper::LogicalPause() {
  SetPlaying(false);
}

void ActiveMediaPipelineBackendWrapper::LogicalResume() {
  SetPlaying(true);
}

std::unique_ptr<AudioDecoderWrapper>
ActiveMediaPipelineBackendWrapper::CreateAudioDecoderWrapper() {
  DCHECK(!audio_decoder_ptr_);

  if (!backend_manager_->IncrementDecoderCount(
          IsSfx() ? DecoderType::SFX_DECODER : DecoderType::AUDIO_DECODER))
    return nullptr;
  MediaPipelineBackend::AudioDecoder* real_decoder =
      backend_->CreateAudioDecoder();
  if (!real_decoder) {
    return nullptr;
  }

  MediaPipelineBackendManager::BufferDelegate* delegate = nullptr;
  // Only set delegate for the primary media stream.
  if (content_type_ == media::AudioContentType::kMedia &&
      audio_stream_type_ ==
          media::MediaPipelineDeviceParams::kAudioStreamNormal) {
    delegate = backend_manager_->buffer_delegate();
  }

  auto audio_decoder = std::make_unique<AudioDecoderWrapper>(
      real_decoder, content_type_, delegate);
  audio_decoder_ptr_ = audio_decoder.get();
  return audio_decoder;
}

std::unique_ptr<VideoDecoderWrapper>
ActiveMediaPipelineBackendWrapper::CreateVideoDecoderWrapper() {
  DCHECK(!video_decoder_created_);
  backend_manager_->BackendUseVideoDecoder(wrapping_backend_);

  if (!backend_manager_->IncrementDecoderCount(DecoderType::VIDEO_DECODER))
    return nullptr;

  MediaPipelineBackend::VideoDecoder* real_decoder =
      backend_->CreateVideoDecoder();
  if (!real_decoder) {
    return nullptr;
  }

  video_decoder_created_ = true;
  auto video_decoder = std::make_unique<VideoDecoderWrapper>(real_decoder);
  return video_decoder;
}

bool ActiveMediaPipelineBackendWrapper::Initialize() {
  LOG(INFO) << "Beginning initialization of MediaPipelineBackend...";
  bool success = backend_->Initialize();
  if (success && audio_decoder_ptr_) {
    audio_decoder_ptr_->OnInitialized();
  }
  LOG(INFO) << "Initialization of MediaPipelineBackend "
            << (success ? "succeeded!" : "failed!");
  return success;
}

bool ActiveMediaPipelineBackendWrapper::Start(int64_t start_pts) {
  if (!backend_->Start(start_pts)) {
    return false;
  }
  SetPlaying(true);
  return true;
}

void ActiveMediaPipelineBackendWrapper::Stop() {
  backend_->Stop();
  SetPlaying(false);
}

bool ActiveMediaPipelineBackendWrapper::Pause() {
  if (!backend_->Pause()) {
    return false;
  }
  SetPlaying(false);
  return true;
}

bool ActiveMediaPipelineBackendWrapper::Resume() {
  if (!backend_->Resume()) {
    return false;
  }
  SetPlaying(true);
  return true;
}

int64_t ActiveMediaPipelineBackendWrapper::GetCurrentPts() {
  return backend_->GetCurrentPts();
}

bool ActiveMediaPipelineBackendWrapper::SetPlaybackRate(float rate) {
  return backend_->SetPlaybackRate(rate);
}

void ActiveMediaPipelineBackendWrapper::SetPlaying(bool playing) {
  if (playing == playing_) {
    return;
  }
  playing_ = playing;
  if (audio_decoder_ptr_) {
    backend_manager_->UpdatePlayingAudioCount(IsSfx(), content_type_,
                                              (playing_ ? 1 : -1));
  }
}

MediaPipelineBackendWrapper::MediaPipelineBackendWrapper(
    const media::MediaPipelineDeviceParams& params,
    MediaPipelineBackendManager* backend_manager,
    MediaResourceTracker* media_resource_tracker)
    : revoked_(false),
      backend_manager_(backend_manager),
      content_type_(params.content_type) {
  backend_ = std::make_unique<ActiveMediaPipelineBackendWrapper>(
      params, this, backend_manager, media_resource_tracker);
}

MediaPipelineBackendWrapper::~MediaPipelineBackendWrapper() {
  backend_manager_->BackendDestroyed(this);
}

void MediaPipelineBackendWrapper::Revoke() {
  if (!revoked_) {
    revoked_ = true;
    if (audio_decoder_)
      audio_decoder_->Revoke();
    if (video_decoder_)
      video_decoder_->Revoke();

    backend_ = std::make_unique<RevokedMediaPipelineBackendWrapper>(
        content_type_, backend_->GetCurrentPts());
  }
}

CmaBackend::AudioDecoder* MediaPipelineBackendWrapper::CreateAudioDecoder() {
  LOG(INFO) << "Beginning creation of AudioDecoder...";
  DCHECK(!audio_decoder_);
  audio_decoder_ = backend_->CreateAudioDecoderWrapper();
  LOG(INFO) << "Completed creation of AudioDecoder!";
  return audio_decoder_.get();
}

CmaBackend::VideoDecoder* MediaPipelineBackendWrapper::CreateVideoDecoder() {
  LOG(INFO) << "Beginning creation of VideoDecoder...";
  DCHECK(!video_decoder_);
  video_decoder_ = backend_->CreateVideoDecoderWrapper();
  LOG(INFO) << "VideoDecoder creation of AudioDecoder!";
  return video_decoder_.get();
}

bool MediaPipelineBackendWrapper::Initialize() {
  return backend_->Initialize();
}
bool MediaPipelineBackendWrapper::Start(int64_t start_pts) {
  return backend_->Start(start_pts);
}
void MediaPipelineBackendWrapper::Stop() {
  backend_->Stop();
}
bool MediaPipelineBackendWrapper::Pause() {
  return backend_->Pause();
}
bool MediaPipelineBackendWrapper::Resume() {
  return backend_->Resume();
}
int64_t MediaPipelineBackendWrapper::GetCurrentPts() {
  return backend_->GetCurrentPts();
}
bool MediaPipelineBackendWrapper::SetPlaybackRate(float rate) {
  return backend_->SetPlaybackRate(rate);
}
void MediaPipelineBackendWrapper::LogicalPause() {
  return backend_->LogicalPause();
}
void MediaPipelineBackendWrapper::LogicalResume() {
  return backend_->LogicalResume();
}

}  // namespace media
}  // namespace chromecast


text:
package com.sun.xml.ws.util.xml;

import javax.xml.stream.Location;

/**
 * {@link Location} that returns no info.
 *
 * @author Santiago.PericasGeertsen@sun.com
 */
public final class DummyLocation implements Location {
    private DummyLocation() {}

    public static final Location INSTANCE = new DummyLocation();

    @Override
    public int getCharacterOffset() {
        return -1;
    }
    @Override
    public int getColumnNumber() {
        return -1;
    }
    @Override
    public int getLineNumber() {
        return -1;
    }
    @Override
    public String getPublicId() {
        return null;
    }
    @Override
    public String getSystemId() {
        return null;
    }
}


text:
package com.sumpfhupe.apps.minitodo;

import android.content.res.Resources;

/**
 * Created by avjindersinghsekhon on 9/21/15.
 */
public class PreferenceKeys {
    final String night_mode_pref_key;

    public PreferenceKeys(Resources resources){
        night_mode_pref_key = resources.getString(R.string.night_mode_pref_key);
    }
}


text: ./steamcmd.sh +runscript mvm_ds.txt


text:
//--------------------------------------
// GenomeBrowser Project
//
// SourcesWidgetSizeChanges.java
// Since: Jun 27, 2007
//
// $URL$
// $Author$
//--------------------------------------
package org.utgenome.gwt.utgb.client.ui;

public interface SourcesWidgetSizeChanges {
	public void addWidgetSizeChangeListener(WidgetSizeChangeListener listener);
	public void removeWidgetSizeChangeListener(WidgetSizeChangeListener listener);
}


text:
#ifndef COMPONENTS_SERVICES_MY_THREAD_BITS_H
#define COMPONENTS_SERVICES_MY_THREAD_BITS_H

/**
  @file mysql/components/services/my_thread_bits.h
  Types to make different thread packages compatible.
*/

#ifndef MYSQL_ABI_CHECK
#if defined(_WIN32)
#include <windows.h>
#else
#include <pthread.h>  // IWYU pragma: export
#include <sched.h>    // IWYU pragma: export
#endif
#endif /* MYSQL_ABI_CHECK */

#ifdef _WIN32
typedef DWORD my_thread_t;
typedef struct thread_attr {
  DWORD dwStackSize;
  int detachstate;
} my_thread_attr_t;
#else
typedef pthread_t my_thread_t;
typedef pthread_attr_t my_thread_attr_t;
#endif

struct my_thread_handle {
  my_thread_t thread{0};
#ifdef _WIN32
  HANDLE handle{INVALID_HANDLE_VALUE};
#endif
};

#endif /* COMPONENTS_SERVICES_MY_THREAD_BITS_H */


text:
package tterrag.difficultyrecipes.recipes;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import net.minecraftforge.oredict.RecipeSorter;
import net.minecraftforge.oredict.RecipeSorter.Category;
import net.minecraftforge.oredict.ShapelessOreRecipe;
import tterrag.difficultyrecipes.DifficultyRecipes;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ShapelessDifficultyRecipe extends DifficultyRecipe<ShapelessOreRecipe>
{
    static
    {
        RecipeSorter.register(DifficultyRecipes.MODID + ":shapeless", ShapelessDifficultyRecipe.class, Category.SHAPED, "after:forge:shapelessore");
    }

    public static Builder<ShapelessOreRecipe> builder()
    {
        return new Builder<ShapelessOreRecipe>(new ShapelessDifficultyRecipe(), ShapelessOreRecipe.class);
    }
}


text:
body {
  padding: 10px 30px;
}
ul#top-menu {
  margin: 0;
  padding: 0;
  padding-left: 20px;
  border-bottom: 1px solid #000099;
}
ul#top-menu li {
  display: inline;
  padding: 0px;
}
ul#top-menu li a, ul#top-menu li a:visited {
  background-color: #cce6ff;
  padding: 0px 5px;
  border: 1px solid #000099;
  text-decoration: none;
  color: #000099;
  font-weight: bold;
}
body#home ul#top-menu li.home a,
body#document ul#top-menu li.document a,
body#term ul#top-menu li.term a,
body#term-vector ul#top-menu li.term-vector a,
body#help ul#top-menu li.help a {
  background-color: #f0f8ff;
  border-bottom: 1px solid #f0f8ff;
}
div#content {
  padding: 10px;
  margin: 0;
  background-color: #f0f8ff;
}
div.display {background-color:#fff;padding:0 5px;}
dl {
  width: 51.1em;
  margin: 0;
  padding: 0;
}
dl dt {
  width: 15em;
  float: left;
  margin: 0;
  padding: .5em;
  border-top: 1px solid #999;
  font-weight: bold;
  color: #cc9900;
}
/* commented backslash hack for mac-ie5 \*/
dt { clear: both; }
/* end hack */
dl dd {
  float: left;
  width: 34em;
  margin: 0 0 0 0;
  padding: .5em;
  border-top: 1px solid #999;
}
hr {clear:both;border:0;}
h1, h2, h3, h4, h5, h6 {color:#cc0033;}
th {
  font-weight: bold;
  background-color: #cc9900;
  color: white;
  padding: 3px;
  font-size: 12px;
}
th.small, td.small {font-size:11px;}
th, td {
  border-top: 1px solid #994400;
  border-left: 1px solid #994400;
}
table {
  border-bottom: 1px solid #994400;
  border-right: 1px solid #994400;
}
table.left-headed th {width:80px;text-align:left;}
table.left-headed td {background-color: white;text-align:right;width:120px;}
td {padding:2px 6px;color:#555;}
tr.even {background-color:#cce6ff;}
tr.odd {background-color:white;}
td.center {text-align:center}
td.right {text-align:right}

label.check {width:150px;float:left;}
pre	{
  border-left: solid 1px #cccccc;
  border-top: solid 1px #cccccc;
  border-bottom: solid 1px #cccccc;
  border-right: dashed 2px #cccccc;
  margin: 1em;
  padding: 0.7em;
  display: block;
  overflow: hidden;
  color: white;
  background-color: black;
}
pre:hover {
  overflow: visible;
  border-right: solid 1px #cccccc;
  width: 1000px;
}
div.nav {color:#007777;font-size:11px;}
div.nav a, div.nav a:visited {
  background-color: white;
  color: #007777;
  padding: 2px 4px;
  border: 1px solid #bbd8ef;
  margin-right: 1px;
  text-decoration: none;
  font-size: 11px;
}
div.nav a.deleted {
  background-color: #fee;
}
div.nav a.deleted:hover {
  background-color: #077;
  color: #fee;
}
div.nav a.disabled, div.nav a.disabled:hover {
  cursor: default;
  color: #ccc;
  border: 1px solid #ccc;
  background-color: white;
}
div.nav a:hover {
  background-color: #007777;
  color: white;
}
/* Auto Suggest */
div.suggestions {
  -moz-box-sizing: border-box;
  box-sizing: border-box;
  border: 1px solid black;
  position: absolute;
}
div.suggestions div {
  cursor: default;
  padding: 0px 3px;
  background-color: white;
  opacity: 0.80;
  filter:alpha(opacity=80);
}
div.suggestions div.current {
  background-color: #3366cc;
  color: white;
}