text:
/* This is a generated file, edit the .stub.php file instead.
 * Stub hash: 7d23f208609b509bb75f8286fc5c93c127c406d6 */

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Topic_getName, 0, 0, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic___construct, 0, 0, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consumeQueueStart, 0, 0, 3)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, offset)
	ZEND_ARG_INFO(0, queue)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consumeCallback, 0, 0, 3)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, timeout_ms)
	ZEND_ARG_INFO(0, callback)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consumeStart, 0, 0, 2)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consumeStop, 0, 0, 1)
	ZEND_ARG_INFO(0, partition)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consume, 0, 0, 2)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, timeout_ms)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ConsumerTopic_consumeBatch, 0, 0, 3)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, timeout_ms)
	ZEND_ARG_INFO(0, batch_size)
ZEND_END_ARG_INFO()

#define arginfo_class_RdKafka_ConsumerTopic_offsetStore arginfo_class_RdKafka_ConsumerTopic_consumeStart

#define arginfo_class_RdKafka_KafkaConsumerTopic___construct arginfo_class_RdKafka_ConsumerTopic___construct

#define arginfo_class_RdKafka_KafkaConsumerTopic_offsetStore arginfo_class_RdKafka_ConsumerTopic_consumeStart

#define arginfo_class_RdKafka_ProducerTopic___construct arginfo_class_RdKafka_ConsumerTopic___construct

ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ProducerTopic_produce, 0, 0, 2)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, msgflags)
	ZEND_ARG_INFO(0, payload)
	ZEND_ARG_INFO(0, key)
	ZEND_ARG_INFO(0, msg_opaque)
ZEND_END_ARG_INFO()

#if defined(HAVE_RD_KAFKA_MESSAGE_HEADERS)
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_ProducerTopic_producev, 0, 0, 2)
	ZEND_ARG_INFO(0, partition)
	ZEND_ARG_INFO(0, msgflags)
	ZEND_ARG_INFO(0, payload)
	ZEND_ARG_INFO(0, key)
	ZEND_ARG_INFO(0, headers)
	ZEND_ARG_INFO(0, timestamp_ms)
	ZEND_ARG_INFO(0, msg_opaque)
ZEND_END_ARG_INFO()
#endif

ZEND_METHOD(RdKafka_Topic, getName);
ZEND_METHOD(RdKafka, __construct);
ZEND_METHOD(RdKafka_ConsumerTopic, consumeQueueStart);
ZEND_METHOD(RdKafka_ConsumerTopic, consumeCallback);
ZEND_METHOD(RdKafka_ConsumerTopic, consumeStart);
ZEND_METHOD(RdKafka_ConsumerTopic, consumeStop);
ZEND_METHOD(RdKafka_ConsumerTopic, consume);
ZEND_METHOD(RdKafka_ConsumerTopic, consumeBatch);
ZEND_METHOD(RdKafka_ConsumerTopic, offsetStore);
ZEND_METHOD(RdKafka_ProducerTopic, produce);
#if defined(HAVE_RD_KAFKA_MESSAGE_HEADERS)
ZEND_METHOD(RdKafka_ProducerTopic, producev);
#endif

static const zend_function_entry class_RdKafka_Topic_methods[] = {
	ZEND_ME(RdKafka_Topic, getName, arginfo_class_RdKafka_Topic_getName, ZEND_ACC_PUBLIC)
	ZEND_FE_END
};

static const zend_function_entry class_RdKafka_ConsumerTopic_methods[] = {
	ZEND_MALIAS(RdKafka, __construct, __construct, arginfo_class_RdKafka_ConsumerTopic___construct, ZEND_ACC_PRIVATE)
	ZEND_ME(RdKafka_ConsumerTopic, consumeQueueStart, arginfo_class_RdKafka_ConsumerTopic_consumeQueueStart, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, consumeCallback, arginfo_class_RdKafka_ConsumerTopic_consumeCallback, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, consumeStart, arginfo_class_RdKafka_ConsumerTopic_consumeStart, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, consumeStop, arginfo_class_RdKafka_ConsumerTopic_consumeStop, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, consume, arginfo_class_RdKafka_ConsumerTopic_consume, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, consumeBatch, arginfo_class_RdKafka_ConsumerTopic_consumeBatch, ZEND_ACC_PUBLIC)
	ZEND_ME(RdKafka_ConsumerTopic, offsetStore, arginfo_class_RdKafka_ConsumerTopic_offsetStore, ZEND_ACC_PUBLIC)
	ZEND_FE_END
};

static const zend_function_entry class_RdKafka_KafkaConsumerTopic_methods[] = {
	ZEND_MALIAS(RdKafka, __construct, __construct, arginfo_class_RdKafka_KafkaConsumerTopic___construct, ZEND_ACC_PRIVATE)
	ZEND_MALIAS(RdKafka_ConsumerTopic, offsetStore, offsetStore, arginfo_class_RdKafka_KafkaConsumerTopic_offsetStore, ZEND_ACC_PUBLIC)
	ZEND_FE_END
};

static const zend_function_entry class_RdKafka_ProducerTopic_methods[] = {
	ZEND_MALIAS(RdKafka, __construct, __construct, arginfo_class_RdKafka_ProducerTopic___construct, ZEND_ACC_PRIVATE)
	ZEND_ME(RdKafka_ProducerTopic, produce, arginfo_class_RdKafka_ProducerTopic_produce, ZEND_ACC_PUBLIC)
#if defined(HAVE_RD_KAFKA_MESSAGE_HEADERS)
	ZEND_ME(RdKafka_ProducerTopic, producev, arginfo_class_RdKafka_ProducerTopic_producev, ZEND_ACC_PUBLIC)
#endif
	ZEND_FE_END
};

static zend_class_entry *register_class_RdKafka_Topic(void)
{
	zend_class_entry ce, *class_entry;

	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Topic", class_RdKafka_Topic_methods);
	class_entry = zend_register_internal_class_ex(&ce, NULL);
	class_entry->ce_flags |= ZEND_ACC_ABSTRACT;

	return class_entry;
}

static zend_class_entry *register_class_RdKafka_ConsumerTopic(zend_class_entry *class_entry_RdKafka_Topic)
{
	zend_class_entry ce, *class_entry;

	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ConsumerTopic", class_RdKafka_ConsumerTopic_methods);
	class_entry = zend_register_internal_class_ex(&ce, class_entry_RdKafka_Topic);

	return class_entry;
}

static zend_class_entry *register_class_RdKafka_KafkaConsumerTopic(zend_class_entry *class_entry_RdKafka_Topic)
{
	zend_class_entry ce, *class_entry;

	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaConsumerTopic", class_RdKafka_KafkaConsumerTopic_methods);
	class_entry = zend_register_internal_class_ex(&ce, class_entry_RdKafka_Topic);

	return class_entry;
}

static zend_class_entry *register_class_RdKafka_ProducerTopic(zend_class_entry *class_entry_RdKafka_Topic)
{
	zend_class_entry ce, *class_entry;

	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "ProducerTopic", class_RdKafka_ProducerTopic_methods);
	class_entry = zend_register_internal_class_ex(&ce, class_entry_RdKafka_Topic);

	return class_entry;
}


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

<title>dollar.http (dollar-http-plugin 0.4.5195 API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="date" content="2017-09-28">
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../jquery/jquery-ui.css" title="Style">

dollar.http

Interfaces

NanoHttpdServer.AsyncRunner

NanoHttpdServer.IHTTPSession

NanoHttpdServer.Response.IStatus

NanoHttpdServer.TempFile

NanoHttpdServer.TempFileManager

NanoHttpdServer.TempFileManagerFactory

Classes

HttpURIHandler

HttpURIHandler.RouteableNanoHttpd

HttpURIHandlerFactory

NanoHttpdServer

NanoHttpdServer.Cookie

NanoHttpdServer.DefaultAsyncRunner

NanoHttpdServer.DefaultTempFile

NanoHttpdServer.DefaultTempFileManager

NanoHttpdServer.Response

Enums

NanoHttpdServer.Method

NanoHttpdServer.Response.Status

Exceptions

NanoHttpdServer.ResponseException

redpajama_set_name: RedPajamaGithub


text:
#include "config.h"
#include "PlatformUtilities.h"
#include "PlatformWebView.h"
#include "Test.h"

namespace TestWebKitAPI {

// State for part 1 - setting up the connection.
static bool connectionEstablished;
static WKConnectionRef connectionToBundle;

// State for part 2 - send/recieving messages.
static bool messageReceived;

// State for part 3 - tearing down the connection.
static bool connectionTornDown;

/* WKContextConnectionClient */
static void didCreateConnection(WKContextRef context, WKConnectionRef connection, const void* clientInfo)
{
    connectionEstablished = true;

    // Store off the conneciton to use.
    connectionToBundle = (WKConnectionRef)WKRetain(connection);
}

/* WKConnectionClient */
static void connectionDidReceiveMessage(WKConnectionRef connection, WKStringRef messageName, WKTypeRef messageBody, const void *clientInfo)
{
    // We only expect to get the "Pong" message.
    EXPECT_WK_STREQ(messageName, "PongMessageName");
    EXPECT_WK_STREQ((WKStringRef)messageBody, "PongMessageBody");

    messageReceived = true;
}

static void connectionDidClose(WKConnectionRef connection, const void* clientInfo)
{
    connectionTornDown = true;
}

TEST(WebKit2, WKConnectionTest)
{
    WKRetainPtr<WKContextRef> context(AdoptWK, Util::createContextForInjectedBundleTest("WKConnectionTest"));

    // Set up the context's connection client so that we can access the connection when
    // it is created.
    WKContextConnectionClient contextConnectionClient;
    memset(&contextConnectionClient, 0, sizeof(contextConnectionClient));
    contextConnectionClient.version = kWKContextConnectionClientCurrentVersion;
    contextConnectionClient.clientInfo = 0;
    contextConnectionClient.didCreateConnection = didCreateConnection;
    WKContextSetConnectionClient(context.get(), &contextConnectionClient);

    // Load a simple page to start the WebProcess and establish a connection.
    PlatformWebView webView(context.get());
    WKRetainPtr<WKURLRef> url(AdoptWK, Util::createURLForResource("simple", "html"));
    WKPageLoadURL(webView.page(), url.get());

    // Wait until the connection is established.
    Util::run(&connectionEstablished);
    ASSERT_NOT_NULL(connectionToBundle);

    // Setup a client on the connection so we can listen for messages and
    // tear down notifications.
    WKConnectionClient connectionClient;
    memset(&connectionClient, 0, sizeof(connectionClient));
    connectionClient.version = WKConnectionClientCurrentVersion;
    connectionClient.clientInfo = 0;
    connectionClient.didReceiveMessage = connectionDidReceiveMessage;
    connectionClient.didClose = connectionDidClose;
    WKConnectionSetConnectionClient(connectionToBundle, &connectionClient);

    // Post a simple message to the bundle via the connection.
    WKConnectionPostMessage(connectionToBundle, Util::toWK("PingMessageName").get(), Util::toWK("PingMessageBody").get());

    // Wait for the reply.
    Util::run(&messageReceived);

    // Terminate the page to force the connection closed.
    WKPageTerminate(webView.page());

    // Wait for the connection to close.
    Util::run(&connectionTornDown);

    // This release is to balance the retain in didCreateConnection.
    WKRelease(connectionToBundle);
}

} // namespace TestWebKitAPI


text:
/**
 * \file
 *
 * This file contains memory allocation functions.
 */

#include "config.h"
#include "util/alloc.h"
#include "util/regional.h"
#include "util/data/packed_rrset.h"
#include "util/fptr_wlist.h"

/** custom size of cached regional blocks */
#define ALLOC_REG_SIZE	16384
/** number of bits for ID part of uint64, rest for number of threads. */
#define THRNUM_SHIFT	48	/* for 65k threads, 2^48 rrsets per thr. */

/** setup new special type */
static void
alloc_setup_special(alloc_special_type* t)
{
	memset(t, 0, sizeof(*t));
	lock_rw_init(&t->entry.lock);
	t->entry.key = t;
}

/** prealloc some entries in the cache. To minimize contention.
 * Result is 1 lock per alloc_max newly created entries.
 * @param alloc: the structure to fill up.
 */
static void
prealloc_setup(struct alloc_cache* alloc)
{
	alloc_special_type* p;
	int i;
	for(i=0; i<ALLOC_SPECIAL_MAX; i++) {
		if(!(p = (alloc_special_type*)malloc(
			sizeof(alloc_special_type)))) {
			log_err("prealloc: out of memory");
			return;
		}
		alloc_setup_special(p);
		alloc_set_special_next(p, alloc->quar);
		alloc->quar = p;
		alloc->num_quar++;
	}
}

/** prealloc region blocks */
static void
prealloc_blocks(struct alloc_cache* alloc, size_t num)
{
	size_t i;
	struct regional* r;
	for(i=0; i<num; i++) {
		r = regional_create_custom(ALLOC_REG_SIZE);
		if(!r) {
			log_err("prealloc blocks: out of memory");
			return;
		}
		r->next = (char*)alloc->reg_list;
		alloc->reg_list = r;
		alloc->num_reg_blocks ++;
	}
}

void
alloc_init(struct alloc_cache* alloc, struct alloc_cache* super,
	int thread_num)
{
	memset(alloc, 0, sizeof(*alloc));
	alloc->super = super;
	alloc->thread_num = thread_num;
	alloc->next_id = (uint64_t)thread_num; 	/* in steps, so that type */
	alloc->next_id <<= THRNUM_SHIFT; 	/* of *_id is used. */
	alloc->last_id = 1; 			/* so no 64bit constants, */
	alloc->last_id <<= THRNUM_SHIFT; 	/* or implicit 'int' ops. */
	alloc->last_id -= 1; 			/* for compiler portability. */
	alloc->last_id |= alloc->next_id;
	alloc->next_id += 1;			/* because id=0 is special. */
	alloc->max_reg_blocks = 100;
	alloc->num_reg_blocks = 0;
	alloc->reg_list = NULL;
	alloc->cleanup = NULL;
	alloc->cleanup_arg = NULL;
	if(alloc->super)
		prealloc_blocks(alloc, alloc->max_reg_blocks);
	if(!alloc->super) {
		lock_quick_init(&alloc->lock);
		lock_protect(&alloc->lock, alloc, sizeof(*alloc));
	}
}

/** free the special list */
static void
alloc_clear_special_list(struct alloc_cache* alloc)
{
	alloc_special_type* p, *np;
	/* free */
	p = alloc->quar;
	while(p) {
		np = alloc_special_next(p);
		/* deinit special type */
		lock_rw_destroy(&p->entry.lock);
		free(p);
		p = np;
	}
}

void
alloc_clear_special(struct alloc_cache* alloc)
{
	if(!alloc->super) {
		lock_quick_lock(&alloc->lock);
	}
	alloc_clear_special_list(alloc);
	alloc->quar = 0;
	alloc->num_quar = 0;
	if(!alloc->super) {
		lock_quick_unlock(&alloc->lock);
	}
}

void
alloc_clear(struct alloc_cache* alloc)
{
	alloc_special_type* p;
	struct regional* r, *nr;
	if(!alloc)
		return;
	if(!alloc->super) {
		lock_quick_destroy(&alloc->lock);
	}
	if(alloc->super && alloc->quar) {
		/* push entire list into super */
		p = alloc->quar;
		while(alloc_special_next(p)) /* find last */
			p = alloc_special_next(p);
		lock_quick_lock(&alloc->super->lock);
		alloc_set_special_next(p, alloc->super->quar);
		alloc->super->quar = alloc->quar;
		alloc->super->num_quar += alloc->num_quar;
		lock_quick_unlock(&alloc->super->lock);
	} else {
		alloc_clear_special_list(alloc);
	}
	alloc->quar = 0;
	alloc->num_quar = 0;
	r = alloc->reg_list;
	while(r) {
		nr = (struct regional*)r->next;
		free(r);
		r = nr;
	}
	alloc->reg_list = NULL;
	alloc->num_reg_blocks = 0;
}

uint64_t
alloc_get_id(struct alloc_cache* alloc)
{
	uint64_t id = alloc->next_id++;
	if(id == alloc->last_id) {
		log_warn("rrset alloc: out of 64bit ids. Clearing cache.");
		fptr_ok(fptr_whitelist_alloc_cleanup(alloc->cleanup));
		(*alloc->cleanup)(alloc->cleanup_arg);

		/* start back at first number */   	/* like in alloc_init*/
		alloc->next_id = (uint64_t)alloc->thread_num;
		alloc->next_id <<= THRNUM_SHIFT; 	/* in steps for comp. */
		alloc->next_id += 1;			/* portability. */
		/* and generate new and safe id */
		id = alloc->next_id++;
	}
	return id;
}

alloc_special_type*
alloc_special_obtain(struct alloc_cache* alloc)
{
	alloc_special_type* p;
	log_assert(alloc);
	/* see if in local cache */
	if(alloc->quar) {
		p = alloc->quar;
		alloc->quar = alloc_special_next(p);
		alloc->num_quar--;
		p->id = alloc_get_id(alloc);
		return p;
	}
	/* see if in global cache */
	if(alloc->super) {
		/* could maybe grab alloc_max/2 entries in one go,
		 * but really, isn't that just as fast as this code? */
		lock_quick_lock(&alloc->super->lock);
		if((p = alloc->super->quar)) {
			alloc->super->quar = alloc_special_next(p);
			alloc->super->num_quar--;
		}
		lock_quick_unlock(&alloc->super->lock);
		if(p) {
			p->id = alloc_get_id(alloc);
			return p;
		}
	}
	/* allocate new */
	prealloc_setup(alloc);
	if(!(p = (alloc_special_type*)malloc(sizeof(alloc_special_type)))) {
		log_err("alloc_special_obtain: out of memory");
		return NULL;
	}
	alloc_setup_special(p);
	p->id = alloc_get_id(alloc);
	return p;
}

/** push mem and some more items to the super */
static void
pushintosuper(struct alloc_cache* alloc, alloc_special_type* mem)
{
	int i;
	alloc_special_type *p = alloc->quar;
	log_assert(p);
	log_assert(alloc && alloc->super &&
		alloc->num_quar >= ALLOC_SPECIAL_MAX);
	/* push ALLOC_SPECIAL_MAX/2 after mem */
	alloc_set_special_next(mem, alloc->quar);
	for(i=1; i<ALLOC_SPECIAL_MAX/2; i++) {
		p = alloc_special_next(p);
	}
	alloc->quar = alloc_special_next(p);
	alloc->num_quar -= ALLOC_SPECIAL_MAX/2;

	/* dump mem+list into the super quar list */
	lock_quick_lock(&alloc->super->lock);
	alloc_set_special_next(p, alloc->super->quar);
	alloc->super->quar = mem;
	alloc->super->num_quar += ALLOC_SPECIAL_MAX/2 + 1;
	lock_quick_unlock(&alloc->super->lock);
	/* so 1 lock per mem+alloc/2 deletes */
}

void
alloc_special_release(struct alloc_cache* alloc, alloc_special_type* mem)
{
	log_assert(alloc);
	if(!mem)
		return;
	if(!alloc->super) {
		lock_quick_lock(&alloc->lock); /* superalloc needs locking */
	}

	alloc_special_clean(mem);
	if(alloc->super && alloc->num_quar >= ALLOC_SPECIAL_MAX) {
		/* push it to the super structure */
		pushintosuper(alloc, mem);
		return;
	}

	alloc_set_special_next(mem, alloc->quar);
	alloc->quar = mem;
	alloc->num_quar++;
	if(!alloc->super) {
		lock_quick_unlock(&alloc->lock);
	}
}

void
alloc_stats(struct alloc_cache* alloc)
{
	log_info("%salloc: %d in cache, %d blocks.", alloc->super?"":"sup",
		(int)alloc->num_quar, (int)alloc->num_reg_blocks);
}

size_t alloc_get_mem(struct alloc_cache* alloc)
{
	alloc_special_type* p;
	size_t s = sizeof(*alloc);
	if(!alloc->super) {
		lock_quick_lock(&alloc->lock); /* superalloc needs locking */
	}
	s += sizeof(alloc_special_type) * alloc->num_quar;
	for(p = alloc->quar; p; p = alloc_special_next(p)) {
		s += lock_get_mem(&p->entry.lock);
	}
	s += alloc->num_reg_blocks * ALLOC_REG_SIZE;
	if(!alloc->super) {
		lock_quick_unlock(&alloc->lock);
	}
	return s;
}

struct regional*
alloc_reg_obtain(struct alloc_cache* alloc)
{
	if(alloc->num_reg_blocks > 0) {
		struct regional* r = alloc->reg_list;
		alloc->reg_list = (struct regional*)r->next;
		r->next = NULL;
		alloc->num_reg_blocks--;
		return r;
	}
	return regional_create_custom(ALLOC_REG_SIZE);
}

void
alloc_reg_release(struct alloc_cache* alloc, struct regional* r)
{
	if(alloc->num_reg_blocks >= alloc->max_reg_blocks) {
		regional_destroy(r);
		return;
	}
	if(!r) return;
	regional_free_all(r);
	log_assert(r->next == NULL);
	r->next = (char*)alloc->reg_list;
	alloc->reg_list = r;
	alloc->num_reg_blocks++;
}

void
alloc_set_id_cleanup(struct alloc_cache* alloc, void (*cleanup)(void*),
        void* arg)
{
	alloc->cleanup = cleanup;
	alloc->cleanup_arg = arg;
}

/** global debug value to keep track of total memory mallocs */
size_t unbound_mem_alloc = 0;
/** global debug value to keep track of total memory frees */
size_t unbound_mem_freed = 0;
#ifdef UNBOUND_ALLOC_STATS
/** special value to know if the memory is being tracked */
uint64_t mem_special = (uint64_t)0xfeed43327766abcdLL;
#ifdef malloc
#undef malloc
#endif
/** malloc with stats */
void *unbound_stat_malloc(size_t size)
{
	void* res;
	if(size == 0) size = 1;
	log_assert(size <= SIZE_MAX-16);
	res = malloc(size+16);
	if(!res) return NULL;
	unbound_mem_alloc += size;
	log_info("stat %p=malloc(%u)", res+16, (unsigned)size);
	memcpy(res, &size, sizeof(size));
	memcpy(res+8, &mem_special, sizeof(mem_special));
	return res+16;
}
#ifdef calloc
#undef calloc
#endif
#ifndef INT_MAX
#define INT_MAX (((int)-1)>>1)
#endif
/** calloc with stats */
void *unbound_stat_calloc(size_t nmemb, size_t size)
{
	size_t s;
	void* res;
	if(nmemb != 0 && INT_MAX/nmemb < size)
		return NULL; /* integer overflow check */
	s = (nmemb*size==0)?(size_t)1:nmemb*size;
	log_assert(s <= SIZE_MAX-16);
	res = calloc(1, s+16);
	if(!res) return NULL;
	log_info("stat %p=calloc(%u, %u)", res+16, (unsigned)nmemb, (unsigned)size);
	unbound_mem_alloc += s;
	memcpy(res, &s, sizeof(s));
	memcpy(res+8, &mem_special, sizeof(mem_special));
	return res+16;
}
#ifdef free
#undef free
#endif
/** free with stats */
void unbound_stat_free(void *ptr)
{
	size_t s;
	if(!ptr) return;
	if(memcmp(ptr-8, &mem_special, sizeof(mem_special)) != 0) {
		free(ptr);
		return;
	}
	ptr-=16;
	memcpy(&s, ptr, sizeof(s));
	log_info("stat free(%p) size %u", ptr+16, (unsigned)s);
	memset(ptr+8, 0, 8);
	unbound_mem_freed += s;
	free(ptr);
}
#ifdef realloc
#undef realloc
#endif
/** realloc with stats */
void *unbound_stat_realloc(void *ptr, size_t size)
{
	size_t cursz;
	void* res;
	if(!ptr) return unbound_stat_malloc(size);
	if(memcmp(ptr-8, &mem_special, sizeof(mem_special)) != 0) {
		return realloc(ptr, size);
	}
	if(size==0) {
		unbound_stat_free(ptr);
		return NULL;
	}
	ptr -= 16;
	memcpy(&cursz, ptr, sizeof(cursz));
	if(cursz == size) {
		/* nothing changes */
		return ptr;
	}
	log_assert(size <= SIZE_MAX-16);
	res = malloc(size+16);
	if(!res) return NULL;
	unbound_mem_alloc += size;
	unbound_mem_freed += cursz;
	log_info("stat realloc(%p, %u) from %u", ptr+16, (unsigned)size, (unsigned)cursz);
	if(cursz > size) {
		memcpy(res+16, ptr+16, size);
	} else if(size > cursz) {
		memcpy(res+16, ptr+16, cursz);
	}
	memset(ptr+8, 0, 8);
	free(ptr);
	memcpy(res, &size, sizeof(size));
	memcpy(res+8, &mem_special, sizeof(mem_special));
	return res+16;
}

/** log to file where alloc was done */
void *unbound_stat_malloc_log(size_t size, const char* file, int line,
        const char* func)
{
	log_info("%s:%d %s malloc(%u)", file, line, func, (unsigned)size);
	return unbound_stat_malloc(size);
}

/** log to file where alloc was done */
void *unbound_stat_calloc_log(size_t nmemb, size_t size, const char* file,
        int line, const char* func)
{
	log_info("%s:%d %s calloc(%u, %u)", file, line, func,
		(unsigned) nmemb, (unsigned)size);
	return unbound_stat_calloc(nmemb, size);
}

/** log to file where free was done */
void unbound_stat_free_log(void *ptr, const char* file, int line,
        const char* func)
{
	if(ptr && memcmp(ptr-8, &mem_special, sizeof(mem_special)) == 0) {
		size_t s;
		memcpy(&s, ptr-16, sizeof(s));
		log_info("%s:%d %s free(%p) size %u",
			file, line, func, ptr, (unsigned)s);
	} else
		log_info("%s:%d %s unmatched free(%p)", file, line, func, ptr);
	unbound_stat_free(ptr);
}

/** log to file where alloc was done */
void *unbound_stat_realloc_log(void *ptr, size_t size, const char* file,
        int line, const char* func)
{
	log_info("%s:%d %s realloc(%p, %u)", file, line, func,
		ptr, (unsigned)size);
	return unbound_stat_realloc(ptr, size);
}

#endif /* UNBOUND_ALLOC_STATS */
#ifdef UNBOUND_ALLOC_LITE
#undef malloc
#undef calloc
#undef free
#undef realloc
/** length of prefix and suffix */
static size_t lite_pad = 16;
/** prefix value to check */
static char* lite_pre = "checkfront123456";
/** suffix value to check */
static char* lite_post= "checkafter123456";

void *unbound_stat_malloc_lite(size_t size, const char* file, int line,
        const char* func)
{
	/*  [prefix .. len .. actual data .. suffix] */
	void* res;
	log_assert(size <= SIZE_MAX-(lite_pad*2+sizeof(size_t)));
	res = malloc(size+lite_pad*2+sizeof(size_t));
	if(!res) return NULL;
	memmove(res, lite_pre, lite_pad);
	memmove(res+lite_pad, &size, sizeof(size_t));
	memset(res+lite_pad+sizeof(size_t), 0x1a, size); /* init the memory */
	memmove(res+lite_pad+size+sizeof(size_t), lite_post, lite_pad);
	return res+lite_pad+sizeof(size_t);
}

void *unbound_stat_calloc_lite(size_t nmemb, size_t size, const char* file,
        int line, const char* func)
{
	size_t req;
	void* res;
	if(nmemb != 0 && INT_MAX/nmemb < size)
		return NULL; /* integer overflow check */
	req = nmemb * size;
	log_assert(req <= SIZE_MAX-(lite_pad*2+sizeof(size_t)));
	res = malloc(req+lite_pad*2+sizeof(size_t));
	if(!res) return NULL;
	memmove(res, lite_pre, lite_pad);
	memmove(res+lite_pad, &req, sizeof(size_t));
	memset(res+lite_pad+sizeof(size_t), 0, req);
	memmove(res+lite_pad+req+sizeof(size_t), lite_post, lite_pad);
	return res+lite_pad+sizeof(size_t);
}

void unbound_stat_free_lite(void *ptr, const char* file, int line,
        const char* func)
{
	void* real;
	size_t orig = 0;
	if(!ptr) return;
	real = ptr-lite_pad-sizeof(size_t);
	if(memcmp(real, lite_pre, lite_pad) != 0) {
		log_err("free(): prefix failed %s:%d %s", file, line, func);
		log_hex("prefix here", real, lite_pad);
		log_hex("  should be", lite_pre, lite_pad);
		fatal_exit("alloc assertion failed");
	}
	memmove(&orig, real+lite_pad, sizeof(size_t));
	if(memcmp(real+lite_pad+orig+sizeof(size_t), lite_post, lite_pad)!=0){
		log_err("free(): suffix failed %s:%d %s", file, line, func);
		log_err("alloc size is %d", (int)orig);
		log_hex("suffix here", real+lite_pad+orig+sizeof(size_t),
			lite_pad);
		log_hex("  should be", lite_post, lite_pad);
		fatal_exit("alloc assertion failed");
	}
	memset(real, 0xdd, orig+lite_pad*2+sizeof(size_t)); /* mark it */
	free(real);
}

void *unbound_stat_realloc_lite(void *ptr, size_t size, const char* file,
        int line, const char* func)
{
	/* always free and realloc (no growing) */
	void* real, *newa;
	size_t orig = 0;
	if(!ptr) {
		/* like malloc() */
		return unbound_stat_malloc_lite(size, file, line, func);
	}
	if(!size) {
		/* like free() */
		unbound_stat_free_lite(ptr, file, line, func);
		return NULL;
	}
	/* change allocation size and copy */
	real = ptr-lite_pad-sizeof(size_t);
	if(memcmp(real, lite_pre, lite_pad) != 0) {
		log_err("realloc(): prefix failed %s:%d %s", file, line, func);
		log_hex("prefix here", real, lite_pad);
		log_hex("  should be", lite_pre, lite_pad);
		fatal_exit("alloc assertion failed");
	}
	memmove(&orig, real+lite_pad, sizeof(size_t));
	if(memcmp(real+lite_pad+orig+sizeof(size_t), lite_post, lite_pad)!=0){
		log_err("realloc(): suffix failed %s:%d %s", file, line, func);
		log_err("alloc size is %d", (int)orig);
		log_hex("suffix here", real+lite_pad+orig+sizeof(size_t),
			lite_pad);
		log_hex("  should be", lite_post, lite_pad);
		fatal_exit("alloc assertion failed");
	}
	/* new alloc and copy over */
	newa = unbound_stat_malloc_lite(size, file, line, func);
	if(!newa)
		return NULL;
	if(orig < size)
		memmove(newa, ptr, orig);
	else	memmove(newa, ptr, size);
	memset(real, 0xdd, orig+lite_pad*2+sizeof(size_t)); /* mark it */
	free(real);
	return newa;
}

char* unbound_strdup_lite(const char* s, const char* file, int line,
        const char* func)
{
	/* this routine is made to make sure strdup() uses the malloc_lite */
	size_t l = strlen(s)+1;
	char* n = (char*)unbound_stat_malloc_lite(l, file, line, func);
	if(!n) return NULL;
	memmove(n, s, l);
	return n;
}

char* unbound_lite_wrapstr(char* s)
{
	char* n = unbound_strdup_lite(s, __FILE__, __LINE__, __func__);
	free(s);
	return n;
}

#undef sldns_pkt2wire
sldns_status unbound_lite_pkt2wire(uint8_t **dest, const sldns_pkt *p,
	size_t *size)
{
	uint8_t* md = NULL;
	size_t ms = 0;
	sldns_status s = sldns_pkt2wire(&md, p, &ms);
	if(md) {
		*dest = unbound_stat_malloc_lite(ms, __FILE__, __LINE__,
			__func__);
		*size = ms;
		if(!*dest) { free(md); return LDNS_STATUS_MEM_ERR; }
		memcpy(*dest, md, ms);
		free(md);
	} else {
		*dest = NULL;
		*size = 0;
	}
	return s;
}

#undef i2d_DSA_SIG
int unbound_lite_i2d_DSA_SIG(DSA_SIG* dsasig, unsigned char** sig)
{
	unsigned char* n = NULL;
	int r= i2d_DSA_SIG(dsasig, &n);
	if(n) {
		*sig = unbound_stat_malloc_lite((size_t)r, __FILE__, __LINE__,
			__func__);
		if(!*sig) return -1;
		memcpy(*sig, n, (size_t)r);
		free(n);
		return r;
	}
	*sig = NULL;
	return r;
}

#endif /* UNBOUND_ALLOC_LITE */


text:
<?xml version="1.0" encoding="utf-8"?>
<doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
  <entity name="Team" table="team">
    <change-tracking-policy>DEFERRED_IMPLICIT</change-tracking-policy>
    <id name="teamId" type="integer" column="team_id">
      <generator strategy="IDENTITY"/>
    </id>
    <field name="name1" type="string" column="name1" length="255"/>
    <field name="surname1" type="string" column="surname1" length="255"/>
    <field name="phone1" type="string" column="phone1" length="255"/>
    <field name="email1" type="string" column="email1" length="255"/>
    <field name="name2" type="string" column="name2" length="255"/>
    <field name="surname2" type="string" column="surname2" length="255"/>
    <field name="phone2" type="string" column="phone2" length="255"/>
    <field name="email2" type="string" column="email2" length="255"/>
    <many-to-many field="divisionsDivision" target-entity="Division" mapped-by="teamsTeam"/>
    <many-to-one field="leagueLeague" target-entity="League" orphan-removal="">
      <join-columns>
        <join-column name="league_league_id" referenced-column-name="league_id"/>
      </join-columns>
    </many-to-one>
    <many-to-one field="userUser" target-entity="User" orphan-removal="">
      <join-columns>
        <join-column name="user_user_id" referenced-column-name="user_id"/>
      </join-columns>
    </many-to-one>
    <lifecycle-callbacks/>
  </entity>
</doctrine-mapping>


text:
(function() {
    'use strict';

    /**
     * The flokPriorityModule is a flok component to organise your task list.
     * @type {module}
     */
    var flokPriorityModule = angular.module('flokPriorityModule', [
        // Angular Core Components:
        'ngSanitize', 'ngMessages',
        // External Components:
        'pascalprecht.translate', 'ui.bootstrap', 'ui.sortable', 'ui.utils', 'ui.router',
        // flok Components:
        'onRootScope',
        'flokFilters', 'flokDirectives', 'flokMenuModule'
    ]);

    flokPriorityModule.config(['$stateProvider', 'menuServiceProvider', function($stateProvider, menuServiceProvider) {

        $stateProvider.state('priority', {
            url: '/priority',
            templateUrl: 'app/priority/priority.tpl.html'
        });

        menuServiceProvider.addMenuItem(
            {
                state: 'priority',
                name: 'flok.priority.title',
                icon: 'list'
            }
        );
    }]);
})();


text:
using System.Collections.Generic;

namespace FFLTask.SRV.ViewModel.Project
{
    public class _SearchModel
    {
        //TODO: should use enum
        public bool IdOrName { get; set; }
        public string Input { get; set; }
        public IList<_LiteralLinkedModel> Projects { get; set; }
    }
}


text:
@interface ImageViewCell : UITableViewCell

@property (weak, nonatomic) IBOutlet UILabel *label;
@property (weak, nonatomic) IBOutlet UIImageView *flickrImageView;

@end


text:
package io.github.dstrekelj.pajamas.data.sources;

import io.github.dstrekelj.pajamas.models.TrackModel;

/**
 * Interface for storing and retrieving data from a Pajamas data source.
 */
public interface IPajamasDataSource {
    /**
     * Saves track to data source.
     * @param track Track
     */
    void saveTrack(TrackModel track);
}


text:
<#
    .SYNOPSIS
        Stop registered watchers for file system change events.

    .DESCRIPTION
        Remove event subscribers for the existing path by getting all event
        subscribers and unregister all with the Unregister-Event command.

    .PARAMETER Path
        Path to stop watching changes.

    .INPUTS
        None.

    .OUTPUTS
        None

    .EXAMPLE
        PS C:\> Stop-WatchPath -Path 'C:\Demo'
        Stop watching the path C:\Demo for all events.

    .NOTES
        Author     : Claudio Spizzi
        License    : MIT License

    .LINK
        https://github.com/claudiospizzi/WindowsFever
#>
function Stop-WatchPath
{
    [CmdletBinding(SupportsShouldProcess = $true)]
    param
    (
        [Parameter(Mandatory = $true)]
        [ValidateScript({ Test-Path -Path $_ })]
        [System.String]
        $Path
    )

    $ErrorActionPreference = 'Stop'

    $Path = $Path.TrimEnd('\')

    # Unregister all event subscribers for the path.
    Get-EventSubscriber -SourceIdentifier "PSWatchPath|$Path|*" -ErrorAction SilentlyContinue | Unregister-Event
}


text:
'use strict';

module.exports = {
    readFile: function(path, binary) {
        return sandboxRequest("zed/fs", "readFile", [path, binary]);
    },
    writeFile: function(path, text, binary) {
        return sandboxRequest("zed/fs", "writeFile", [path, text, binary]);
    },
    listFiles: function() {
        return sandboxRequest("zed/fs", "listFiles", []);
    },
    listFilesOfKnownFileTypes: function() {
        return sandboxRequest("zed/fs", "listFilesOfKnownFileTypes", []);
    },
    reloadFileList: function() {
        return sandboxRequest("zed/fs", "reloadFileList", []);
    },
    isConfig: function() {
        return sandboxRequest("zed/fs", "isConfig", []);
    },
    getProjectPath: function() {
        return sandboxRequest("zed/fs", "getProjectPath", []);
    },
    getCapabilities: function() {
        return sandboxRequest("zed/fs", "getCapabilities", []);
    },
    run: function(command, stdin) {
        return sandboxRequest("zed/fs", "run", [command, stdin]);
    }
};


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/EverliveDemo.iml" filepath="$PROJECT_DIR$/EverliveDemo.iml" />
      <module fileurl="file://$PROJECT_DIR$/app/app.iml" filepath="$PROJECT_DIR$/app/app.iml" />
    </modules>
  </component>
</project>


text:
module.exports = function (plop) {
	'use strict';

	///////
	// helpers are passed through to handlebars and made
	// available for use in the generator templates
	//

	// adds 4 dashes around some text (yes es6/es2015 is supported)
	plop.setHelper('dashAround', function (text) { return '---- ' + text + ' ----'; });
	// plop.setHelper('dashAround', (text) => '---- ' + text + ' ----');

	// formats an array of options like you would write
	// it if you were speaking (one, two, and three)
	plop.setHelper('wordJoin', function (words) {
		return words.join(', ').replace(/(:?.*),/, '$1, and');
	});

	// greet the user using a partial
	plop.setPartial('salutation', 'my name is {{ properCase name }} and I am {{ age }}.');

	// setGenerator creates a generator that can be run with "plop generatorName"
	plop.setGenerator('basic-add', {
		description: 'adds a file using a template',
		prompts: [
			{
				type: 'input',
				name: 'name',
				message: 'What is your name?',
				validate: function (value) {
					if ((/.+/).test(value)) { return true; }
					return 'name is required';
				}
			}, {
				type: 'input',
				name: 'age',
				message: 'How old are you?',
				validate: function (value) {
					var digitsOnly = /\d+/;
					if (digitsOnly.test(value)) { return true; }
					return 'Invalid age! Must be a number genius!';
				}
			}
		],
		actions: [
			{
				type: 'add',
				path: 'src/{{dashCase name}}.txt',
				templateFile: 'plop-templates/add.txt',
				abortOnFail: true
			}, {
				type: 'add',
				path: 'src/_{{constantCase name}}.txt',
				template: 'test: {{pkg "name"}}\npropertyPathTest: {{pkg "config.nested[1]"}}\ninline template: {{name}}',
				abortOnFail: true
			},
			function customAction(answers) {
				// move the current working directory to the plop file path
				// this allows this action to work even when the generator is
				// executed from inside a subdirectory
				process.chdir(plop.getPlopfilePath());

				// custom function can be synchronous or async (by returning a promise)
				var fs = require('fs'),
					existsMsg = 'psst {{name}}, change-me.txt already exists',
					copiedMsg = 'hey {{name}}, I copied change-me.txt for you',
					changeFile = 'change-me.txt';

				// you can use plop.renderString to render templates
				existsMsg = plop.renderString(existsMsg, answers);
				copiedMsg = plop.renderString(copiedMsg, answers);

				if (fs.existsSync(changeFile)) {
					// returned value shows up in the console
					return existsMsg;
				} else {
					// do a synchronous copy via node fs
					fs.writeFileSync(`src/${changeFile}`, fs.readFileSync(`plop-templates/${changeFile}`));
					return copiedMsg;
				}
			},{
				type: 'modify',
				path: 'src/change-me.txt',
				pattern: /(-- APPEND ITEMS HERE --)/gi,
				template: '$1\r\n{{name}}: {{age}}'
			},{
				type: 'modify',
				path: 'src/change-me.txt',
				pattern: /(-- PREPEND ITEMS HERE --)/gi,
				templateFile: 'plop-templates/part.txt'
			},{
				type: 'modify',
				path: 'src/change-me.txt',
				pattern: /## replace name here ##/gi,
				template: 'replaced => {{dashCase name}}'
			}
		]
	});
};


text:
.. zeex documentation master file, created by
   sphinx-quickstart on Sun Dec 11 17:14:31 2016.
   You can adapt this file completely to your liking, but it should at least
   contain the root `toctree` directive.

Welcome to zeex's documentation!
================================

.. toctree::
   :maxdepth: 2
   :caption: Contents:

.. automodule:: core.views
.. automodule:: core.models
.. automodule:: core.ctrls

.. autoclass:: core.main.ZeexApp
	:members:
.. autoclass:: core.views.main.ZeexMainWindow
	:members:
.. autoclass:: core.views.settings.SettingsDialog
	:members:

Indices and tables
==================

* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`


text:
package org.camunda.bpm.engine.impl.tree;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

/**
 *
A walker for walking through an object reference structure (e.g. an execution tree).
 * Any visited element can have any number of following elements. The elements are visited
 * with a breadth-first approach: The walker maintains a list of next elements to which it adds
 * a new elements at the end whenever it has visited an element. The walker stops when it encounters
 * an element that fulfills the given {@link WalkCondition}.
 *
 *
Subclasses define the type of objects and provide the walking behavior.
 *
 * @author Thorben Lindhauer
 */
public abstract class ReferenceWalker<T> {

  protected List<T> currentElements;

  protected List<TreeVisitor<T>> preVisitor = new ArrayList<TreeVisitor<T>>();

  protected List<TreeVisitor<T>> postVisitor = new ArrayList<TreeVisitor<T>>();

  protected abstract Collection<T> nextElements();

  public ReferenceWalker(T initialElement) {
    currentElements = new LinkedList<T>();
    currentElements.add(initialElement);
  }

  public ReferenceWalker(List<T> initialElements) {
    currentElements = new LinkedList<T>(initialElements);
  }

  public ReferenceWalker<T> addPreVisitor(TreeVisitor<T> collector) {
    this.preVisitor.add(collector);
    return this;
  }

  public ReferenceWalker<T> addPostVisitor(TreeVisitor<T> collector) {
    this.postVisitor.add(collector);
    return this;
  }

  public T walkWhile() {
    return walkWhile(new ReferenceWalker.NullCondition<T>());
  }

  public T walkUntil() {
    return walkUntil(new ReferenceWalker.NullCondition<T>());
  }

  public T walkWhile(ReferenceWalker.WalkCondition<T> condition) {
    while (!condition.isFulfilled(getCurrentElement())) {
      for (TreeVisitor<T> collector : preVisitor) {
        collector.visit(getCurrentElement());
      }

      currentElements.addAll(nextElements());
      currentElements.remove(0);

      for (TreeVisitor<T> collector : postVisitor) {
        collector.visit(getCurrentElement());
      }
    }
    return getCurrentElement();
  }

  public T walkUntil(ReferenceWalker.WalkCondition<T> condition) {
    do {
      for (TreeVisitor<T> collector : preVisitor) {
        collector.visit(getCurrentElement());
      }

      currentElements.addAll(nextElements());
      currentElements.remove(0);

      for (TreeVisitor<T> collector : postVisitor) {
        collector.visit(getCurrentElement());
      }
    } while (!condition.isFulfilled(getCurrentElement()));
    return getCurrentElement();
  }

  public T getCurrentElement() {
    return currentElements.isEmpty() ? null : currentElements.get(0);
  }

  public interface WalkCondition<S> {
    boolean isFulfilled(S element);
  }

  public static class NullCondition<S> implements ReferenceWalker.WalkCondition<S> {

    public boolean isFulfilled(S element) {
      return element == null;
    }

    public static <S> ReferenceWalker.WalkCondition<S> notNull() {
      return new NullCondition<S>();
    }

  }

}


text:
/**
 * @class Ext.layout.ContainerLayout
 *
The ContainerLayout class is the default layout manager delegated by {@link Ext.Container} to
 * render any child Components when no <tt>{@link Ext.Container#layout layout}</tt> is configured into
 * a {@link Ext.Container Container}. ContainerLayout provides the basic foundation for all other layout
 * classes in Ext. It simply renders all child Components into the Container, performing no sizing or
 * positioning services. To utilize a layout that provides sizing and positioning of child Components,
 * specify an appropriate <tt>{@link Ext.Container#layout layout}</tt>.

 *
This class is intended to be extended or created via the <tt>{@link Ext.Container#layout layout}</tt>
 * configuration property.  See <tt>{@link Ext.Container#layout}</tt> for additional details.

 */
Ext.layout.ContainerLayout = function(config){
    Ext.apply(this, config);
};

Ext.layout.ContainerLayout.prototype = {
    /**
     * @cfg {String} extraCls
     *
An optional extra CSS class that will be added to the container. This can be useful for adding
     * customized styles to the container or any of its children using standard CSS rules. See
     * {@link Ext.Component}.{@link Ext.Component#ctCls ctCls} also.

     *
Note: <tt>extraCls</tt> defaults to <tt>''</tt> except for the following classes
     * which assign a value by default:
     *

     *
{@link Ext.layout.AbsoluteLayout Absolute Layout} : <tt>'x-abs-layout-item'</tt>

     *
{@link Ext.layout.Box Box Layout} : <tt>'x-box-item'</tt>

     *
{@link Ext.layout.ColumnLayout Column Layout} : <tt>'x-column'</tt>

     *

     * To configure the above Classes with an extra CSS class append to the default.  For example,
     * for ColumnLayout:

     * extraCls: 'x-column custom-class'
     *

     *

     */
    /**
     * @cfg {Boolean} renderHidden
     * True to hide each contained item on render (defaults to false).
     */

    /**
     * A reference to the {@link Ext.Component} that is active.  For example,

     * if(myPanel.layout.activeItem.id == 'item-1') { ... }
     *

     * <tt>activeItem</tt> only applies to layout styles that can display items one at a time
     * (like {@link Ext.layout.AccordionLayout}, {@link Ext.layout.CardLayout}
     * and {@link Ext.layout.FitLayout}).  Read-only.  Related to {@link Ext.Container#activeItem}.
     * @type {Ext.Component}
     * @property activeItem
     */

    // private
    monitorResize:false,
    // private
    activeItem : null,

    // private
    layout : function(){
        var target = this.container.getLayoutTarget();
        this.onLayout(this.container, target);
        this.container.fireEvent('afterlayout', this.container, this);
    },

    // private
    onLayout : function(ct, target){
        this.renderAll(ct, target);
    },

    // private
    isValidParent : function(c, target){
		return target && c.getDomPositionEl().dom.parentNode == (target.dom || target);
    },

    // private
    renderAll : function(ct, target){
        var items = ct.items.items;
        for(var i = 0, len = items.length; i < len; i++) {
            var c = items[i];
            if(c && (!c.rendered || !this.isValidParent(c, target))){
                this.renderItem(c, i, target);
            }
        }
    },

    // private
    renderItem : function(c, position, target){
        if(c && !c.rendered){
            c.render(target, position);
            this.configureItem(c, position);
        }else if(c && !this.isValidParent(c, target)){
            if(Ext.isNumber(position)){
                position = target.dom.childNodes[position];
            }
            target.dom.insertBefore(c.getDomPositionEl().dom, position || null);
            c.container = target;
            this.configureItem(c, position);
        }
    },

    // private
    configureItem: function(c, position){
        if(this.extraCls){
            var t = c.getPositionEl ? c.getPositionEl() : c;
            t.addClass(this.extraCls);
        }
        if (this.renderHidden && c != this.activeItem) {
            c.hide();
        }
        if(c.doLayout && this.forceLayout){
            c.doLayout(false, true);
        }
    },

    onRemove: function(c){
         if(this.activeItem == c){
            delete this.activeItem;
         }
         if(c.rendered && this.extraCls){
            var t = c.getPositionEl ? c.getPositionEl() : c;
            t.removeClass(this.extraCls);
        }
    },

    // private
    onResize: function(){
        var ct = this.container,
            b;

        if(ct.collapsed){
            return;
        }
        if(b = ct.bufferResize){
            // Only allow if we should buffer the layout
            if(ct.shouldBufferLayout()){
                if(!this.resizeTask){
                    this.resizeTask = new Ext.util.DelayedTask(this.runLayout, this);
                    this.resizeBuffer = Ext.isNumber(b) ? b : 50;
                }
                ct.layoutPending = true;
                this.resizeTask.delay(this.resizeBuffer);
            }
        }else{
            ct.doLayout();
        }
    },

    // private
    runLayout: function(){
        var ct = this.container;
        ct.doLayout();
        delete ct.layoutPending;
    },

    // private
    setContainer : function(ct){
        if(this.monitorResize && ct != this.container){
            var old = this.container;
            if(old){
                old.un(old.resizeEvent, this.onResize, this);
            }
            if(ct){
                ct.on(ct.resizeEvent, this.onResize, this);
            }
        }
        this.container = ct;
    },

    // private
    parseMargins : function(v){
        if(Ext.isNumber(v)){
            v = v.toString();
        }
        var ms = v.split(' ');
        var len = ms.length;
        if(len == 1){
            ms[1] = ms[0];
            ms[2] = ms[0];
            ms[3] = ms[0];
        }
        if(len == 2){
            ms[2] = ms[0];
            ms[3] = ms[1];
        }
        if(len == 3){
            ms[3] = ms[1];
        }
        return {
            top:parseInt(ms[0], 10) || 0,
            right:parseInt(ms[1], 10) || 0,
            bottom:parseInt(ms[2], 10) || 0,
            left:parseInt(ms[3], 10) || 0
        };
    },

    /**
     * The {@link Ext.Template Ext.Template} used by Field rendering layout classes (such as
     * {@link Ext.layout.FormLayout}) to create the DOM structure of a fully wrapped,
     * labeled and styled form Field. A default Template is supplied, but this may be
     * overriden to create custom field structures. The template processes values returned from
     * {@link Ext.layout.FormLayout#getTemplateArgs}.
     * @property fieldTpl
     * @type Ext.Template
     */
    fieldTpl: (function() {
        var t = new Ext.Template(
            '
',
                '{label}{labelSeparator}',
                '
',
                '

',
            '
'
        );
        t.disableFormats = true;
        return t.compile();
    })(),

    /*
     * Destroys this layout. This is a template method that is empty by default, but should be implemented
     * by subclasses that require explicit destruction to purge event handlers or remove DOM nodes.
     * @protected
     */
    destroy : Ext.emptyFn
};
Ext.Container.LAYOUTS['auto'] = Ext.layout.ContainerLayout;


text:
import subprocess

#
# GCCFacade
#
class GCCFacade:
    @staticmethod
    def processCompOptions( options ):
        options = GCCFacade.__removeCompilationOption( options )
        options = GCCFacade.__runPreprocessingOnly( options )

        return options.strip()

    @staticmethod
    def getHeaders( filename, options ):
        args = GCCFacade.__name()
        args += " " + options
        args += " " + filename

        proc = subprocess.Popen(
            args,
            shell = True,
            stdin = subprocess.PIPE,
            stdout = subprocess.PIPE,
            stderr = subprocess.PIPE,
            universal_newlines=True
        )

        stdout_output, stderr_output = proc.communicate()

        return stderr_output

    @staticmethod
    def parseLine( line ):
        i = 0
        length = len( line )

        while i < length and line[i] == '.':
            i += 1

        if i == 0:
            raise Exception( "Wrong line format: ", line )

        if line[i] != ' ':
            raise Exception( "Wrong line format: ", line )

        if i + 1 == length:
            raise Exception( "Wrong line format: ", line )

        return ( i, line[ i + 1 : len(line) ] )

    @staticmethod
    def __name():
        return "g++"

    @staticmethod
    def __removeCompilationOption( options ):
        options.replace( "-c", "" )
        options.replace( "-fPIC", "" )

        return options

    @staticmethod
    def __runPreprocessingOnly( options ):
        return "-x c++ -E -H " + options


text:
package org.mockito.internal.stubbing.answers;

import static org.mockito.internal.exceptions.Reporter.onlyVoidMethodsCanBeSetToDoNothing;

import java.io.Serializable;

import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.ValidableAnswer;

public class DoesNothing implements Answer<Object>, ValidableAnswer, Serializable {

    private static final long serialVersionUID = 4840880517740698416L;

    private static final DoesNothing SINGLETON = new DoesNothing();

    private DoesNothing() {}

    public static DoesNothing doesNothing() {
        return SINGLETON;
    }

    @Override
    public Object answer(InvocationOnMock invocation) {
        return null;
    }

    @Override
    public void validateFor(InvocationOnMock invocation) {
        if (!new InvocationInfo(invocation).isVoid()) {
            throw onlyVoidMethodsCanBeSetToDoNothing();
        }
    }
}


text:
class Solution {
    public List<String> buildArray(int[] target, int n) {
        int index = 0;
        List<String> result = new LinkedList<>();
        for (int i = 1; i <= n && index < target.length; i++) {
            result.add("Push");
            if (target[index] == i) {
                index++;
            } else {
                result.add("Pop");
            }
        }
        return result;
    }
}


text:
package challenge25

import (
	"bytes"
	"io/ioutil"
	"testing"

	"github.com/stripedpajamas/cryptopals/set3/challenge18"
)

var globalPlaintext []byte

func init() {
	var err error
	globalPlaintext, err = ioutil.ReadFile("25_decoded.txt")
	if err != nil {
		panic(err)
	}
}

func TestEncryptSecretWithCTR(t *testing.T) {
	enc := EncryptSecretWithCTR(globalPlaintext)
	dec := challenge18.CTR(enc, globalKey, globalNonce)

	if !bytes.Equal(dec, globalPlaintext) {
		t.Fail()
	}
}

func TestEdit(t *testing.T) {
	input := []byte("HELLO POTATO FACE")
	key := []byte("YELLOW SUBMARINE")
	nonce := []byte{0, 0, 0, 0, 0, 0, 0, 0}
	enc := challenge18.CTR(input, key, nonce)
	edited := Edit(enc, key, nonce, []byte("TOMATO"), 6)
	dec := challenge18.CTR(edited, key, nonce)

	if string(dec) != "HELLO TOMATO FACE" {
		t.Fail()
	}
}

func TestEditAPI(t *testing.T) {
	input := []byte("HELLO POTATO FACE")
	enc := challenge18.CTR(input, globalKey, globalNonce)
	edited := EditAPI(enc, []byte("TOMATO"), 6)
	dec := challenge18.CTR(edited, globalKey, globalNonce)

	if string(dec) != "HELLO TOMATO FACE" {
		t.Fail()
	}
}

func TestRecoverPTFromAPI(t *testing.T) {
	// https://cryptopals.com/sets/4/challenges/25
	enc := EncryptSecretWithCTR(globalPlaintext)
	recovered := RecoverPTFromAPI(enc)
	if !bytes.Equal(recovered, globalPlaintext) {
		t.Fail()
	}
}


text:
// Provides enumeration sap.ui.table.TreeAutoExpandMode
sap.ui.define(['jquery.sap.global'],
	function(jQuery) {
	"use strict";

	/**
	* @class
	* Different modes for setting the auto expand mode on different tables (Analytical-, TreeTable, ...)
	*
	* @static
	* @public
	* @alias sap.ui.table.TreeAutoExpandMode
	*/
	var TreeAutoExpandMode = {
			/**
			 * Tree nodes will be expanded in sequence, level by level (Single requests are sent)
			 * @public
			 */
			Sequential: "Sequential",

			/**
			 * If supported by a backend provider with analytical capabilities, the requests needed for an automatic node expansion are bundled.
			 * @public
			 */
			Bundled: "Bundled"
	};

	return TreeAutoExpandMode;

}, /* bExport= */ true);


text:
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace NetOffice.DeveloperToolbox.ToolboxControls.ApplicationObserver
{
    /// <summary>
    /// process watcher for ms-office products
    /// </summary>
    internal class OfficeApplicationObserver : IDisposable
    {
        #region Fields

        private string      _killQuestion = "Ausgewählte Instanzen löschen?";
        private bool        _showQuesionBeforeKill;
        private NotifyIcon  _notify;
        private Icon        _runIcon;
        private Icon        _stopIcon;
        private Timer       _timer;
        private Keys        _key = Keys.A;
        private Hotkey      _hotKey;
        private bool        _hotKeyEnabled;
        private Process[]   _allProcs = new Process[0];
        private Process[]   _excelProcs;
        private Process[]   _wordProcs;
        private Process[]   _outlookProcs;
        private Process[]   _powerProcs;
        private Process[]   _accessProcs;
        private Process[]   _projectProcs;
        private int         _currentLanguageID = 1031;

        #endregion

        #region Construction

        /// <summary>
        /// Creates an instance of the class
        /// </summary>
        /// <param name="listViewApps">view control</param>
        internal OfficeApplicationObserver(ListView listViewApps)
        {
            string assemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
            _runIcon = new Icon(this.GetType().Assembly.GetManifestResourceStream(assemblyName + ".ToolboxControls.ApplicationObserver.IconsAndConfig.Running.ico"));
            _stopIcon = new Icon(this.GetType().Assembly.GetManifestResourceStream(assemblyName + ".ToolboxControls.ApplicationObserver.IconsAndConfig.NotRunning.ico"));
            _notify = new NotifyIcon();

            AttachedControl = listViewApps;
            _timer = new Timer();
            _timer.Interval = 100;
            _timer.Tick += new EventHandler(Timer_Tick);
            _timer.Enabled = true;
        }

        #endregion

        #region Events

        /// <summary>
        /// The whole process list has been changed
        /// </summary>
        public event EventHandler AllProcessesChanged;

        /// <summary>
        /// an office process has been started or terminated
        /// </summary>
        public event EventHandler InstanceRunningCountChanged;

        #endregion

        #region Properties

        /// <summary>
        /// Current user language id
        /// </summary>
        public int CurrentLanguageID
        {
            get
            {
                return _currentLanguageID;
            }
            set
            {
                _currentLanguageID = value;
            }
        }

        /// <summary>
        /// Question for the user before kill someone
        /// </summary>
        public string KillQuestion
        {
            get
            {
                return _killQuestion;
            }
            set
            {
                _killQuestion = value;
            }
        }

        /// <summary>
        /// Show KillQuestion as message box before kill
        /// </summary>
        public bool ShowQuestionBeforeKill
        {
            get
            {
                return _showQuesionBeforeKill;
            }
            set
            {
                _showQuesionBeforeKill = value;
            }
        }

        /// <summary>
        /// Show tray icon to indicates one ore more (selected) office application is running
        /// </summary>
        public bool TrayIcon
        {
            get
            {
                return _notify.Visible;
            }
            set
            {
                _notify.Visible = value;
            }
        }

        /// <summary>
        /// View control to show current processes in real time
        /// </summary>
        public ListView AttachedControl{get;set;}

        /// <summary>
        /// Hotkey definition to kill instances with one hit
        /// </summary>
        public Keys HotKey
        {
            get
            {
                return _key;
            }
            set
            {
                if (true == HotKeyEnabled)
                {
                    if (_hotKey != null)
                    {
                        Hotkey.UnRegister(_hotKey);
                        _hotKey.Dispose();
                    }
                   _hotKey = Hotkey.Register(value);
                   _hotKey.HotkeyPressed += new EventHandler(HotKey_HotkeyPressed);
                }
                _key = value;
            }
        }

        /// <summary>
        /// Hotkey definition is enabled
        /// </summary>
        public bool HotKeyEnabled
        {
            get
            {
                return _hotKeyEnabled;
            }
            set
            {
                if (true == value)
                {
                    if (_hotKey != null)
                    {
                        Hotkey.UnRegister(_hotKey);
                        _hotKey.Dispose();
                    }
                    _hotKey = Hotkey.Register(_key);
                    _hotKey.HotkeyPressed += new EventHandler(HotKey_HotkeyPressed);
                }
                else
                {
                    Hotkey.UnRegister(_hotKey);
                }
                _hotKeyEnabled = value;
            }
        }

        /// <summary>
        /// Refresh intervall for the process list
        /// </summary>
        public int WatchIntervallMs
        {
            get
            {
                return _timer.Interval;
            }
            set
            {
                _timer.Interval = value;
            }
        }

        /// <summary>
        /// Enable to observe the process list
        /// </summary>
        public bool WatchEnabled
        {
            get
            {
                return _timer.Enabled;
            }
            set
            {
                _timer.Enabled = value;
            }
        }

        /// <summary>
        /// Enable to kill excel
        /// </summary>
        public bool Excel{get;set;}

        /// <summary>
        /// Enable to kill word
        /// </summary>
        public bool Word { get; set; }

        /// <summary>
        /// Enable to kill outlook
        /// </summary>
        public bool Outlook { get; set; }

        /// <summary>
        /// Enable to kill power point
        /// </summary>
        public bool PowerPoint { get; set; }

        /// <summary>
        /// Enable to kill access
        /// </summary>
        public bool Access { get; set; }

        /// <summary>
        /// Enable to kill project
        /// </summary>
        public bool Project { get; set; }

        #endregion

        #region Methods

        /// <summary>
        /// Kill selected processes if running
        /// </summary>
        public void KillProcesses()
        {
            if(DialogResult.Yes != MessageBox.Show(_killQuestion, "NetOffice Developer Toolbox", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
                return ;

            if(Excel)
                KillProcesses(_excelProcs);

            if(Word)
                KillProcesses(_wordProcs);

            if(Outlook)
                KillProcesses(_outlookProcs);

            if(PowerPoint)
                KillProcesses(_powerProcs);

            if(Access)
                KillProcesses(_accessProcs);

            if (Project)
                KillProcesses(_projectProcs);
        }

        private void KillProcesses(string name)
        {
            try
            {
                Process[] procs = Process.GetProcessesByName(name);

                foreach (Process p in procs)
                    p.Kill();
            }
            catch (System.ComponentModel.Win32Exception) { ;}
            catch (NotSupportedException) { ;}
            catch (InvalidOperationException) { ;}
            catch(Exception)
            {
                throw;
            }
        }

        private void ShowProcesses(string name, Process[] procs)
        {
            ListViewItem itemControl = null;
            foreach (ListViewItem item in AttachedControl.Items)
            {
                if (true == item.Text.Equals(name, StringComparison.InvariantCultureIgnoreCase))
                {
                    itemControl = item;
                    break;
                }
            }

            if (null != itemControl)
            {
                string length = procs.Length.ToString();
                if (length != itemControl.SubItems[1].Text)
                {
                    itemControl.SubItems[1].Text = length;
                    if (null != InstanceRunningCountChanged)
                        InstanceRunningCountChanged(this, new EventArgs());
                }
            }
        }

        private void KillProcesses(Process[] procs)
        {
            try
            {
                if (null == procs)
                    return;

                foreach (Process p in procs)
                    p.Kill();
            }
            catch
            {
                ;
            }
        }

        private void ShowOfficeProcesses()
        {
            if (null != AttachedControl)
            {
                Process[] procs = Process.GetProcessesByName("Excel");
                AttachedControl.Items[0].SubItems[1].Text = procs.Length.ToString();

                procs = Process.GetProcessesByName("WINWORD");
                AttachedControl.Items[1].SubItems[1].Text = procs.Length.ToString();

                procs = Process.GetProcessesByName("Outlook");
                AttachedControl.Items[2].SubItems[1].Text = procs.Length.ToString();

                procs = Process.GetProcessesByName("POWERPNT");
                AttachedControl.Items[3].SubItems[1].Text = procs.Length.ToString();

                procs = Process.GetProcessesByName("MSACCESS");
                AttachedControl.Items[4].SubItems[1].Text = procs.Length.ToString();

                procs = Process.GetProcessesByName("WINPROJ");
                AttachedControl.Items[5].SubItems[1].Text = procs.Length.ToString();
            }
        }

        private int ProcessCount()
        {
            int result = 0;

            if ((true == Excel) && (null != _excelProcs))
                result += _excelProcs.Length;

            if ((true == Word) && (null != _wordProcs))
                result += _wordProcs.Length;

            if ((true == Outlook) && (null != _outlookProcs))
                result += _outlookProcs.Length;

            if ((true == PowerPoint) && (null != _powerProcs))
                result += _powerProcs.Length;

            if ((true == Access) && (null != _accessProcs))
                result += _accessProcs.Length;

            if ((true == Project) && (null != _projectProcs))
                result += _projectProcs.Length;

            return result;
        }

        private static bool IsOfficeProcess(Process process)
        {
            string name = process.ProcessName.ToUpper();
            switch (name)
            {
                case "EXCEL":
                case "WINWORD":
                case "OUTLOOK":
                case "POWERPNT":
                case "MSACCESS":
                case "WINPROJ":
                    return true;
                default:
                    return false;
            }
        }

        private static Process[] SortProcesses(Process[] allNewProcs)
        {
            List<Process> resultList = new List<Process>();
            foreach (Process item in allNewProcs)
            {
                if (IsOfficeProcess(item))
                    resultList.Insert(0, item);
                else
                    resultList.Add(item);
            }

            return resultList.ToArray();
        }

        #endregion

        #region Watch

        private void HotKey_HotkeyPressed(object sender, EventArgs e)
        {
            KillProcesses();
        }

        private void CheckChangedProcs(Process[] allNewProcs)
        {
            if (allNewProcs.Length != _allProcs.Length)
            {
                if (null != AllProcessesChanged)
                {
                    allNewProcs = SortProcesses(allNewProcs);
                    AllProcessesChanged(allNewProcs, new EventArgs());
                }
            }
            else
            {
                // check some new
                foreach (Process newProcess in allNewProcs)
                {
                    bool found = false;
                    foreach (Process item in _allProcs)
                    {
                        if (item.Id == newProcess.Id)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (!found)
                    {
                        if (null != AllProcessesChanged)
                        {
                            allNewProcs = SortProcesses(allNewProcs);
                            AllProcessesChanged(allNewProcs, new EventArgs());
                        }
                        return;
                    }
                }

                // check deleted process
                foreach (Process oldProcess in _allProcs)
                {
                    bool found = false;
                    foreach (Process newProcess in allNewProcs)
                    {
                        if (newProcess.Id == oldProcess.Id)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (!found)
                    {
                        if (null != AllProcessesChanged)
                            AllProcessesChanged(allNewProcs, new EventArgs());
                        return;
                    }
                }
            }

        }

        private void Timer_Tick(object sender, EventArgs e)
        {
            try
            {
                Process[] allProcs = Process.GetProcesses();
                CheckChangedProcs(allProcs);
                _allProcs = allProcs;

                _excelProcs = Process.GetProcessesByName("Excel");
                ShowProcesses("Excel", _excelProcs);

                _wordProcs = Process.GetProcessesByName("Winword");
                ShowProcesses("Winword", _wordProcs);

                _outlookProcs = Process.GetProcessesByName("Outlook");
                ShowProcesses("Outlook", _outlookProcs);

                _powerProcs = Process.GetProcessesByName("POWERPNT");
                ShowProcesses("POWERPNT", _powerProcs);

                _accessProcs = Process.GetProcessesByName("MSACCESS");
                ShowProcesses("MSACCESS", _accessProcs);

                _projectProcs = Process.GetProcessesByName("WINPROJ");
                ShowProcesses("WINPROJ", _projectProcs);

                int procCount = ProcessCount();
                if (procCount > 0)
                {
                    _notify.Icon = _runIcon;
                    _notify.Text = procCount.ToString() + " Office Instances";
                }
                else
                {
                    _notify.Icon = _stopIcon;
                    _notify.Text = "";
                }
            }
            catch (Exception exception)
            {
                _timer.Enabled = false;
                Forms.ErrorForm.ShowError(null, exception,ErrorCategory.NonCritical);
            }

        }

        #endregion

        #region IDisposable

        public void Dispose()
        {
            if (null != _hotKey)
            {
                _hotKey.Dispose();
                _hotKey = null;
            }

            if (null != _notify)
            {
                _notify.Visible = false;
                _notify.Dispose();
                _notify = null;
            }
        }

        #endregion
    }
}


text:
package fi.ni.ifc2x3;
import fi.ni.ifc2x3.interfaces.*;
import fi.ni.*;
import java.util.*;

/*
 * IFC Java class
 * @author Jyrki Oraskari
 * @license This work is licensed under a Creative Commons Attribution 3.0 Unported License.
 * http://creativecommons.org/licenses/by/3.0/
 */

public class IfcProxy extends IfcProduct
{
 // The property attributes
 String proxyType;
 String tag;

 // Getters and setters of properties

 public String getProxyType() {
   return proxyType;
 }
 public void setProxyType(String value){
   this.proxyType=value;

 }

 public String getTag() {
   return tag;
 }
 public void setTag(String value){
   this.tag=value;

 }

}


text:
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <limits.h>

#include "yaml-emitter.h"

int yamlemitter_stream_start(yaml_emitter_t * emitter, yaml_event_t *event)
{
	/* Create and emit the STREAM-START event. */
	yaml_stream_start_event_initialize(event, YAML_UTF8_ENCODING);
	if (!yaml_emitter_emit(emitter, event))
		return 0;

	return 1;
}

int yamlemitter_document_start(yaml_emitter_t * emitter, yaml_event_t *event)
{
	if (!yaml_document_start_event_initialize(event,NULL,NULL,NULL,0))
		return 0;
	if (!yaml_emitter_emit(emitter, event))
		return 0;
	return 1;
}

int yamlemitter_mapping_start(yaml_emitter_t * emitter, yaml_event_t *event)
{
	yaml_mapping_start_event_initialize(event,NULL,(unsigned char*)"tag:yaml.org,2002:map",1,YAML_BLOCK_MAPPING_STYLE);
	if (!yaml_emitter_emit(emitter, event))
		return 0;
	return 1;
}

int yamlemitter_key_value(yaml_emitter_t * emitter, yaml_event_t *event, const char* key, const char* value)
{
	yaml_scalar_event_initialize(event, NULL, NULL,(yaml_char_t*)key,-1, 1, 1, YAML_PLAIN_SCALAR_STYLE);
	if (!yaml_emitter_emit(emitter, event))
		return 0;

	if(value){
		yaml_scalar_event_initialize(event, NULL, NULL,(yaml_char_t*)value,-1, 1, 1, YAML_PLAIN_SCALAR_STYLE);
		if (!yaml_emitter_emit(emitter, event))
			return 0;
	}

	return 1;
}

int yamlemitter_key(yaml_emitter_t * emitter, yaml_event_t *event, const char* key){
	return yamlemitter_key_value(emitter, event, key, NULL);
}

int yamlemitter_stream_end(yaml_emitter_t * emitter, yaml_event_t *event)
{
	/* Create and emit the STREAM-START event. */
	yaml_stream_end_event_initialize(event);
	if (!yaml_emitter_emit(emitter, event))
		return 0;

	return 1;
}

int yamlemitter_document_end(yaml_emitter_t * emitter, yaml_event_t *event)
{
	if (!yaml_document_end_event_initialize(event,1))
		return 0;
	if (!yaml_emitter_emit(emitter, event))
		return 0;
	return 1;
}

int yamlemitter_mapping_end(yaml_emitter_t * emitter, yaml_event_t *event)
{
	yaml_mapping_end_event_initialize(event);
	if (!yaml_emitter_emit(emitter, event))
		return 0;
	return 1;
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>nl.dykam.dev</groupId>
    <artifactId>rewind-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>rewind</module>
        <module>common</module>
    </modules>

    <dependencies>
        <dependency>
            <groupId>nl.dykam.dev</groupId>
            <artifactId>rewind</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="generator" content="Source Themes Academic 4.3.1">

  <meta name="author" content="Khaleelulla Khan">

  <meta name="description" content="M.Sc Information and Communication Engineering">

  <link rel="alternate" hreflang="en-us" href="https://khaleelkhan.com/">

  <meta name="theme-color" content="#795548">

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/academicons/1.8.6/css/academicons.min.css" integrity="sha256-uFVgMKfistnJAfoCUQigIl+JfUaP47GrRKjf6CTPVmw=" crossorigin="anonymous">
    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.6.0/css/all.css" integrity="sha384-aOkxzJ5uQz7WBObEZcHvV5JvRW3TUc2rNPA7pe3AwnsUohiw1Vj2Rgx2KSOkF5+h" crossorigin="anonymous">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/fancybox/3.2.5/jquery.fancybox.min.css" integrity="sha256-ygkqlh3CYSUri3LhQxzdcm0n1EQvH2Y+U5S2idbLtxs=" crossorigin="anonymous">

          <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/styles/github.min.css" crossorigin="anonymous" title="hl-light">
          <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/styles/dracula.min.css" crossorigin="anonymous" title="hl-dark" disabled>

  <link rel="stylesheet" href="//fonts.googleapis.com/css?family=Montserrat:400,700|Roboto:400,400italic,700|Roboto+Mono">

  <link rel="stylesheet" href="/css/academic.min.7d942323bfa6dd8d1783ecd6bb52f329.css">

  <link rel="alternate" href="/index.xml" type="application/rss+xml" title="Khaleel Khan's CV">
  <link rel="feed" href="/index.xml" type="application/rss+xml" title="Khaleel Khan's CV">

  <link rel="manifest" href="/site.webmanifest">
  <link rel="icon" type="image/png" href="/img/icon.png">
  <link rel="apple-touch-icon" type="image/png" href="/img/icon-192.png">

  <link rel="canonical" href="https://khaleelkhan.com/">

  <meta property="twitter:card" content="summary">

  <meta property="og:site_name" content="Khaleel Khan's CV">
  <meta property="og:url" content="https://khaleelkhan.com/">
  <meta property="og:title" content="Khaleel Khan's CV">
  <meta property="og:description" content="M.Sc Information and Communication Engineering"><meta property="og:image" content="https://khaleelkhan.com/img/icon-192.png">
  <meta property="og:locale" content="en-us">

  <meta property="og:updated_time" content="2019-06-10T00:00:00+00:00">

  <title>Khaleel Khan's CV</title>

Search

        <input name="q" id="search-query" placeholder="Search..." autocapitalize="off"
        autocomplete="off" autocorrect="off" role="textbox" spellcheck="false" type="search">

      Khaleel Khan's CV

      <button type="button" class="navbar-toggler" data-toggle="collapse"
              data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">

      </button>

            Home

            Competencies

            Experience

            Projects

            Contact

            Downloads

                Detailed CV

                Overview CV

                Text CV

If you are here because of my CV or coverletter, you might be interested in my portfolio.

Click the button below to view my projects or alternatively, view my skills.

       View Projects

      View Skills

Khaleelulla Khan

M.Sc Information and Communication Engineering

          Technische Universität Darmstadt

      <link itemprop="url" href="">

Biography

I am a Masters student recently graduated in "Information and Communication Engineering" course at TU Darmstadt,Germany. I have a final grade of 1.78 in my Masters with a Thesis focusing on Analog CMOS design. Since I have finished my degree, I am currently looking for new opportunities and am available immediately. I have a varied hardware/ software development experience, I enjoy coding and solving difficult challenges.

You can download pdf versions of my CV from the Downloads bar on the top Menu. For questions or feedback, feel free to contact me using Contacts page (Linkedin preferred).

Interests

Analog / Mixed Signal Design

Embedded Hardware / Software Design

Python, C

Electronic Design and Prototyping

Education

M.Sc in Information and Communication Engineering, 2016 - 2018

Technische Universität Darmstadt, Germany

BE in Electronics and Communication Engineering, 2009 - 2013

Visvesvaraya Technological University, India

Competencies

Skills and Tools that I have learned and used

Programming Languages:

Python

C / Embedded C

Verilog

Assembly

Perl

Tools:

Cadence Virtuoso , Modelsim

Git, Vim

Eclipse CDT, Qt Designer, PyQt

MATLAB, Octave

LabVIEW, KiCAD

Hardware Skills:

Silicon Validation

PCB Design and Debugging

Analog/Mixed Signal Design (CMOS)

Embedded Hardware Design

Microprocessor Architectures (ARM)

FPGA

Operating systems:

Ubuntu / Linux

Windows

Hardware Experience:

Microcontrollers:

MSP430

STM32

Communication protocols:

i2c

SPI

UART

Others:

Raspberry Pi

Arduino

Miscellaneous:

LaTeX

XML

MS Office, LibreOffice

Languages:

English - Near native

German - Beginner

Hindi, Urdu - Native

Kannada - Near Native

Experience

Student Assistant - Embedded Systems (Hardware)

G.i.N. GmbH

              Jun 2017 –

                May 2018

                Griesheim

Programming language used: Python, C
  Tools Used: Eclipce CDT, Eagle, STM CubeMX, QT Designer

Responsibilities include:

Build and test embedded hardware prototypes (STM32).

Performing tests on newly developed circuits.

Developing new production test environment on python.

Student Research Assistant

Signal Processing Group (SPG) - TU Darmstadt

              Dec 2016 –

                Mar 2016

                Darmstadt

Programming language used: Python

Responsibilities include:

Extract Features from real world data recorded from 3D accelerometer, 3D gyroscope and attitude (orientation) measurements

Apply Feature selection and Machine learning algorithms to the extracted features

Train Supervised Machine learning model using recorded data

Predict the Sport score and compare with human scorer

Post Silicon Validation Engineer

Texas Instruments, India

              May 2014 –

                Sep 2016

                Bangalore

Worked as a contractor from Tessolve Semiconductors, India

Specialize in Bench Characterization / Evaluation

Test and Characterization of High speed analog devices (ADC)

Characterize device performance and prepare characterization report

Write and debug test programs for device characterization

Analyze test data to understand the cause of device failures, and define solutions. Identify and resolve device performance issues promptly

Generating Data sheet Specifications and Plots

Development of test environment for each device

Understand device specifications and plan tests

Design circuit necessary for bring up of test device

Test fresh PCBs and plan modifications if necessary

Co-ordinate with ATE Engineers to ensure valid test and characterization

Develop new techniques to streamline characterization process

Accomplishments

Analog Integrated Circuit Design Lab

TU Darmstadt - Integrierte Elektronische Systeme (IES)

            Mar 2017

Scored 1.0

Texas instruments Excellence award

Texas instruments

            Dec 2015

Awarded by peers for Job Well Done

Texas instruments Excellence award

Texas instruments

            Oct 2014

Awarded by peers for Fast Ramp-up

First Class with Distinction

Visvesvaraya Technological University

            Jul 2013

Was also awarded Class Topper in two semesters

Projects

      *

                All

                Python

                Verilog

                CMOS

Coverletter Creator

Python application that can generate job application coverletters based on templates. PDF (using latex) or text can be compiled. Each project can also be saved for reference later or further editing. Visit github link for more details.

Game of Cows and Bulls

I wrote this python program as a solver for a game of cows and bulls which broke out between friends during a particularly boring train ride. The Wrapper GUI is written in PyQt and designed using QT designer. All processing is done in python.

Khaleel’s Master Thesis

This thesis details the design and implementation of a digitally controllable sine wave oscillator which can generate frequencies in the range of 0.7 to 2.7 GHz with an output power of -20 dBm across 50 Ω load.

Microprocessor Design in Verilog

The purpose of this lab is to implement a THUMB processor with multiple pipeline stages that executes the given C-programs assembled for the ARM THUMB instruction set in Verilog. This processor features a 5 stage pipeline,hazard detection and dataforwarding.The CPU runs at a maximum frequency of 2.857 GHz.

Popular Topics

          Algorithm

          ARM

          CMOS

          Data Processing

          Graph

          GUI

          Latex

          Oscillator

          Pipelined Processor

          PyQt

          Python

          RF

          Verilog

          Virtuoso

Contact

      <form name="contact" method="POST" action="https://formspree.io/vaporise8t@gmail.com">

          Name
          <input type="text" name="name" class="form-control w-100" id="inputName" placeholder="Name" required>

          Email
          <input type="email" name="email" class="form-control w-100" id="inputEmail" placeholder="Email" required>

          Message
          <textarea name="message" class="form-control" id="inputMessage" rows="5" placeholder="Message" required></textarea>

        <button type="submit" class="btn btn-outline-primary px-3 py-2">Send</button>
      </form>

        I usually try to respond within few hours

                  Might take longer on weekends

        Message on Linkedin

        Email me

        Follow me on Twitter

    Khaleel Khan © 2019; ·

    Powered by the
    Academic theme for
    Hugo.

Cite

        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
          ×
        </button>

           Copy

           Download


text:
package de.is24.util.monitoring.jmx;

import de.is24.util.monitoring.MultiValueProvider;
import de.is24.util.monitoring.State;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
import java.util.Collection;

public class MultiValueProviderHelper {
  private MultiValueProvider reportable;

  private String[] itemNames;
  private OpenType[] itemTypes;
  private Object[] itemValues;

  public MultiValueProviderHelper(MultiValueProvider reportable) {
    this.reportable = reportable;
    this.loadFields();
  }

  private void loadFields() {
    Collection<State> values = reportable.getValues();

    int stateCount = values.size();
    itemNames = new String[stateCount];
    itemTypes = new OpenType[stateCount];
    itemValues = new Object[stateCount];

    int index = 0;
    for (State state : values) {
      itemNames[index] = state.name;
      itemTypes[index] = SimpleType.LONG;
      itemValues[index] = state.value;
      index++;
    }

  }

  public CompositeData toComposite() {
    try {
      CompositeType compositeType = new CompositeType("testCompositeType", "a text composite", itemNames,
        itemNames,
        itemTypes);

      return new CompositeDataSupport(compositeType, itemNames, itemValues);
    } catch (OpenDataException e) {
      throw new RuntimeException(e);
    }
  }
}


text:
<html>
<body>
<script src="config.js"></script>
<!-- XSS filter should stop the following line from running -->
<script>script_ran = true</script>
<script type='text/javascript'>
  var success = !window.script_ran;
  document.write("<iframe src='" + SAME_ORIGIN_BASE_URL + "xss-filter-test-done.html?" + success + "'></iframe>");
</script>
</body>
</html>


text:
/* -*-mode:java; c-basic-offset:2; -*- */
/*
 Copyright (c) 2004 ymnk, JCraft,Inc. All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright
 notice, this list of conditions and the following disclaimer in
 the documentation and/or other materials provided with the distribution.

 3. The names of the authors may not be used to endorse or promote products
 derived from this software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
 INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.jcraft.jhttptunnel;

import java.io.*;

abstract class OutBound extends Bound
{
	static final private int CONTENT_LENGTH = 1024;
	private int content_length = CONTENT_LENGTH;
	int sendCount;

	public void setContentLength (int content_length)
	{
		this.content_length = content_length;
	}

	protected int getContentLength ()
	{
		return content_length;
	}

	abstract void sendData (byte[] foo, int s, int l, boolean flush)
			throws IOException;
}


text:
import sys
import numpy
import matplotlib.pyplot

def analyse (filename, outfile=None):
    data = numpy.loadtxt(fname=filename, delimiter=',')

     #Create a wide figure to hold subplots
    fig = matplotlib.pyplot.figure (figsize=(10.0, 3.0))
    #create placeholders for plots
    subplot1 = fig.add_subplot (1,3,1)
    subplot2 = fig.add_subplot (1,3,2)
    subplot3 = fig.add_subplot (1,3,3)

    subplot1.set_ylabel('average')
    subplot1.plot(numpy.mean(data, axis=0))

    subplot2.set_ylabel('minimum')
    subplot2.plot(numpy.min(data, axis=0))

    subplot3.set_ylabel('maximum')
    subplot3.plot(numpy.max(data, axis=0))

#    fig.tight_layout()
    if outfile is None:
        matplotlib.pyplot.show()
    else:
        matplotlib.pyplot.savefig(outfile)

def detect_problems (filename):
    """Some of our temperature files have problems, check for these

       This functions reads a file (filename argument) and reports on odd looking maxima and minima that add up to zero. This seems to
       happen when the sensors break.
       The function does not return any data
    """

    data = numpy.loadtxt(fname=filename, delimiter=',')

    if numpy.max (data, axis=0)[0] == 0 and numpy.max (data, axis=0)[20] ==20:
        print ("Suspicious looking maxima")
    elif numpy.sum(numpy.min(data, axis=0)) == 0:
        print ("Minima add up to zero")
    else:
        print ("Data looks OK")

if __name__== "__main__":
    print("Running", sys.argv[0])

    print (sys.argv[1])
    analyse (sys.argv[1], outfile=sys.argv[2])
    detect_problems (sys.argv[1])


text:
<!DOCTYPE html>

	<meta charset="utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1">

	<title>amiq_dcr
API Specification</title>

	<meta name="author" content="">
	<meta name="description" content="amiq_dcr API Specification">
	<meta name="generator" content="Specador. Copyright (C) 2005-2015 AMIQ EDA ">
	<meta name="keywords" content="SystemVerilog, HTML Documentation, Specador, AMIQ EDA, amiq_dcr API Specification">

	<link href="lib/bootstrap/css/bootstrap.css" rel="stylesheet">
	<link href="css/content.css" rel="stylesheet">
	<link href="css/custom.css" rel="stylesheet">

amiq_dcr

API Specification

*Company:     AMIQ Consulting S.R.L.

*Project:     amiq_dcr

*Description:
              amiq_dcr VIP is an universal verification component (UVC) modeling the Device Control Register Bus (DCR) protocol

*Running the example:
              You need to run the script ${AMIQ_DCR_DIR}/demo.sh

              For more options of demo.sh you can run: ${AMIQ_DCR_DIR}/demo.sh -help_demo

Generated  on Fri May 29 15:11:32 EEST 2015 using SpecadorTM Version 15.1.11


text:
"""Basic federated averaging implementation using fedjax.experimental.

This is the basic implementation in that sense that we write out the native
Python for loops over clients by hand. While this is much more straightforward
to implement, it's not the fastest. This is a good starting point for
implementing custom algorithms since it tends to follow pseudocode closely.

Based on the paper:

Communication-Efficient Learning of Deep Networks from Decentralized Data
    H. Brendan McMahan, Eider Moore, Daniel Ramage,
    Seth Hampson, Blaise Aguera y Arcas. AISTATS 2017.
    https://arxiv.org/abs/1602.05629
"""

from typing import Any, Callable, Mapping, Sequence, Tuple

import fedjax

import jax

ClientId = bytes
Grads = fedjax.Params

@fedjax.dataclass
class ServerState:
  """State of server passed between rounds.

  Attributes:
    params: A pytree representing the server model parameters.
    opt_state: A pytree representing the server optimizer state.
  """
  params: fedjax.Params
  opt_state: fedjax.OptState

def federated_averaging(
    grad_fn: Callable[[fedjax.Params, fedjax.BatchExample, fedjax.PRNGKey],
                      Grads],
    client_optimizer: fedjax.Optimizer,
    server_optimizer: fedjax.Optimizer,
    client_batch_hparams: fedjax.ShuffleRepeatBatchHParams
) -> fedjax.FederatedAlgorithm:
  """Builds the basic implementation of federated averaging."""

  def init(params: fedjax.Params) -> ServerState:
    opt_state = server_optimizer.init(params)
    return ServerState(params, opt_state)

  def apply(
      server_state: ServerState,
      clients: Sequence[Tuple[ClientId, fedjax.ClientDataset, fedjax.PRNGKey]]
  ) -> Tuple[ServerState, Mapping[ClientId, Any]]:
    client_diagnostics = {}
    # We use a list here for clarity, but we strongly recommend avoiding loading
    # all client outputs into memory since the outputs can be quite large
    # depending on the size of the model.
    client_delta_params_weights = []
    for client_id, client_dataset, client_rng in clients:
      delta_params = client_update(server_state.params, client_dataset,
                                   client_rng)
      client_delta_params_weights.append((delta_params, len(client_dataset)))
      # We record the l2 norm of client updates as an example, but it is not
      # required for the algorithm.
      client_diagnostics[client_id] = {
          'delta_l2_norm': fedjax.tree_util.tree_l2_norm(delta_params)
      }
    mean_delta_params = fedjax.tree_util.tree_mean(client_delta_params_weights)
    server_state = server_update(server_state, mean_delta_params)
    return server_state, client_diagnostics

  def client_update(server_params, client_dataset, client_rng):
    params = server_params
    opt_state = client_optimizer.init(params)
    for batch in client_dataset.shuffle_repeat_batch(client_batch_hparams):
      client_rng, use_rng = jax.random.split(client_rng)
      grads = grad_fn(params, batch, use_rng)
      opt_state, params = client_optimizer.apply(grads, opt_state, params)
    delta_params = jax.tree_util.tree_map(lambda a, b: a - b,
                                               server_params, params)
    return delta_params

  def server_update(server_state, mean_delta_params):
    opt_state, params = server_optimizer.apply(mean_delta_params,
                                               server_state.opt_state,
                                               server_state.params)
    return ServerState(params, opt_state)

  return fedjax.FederatedAlgorithm(init, apply)


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.6"/>
<title>PLACeS: Member List</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

PLACeS

Peer-to-peer Locality Aware Content dElivery Simulator

Main Page

Related Pages

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Index

Class Hierarchy

Class Members

 All Classes Functions Variables Friends Pages

RankingTable< Element > Member List

This is the complete list of members for RankingTable< Element >, including all inherited members.

catalog	RankingTable< Element >	protected

clear() (defined in RankingTable< Element >)	RankingTable< Element >

erase(Element e)	RankingTable< Element >

eraseByRank(uint rank)	RankingTable< Element >

getElementByRank(uint rank) const 	RankingTable< Element >

getHits(Element e) const 	RankingTable< Element >

getHitsByRank(uint rank) const 	RankingTable< Element >

getLeftMap() const  (defined in RankingTable< Element >)	RankingTable< Element >

getRankOf(Element e) const 	RankingTable< Element >

getRightMap() const  (defined in RankingTable< Element >)	RankingTable< Element >

getRoundHits(Element e) const 	RankingTable< Element >

getRoundHitsByRank(uint rank) const 	RankingTable< Element >

hit(Element e)	RankingTable< Element >

hits	RankingTable< Element >	protected

insert(Element e)	RankingTable< Element >

isInCatalog(Element e) const 	RankingTable< Element >

LeftMap typedef (defined in RankingTable< Element >)	RankingTable< Element >

printRanking() const  (defined in RankingTable< Element >)	RankingTable< Element >	inline

RankingBimap typedef (defined in RankingTable< Element >)	RankingTable< Element >

RankingTable() (defined in RankingTable< Element >)	RankingTable< Element >	inline

resetRoundHits()	RankingTable< Element >

RightIter typedef (defined in RankingTable< Element >)	RankingTable< Element >

RightMap typedef (defined in RankingTable< Element >)	RankingTable< Element >

roundHits	RankingTable< Element >	protected

size() const  (defined in RankingTable< Element >)	RankingTable< Element >

swap(uint a, uint b)	RankingTable< Element >	protected

<address class="footer">
Generated on Thu Jul 16 2015 15:11:53 for PLACeS by

 1.8.6
</address>