text:
module("popup", {
 setup: function() {
   $.support.transition = false;
 }
});

test("trigger: focus + hide + destroy", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm',
    trigger: 'focus'
  }),
  o = e.data('clockface');
  e.focus();
  ok($('.clockface:visible').length, 'shown on focus');
  equal(o.hour, 23, 'hour ok');
  equal(o.minute, 30, 'minute ok');
  equal(o.ampm, 'pm', 'ampm ok');
  ok(e.hasClass('clockface-open'), 'element has class clockface-open');

  e.clockface('hide');
  ok(!$('.clockface:visible').length, 'closed');
  ok(!e.hasClass('clockface-open'), 'element does not have class clockface-open');

  e.clockface('destroy');
  ok(!$('.clockface').length, 'destroyed');
});

test("trigger: manual", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm',
    trigger: 'manual'
  }),
  o = e.data('clockface');
  e.focus();
  ok(!$('.clockface:visible').length, 'not shown on focus');

  e.clockface('destroy');
  ok(!$('.clockface').length, 'destroyed');
});

test("toggle", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm'
  }),
  o = e.data('clockface');
  e.clockface('toggle');
  ok($('.clockface:visible').length, 'shown on toggle');

  e.clockface('toggle');
  ok(!$('.clockface:visible').length, 'closed on toggle');

  e.clockface('destroy');
  ok(!$('.clockface').length, 'destroyed');
});

test("click outside close widget", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm'
  }),
  e2 = $('<input value="23:30">').appendTo('#qunit-fixture').clockface(),
  o = e.data('clockface');
  e.focus();
  ok($('.clockface:visible').length, 'shown');

  //click on element --> not close
  e.click();
  ok($('.clockface:visible').length, 'shown');

  //click inside clockface --> not close
  o.$clockface.click();
  ok($('.clockface:visible').length, 'shown');

  //click on another element --> close
  e2.click();
  ok(!o.$clockface.is(':visible'), 'closed');

  o.show();

  e.clockface('destroy');
  e2.clockface('destroy');
});

test("esc, enter, tab close widget", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm'
  }),
  ev, o = e.data('clockface');

  e.focus();
  ok($('.clockface:visible').length, 'shown');

  //esc
  ev = jQuery.Event("keydown");
  ev.which = 27;
  e.trigger(ev);
  ok(!o.$clockface.is(':visible'), 'closed on esc');

  e.focus();
  ok($('.clockface:visible').length, 'shown');
  //enter
  ev = jQuery.Event("keydown");
  ev.which = 13;
  e.trigger(ev);
  ok(!o.$clockface.is(':visible'), 'closed on enter');

  e.focus();
  ok($('.clockface:visible').length, 'shown');
  //tab
  ev = jQuery.Event("keydown");
  ev.which = 9;
  e.trigger(ev);
  ok(!o.$clockface.is(':visible'), 'closed on tab');

  e.clockface('destroy');
});

asyncTest("change value in input reflects clockface", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'H:mm'
  }),
  o = e.data('clockface');
  e.focus();
  ok($('.clockface:visible').length, 'shown on focus');

  e.val('11:05');
  e.keydown();

  setTimeout(function(){
    ok(o.$inner.eq(0).is('.active'), 'hour selected');
    equal(o.hour, 11, 'hour ok');
    equal(o.minute, 5, 'minute ok');
    equal(o.ampm, 'am', 'ampm ok');
    e.clockface('destroy');
    start();
  }, 700);

});

test("change value in clockface reflects on input", function () {
  var e = $('<input value="23:30">').appendTo('#qunit-fixture').clockface({
    format: 'h:mm'
  }),
  o = e.data('clockface');

  e.focus();
  ok($('.clockface:visible').length, 'shown on focus');

  o.$inner.eq(2).click();
  equal(e.val(), o.getTime(), 'hour in input changed');

  o.$outer.eq(2).click();
  equal(e.val(), o.getTime(), 'minute in input changed');

  o.$ampm.click();
  equal(e.val(), o.getTime(), 'ampm in input changed');

  e.clockface('destroy');
});

redpajama_set_name: RedPajamaGithub


text:
package org.lilyproject.indexer.hbase.mapper;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ngdata.hbaseindexer.parse.ResultToSolrMapper;
import com.ngdata.hbaseindexer.parse.SolrUpdateWriter;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.solr.common.SolrInputDocument;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.lilyproject.bytes.api.DataOutput;
import org.lilyproject.bytes.impl.DataOutputImpl;
import org.lilyproject.indexer.model.indexerconf.LilyIndexerConf;
import org.lilyproject.indexer.model.indexerconf.LilyIndexerConfBuilder;
import org.lilyproject.repository.api.FieldType;
import org.lilyproject.repository.api.IdGenerator;
import org.lilyproject.repository.api.IdentityRecordStack;
import org.lilyproject.repository.api.LRepository;
import org.lilyproject.repository.api.LTable;
import org.lilyproject.repository.api.Metadata;
import org.lilyproject.repository.api.QName;
import org.lilyproject.repository.api.Record;
import org.lilyproject.repository.api.RepositoryException;
import org.lilyproject.repository.api.RepositoryManager;
import org.lilyproject.repository.api.Scope;
import org.lilyproject.repository.api.TypeManager;
import org.lilyproject.repository.fake.FakeRepositoryManager;
import org.lilyproject.repository.impl.FieldFlags;
import org.lilyproject.repository.impl.HBaseRepository;
import org.lilyproject.repository.impl.id.IdGeneratorImpl;
import org.lilyproject.tools.import_.cli.JsonImport;
import org.lilyproject.util.hbase.LilyHBaseSchema;
import org.lilyproject.util.repo.RecordEvent;

import java.util.List;

public class LilyResultToSolrMapperTest {
    private static final String NS1 = "org.lilyproject.indexer.hbase.mapper.test";
    private static final String NS2 = "org.lilyproject.indexer.hbase.mapper.test.2";

    private RepositoryManager repositoryManager;
    private LRepository repository;
    private FakeSolrUpdateWriter solrUpdateWriter;
    private LilyResultToSolrMapper mapper;

    @Before
    public void setup () throws Exception{
        repositoryManager = FakeRepositoryManager.bootstrapRepositoryManager();
        repository = repositoryManager.getDefaultRepository();

        JsonImport.loadSchema(repository, LilyResultToSolrMapperTest.class.getResourceAsStream("schema.json"));

        LilyIndexerConf conf = LilyIndexerConfBuilder.build(LilyResultToSolrMapperTest.class.getResourceAsStream("indexer-conf.xml"), repository);
        // the zookeeper argument is only needed when there are deref expressions, hence it's ok to pass 'null'
        mapper = new LilyResultToSolrMapper("testindex", conf, repositoryManager, null);
        mapper.configure(Maps.<String, String>newHashMap());

        solrUpdateWriter = new FakeSolrUpdateWriter();
    }

    @Test
    public void testMap() throws Exception {
        IdGenerator idGenerator = new IdGeneratorImpl();
        System.out.println(Bytes.toString(idGenerator.fromString("USER.batch-index-custom").toBytes()));
        LTable table = repository.getDefaultTable();
        Record record = table.recordBuilder()
                .assignNewUuid()
                .recordType(new QName(NS1, "rt1"))
                .field(new QName(NS1, "a_string"), "myvalue")
                .create();

        Result result = encodeRecord(record);

        mapper.map(result, solrUpdateWriter);
        Assert.assertFalse(solrUpdateWriter.documents.isEmpty());
        SolrInputDocument doc = solrUpdateWriter.documents.get(0);
        Assert.assertTrue(doc.containsKey("a_string"));
        Assert.assertEquals("myvalue", doc.get("a_string").getValue());
    }

    public Result encodeRecord(Record record) throws InterruptedException, RepositoryException {
        TypeManager typeManager = repositoryManager.getDefaultRepository().getTypeManager();
        List<KeyValue> kvs = Lists.newArrayList();

        RecordEvent event = new RecordEvent();
        event.setType(RecordEvent.Type.CREATE);
        event.setTableName(LilyHBaseSchema.Table.RECORD.name);
        event.setVersionCreated(record.getVersion());

        byte[] rowKey = record.getId().toBytes();
        byte[] family = LilyHBaseSchema.RecordCf.DATA.bytes;

        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.VERSION.bytes, 1L, Bytes.toBytes(record.getVersion())));

        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.NON_VERSIONED_RT_ID.bytes,
                1L, typeManager.getRecordTypeByName(record.getRecordTypeName(Scope.NON_VERSIONED),
                        record.getRecordTypeVersion(Scope.NON_VERSIONED)).getId().getBytes()));
        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.NON_VERSIONED_RT_VERSION.bytes,
                1L, Bytes.toBytes(record.getRecordTypeVersion(Scope.NON_VERSIONED))));
        /*
        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.VERSIONED_RT_ID.bytes,
                typeManager.getRecordTypeByName(record.getRecordTypeName(Scope.VERSIONED),
                        record.getRecordTypeVersion(Scope.VERSIONED)).getId().getBytes()));
        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.VERSIONED_RT_VERSION.bytes,
                Bytes.toBytes(record.getRecordTypeVersion(Scope.VERSIONED))));

        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.VERSIONED_MUTABLE_RT_ID.bytes,
                typeManager.getRecordTypeByName(record.getRecordTypeName(Scope.VERSIONED_MUTABLE),
                        record.getRecordTypeVersion(Scope.VERSIONED_MUTABLE)).getId().getBytes()));
        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.NON_VERSIONED_RT_VERSION.bytes,
                Bytes.toBytes(record.getRecordTypeVersion(Scope.VERSIONED_MUTABLE))));
                */

        for (QName fieldName : record.getFields().keySet()) {
            FieldType fieldType = typeManager.getFieldTypeByName(fieldName);
            Metadata metadata = record.getMetadata(fieldName);
            boolean hasMetadata = metadata != null && !metadata.getMap().isEmpty();

            DataOutput output = new DataOutputImpl();

            output.writeByte(hasMetadata ? FieldFlags.METADATA_V1 : FieldFlags.DEFAULT);
            output.writeBytes(fieldType.getValueType().toBytes(record.getField(fieldName), new IdentityRecordStack()));
            if (hasMetadata) {
                HBaseRepository.writeMetadataWithLengthSuffix(metadata, output);
            }

            event.addUpdatedField(fieldType.getId());

            kvs.add(new KeyValue(rowKey, family,
                    Bytes.add(new byte[]{LilyHBaseSchema.RecordColumn.DATA_PREFIX}, fieldType.getId().getBytes()),
                    output.toByteArray()));
        }

        // fields to delete, should we add these too?
        kvs.add(new KeyValue(rowKey, family, LilyHBaseSchema.RecordColumn.PAYLOAD.bytes, event.toJsonBytes()));

        return new Result(kvs);
    }

    private static class FakeSolrUpdateWriter implements SolrUpdateWriter {
        private List<SolrInputDocument> documents = Lists.newArrayList();
        @Override
        public void add(SolrInputDocument solrDocument) {
            documents.add(solrDocument);
        }

        @Override
        public void deleteById(String documentId) {
            //To change body of implemented methods use File | Settings | File Templates.
        }

        @Override
        public void deleteByQuery(String query) {
            //To change body of implemented methods use File | Settings | File Templates.
        }
    }
}


text:
// Esquema: Divide y vencerás
// Ejemplo: Quicksort

using System;
using System.Collections.Generic;
using System.Linq;

namespace MTP.DyV {
    public static partial class DivideyVenceras {
        private static void Particion(int[] lista, int inf, int sup, out int p) {
            int pivote = lista[inf];
            int j = inf;
            for(int i = inf + 1; i <= sup; i++) {
                if(lista[i] < pivote) {
                    j++;
                    Util.Intercambiar(ref lista[i], ref lista[j]);
                }
            }

            p = j;
            Util.Intercambiar(ref lista[inf], ref lista[p]);
        }

        public static void QuickSort(int[] lista, int inf, int sup) {
            if(inf < sup) {
                int piv;
                Particion(lista, inf, sup, out piv);
                QuickSort(lista, inf, piv);
                QuickSort(lista, piv + 1, sup);
            }
        }

        public static void QuickSort(int[] lista) {
            QuickSort(lista, 0, lista.Length - 1);
        }
    }
}


text:
(function(){
  // Pts.namespace( this ); // add Pts into scope if needed

  var demoID = "pt_create";

  // create Space and Form
  var space = new CanvasSpace("#"+demoID).setup({ retina: true, bgcolor: "#e2e6ef", resize: true });
  var form = space.getForm();

  // animation
  space.add( (time, ftime) => {

    // space.pointer stores the last mouse or touch position
    let m = space.pointer;

    // drawing
    form.strokeOnly("#123", 5).line( [new Pt( m.x, 0), m, new Pt( 0, m.y)] );
    form.stroke("#42e").line( [new Pt(0,0), m] );
    form.stroke("#fff", 5).fill("#42e").point( m, 10, "circle")
    form.fill("#123").font(14, "bold").text( m.$add(20, 5), m.toString() );

  });

  // start
  // Note that `playOnce(200)` will stop after 200ms. Use `play()` to run the animation loop continuously.
  space.playOnce(200).bindMouse().bindTouch();

  // For use in demo page only
  if (window.registerDemo) window.registerDemo(demoID, space);

})();


text:
package io.leao.codecolors.core.app;

import android.app.Activity;
import android.content.res.Configuration;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.view.LayoutInflater;

import io.leao.codecolors.CodeColors;
import io.leao.codecolors.core.CcCore;
import io.leao.codecolors.core.view.CcLayoutInflater;

public class CcActivity extends Activity {
    private CcLayoutInflater mLayoutInflater;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        CcCore.getActivityManager().onActivityCreated(this);

        super.onCreate(savedInstanceState);
    }

    @Override
    protected void onResume() {
        CcCore.getActivityManager().onActivityResumed(this);

        super.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();

        CcCore.getActivityManager().onActivityPaused(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        CcCore.getActivityManager().onActivityDestroyed(this);
    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        CcCore.getActivityManager().onConfigurationChanged(newConfig, getResources());

        super.onConfigurationChanged(newConfig);
    }

    @Override
    public Object getSystemService(@NonNull String name) {
        Object systemService = super.getSystemService(name);

        if (CodeColors.isActive() && LAYOUT_INFLATER_SERVICE.equals(name)) {
            if (mLayoutInflater == null) {
                LayoutInflater layoutInflater = (LayoutInflater) systemService;
                // Copy the existing layout inflater and clone it to this context.
                // That also allows its factory to be reset.
                mLayoutInflater = CcLayoutInflater.copy(layoutInflater).cloneInContext(this);
            }
            return mLayoutInflater;
        } else {
            return systemService;
        }
    }
}


text:
import {DirectiveIndex} from './directive_record';
import {ProtoRecord} from './proto_record';

export class EventBinding {
  constructor(
      public eventName: string, public elIndex: number, public dirIndex: DirectiveIndex,
      public records: ProtoRecord[]) {}
}


text:
#import <iTunesStoreUI/SUScriptNativeObject.h>

#import "SUActivityDelegate-Protocol.h"

@interface SUScriptActivityNativeObject : SUScriptNativeObject <SUActivityDelegate>
{
}

- (void)performActionForActivity:(id)arg1;
- (void)activity:(id)arg1 prepareWithActivityItems:(id)arg2;
- (_Bool)activity:(id)arg1 canPerformWithActivityItems:(id)arg2;
- (void)setupNativeObject;
- (void)destroyNativeObject;

@end


text:
#include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <tuple>
#include <typeindex>
#include <vector>

#include <derecho/core/derecho.hpp>
#include <derecho/conf/conf.hpp>

/*
 * The Eclipse CDT parser crashes if it tries to expand the REGISTER_RPC_FUNCTIONS
 * macro, probably because there are too many layers of variadic argument expansion.
 * This definition makes the RPC macros no-ops when the CDT parser tries to expand
 * them, which allows it to continue syntax-highlighting the rest of the file.
 */
#ifdef __CDT_PARSER__
#define REGISTER_RPC_FUNCTIONS(...)
#define RPC_NAME(...) 0ULL
#endif

class Cache : public mutils::ByteRepresentable {
    std::map<std::string, std::string> cache_map;

public:
    void put(const std::string& key, const std::string& value) {
        cache_map[key] = value;
    }
    std::string get(const std::string& key) const {
        return cache_map.at(key);
    }
    bool contains(const std::string& key) const {
        return cache_map.find(key) != cache_map.end();
    }
    bool invalidate(const std::string& key) {
        auto key_pos = cache_map.find(key);
        if(key_pos == cache_map.end()) {
            return false;
        }
        cache_map.erase(key_pos);
        return true;
    }
    REGISTER_RPC_FUNCTIONS(Cache, ORDERED_TARGETS(put, invalidate), P2P_TARGETS(get, contains));

    Cache() : cache_map() {}
    Cache(const std::map<std::string, std::string>& cache_map) : cache_map(cache_map) {}

    DEFAULT_SERIALIZATION_SUPPORT(Cache, cache_map);
};

class LoadBalancer : public mutils::ByteRepresentable {
    std::vector<std::pair<std::string, std::string>> key_ranges_by_shard;

public:
    //I can't think of any RPC methods this class needs, but it can't be a Replicated Object without an RPC method
    void dummy() {}

    REGISTER_RPC_FUNCTIONS(LoadBalancer, ORDERED_TARGETS(dummy));

    LoadBalancer() : LoadBalancer({{"a", "i"}, {"j", "r"}, {"s", "z"}}) {}
    LoadBalancer(const std::vector<std::pair<std::string, std::string>>& key_ranges_by_shard)
            : key_ranges_by_shard(key_ranges_by_shard) {}

    DEFAULT_SERIALIZATION_SUPPORT(LoadBalancer, key_ranges_by_shard);
};

using std::cout;
using std::endl;

int main(int argc, char** argv) {
    derecho::Conf::initialize(argc, argv);

    auto load_balancer_factory = [](persistent::PersistentRegistry*,derecho::subgroup_id_t) { return std::make_unique<LoadBalancer>(); };
    auto cache_factory = [](persistent::PersistentRegistry*,derecho::subgroup_id_t) { return std::make_unique<Cache>(); };

    derecho::SubgroupAllocationPolicy load_balancer_policy = derecho::one_subgroup_policy(derecho::fixed_even_shards(1, 3));
    derecho::SubgroupAllocationPolicy cache_policy = derecho::one_subgroup_policy(derecho::fixed_even_shards(3, 3));
    derecho::SubgroupInfo subgroup_info(derecho::DefaultSubgroupAllocator({
        {std::type_index(typeid(LoadBalancer)), load_balancer_policy},
        {std::type_index(typeid(Cache)), cache_policy}
    }));

    derecho::Group<LoadBalancer, Cache> group({},
					      subgroup_info, {},
					      std::vector<derecho::view_upcall_t> {},
					      load_balancer_factory, cache_factory);
    cout << "Finished constructing/joining Group" << endl;
    uint32_t node_rank = group.get_my_rank();

    if(node_rank == 1) {
        derecho::ExternalCaller<Cache>& cache_handle = group.get_nonmember_subgroup<Cache>();
        node_id_t who = 3;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        derecho::rpc::QueryResults<std::string> cache_results = cache_handle.p2p_send<RPC_NAME(get)>(who, "6");
        std::string response = cache_results.get().get(who);
        cout << " Response from node " << who << ":" << response << endl;
    }
    if(node_rank > 2) {
        derecho::Replicated<Cache>& cache_handle = group.get_subgroup<Cache>();
        std::stringstream string_builder;
        string_builder << "Node " << node_rank << "'s things";
        cache_handle.ordered_send<RPC_NAME(put)>(std::to_string(node_rank), string_builder.str());
    }

    std::cout << "Reached end of main(), entering infinite loop so program doesn't exit" << std::endl;
    while(true) {
    }
}


text:
package util

import (
	"os"
	"os/exec"
	"strings"

	"github.com/fsouza/go-dockerclient"
	"github.com/golang/glog"
)

func GetHostname(hostnameOverride string) string {
	hostname := []byte(hostnameOverride)
	if string(hostname) == "" {
		// Note: We use exec here instead of os.Hostname() because we
		// want the FQDN, and this is the easiest way to get it.
		fqdn, err := exec.Command("hostname", "-f").Output()
		if err != nil {
			glog.Fatalf("Couldn't determine hostname: %v", err)
		}
		hostname = fqdn
	}
	return strings.TrimSpace(string(hostname))
}

// Get a docker endpoint, either from the string passed in, or $DOCKER_HOST environment variables
func GetDockerEndpoint(dockerEndpoint string) string {
	var endpoint string
	if len(dockerEndpoint) > 0 {
		endpoint = dockerEndpoint
	} else if len(os.Getenv("DOCKER_HOST")) > 0 {
		endpoint = os.Getenv("DOCKER_HOST")
	} else {
		endpoint = "unix:///var/run/docker.sock"
	}
	glog.Infof("Connecting to docker on %s", endpoint)

	return endpoint
}

func ConnectToDockerOrDie(dockerEndpoint string) *docker.Client {
	client, err := docker.NewClient(GetDockerEndpoint(dockerEndpoint))
	if err != nil {
		glog.Fatal("Couldn't connect to docker.")
	}
	return client
}


text:
package org.openxava.test.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

import org.openxava.annotations.View;

/**
 *
 * @author Federico Alcantara
 */
@Entity
@View(members="id;description")
public class TreeItemNoIdGeneration {
	@Id
	private Integer id;

	@Column(length=255)
	private String path;

	@Column(length=30)
	private String description;

	@ManyToOne
	private TreeContainerNoIdGeneration parentContainer;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getPath() {
		return path;
	}

	public void setPath(String path) {
		this.path = path;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public TreeContainerNoIdGeneration getParentContainer() {
		return parentContainer;
	}

	public void setParentContainer(TreeContainerNoIdGeneration parentContainer) {
		this.parentContainer = parentContainer;
	}

	@Override
	public String toString() {
		return id.toString();
	}
}


text:
package org.apache.kafka.streams.state;

import org.apache.kafka.common.annotation.InterfaceStability;
import org.apache.kafka.streams.kstream.Windowed;

/**
 * A session store that only supports read operations.
 * Implementations should be thread-safe as concurrent reads and writes
 * are expected.
 *
 * @param <K> the key type
 * @param <AGG> the aggregated value type
 */
@InterfaceStability.Unstable
public interface ReadOnlySessionStore<K, AGG> {

    /**
     * Retrieve all aggregated sessions for the provided key
     * @param    key record key to find aggregated session values for
     * @return   KeyValueIterator containing all sessions for the provided key.
     */
    KeyValueIterator<Windowed<K>, AGG> fetch(final K key);
}


text:
case $language in
	pt-br) echo -e "$green install $fcolor - Executa instalação de programas e pacotes de programas" ;;
	*) echo -e "$green install $fcolor - Run installation programs and software packages" ;;
esac


text:
function crazyCode() {

	var personalities = document.getElementById('personalities'),
		personalitySelected = document.getElementById('personalitySelected');

	function getTarget(target) {
		if (target.nodeName === 'A') {
			target = target.parentNode.parentNode;
		} else if (target.nodeName === 'LI') {
			target = target.parentNode;
		}
		return target;
	}

	function isActive(target) {
		var status = (getTarget(target).getAttribute('data-status')? true : false);
		return status;
	}

	function activePersonality (target) {
		target = getTarget(target);
		resetActives(target);
		target.setAttribute('data-status', 'active');
	}

	function resetActives(target) {
		var actives = document.querySelectorAll('[data-status]'),
			i = 0;
		if (actives.length === 0) {
			return false;
		}
		for (;i < actives.length; i += 1) {
			actives[i].removeAttribute('data-status');
		};
	}

	function showName (target) {
		if (target.nodeName === 'UL') {
			target = target.children[0];
		}
		personalitySelected.innerHTML = target.innerText;
	}

	function redirect(target) {
		window.location.href = target.href;
	}

	function selectPersonality(event) {
		// prevengo el comportamiento default
		// chequeo que elemento fue clickeado
		// si es el li de una personalidad, lo "activo" (pongo nombre en recuadro)
		// si el li ya esta "activo" y se clickea el a, redirijo
		event.preventDefault();

		var target = event.target,
			currentTarget = event.currentTarget;

		if (target !== currentTarget && !isActive(target)) {
			activePersonality(target);
			showName(target);
		} else if (target !== currentTarget && target.nodeName === 'A' && isActive(target)) {
			redirect(target);
		}

	}

	personalities.addEventListener('click', selectPersonality);

}

document.addEventListener('DOMContentLoaded', crazyCode);


text:
package com.urqa.alpha.exception;

import com.urqa.alpha.common.Command;

import java.util.zip.DataFormatException;

/**
 * @author seunoh on 2014. 05. 11..
 */
public class DataFormatExceptionCommand extends Command {

    public DataFormatExceptionCommand() {
        setName(DataFormatException.class.getSimpleName());
    }

    @Override
    public void execute() throws Exception {
        throw new DataFormatException(name());
    }
}


text:
#include "btBulletFile.h"
#include "bDefines.h"
#include "bDNA.h"

#if !defined( __CELLOS_LV2__) && !defined(__MWERKS__)
#include <memory.h>
#endif
#include <string.h>

// 32 && 64 bit versions
#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
#ifdef _WIN64
extern unsigned char sBulletDNAstr64[];
extern int sBulletDNAlen64;
#else
extern unsigned char sBulletDNAstr[];
extern int sBulletDNAlen;
#endif //_WIN64
#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES

extern unsigned char sBulletDNAstr64[];
extern int sBulletDNAlen64;
extern unsigned char sBulletDNAstr[];
extern int sBulletDNAlen;

#endif //BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES

using namespace bParse;

btBulletFile::btBulletFile()
:bFile("", "BULLET ")
{
	mMemoryDNA = new bDNA(); //this memory gets released in the bFile::~bFile destructor,@todo not consistent with the rule 'who allocates it, has to deallocate it"

	m_DnaCopy = 0;

#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
#ifdef _WIN64
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
#else//_WIN64
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
#endif//_WIN64
#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
	if (VOID_IS_8)
	{
		m_DnaCopy = (char*) btAlignedAlloc(sBulletDNAlen64,16);
		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen64);
	}
	else
	{
		m_DnaCopy =(char*) btAlignedAlloc(sBulletDNAlen,16);
		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
		mMemoryDNA->init(m_DnaCopy,sBulletDNAlen);
	}
#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}

btBulletFile::btBulletFile(const char* fileName)
:bFile(fileName, "BULLET ")
{
	m_DnaCopy = 0;
}

btBulletFile::btBulletFile(char *memoryBuffer, int len)
:bFile(memoryBuffer,len, "BULLET ")
{
	m_DnaCopy = 0;
}

btBulletFile::~btBulletFile()
{
	if (m_DnaCopy)
		btAlignedFree(m_DnaCopy);

	while (m_dataBlocks.size())
	{
		char* dataBlock = m_dataBlocks[m_dataBlocks.size()-1];
		delete[] dataBlock;
		m_dataBlocks.pop_back();
	}

}

// ----------------------------------------------------- //
void btBulletFile::parseData()
{
	printf ("Building datablocks");
	printf ("Chunk size = %d",CHUNK_HEADER_LEN);
	printf ("File chunk size = %d",ChunkUtils::getOffset(mFlags));

	const bool brokenDNA = (mFlags&FD_BROKEN_DNA)!=0;

	//const bool swap = (mFlags&FD_ENDIAN_SWAP)!=0;

	mDataStart = 12;

	char *dataPtr = mFileBuffer+mDataStart;

	bChunkInd dataChunk;
	dataChunk.code = 0;

	//dataPtr += ChunkUtils::getNextBlock(&dataChunk, dataPtr, mFlags);
	int seek = getNextBlock(&dataChunk, dataPtr, mFlags);
	//dataPtr += ChunkUtils::getOffset(mFlags);
	char *dataPtrHead = 0;

	while (dataChunk.code != DNA1)
	{
		if (!brokenDNA || (dataChunk.code != BT_QUANTIZED_BVH_CODE) )
		{

			// one behind
			if (dataChunk.code == SDNA) break;
			//if (dataChunk.code == DNA1) break;

			// same as (BHEAD+DATA dependency)
			dataPtrHead = dataPtr+ChunkUtils::getOffset(mFlags);
			if (dataChunk.dna_nr>=0)
			{
				char *id = readStruct(dataPtrHead, dataChunk);

				// lookup maps
				if (id)
				{
					m_chunkPtrPtrMap.insert(dataChunk.oldPtr, dataChunk);
					mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)id);

					m_chunks.push_back(dataChunk);
					// block it
					//bListBasePtr *listID = mMain->getListBasePtr(dataChunk.code);
					//if (listID)
					//	listID->push_back((bStructHandle*)id);
				}

				if (dataChunk.code == BT_SOFTBODY_CODE)
				{
					m_softBodies.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_RIGIDBODY_CODE)
				{
					m_rigidBodies.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_CONSTRAINT_CODE)
				{
					m_constraints.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_QUANTIZED_BVH_CODE)
				{
					m_bvhs.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_TRIANLGE_INFO_MAP)
				{
					m_triangleInfoMaps.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_COLLISIONOBJECT_CODE)
				{
					m_collisionObjects.push_back((bStructHandle*) id);
				}

				if (dataChunk.code == BT_SHAPE_CODE)
				{
					m_collisionShapes.push_back((bStructHandle*) id);
				}

		//		if (dataChunk.code == GLOB)
		//		{
		//			m_glob = (bStructHandle*) id;
		//		}
			} else
			{
				printf("unknown chunk\n");

				mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)dataPtrHead);
			}
		} else
		{
			printf("skipping BT_QUANTIZED_BVH_CODE due to broken DNA\n");
		}

		// next please!
		dataPtr += seek;

		seek =  getNextBlock(&dataChunk, dataPtr, mFlags);
		if (seek < 0)
			break;
	}

}

void	btBulletFile::addDataBlock(char* dataBlock)
{
	m_dataBlocks.push_back(dataBlock);

}

void	btBulletFile::writeDNA(FILE* fp)
{

	bChunkInd dataChunk;
	dataChunk.code = DNA1;
	dataChunk.dna_nr = 0;
	dataChunk.nr = 1;
#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
	if (VOID_IS_8)
	{
#ifdef _WIN64
		dataChunk.len = sBulletDNAlen64;
		dataChunk.oldPtr = sBulletDNAstr64;
		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
#else
		btAssert(0);
#endif
	}
	else
	{
#ifndef _WIN64
		dataChunk.len = sBulletDNAlen;
		dataChunk.oldPtr = sBulletDNAstr;
		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
#else//_WIN64
		btAssert(0);
#endif//_WIN64
	}
#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
	if (VOID_IS_8)
	{
		dataChunk.len = sBulletDNAlen64;
		dataChunk.oldPtr = sBulletDNAstr64;
		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
		fwrite(sBulletDNAstr64, sBulletDNAlen64,1,fp);
	}
	else
	{
		dataChunk.len = sBulletDNAlen;
		dataChunk.oldPtr = sBulletDNAstr;
		fwrite(&dataChunk,sizeof(bChunkInd),1,fp);
		fwrite(sBulletDNAstr, sBulletDNAlen,1,fp);
	}
#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}

void	btBulletFile::parse(bool verboseDumpAllTypes)
{
#ifdef BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
	if (VOID_IS_8)
	{
#ifdef _WIN64

		if (m_DnaCopy)
			delete m_DnaCopy;
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
		parseInternal(verboseDumpAllTypes,(char*)sBulletDNAstr64,sBulletDNAlen64);
#else
		btAssert(0);
#endif
	}
	else
	{
#ifndef _WIN64

		if (m_DnaCopy)
			delete m_DnaCopy;
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
		parseInternal(verboseDumpAllTypes,m_DnaCopy,sBulletDNAlen);
#else
		btAssert(0);
#endif
	}
#else//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
	if (VOID_IS_8)
	{
		if (m_DnaCopy)
			delete m_DnaCopy;
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen64,16);
		memcpy(m_DnaCopy,sBulletDNAstr64,sBulletDNAlen64);
		parseInternal(verboseDumpAllTypes,m_DnaCopy,sBulletDNAlen64);
	}
	else
	{
		if (m_DnaCopy)
			delete m_DnaCopy;
		m_DnaCopy = (char*)btAlignedAlloc(sBulletDNAlen,16);
		memcpy(m_DnaCopy,sBulletDNAstr,sBulletDNAlen);
		parseInternal(verboseDumpAllTypes,m_DnaCopy,sBulletDNAlen);
	}
#endif//BT_INTERNAL_UPDATE_SERIALIZATION_STRUCTURES
}

// experimental
int		btBulletFile::write(const char* fileName, bool fixupPointers)
{
	FILE *fp = fopen(fileName, "wb");
	if (fp)
	{
		char header[SIZEOFBLENDERHEADER] ;
		memcpy(header, m_headerString, 7);
		int endian= 1;
		endian= ((char*)&endian)[0];

		if (endian)
		{
			header[7] = '_';
		} else
		{
			header[7] = '-';
		}
		if (VOID_IS_8)
		{
			header[8]='V';
		} else
		{
			header[8]='v';
		}

		header[9] = '2';
		header[10] = '7';
		header[11] = '5';

		fwrite(header,SIZEOFBLENDERHEADER,1,fp);

		writeChunks(fp, fixupPointers);

		writeDNA(fp);

		fclose(fp);

	} else
	{
		printf("Error: cannot open file %s for writing\n",fileName);
		return 0;
	}
	return 1;
}

void	btBulletFile::addStruct(const	char* structType,void* data, int len, void* oldPtr, int code)
{

	bParse::bChunkInd dataChunk;
	dataChunk.code = code;
	dataChunk.nr = 1;
	dataChunk.len = len;
	dataChunk.dna_nr = mMemoryDNA->getReverseType(structType);
	dataChunk.oldPtr = oldPtr;

	///Perform structure size validation
	short* structInfo= mMemoryDNA->getStruct(dataChunk.dna_nr);
	int elemBytes;
	elemBytes= mMemoryDNA->getLength(structInfo[0]);
//	int elemBytes = mMemoryDNA->getElementSize(structInfo[0],structInfo[1]);
	assert(len==elemBytes);

	mLibPointers.insert(dataChunk.oldPtr, (bStructHandle*)data);
	m_chunks.push_back(dataChunk);
}


text:
describe('tooltip template', function() {
  var elm,
      elmBody,
      scope,
      elmScope,
      tooltipScope;

  // load the popover code
  beforeEach(module('ui.bootstrap.tooltip'));

  // load the template
  beforeEach(module('template/tooltip/tooltip-template-popup.html'));

  beforeEach(inject(function($templateCache) {
    $templateCache.put('myUrl', [200, '{{ myTemplateText }}', {}]);
  }));

  beforeEach(inject(function($rootScope, $compile) {
    elmBody = angular.element(
      '
Selector Text
'
    );

    scope = $rootScope;
    $compile(elmBody)(scope);
    scope.templateUrl = 'myUrl';

    scope.$digest();
    elm = elmBody.find('span');
    elmScope = elm.scope();
    tooltipScope = elmScope.$$childTail;
  }));

  function trigger(element, evt) {
    evt = new Event(evt);

    element[0].dispatchEvent(evt);
    element.scope().$$childTail.$digest();
  }

  it('should open on mouseenter', inject(function() {
    trigger(elm, 'mouseenter');
    expect(tooltipScope.isOpen).toBe(true);

    expect(elmBody.children().length).toBe(2);
  }));

  it('should not open on mouseenter if templateUrl is empty', inject(function() {
    scope.templateUrl = null;
    scope.$digest();

    trigger(elm, 'mouseenter');
    expect(tooltipScope.isOpen).toBe(false);

    expect(elmBody.children().length).toBe(1);
  }));

  it('should show updated text', inject(function() {
    scope.myTemplateText = 'some text';

    trigger(elm, 'mouseenter');
    expect(tooltipScope.isOpen).toBe(true);
    scope.$digest();

    expect(elmBody.children().eq(1).text().trim()).toBe('some text');

    scope.myTemplateText = 'new text';
    scope.$digest();

    expect(elmBody.children().eq(1).text().trim()).toBe('new text');
  }));

  it('should hide tooltip when template becomes empty', inject(function($timeout) {
    trigger(elm, 'mouseenter');
    expect(tooltipScope.isOpen).toBe(true);

    scope.templateUrl = '';
    scope.$digest();

    expect(tooltipScope.isOpen).toBe(false);

    $timeout.flush();
    expect(elmBody.children().length).toBe(1);
  }));
});

/* Deprecation tests below */

describe('tooltip template deprecation', function() {
  beforeEach(module('ui.bootstrap.tooltip'));
  beforeEach(module('template/tooltip/tooltip-template-popup.html'));

  var elm, elmBody, elmScope, tooltipScope;

  function trigger(element, evt) {
    evt = new Event(evt);

    element[0].dispatchEvent(evt);
    element.scope().$$childTail.$digest();
  }

  it('should suppress warning', function() {
    module(function($provide) {
      $provide.value('$tooltipSuppressWarning', true);
    });

    inject(function($compile, $log, $rootScope, $templateCache) {
      spyOn($log, 'warn');
      $templateCache.put('myUrl', [200, '{{ myTemplateText }}', {}]);
      $rootScope.templateUrl = 'myUrl';

      elmBody = angular.element('
Selector Text
');
      $compile(elmBody)($rootScope);
      $rootScope.$digest();
      elm = elmBody.find('span');
      elmScope = elm.scope();
      tooltipScope = elmScope.$$childTail;

      trigger(elm, 'mouseenter');

      expect($log.warn.calls.count()).toBe(0);
    });
  });

  it('should give warning by default', inject(function($compile, $log, $rootScope, $templateCache) {
    spyOn($log, 'warn');
    $templateCache.put('myUrl', [200, '{{ myTemplateText }}', {}]);
    $rootScope.templateUrl = 'myUrl';

    var element = '
Selector Text
';
    element = $compile(element)($rootScope);
    $rootScope.$digest();

    elmBody = angular.element('
Selector Text
');
    $compile(elmBody)($rootScope);
    $rootScope.$digest();
    elm = elmBody.find('span');
    elmScope = elm.scope();
    tooltipScope = elmScope.$$childTail;

    trigger(elm, 'mouseenter');

    expect($log.warn.calls.count()).toBe(2);
    expect($log.warn.calls.argsFor(0)).toEqual(['$tooltip is now deprecated. Use $uibTooltip instead.']);
    expect($log.warn.calls.argsFor(1)).toEqual(['tooltip-template-popup is now deprecated. Use uib-tooltip-template-popup instead.']);
  }));
});


text:
#Install dependencies
sudo apt-get update
sudo apt-get install -y wget git

wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.31.1/install.sh | sh
source $HOME/.nvm/nvm.sh
nvm install stable
nvm use stable

#Build and test spin.js
git clone https://github.com/fgnass/spin.js.git
cd spin.js/
npm install
npm test


text:
require_relative 'base'
require 'whois/scanners/whois.nic.it.rb'

module Whois
  class Parsers

    # Parser for the whois.nic.it server.
    class WhoisNicIt < Base
      include Scanners::Scannable

      self.scanner = Scanners::WhoisNicIt

      property_supported :disclaimer do
        node("Disclaimer")
      end

      property_supported :domain do
        node("Domain") { |str| str.downcase }
      end

      property_not_supported :domain_id

      property_supported :status do
        case s = node("Status").to_s.downcase
        when /^ok/, /\bclient/
          :registered
        when "grace-period", "no-provider"
          :registered
        when /^pendingupdate/
          :registered
        when /^pendingtransfer/
          :registered
        when /redemption-/
          :redemption
        when "pending-delete"
          :redemption
        # The domain will be deleted in 5 days
        when /^pendingdelete/
          :redemption
        when "unassignable"
          :unavailable
        when "reserved"
          :reserved
        when "available"
          :available
        when /^inactive/
          :inactive
        else
          Whois::Parser.bug!(ParserError, "Unknown status `#{s}'.")
        end
      end

      property_supported :available? do
        status == :available
      end

      property_supported :registered? do
        !available? &&
        !unavailable?
      end

      # NEWPROPERTY
      def unavailable?
        status == :unavailable
      end

      property_supported :created_on do
        node("Created") { |str| parse_time(str) }
      end

      property_supported :updated_on do
        node("Last Update") { |str| parse_time(str) }
      end

      property_supported :expires_on do
        node("Expire Date") { |str| parse_time(str) }
      end

      property_supported :registrar do
        node("Registrar") do |str|
          Parser::Registrar.new(
              id:           str["Name"],
              name:         str["Name"],
              organization: str["Organization"],
              url:          str["Web"]
          )
        end
      end

      property_supported :registrant_contacts do
        build_contact("Registrant", Parser::Contact::TYPE_REGISTRANT)
      end

      property_supported :admin_contacts do
        build_contact("Admin Contact", Parser::Contact::TYPE_ADMINISTRATIVE)
      end

      property_supported :technical_contacts do
        build_contact("Technical Contacts", Parser::Contact::TYPE_TECHNICAL)
      end

      property_supported :nameservers do
        Array.wrap(node("Nameservers")).map do |name|
          Parser::Nameserver.new(:name => name)
        end
      end

      # Checks whether this response contains a message
      # that can be reconducted to a "WHOIS Server Unavailable" status.
      #
      # @return [Boolean]
      def response_unavailable?
        !!node("response:unavailable")
      end

      private

      def build_contact(element, type)
        node(element) do |str|
          address = (str["Address"] || "").split("\n")
          company = address.size == 6 ? address.shift : nil
          Parser::Contact.new(
            :id           => str["ContactID"],
            :type         => type,
            :name         => str["Name"],
            :organization => str["Organization"] || company,
            :address      => address[0],
            :city         => address[1],
            :zip          => address[2],
            :state        => address[3],
            :country_code => address[4],
            :created_on   => str["Created"] ? parse_time(str["Created"]) : nil,
            :updated_on   => str["Last Update"] ? parse_time(str["Last Update"]) : nil
          )
        end
      end

    end

  end
end


text:
import * as React from "react";
import {
  Split,
  SplitItem,
  Dropdown,
  DropdownItem,
  DropdownPosition,
  KebabToggle,
  Title,
  Flex,
  FlexItem,
  PageSectionVariants,
  PageSection
} from "@patternfly/react-core";
import { css, StyleSheet } from "@patternfly/react-styles";
import { TypeBadge } from "components/common/TypePlan";

export interface IAddressDetailHeaderProps {
  type: string;
  topic: string | null;
  name: string;
  plan: string;
  partitions: number | string;
  storedMessages: number | string;
  onEdit: (name: string) => void;
  onDelete: (name: string) => void;
  onPurge: (name: string) => void;
}
const styles = StyleSheet.create({
  flex_left_border: {
    paddingLeft: "1em",
    borderLeft: "0.05em solid",
    borderRightColor: "lightgrey"
  },
  address_space_icon_margin: {
    backgroundColor: "#EC7A08",
    fontSize: 25
  },
  address_icon_align: {
    paddingTop: 5,
    paddingRight: 16
  },
  kebab_toggle_margin: {
    marginTop: 20,
    marginLeft: 10,
    fontSize: 15
  },
  namespace_info_margin: {
    marginTop: 16,
    marginBottom: 24
  },
  no_bottom_padding: {
    paddingBottom: 0
  }
});

export const AddressDetailHeader: React.FunctionComponent<IAddressDetailHeaderProps> = ({
  type,
  topic,
  name,
  plan,
  partitions,
  storedMessages,
  onEdit,
  onDelete,
  onPurge
}) => {
  const [isOpen, setIsOpen] = React.useState(false);
  const onSelect = (result: any) => {
    setIsOpen(!isOpen);
  };
  const onToggle = () => {
    setIsOpen(!isOpen);
  };
  const dropdownItems = [
    <DropdownItem
      id="adheader-dropdown-item-edit"
      key="download"
      aria-label="download"
      onClick={() => onEdit(name)}
    >
      Edit
    </DropdownItem>,
    <DropdownItem
      id="adheader-dropdown-item-delete"
      key="delete"
      aria-label="delete"
      onClick={() => onDelete(name)}
    >
      Delete
    </DropdownItem>
  ];
  if (
    type &&
    (type.toLowerCase() === "queue" || type.toLowerCase() === "subscription")
  ) {
    dropdownItems.push(
      <DropdownItem
        id="adheader-dropdown-item-purge"
        key="purge"
        aria-label="purge"
        onClick={() => onPurge(name)}
      >
        Purge
      </DropdownItem>
    );
  }
  return (
    <PageSection
      variant={PageSectionVariants.light}
      className={css(styles.no_bottom_padding)}
    >
      <Split>
        <SplitItem className={css(styles.address_icon_align)}>
          <TypeBadge type={type} />
        </SplitItem>
        <SplitItem>
          <Split gutter="md">
            <SplitItem>
              <Title headingLevel="h1" size="4xl" id="adheader-name">
                {name}
              </Title>
            </SplitItem>
          </Split>
          <Flex className={css(styles.namespace_info_margin)}>
            <FlexItem id="adheader-plans">
              Plan : {plan}
            </FlexItem>
            {topic && topic !== null && (
              <FlexItem
                id="adheader-subscription-topic"
                className={css(styles.flex_left_border)}
              >
                Topic : {topic}
              </FlexItem>
            )}
            {type && (type === "anycast" || type === "multicast") ? (
              ""
            ) : (
              <FlexItem
                id="adheader-stored-messages"
                className={css(styles.flex_left_border)}
              >

                  {storedMessages && storedMessages !== "" ? storedMessages : 0}
                {" "}
                stored messages
              </FlexItem>
            )}
          </Flex>
        </SplitItem>
        <SplitItem isFilled></SplitItem>
        <SplitItem className={css(styles.kebab_toggle_margin)}>
          <Dropdown
            id="adheader-dropdown"
            onSelect={onSelect}
            position={DropdownPosition.right}
            toggle={<KebabToggle id="adheader-kebab" onToggle={onToggle} />}
            isOpen={isOpen}
            isPlain={true}
            dropdownItems={dropdownItems}
          />
        </SplitItem>
      </Split>
    </PageSection>
  );
};


text:
package com.google.cloud.dataflow.sdk.transforms;

import com.google.cloud.dataflow.sdk.Pipeline;
import com.google.cloud.dataflow.sdk.testing.PAssert;
import com.google.cloud.dataflow.sdk.testing.TestPipeline;
import com.google.cloud.dataflow.sdk.values.PCollection;
import com.google.cloud.dataflow.sdk.values.TypeDescriptor;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

import java.io.Serializable;

/**
 * Java 8 tests for {@link MapElements}.
 */
@RunWith(JUnit4.class)
public class MapElementsJava8Test implements Serializable {

  /**
   * Basic test of {@link MapElements} with a lambda (which is instantiated as a
   * {@link SerializableFunction}).
   */
  @Test
  public void testMapBasic() throws Exception {
    Pipeline pipeline = TestPipeline.create();
    PCollection<Integer> output = pipeline
        .apply(Create.of(1, 2, 3))
        .apply(MapElements
            // Note that the type annotation is required (for Java, not for Dataflow)
            .via((Integer i) -> i * 2)
            .withOutputType(new TypeDescriptor<Integer>() {}));

    PAssert.that(output).containsInAnyOrder(6, 2, 4);
    pipeline.run();
  }

  /**
   * Basic test of {@link MapElements} with a method reference.
   */
  @Test
  public void testMapMethodReference() throws Exception {
    Pipeline pipeline = TestPipeline.create();
    PCollection<Integer> output = pipeline
        .apply(Create.of(1, 2, 3))
        .apply(MapElements
            // Note that the type annotation is required (for Java, not for Dataflow)
            .via(new Doubler()::doubleIt)
            .withOutputType(new TypeDescriptor<Integer>() {}));

    PAssert.that(output).containsInAnyOrder(6, 2, 4);
    pipeline.run();
  }

  private static class Doubler implements Serializable {
    public int doubleIt(int val) {
      return val * 2;
    }
  }
}


text:
using System;
using Microsoft.AspNetCore.Http;

namespace IndecisionEngine.Controllers
{
    public static class StateHelper
    {
        private const string StateKey = "story.state";

        public static void SetState(HttpContext context, string state)
        {
            context.Session.SetString(StateKey, state ?? string.Empty);
        }

        public static string GetState(HttpContext context)
        {
            return context.Session.GetString(StateKey);
        }

        public static string Update(HttpContext httpContext, string effects)
        {
            var state = GetState(httpContext);

            // TODO: Apply effects for real
            state += ";" + effects;

            SetState(httpContext, state);
            return state;
        }
    }
}


text:
<?php

namespace GoogleApi\Service;

abstract class Service
{
  public $version;
  public $restBasePath;
  public $resource;

  protected $client = null;

  public function __construct($client)
  {
      $this->client = $client;
  }

  public function getClient()
  {
      return $this->client;
  }
}


text:
class Ray {

public:
  //! direct access to vector data
  Vector origin;
  Vector direction;
  Ray(): origin(), direction() {}

  Ray(const Vector &orig, const Vector &dir) :
    origin(orig), direction(dir) {}

private:

};
#endif


text:
@implementation RNNLayoutOptions

- (instancetype)initWithDict:(NSDictionary *)dict {
    self = [super initWithDict:dict];
    self.backgroundColor = [ColorParser parse:dict key:@"backgroundColor"];
    self.componentBackgroundColor = [ColorParser parse:dict key:@"componentBackgroundColor"];
    self.direction = [TextParser parse:dict key:@"direction"];
    self.orientation = dict[@"orientation"];
    self.autoHideHomeIndicator = [BoolParser parse:dict key:@"autoHideHomeIndicator"];
    self.insets = [[RNNInsetsOptions alloc] initWithDict:dict[@"insets"]];
    return self;
}

- (void)mergeOptions:(RNNLayoutOptions *)options {
    if (options.backgroundColor.hasValue)
        self.backgroundColor = options.backgroundColor;
    if (options.componentBackgroundColor.hasValue)
        self.componentBackgroundColor = options.componentBackgroundColor;
    if (options.direction.hasValue)
        self.direction = options.direction;
    if (options.orientation)
        self.orientation = options.orientation;
    if (options.autoHideHomeIndicator)
        self.autoHideHomeIndicator = options.autoHideHomeIndicator;
    if (options.insets.hasValue) {
        self.insets = options.insets;
    }
}

- (UIInterfaceOrientationMask)supportedOrientations {
    NSArray *orientationsArray = [self.orientation isKindOfClass:[NSString class]]
                                     ? @[ self.orientation ]
                                     : self.orientation;
    NSUInteger supportedOrientationsMask = 0;
    if (!orientationsArray || [self.orientation isEqual:@"default"]) {
        return [[UIApplication sharedApplication]
            supportedInterfaceOrientationsForWindow:[[UIApplication sharedApplication] keyWindow]];
    } else {
        for (NSString *orientation in orientationsArray) {
            if ([orientation isEqualToString:@"all"]) {
                supportedOrientationsMask = UIInterfaceOrientationMaskAll;
                break;
            }
            if ([orientation isEqualToString:@"landscape"]) {
                supportedOrientationsMask =
                    (supportedOrientationsMask | UIInterfaceOrientationMaskLandscape);
            }
            if ([orientation isEqualToString:@"portrait"]) {
                supportedOrientationsMask =
                    (supportedOrientationsMask | UIInterfaceOrientationMaskPortrait);
            }
            if ([orientation isEqualToString:@"upsideDown"]) {
                supportedOrientationsMask =
                    (supportedOrientationsMask | UIInterfaceOrientationMaskPortraitUpsideDown);
            }
        }
    }

    return supportedOrientationsMask;
}

@end


text:
#ifndef SPECKLE_H
#define SPECKLE_H

/*-----------------------------------------------------------------------------
          Include Files and Type Defines
-----------------------------------------------------------------------------*/

#include "baseline.h"
#include "ratngs.h"

/*-----------------------------------------------------------------------------
          Public Function Prototypes
-----------------------------------------------------------------------------*/
void AddLargeSpeckleTo(BLOB_CHOICE_LIST *Choices);

BOOL8 LargeSpeckle(TBLOB *Blob);

#endif


text:
use std::collections::{HashMap, BTreeMap, HashSet, BTreeSet};
use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::str;

use semver::{self, VersionReq};
use serde::ser;
use serde::de::{self, Deserialize};
use serde_ignored;
use toml;
use url::Url;

use core::{SourceId, Profiles, PackageIdSpec, GitReference, WorkspaceConfig, WorkspaceRootConfig};
use core::{Summary, Manifest, Target, Dependency, PackageId};
use core::{EitherManifest, VirtualManifest, Features, Feature};
use core::dependency::{Kind, Platform};
use core::manifest::{LibKind, Profile, ManifestMetadata};
use sources::CRATES_IO;
use util::paths;
use util::{self, ToUrl, Config};
use util::errors::{CargoError, CargoResult, CargoResultExt};

mod targets;
use self::targets::targets;

pub fn read_manifest(path: &Path, source_id: &SourceId, config: &Config)
                     -> CargoResult<(EitherManifest, Vec<PathBuf>)> {
    trace!("read_manifest; path={}; source-id={}", path.display(), source_id);
    let contents = paths::read(path)?;

    do_read_manifest(&contents, path, source_id, config).chain_err(|| {
        format!("failed to parse manifest at `{}`", path.display())
    })
}

fn do_read_manifest(contents: &str,
                    manifest_file: &Path,
                    source_id: &SourceId,
                    config: &Config)
                    -> CargoResult<(EitherManifest, Vec<PathBuf>)> {
    let package_root = manifest_file.parent().unwrap();

    let toml = {
        let pretty_filename =
            util::without_prefix(manifest_file, config.cwd()).unwrap_or(manifest_file);
        parse(contents, pretty_filename, config)?
    };

    let mut unused = BTreeSet::new();
    let manifest: TomlManifest = serde_ignored::deserialize(toml, |path| {
        let mut key = String::new();
        stringify(&mut key, &path);
        unused.insert(key);
    })?;

    let manifest = Rc::new(manifest);
    return match TomlManifest::to_real_manifest(&manifest,
                                                source_id,
                                                package_root,
                                                config) {
        Ok((mut manifest, paths)) => {
            for key in unused {
                manifest.add_warning(format!("unused manifest key: {}", key));
            }
            if !manifest.targets().iter().any(|t| !t.is_custom_build()) {
                bail!("no targets specified in the manifest\n  \
                       either src/lib.rs, src/main.rs, a [lib] section, or \
                       [[bin]] section must be present")
            }
            Ok((EitherManifest::Real(manifest), paths))
        }
        Err(e) => {
            match TomlManifest::to_virtual_manifest(&manifest,
                                                    source_id,
                                                    package_root,
                                                    config) {
                Ok((m, paths)) => Ok((EitherManifest::Virtual(m), paths)),
                Err(..) => Err(e),
            }
        }
    };

    fn stringify(dst: &mut String, path: &serde_ignored::Path) {
        use serde_ignored::Path;

        match *path {
            Path::Root => {}
            Path::Seq { parent, index } => {
                stringify(dst, parent);
                if !dst.is_empty() {
                    dst.push('.');
                }
                dst.push_str(&index.to_string());
            }
            Path::Map { parent, ref key } => {
                stringify(dst, parent);
                if !dst.is_empty() {
                    dst.push('.');
                }
                dst.push_str(key);
            }
            Path::Some { parent } |
            Path::NewtypeVariant { parent } |
            Path::NewtypeStruct { parent } => stringify(dst, parent),
        }
    }
}

pub fn parse(toml: &str,
             file: &Path,
             config: &Config) -> CargoResult<toml::Value> {
    let first_error = match toml.parse() {
        Ok(ret) => return Ok(ret),
        Err(e) => e,
    };

    let mut second_parser = toml::de::Deserializer::new(toml);
    second_parser.set_require_newline_after_table(false);
    if let Ok(ret) = toml::Value::deserialize(&mut second_parser) {
        let msg = format!("\
TOML file found which contains invalid syntax and will soon not parse
at `{}`.

The TOML spec requires newlines after table definitions (e.g. `[a] b = 1` is
invalid), but this file has a table header which does not have a newline after
it. A newline needs to be added and this warning will soon become a hard error
in the future.", file.display());
        config.shell().warn(&msg)?;
        return Ok(ret)
    }

    Err(first_error).chain_err(|| {
        "could not parse input as TOML"
    })
}

type TomlLibTarget = TomlTarget;
type TomlBinTarget = TomlTarget;
type TomlExampleTarget = TomlTarget;
type TomlTestTarget = TomlTarget;
type TomlBenchTarget = TomlTarget;

#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum TomlDependency {
    Simple(String),
    Detailed(DetailedTomlDependency)
}

impl<'de> de::Deserialize<'de> for TomlDependency {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: de::Deserializer<'de>
    {
        struct TomlDependencyVisitor;

        impl<'de> de::Visitor<'de> for TomlDependencyVisitor {
            type Value = TomlDependency;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a version string like \"0.9.8\" or a \
                                     detailed dependency like { version = \"0.9.8\" }")
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
                where E: de::Error
            {
                Ok(TomlDependency::Simple(s.to_owned()))
            }

            fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
                where V: de::MapAccess<'de>
            {
                let mvd = de::value::MapAccessDeserializer::new(map);
                DetailedTomlDependency::deserialize(mvd).map(TomlDependency::Detailed)
            }
        }

        deserializer.deserialize_any(TomlDependencyVisitor)
    }
}

#[derive(Deserialize, Serialize, Clone, Debug, Default)]
pub struct DetailedTomlDependency {
    version: Option<String>,
    registry: Option<String>,
    path: Option<String>,
    git: Option<String>,
    branch: Option<String>,
    tag: Option<String>,
    rev: Option<String>,
    features: Option<Vec<String>>,
    optional: Option<bool>,
    #[serde(rename = "default-features")]
    default_features: Option<bool>,
    #[serde(rename = "default_features")]
    default_features2: Option<bool>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct TomlManifest {
    #[serde(rename = "cargo-features")]
    cargo_features: Option<Vec<String>>,
    package: Option<Box<TomlProject>>,
    project: Option<Box<TomlProject>>,
    profile: Option<TomlProfiles>,
    lib: Option<TomlLibTarget>,
    bin: Option<Vec<TomlBinTarget>>,
    example: Option<Vec<TomlExampleTarget>>,
    test: Option<Vec<TomlTestTarget>>,
    bench: Option<Vec<TomlTestTarget>>,
    dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "dev-dependencies")]
    dev_dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "dev_dependencies")]
    dev_dependencies2: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "build-dependencies")]
    build_dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "build_dependencies")]
    build_dependencies2: Option<BTreeMap<String, TomlDependency>>,
    features: Option<BTreeMap<String, Vec<String>>>,
    target: Option<BTreeMap<String, TomlPlatform>>,
    replace: Option<BTreeMap<String, TomlDependency>>,
    patch: Option<BTreeMap<String, BTreeMap<String, TomlDependency>>>,
    workspace: Option<TomlWorkspace>,
    badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
}

#[derive(Deserialize, Serialize, Clone, Debug, Default)]
pub struct TomlProfiles {
    test: Option<TomlProfile>,
    doc: Option<TomlProfile>,
    bench: Option<TomlProfile>,
    dev: Option<TomlProfile>,
    release: Option<TomlProfile>,
}

#[derive(Clone, Debug)]
pub struct TomlOptLevel(String);

impl<'de> de::Deserialize<'de> for TomlOptLevel {
    fn deserialize<D>(d: D) -> Result<TomlOptLevel, D::Error>
        where D: de::Deserializer<'de>
    {
        struct Visitor;

        impl<'de> de::Visitor<'de> for Visitor {
            type Value = TomlOptLevel;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("an optimization level")
            }

            fn visit_i64<E>(self, value: i64) -> Result<TomlOptLevel, E>
                where E: de::Error
            {
                Ok(TomlOptLevel(value.to_string()))
            }

            fn visit_str<E>(self, value: &str) -> Result<TomlOptLevel, E>
                where E: de::Error
            {
                if value == "s" || value == "z" {
                    Ok(TomlOptLevel(value.to_string()))
                } else {
                    Err(E::custom(format!("must be an integer, `z`, or `s`, \
                                           but found: {}", value)))
                }
            }
        }

        d.deserialize_u32(Visitor)
    }
}

impl ser::Serialize for TomlOptLevel {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: ser::Serializer,
    {
        match self.0.parse::<u32>() {
            Ok(n) => n.serialize(serializer),
            Err(_) => self.0.serialize(serializer),
        }
    }
}

#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum U32OrBool {
    U32(u32),
    Bool(bool),
}

impl<'de> de::Deserialize<'de> for U32OrBool {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: de::Deserializer<'de>
    {
        struct Visitor;

        impl<'de> de::Visitor<'de> for Visitor {
            type Value = U32OrBool;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a boolean or an integer")
            }

            fn visit_i64<E>(self, u: i64) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(U32OrBool::U32(u as u32))
            }

            fn visit_u64<E>(self, u: u64) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(U32OrBool::U32(u as u32))
            }

            fn visit_bool<E>(self, b: bool) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(U32OrBool::Bool(b))
            }
        }

        deserializer.deserialize_any(Visitor)
    }
}

#[derive(Deserialize, Serialize, Clone, Debug, Default)]
pub struct TomlProfile {
    #[serde(rename = "opt-level")]
    opt_level: Option<TomlOptLevel>,
    lto: Option<bool>,
    #[serde(rename = "codegen-units")]
    codegen_units: Option<u32>,
    debug: Option<U32OrBool>,
    #[serde(rename = "debug-assertions")]
    debug_assertions: Option<bool>,
    rpath: Option<bool>,
    panic: Option<String>,
    #[serde(rename = "overflow-checks")]
    overflow_checks: Option<bool>,
}

#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum StringOrBool {
    String(String),
    Bool(bool),
}

impl<'de> de::Deserialize<'de> for StringOrBool {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: de::Deserializer<'de>
    {
        struct Visitor;

        impl<'de> de::Visitor<'de> for Visitor {
            type Value = StringOrBool;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a boolean or a string")
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(StringOrBool::String(s.to_string()))
            }

            fn visit_bool<E>(self, b: bool) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(StringOrBool::Bool(b))
            }
        }

        deserializer.deserialize_any(Visitor)
    }
}

#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum VecStringOrBool {
    VecString(Vec<String>),
    Bool(bool),
}

impl<'de> de::Deserialize<'de> for VecStringOrBool {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: de::Deserializer<'de>
    {
        struct Visitor;

        impl<'de> de::Visitor<'de> for Visitor {
            type Value = VecStringOrBool;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a boolean or vector of strings")
            }

            fn visit_seq<V>(self, v: V) -> Result<Self::Value, V::Error>
                where V: de::SeqAccess<'de>
            {
                let seq = de::value::SeqAccessDeserializer::new(v);
                Vec::deserialize(seq).map(VecStringOrBool::VecString)
            }

            fn visit_bool<E>(self, b: bool) -> Result<Self::Value, E>
                where E: de::Error,
            {
                Ok(VecStringOrBool::Bool(b))
            }
        }

        deserializer.deserialize_any(Visitor)
    }
}

#[derive(Deserialize, Serialize, Clone, Debug)]
pub struct TomlProject {
    name: String,
    version: semver::Version,
    authors: Option<Vec<String>>,
    build: Option<StringOrBool>,
    links: Option<String>,
    exclude: Option<Vec<String>>,
    include: Option<Vec<String>>,
    publish: Option<VecStringOrBool>,
    workspace: Option<String>,
    #[serde(rename = "im-a-teapot")]
    im_a_teapot: Option<bool>,

    // package metadata
    description: Option<String>,
    homepage: Option<String>,
    documentation: Option<String>,
    readme: Option<String>,
    keywords: Option<Vec<String>>,
    categories: Option<Vec<String>>,
    license: Option<String>,
    #[serde(rename = "license-file")]
    license_file: Option<String>,
    repository: Option<String>,
    metadata: Option<toml::Value>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct TomlWorkspace {
    members: Option<Vec<String>>,
    exclude: Option<Vec<String>>,
}

impl TomlProject {
    pub fn to_package_id(&self, source_id: &SourceId) -> CargoResult<PackageId> {
        PackageId::new(&self.name, self.version.clone(), source_id)
    }
}

struct Context<'a, 'b> {
    pkgid: Option<&'a PackageId>,
    deps: &'a mut Vec<Dependency>,
    source_id: &'a SourceId,
    nested_paths: &'a mut Vec<PathBuf>,
    config: &'b Config,
    warnings: &'a mut Vec<String>,
    platform: Option<Platform>,
    root: &'a Path,
    features: &'a Features,
}

impl TomlManifest {
    pub fn prepare_for_publish(&self) -> TomlManifest {
        let mut package = self.package.as_ref()
                              .or_else(|| self.project.as_ref())
                              .unwrap()
                              .clone();
        package.workspace = None;
        return TomlManifest {
            package: Some(package),
            project: None,
            profile: self.profile.clone(),
            lib: self.lib.clone(),
            bin: self.bin.clone(),
            example: self.example.clone(),
            test: self.test.clone(),
            bench: self.bench.clone(),
            dependencies: map_deps(self.dependencies.as_ref()),
            dev_dependencies: map_deps(self.dev_dependencies.as_ref()
                                         .or_else(|| self.dev_dependencies2.as_ref())),
            dev_dependencies2: None,
            build_dependencies: map_deps(self.build_dependencies.as_ref()
                                         .or_else(|| self.build_dependencies2.as_ref())),
            build_dependencies2: None,
            features: self.features.clone(),
            target: self.target.as_ref().map(|target_map| {
                target_map.iter().map(|(k, v)| {
                    (k.clone(), TomlPlatform {
                        dependencies: map_deps(v.dependencies.as_ref()),
                        dev_dependencies: map_deps(v.dev_dependencies.as_ref()
                                                     .or_else(|| v.dev_dependencies2.as_ref())),
                        dev_dependencies2: None,
                        build_dependencies: map_deps(v.build_dependencies.as_ref()
                                                     .or_else(|| v.build_dependencies2.as_ref())),
                        build_dependencies2: None,
                    })
                }).collect()
            }),
            replace: None,
            patch: None,
            workspace: None,
            badges: self.badges.clone(),
            cargo_features: self.cargo_features.clone(),
        };

        fn map_deps(deps: Option<&BTreeMap<String, TomlDependency>>)
                        -> Option<BTreeMap<String, TomlDependency>>
        {
            let deps = match deps {
                Some(deps) => deps,
                None => return None
            };
            Some(deps.iter().map(|(k, v)| (k.clone(), map_dependency(v))).collect())
        }

        fn map_dependency(dep: &TomlDependency) -> TomlDependency {
            match *dep {
                TomlDependency::Detailed(ref d) => {
                    let mut d = d.clone();
                    d.path.take(); // path dependencies become crates.io deps
                    TomlDependency::Detailed(d)
                }
                TomlDependency::Simple(ref s) => {
                    TomlDependency::Detailed(DetailedTomlDependency {
                        version: Some(s.clone()),
                        ..Default::default()
                    })
                }
            }
        }
    }

    fn to_real_manifest(me: &Rc<TomlManifest>,
                        source_id: &SourceId,
                        package_root: &Path,
                        config: &Config)
                        -> CargoResult<(Manifest, Vec<PathBuf>)> {
        let mut nested_paths = vec![];
        let mut warnings = vec![];
        let mut errors = vec![];

        // Parse features first so they will be available when parsing other parts of the toml
        let empty = Vec::new();
        let cargo_features = me.cargo_features.as_ref().unwrap_or(&empty);
        let features = Features::new(&cargo_features, &mut warnings)?;

        let project = me.project.as_ref().or_else(|| me.package.as_ref());
        let project = project.ok_or_else(|| {
            CargoError::from("no `package` section found.")
        })?;

        let package_name = project.name.trim();
        if package_name.is_empty() {
            bail!("package name cannot be an empty string.")
        }

        let pkgid = project.to_package_id(source_id)?;

        // If we have no lib at all, use the inferred lib if available
        // If we have a lib with a path, we're done
        // If we have a lib with no path, use the inferred lib or_else package name
        let targets = targets(me, package_name, package_root, &project.build,
                              &mut warnings, &mut errors)?;

        if targets.is_empty() {
            debug!("manifest has no build targets");
        }

        if let Err(e) = unique_build_targets(&targets, package_root) {
            warnings.push(format!("file found to be present in multiple \
                                   build targets: {}", e));
        }

        let mut deps = Vec::new();
        let replace;
        let patch;

        {

            let mut cx = Context {
                pkgid: Some(&pkgid),
                deps: &mut deps,
                source_id: source_id,
                nested_paths: &mut nested_paths,
                config: config,
                warnings: &mut warnings,
                features: &features,
                platform: None,
                root: package_root,
            };

            fn process_dependencies(
                cx: &mut Context,
                new_deps: Option<&BTreeMap<String, TomlDependency>>,
                kind: Option<Kind>)
                -> CargoResult<()>
            {
                let dependencies = match new_deps {
                    Some(dependencies) => dependencies,
                    None => return Ok(())
                };
                for (n, v) in dependencies.iter() {
                    let dep = v.to_dependency(n, cx, kind)?;
                    cx.deps.push(dep);
                }

                Ok(())
            }

            // Collect the deps
            process_dependencies(&mut cx, me.dependencies.as_ref(),
                                 None)?;
            let dev_deps = me.dev_dependencies.as_ref()
                               .or_else(|| me.dev_dependencies2.as_ref());
            process_dependencies(&mut cx, dev_deps, Some(Kind::Development))?;
            let build_deps = me.build_dependencies.as_ref()
                               .or_else(|| me.build_dependencies2.as_ref());
            process_dependencies(&mut cx, build_deps, Some(Kind::Build))?;

            for (name, platform) in me.target.iter().flat_map(|t| t) {
                cx.platform = Some(name.parse()?);
                process_dependencies(&mut cx, platform.dependencies.as_ref(),
                                     None)?;
                let build_deps = platform.build_dependencies.as_ref()
                                         .or_else(|| platform.build_dependencies2.as_ref());
                process_dependencies(&mut cx, build_deps, Some(Kind::Build))?;
                let dev_deps = platform.dev_dependencies.as_ref()
                                         .or_else(|| platform.dev_dependencies2.as_ref());
                process_dependencies(&mut cx, dev_deps, Some(Kind::Development))?;
            }

            replace = me.replace(&mut cx)?;
            patch = me.patch(&mut cx)?;
        }

        {
            let mut names_sources = BTreeMap::new();
            for dep in &deps {
                let name = dep.name();
                let prev = names_sources.insert(name, dep.source_id());
                if prev.is_some() && prev != Some(dep.source_id()) {
                    bail!("Dependency '{}' has different source paths depending on the build \
                           target. Each dependency must have a single canonical source path \
                           irrespective of build target.", name);
                }
            }
        }

        let exclude = project.exclude.clone().unwrap_or_default();
        let include = project.include.clone().unwrap_or_default();

        let summary = Summary::new(pkgid, deps, me.features.clone()
            .unwrap_or_else(BTreeMap::new))?;
        let metadata = ManifestMetadata {
            description: project.description.clone(),
            homepage: project.homepage.clone(),
            documentation: project.documentation.clone(),
            readme: project.readme.clone(),
            authors: project.authors.clone().unwrap_or_default(),
            license: project.license.clone(),
            license_file: project.license_file.clone(),
            repository: project.repository.clone(),
            keywords: project.keywords.clone().unwrap_or_default(),
            categories: project.categories.clone().unwrap_or_default(),
            badges: me.badges.clone().unwrap_or_default(),
        };

        let workspace_config = match (me.workspace.as_ref(),
                                      project.workspace.as_ref()) {
            (Some(config), None) => {
                WorkspaceConfig::Root(
                    WorkspaceRootConfig::new(&package_root, &config.members, &config.exclude)
                )
            }
            (None, root) => {
                WorkspaceConfig::Member { root: root.cloned() }
            }
            (Some(..), Some(..)) => {
                bail!("cannot configure both `package.workspace` and \
                       `[workspace]`, only one can be specified")
            }
        };
        let profiles = build_profiles(&me.profile);
        let publish = match project.publish {
            Some(VecStringOrBool::VecString(ref vecstring)) => {
                features.require(Feature::alternative_registries()).chain_err(|| {
                    "the `publish` manifest key is unstable for anything other than a value of true or false"
                })?;
                Some(vecstring.clone())
            },
            Some(VecStringOrBool::Bool(false)) => Some(vec![]),
            None | Some(VecStringOrBool::Bool(true)) => None,
        };
        let mut manifest = Manifest::new(summary,
                                         targets,
                                         exclude,
                                         include,
                                         project.links.clone(),
                                         metadata,
                                         profiles,
                                         publish,
                                         replace,
                                         patch,
                                         workspace_config,
                                         features,
                                         project.im_a_teapot,
                                         Rc::clone(me));
        if project.license_file.is_some() && project.license.is_some() {
            manifest.add_warning("only one of `license` or \
                                 `license-file` is necessary".to_string());
        }
        for warning in warnings {
            manifest.add_warning(warning);
        }
        for error in errors {
            manifest.add_critical_warning(error);
        }

        manifest.feature_gate()?;

        Ok((manifest, nested_paths))
    }

    fn to_virtual_manifest(me: &Rc<TomlManifest>,
                           source_id: &SourceId,
                           root: &Path,
                           config: &Config)
                           -> CargoResult<(VirtualManifest, Vec<PathBuf>)> {
        if me.project.is_some() {
            bail!("virtual manifests do not define [project]");
        }
        if me.package.is_some() {
            bail!("virtual manifests do not define [package]");
        }
        if me.lib.is_some() {
            bail!("virtual manifests do not specify [lib]");
        }
        if me.bin.is_some() {
            bail!("virtual manifests do not specify [[bin]]");
        }
        if me.example.is_some() {
            bail!("virtual manifests do not specify [[example]]");
        }
        if me.test.is_some() {
            bail!("virtual manifests do not specify [[test]]");
        }
        if me.bench.is_some() {
            bail!("virtual manifests do not specify [[bench]]");
        }

        let mut nested_paths = Vec::new();
        let mut warnings = Vec::new();
        let mut deps = Vec::new();
        let empty = Vec::new();
        let cargo_features = me.cargo_features.as_ref().unwrap_or(&empty);
        let features = Features::new(&cargo_features, &mut warnings)?;

        let (replace, patch) = {
            let mut cx = Context {
                pkgid: None,
                deps: &mut deps,
                source_id: source_id,
                nested_paths: &mut nested_paths,
                config: config,
                warnings: &mut warnings,
                platform: None,
                features: &features,
                root: root
            };
            (me.replace(&mut cx)?, me.patch(&mut cx)?)
        };
        let profiles = build_profiles(&me.profile);
        let workspace_config = match me.workspace {
            Some(ref config) => {
                WorkspaceConfig::Root(
                    WorkspaceRootConfig::new(&root, &config.members, &config.exclude)
                )
            }
            None => {
                bail!("virtual manifests must be configured with [workspace]");
            }
        };
        Ok((VirtualManifest::new(replace, patch, workspace_config, profiles), nested_paths))
    }

    fn replace(&self, cx: &mut Context)
               -> CargoResult<Vec<(PackageIdSpec, Dependency)>> {
        if self.patch.is_some() && self.replace.is_some() {
            bail!("cannot specify both [replace] and [patch]");
        }
        let mut replace = Vec::new();
        for (spec, replacement) in self.replace.iter().flat_map(|x| x) {
            let mut spec = PackageIdSpec::parse(spec).chain_err(|| {
                format!("replacements must specify a valid semver \
                         version to replace, but `{}` does not",
                        spec)
            })?;
            if spec.url().is_none() {
                spec.set_url(CRATES_IO.parse().unwrap());
            }

            let version_specified = match *replacement {
                TomlDependency::Detailed(ref d) => d.version.is_some(),
                TomlDependency::Simple(..) => true,
            };
            if version_specified {
                bail!("replacements cannot specify a version \
                       requirement, but found one for `{}`", spec);
            }

            let mut dep = replacement.to_dependency(spec.name(), cx, None)?;
            {
                let version = spec.version().ok_or_else(|| {
                    CargoError::from(format!("replacements must specify a version \
                             to replace, but `{}` does not",
                            spec))
                })?;
                dep.set_version_req(VersionReq::exact(version));
            }
            replace.push((spec, dep));
        }
        Ok(replace)
    }

    fn patch(&self, cx: &mut Context)
             -> CargoResult<HashMap<Url, Vec<Dependency>>> {
        let mut patch = HashMap::new();
        for (url, deps) in self.patch.iter().flat_map(|x| x) {
            let url = match &url[..] {
                "crates-io" => CRATES_IO.parse().unwrap(),
                _ => url.to_url()?,
            };
            patch.insert(url, deps.iter().map(|(name, dep)| {
                dep.to_dependency(name, cx, None)
            }).collect::<CargoResult<Vec<_>>>()?);
        }
        Ok(patch)
    }

    fn maybe_custom_build(&self,
                          build: &Option<StringOrBool>,
                          package_root: &Path)
                          -> Option<PathBuf> {
        let build_rs = package_root.join("build.rs");
        match *build {
            Some(StringOrBool::Bool(false)) => None,        // explicitly no build script
            Some(StringOrBool::Bool(true)) => Some(build_rs.into()),
            Some(StringOrBool::String(ref s)) => Some(PathBuf::from(s)),
            None => {
                match fs::metadata(&build_rs) {
                    // If there is a build.rs file next to the Cargo.toml, assume it is
                    // a build script
                    Ok(ref e) if e.is_file() => Some(build_rs.into()),
                    Ok(_) | Err(_) => None,
                }
            }
        }
    }
}

/// Will check a list of build targets, and make sure the target names are unique within a vector.
/// If not, the name of the offending build target is returned.
fn unique_build_targets(targets: &[Target], package_root: &Path) -> Result<(), String> {
    let mut seen = HashSet::new();
    for v in targets.iter().map(|e| package_root.join(e.src_path())) {
        if !seen.insert(v.clone()) {
            return Err(v.display().to_string());
        }
    }
    Ok(())
}

impl TomlDependency {
    fn to_dependency(&self,
                     name: &str,
                     cx: &mut Context,
                     kind: Option<Kind>)
                     -> CargoResult<Dependency> {
        let details = match *self {
            TomlDependency::Simple(ref version) => DetailedTomlDependency {
                version: Some(version.clone()),
                .. Default::default()
            },
            TomlDependency::Detailed(ref details) => details.clone(),
        };

        if details.version.is_none() && details.path.is_none() &&
           details.git.is_none() {
            let msg = format!("dependency ({}) specified without \
                               providing a local path, Git repository, or \
                               version to use. This will be considered an \
                               error in future versions", name);
            cx.warnings.push(msg);
        }

        if details.git.is_none() {
            let git_only_keys = [
                (&details.branch, "branch"),
                (&details.tag, "tag"),
                (&details.rev, "rev")
            ];

            for &(key, key_name) in &git_only_keys {
                if key.is_some() {
                    let msg = format!("key `{}` is ignored for dependency ({}). \
                                       This will be considered an error in future versions",
                                      key_name, name);
                    cx.warnings.push(msg)
                }
            }
        }

        let new_source_id = match (details.git.as_ref(), details.path.as_ref(), details.registry.as_ref()) {
            (Some(_), _, Some(_)) => bail!("dependency ({}) specification is ambiguous. \
                                            Only one of `git` or `registry` is allowed.", name),
            (_, Some(_), Some(_)) => bail!("dependency ({}) specification is ambiguous. \
                                            Only one of `path` or `registry` is allowed.", name),
            (Some(git), maybe_path, _) => {
                if maybe_path.is_some() {
                    let msg = format!("dependency ({}) specification is ambiguous. \
                                       Only one of `git` or `path` is allowed. \
                                       This will be considered an error in future versions", name);
                    cx.warnings.push(msg)
                }

                let n_details = [&details.branch, &details.tag, &details.rev]
                    .iter()
                    .filter(|d| d.is_some())
                    .count();

                if n_details > 1 {
                    let msg = format!("dependency ({}) specification is ambiguous. \
                                       Only one of `branch`, `tag` or `rev` is allowed. \
                                       This will be considered an error in future versions", name);
                    cx.warnings.push(msg)
                }

                let reference = details.branch.clone().map(GitReference::Branch)
                    .or_else(|| details.tag.clone().map(GitReference::Tag))
                    .or_else(|| details.rev.clone().map(GitReference::Rev))
                    .unwrap_or_else(|| GitReference::Branch("master".to_string()));
                let loc = git.to_url()?;
                SourceId::for_git(&loc, reference)?
            },
            (None, Some(path), _) => {
                cx.nested_paths.push(PathBuf::from(path));
                // If the source id for the package we're parsing is a path
                // source, then we normalize the path here to get rid of
                // components like `..`.
                //
                // The purpose of this is to get a canonical id for the package
                // that we're depending on to ensure that builds of this package
                // always end up hashing to the same value no matter where it's
                // built from.
                if cx.source_id.is_path() {
                    let path = cx.root.join(path);
                    let path = util::normalize_path(&path);
                    SourceId::for_path(&path)?
                } else {
                    cx.source_id.clone()
                }
            },
            (None, None, Some(registry)) => {
                cx.features.require(Feature::alternative_registries())?;
                SourceId::alt_registry(cx.config, registry)?
            }
            (None, None, None) => SourceId::crates_io(cx.config)?,
        };

        let version = details.version.as_ref().map(|v| &v[..]);
        let mut dep = match cx.pkgid {
            Some(id) => {
                Dependency::parse(name, version, &new_source_id,
                                  id, cx.config)?
            }
            None => Dependency::parse_no_deprecated(name, version, &new_source_id)?,
        };
        dep.set_features(details.features.unwrap_or_default())
           .set_default_features(details.default_features
                                        .or(details.default_features2)
                                        .unwrap_or(true))
           .set_optional(details.optional.unwrap_or(false))
           .set_platform(cx.platform.clone());
        if let Some(kind) = kind {
            dep.set_kind(kind);
        }
        Ok(dep)
    }
}

#[derive(Default, Serialize, Deserialize, Debug, Clone)]
struct TomlTarget {
    name: Option<String>,

    // The intention was to only accept `crate-type` here but historical
    // versions of Cargo also accepted `crate_type`, so look for both.
    #[serde(rename = "crate-type")]
    crate_type: Option<Vec<String>>,
    #[serde(rename = "crate_type")]
    crate_type2: Option<Vec<String>>,

    path: Option<PathValue>,
    test: Option<bool>,
    doctest: Option<bool>,
    bench: Option<bool>,
    doc: Option<bool>,
    plugin: Option<bool>,
    #[serde(rename = "proc-macro")]
    proc_macro: Option<bool>,
    #[serde(rename = "proc_macro")]
    proc_macro2: Option<bool>,
    harness: Option<bool>,
    #[serde(rename = "required-features")]
    required_features: Option<Vec<String>>,
}

#[derive(Clone)]
struct PathValue(PathBuf);

impl<'de> de::Deserialize<'de> for PathValue {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: de::Deserializer<'de>
    {
        Ok(PathValue(String::deserialize(deserializer)?.into()))
    }
}

impl ser::Serialize for PathValue {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: ser::Serializer,
    {
        self.0.serialize(serializer)
    }
}

/// Corresponds to a `target` entry, but `TomlTarget` is already used.
#[derive(Serialize, Deserialize, Debug)]
struct TomlPlatform {
    dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "build-dependencies")]
    build_dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "build_dependencies")]
    build_dependencies2: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "dev-dependencies")]
    dev_dependencies: Option<BTreeMap<String, TomlDependency>>,
    #[serde(rename = "dev_dependencies")]
    dev_dependencies2: Option<BTreeMap<String, TomlDependency>>,
}

impl TomlTarget {
    fn new() -> TomlTarget {
        TomlTarget::default()
    }

    fn name(&self) -> String {
        match self.name {
            Some(ref name) => name.clone(),
            None => panic!("target name is required")
        }
    }

    fn proc_macro(&self) -> Option<bool> {
        self.proc_macro.or(self.proc_macro2)
    }

    fn crate_types(&self) -> Option<&Vec<String>> {
        self.crate_type.as_ref().or_else(|| self.crate_type2.as_ref())
    }
}

impl fmt::Debug for PathValue {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

fn build_profiles(profiles: &Option<TomlProfiles>) -> Profiles {
    let profiles = profiles.as_ref();
    let mut profiles = Profiles {
        release: merge(Profile::default_release(),
                       profiles.and_then(|p| p.release.as_ref())),
        dev: merge(Profile::default_dev(),
                   profiles.and_then(|p| p.dev.as_ref())),
        test: merge(Profile::default_test(),
                    profiles.and_then(|p| p.test.as_ref())),
        test_deps: merge(Profile::default_dev(),
                         profiles.and_then(|p| p.dev.as_ref())),
        bench: merge(Profile::default_bench(),
                     profiles.and_then(|p| p.bench.as_ref())),
        bench_deps: merge(Profile::default_release(),
                          profiles.and_then(|p| p.release.as_ref())),
        doc: merge(Profile::default_doc(),
                   profiles.and_then(|p| p.doc.as_ref())),
        custom_build: Profile::default_custom_build(),
        check: merge(Profile::default_check(),
                     profiles.and_then(|p| p.dev.as_ref())),
        check_test: merge(Profile::default_check_test(),
                          profiles.and_then(|p| p.dev.as_ref())),
        doctest: Profile::default_doctest(),
    };
    // The test/bench targets cannot have panic=abort because they'll all get
    // compiled with --test which requires the unwind runtime currently
    profiles.test.panic = None;
    profiles.bench.panic = None;
    profiles.test_deps.panic = None;
    profiles.bench_deps.panic = None;
    return profiles;

    fn merge(profile: Profile, toml: Option<&TomlProfile>) -> Profile {
        let &TomlProfile {
            ref opt_level, lto, codegen_units, ref debug, debug_assertions, rpath,
            ref panic, ref overflow_checks,
        } = match toml {
            Some(toml) => toml,
            None => return profile,
        };
        let debug = match *debug {
            Some(U32OrBool::U32(debug)) => Some(Some(debug)),
            Some(U32OrBool::Bool(true)) => Some(Some(2)),
            Some(U32OrBool::Bool(false)) => Some(None),
            None => None,
        };
        Profile {
            opt_level: opt_level.clone().unwrap_or(TomlOptLevel(profile.opt_level)).0,
            lto: lto.unwrap_or(profile.lto),
            codegen_units: codegen_units,
            rustc_args: None,
            rustdoc_args: None,
            debuginfo: debug.unwrap_or(profile.debuginfo),
            debug_assertions: debug_assertions.unwrap_or(profile.debug_assertions),
            overflow_checks: overflow_checks.unwrap_or(profile.overflow_checks),
            rpath: rpath.unwrap_or(profile.rpath),
            test: profile.test,
            doc: profile.doc,
            run_custom_build: profile.run_custom_build,
            check: profile.check,
            panic: panic.clone().or(profile.panic),
        }
    }
}


text:
namespace GrantApp {
	partial class ExpandedTextDialog {
		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.IContainer components = null;

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
		protected override void Dispose(bool disposing) {
			if (disposing && (components != null)) {
				components.Dispose();
			}
			base.Dispose(disposing);
		}

		#region Windows Form Designer generated code

		/// <summary>
		/// Required method for Designer support - do not modify
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent() {
			this.textBox1 = new System.Windows.Forms.TextBox();
			this.btnOkay = new System.Windows.Forms.Button();
			this.btnCancel = new System.Windows.Forms.Button();
			this.SuspendLayout();
			//
			// textBox1
			//
			this.textBox1.AcceptsReturn = true;
			this.textBox1.AcceptsTab = true;
			this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
            | System.Windows.Forms.AnchorStyles.Left)
            | System.Windows.Forms.AnchorStyles.Right)));
			this.textBox1.Font = new System.Drawing.Font("Times New Roman", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
			this.textBox1.Location = new System.Drawing.Point(12, 12);
			this.textBox1.Multiline = true;
			this.textBox1.Name = "textBox1";
			this.textBox1.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
			this.textBox1.Size = new System.Drawing.Size(460, 308);
			this.textBox1.TabIndex = 0;
			//
			// btnOkay
			//
			this.btnOkay.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
			this.btnOkay.DialogResult = System.Windows.Forms.DialogResult.OK;
			this.btnOkay.Location = new System.Drawing.Point(316, 326);
			this.btnOkay.Name = "btnOkay";
			this.btnOkay.Size = new System.Drawing.Size(75, 23);
			this.btnOkay.TabIndex = 1;
			this.btnOkay.Text = "OK";
			this.btnOkay.UseVisualStyleBackColor = true;
			//
			// btnCancel
			//
			this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
			this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
			this.btnCancel.Location = new System.Drawing.Point(397, 326);
			this.btnCancel.Name = "btnCancel";
			this.btnCancel.Size = new System.Drawing.Size(75, 23);
			this.btnCancel.TabIndex = 2;
			this.btnCancel.Text = "Cancel";
			this.btnCancel.UseVisualStyleBackColor = true;
			//
			// ExpandedTextDialog
			//
			this.AcceptButton = this.btnOkay;
			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
			this.CancelButton = this.btnCancel;
			this.ClientSize = new System.Drawing.Size(484, 361);
			this.Controls.Add(this.btnCancel);
			this.Controls.Add(this.btnOkay);
			this.Controls.Add(this.textBox1);
			this.Name = "ExpandedTextDialog";
			this.Text = "Edit Text";
			this.ResumeLayout(false);
			this.PerformLayout();

		}

		#endregion

		private System.Windows.Forms.TextBox textBox1;
		private System.Windows.Forms.Button btnOkay;
		private System.Windows.Forms.Button btnCancel;
	}
}