text:
#ifndef CARYLL_SUPPORT_JSON_FUNCS_H
#define CARYLL_SUPPORT_JSON_FUNCS_H

#include <stdint.h>
#include <math.h>

#include "dep/json-builder.h"
#include "dep/json.h"
#include "dep/sds.h"

#include "caryll/ownership.h"
#include "otfcc/primitives.h"
#include "otfcc/vf/vq.h"
#include "otfcc/table/fvar.h"

#ifndef INLINE
#ifdef _MSC_VER
#define INLINE __forceinline /* use __forceinline (VC++ specific) */
#else
#define INLINE inline /* use standard inline */
#endif
#endif

static INLINE json_value *preserialize(MOVE json_value *x);

static INLINE json_value *json_obj_get(const json_value *obj, const char *key) {
	if (!obj || obj->type != json_object) return NULL;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		if (strcmp(ck, key) == 0) return obj->u.object.values[_k].value;
	}
	return NULL;
}
static INLINE json_value *json_obj_get_type(const json_value *obj, const char *key,
                                            const json_type type) {
	json_value *v = json_obj_get(obj, key);
	if (v && v->type == type) return v;
	return NULL;
}
static INLINE sds json_obj_getsds(const json_value *obj, const char *key) {
	json_value *v = json_obj_get_type(obj, key, json_string);
	if (!v)
		return NULL;
	else
		return sdsnewlen(v->u.string.ptr, v->u.string.length);
}
static INLINE char *json_obj_getstr_share(const json_value *obj, const char *key) {
	json_value *v = json_obj_get_type(obj, key, json_string);
	if (!v)
		return NULL;
	else
		return v->u.string.ptr;
}

static INLINE json_value *json_object_push_tag(json_value *a, uint32_t tag, json_value *b) {
	char tags[4] = {(tag & 0xff000000) >> 24, (tag & 0xff0000) >> 16, (tag & 0xff00) >> 8,
	                (tag & 0xff)};
	return json_object_push_length(a, 4, tags, b);
}

// Coordinates, VV and VQ
static INLINE double json_numof(const json_value *cv) {
	if (cv && cv->type == json_integer) return cv->u.integer;
	if (cv && cv->type == json_double) return cv->u.dbl;
	return 0;
}
static INLINE json_value *json_new_position(pos_t z) {
	if (round(z) == z) {
		return json_integer_new(z);
	} else {
		return json_double_new(z);
	}
}
json_value *json_new_VQRegion_Explicit(const vq_Region *rs, const table_fvar *fvar);
json_value *json_new_VQRegion(const vq_Region *rs, const table_fvar *fvar);
json_value *json_new_VQ(const VQ z, const table_fvar *fvar);
json_value *json_new_VV(const VV x, const table_fvar *fvar);
json_value *json_new_VVp(const VV *x, const table_fvar *fvar);
VQ json_vqOf(const json_value *cv, const table_fvar *fvar);

static INLINE double json_obj_getnum(const json_value *obj, const char *key) {
	if (!obj || obj->type != json_object) return 0.0;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_integer) return cv->u.integer;
			if (cv && cv->type == json_double) return cv->u.dbl;
		}
	}
	return 0.0;
}
static INLINE int32_t json_obj_getint(const json_value *obj, const char *key) {
	if (!obj || obj->type != json_object) return 0;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_integer) return (int32_t)cv->u.integer;
			if (cv && cv->type == json_double) return cv->u.dbl;
		}
	}
	return 0;
}
static INLINE double json_obj_getnum_fallback(const json_value *obj, const char *key,
                                              double fallback) {
	if (!obj || obj->type != json_object) return fallback;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_integer) return cv->u.integer;
			if (cv && cv->type == json_double) return cv->u.dbl;
		}
	}
	return fallback;
}
static INLINE int32_t json_obj_getint_fallback(const json_value *obj, const char *key,
                                               int32_t fallback) {
	if (!obj || obj->type != json_object) return fallback;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_integer) return (int32_t)cv->u.integer;
			if (cv && cv->type == json_double) return cv->u.dbl;
		}
	}
	return fallback;
}
static INLINE bool json_boolof(const json_value *cv) {
	if (cv && cv->type == json_boolean) return cv->u.boolean;
	return false;
}
static INLINE bool json_obj_getbool(const json_value *obj, const char *key) {
	if (!obj || obj->type != json_object) return false;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_boolean) return cv->u.boolean;
		}
	}
	return false;
}
static INLINE bool json_obj_getbool_fallback(const json_value *obj, const char *key,
                                             bool fallback) {
	if (!obj || obj->type != json_object) return fallback;
	for (uint32_t _k = 0; _k < obj->u.object.length; _k++) {
		char *ck = obj->u.object.values[_k].name;
		json_value *cv = obj->u.object.values[_k].value;
		if (strcmp(ck, key) == 0) {
			if (cv && cv->type == json_boolean) return cv->u.boolean;
		}
	}
	return fallback;
}

static INLINE json_value *json_from_sds(const sds str) {
	return json_string_new_length((uint32_t)sdslen(str), str);
}

// flags reader and writer
static INLINE json_value *otfcc_dump_flags(int flags, const char *labels[]) {
	json_value *v = json_object_new(0);
	for (uint16_t j = 0; labels[j]; j++)
		if (flags & (1 << j)) { json_object_push(v, labels[j], json_boolean_new(true)); }
	return v;
}
static INLINE uint32_t otfcc_parse_flags(const json_value *v, const char *labels[]) {
	if (!v) return 0;
	if (v->type == json_integer) {
		return (uint32_t)v->u.integer;
	} else if (v->type == json_double) {
		return (uint32_t)v->u.dbl;
	} else if (v->type == json_object) {
		uint32_t flags = 0;
		for (uint16_t j = 0; labels[j]; j++) {
			if (json_obj_getbool(v, labels[j])) { flags |= (1 << j); }
		}
		return flags;
	} else {
		return 0;
	}
}

static INLINE json_value *preserialize(MOVE json_value *x) {
#ifdef CARYLL_USE_PRE_SERIALIZED
	json_serialize_opts opts = {.mode = json_serialize_mode_packed};
	size_t preserialize_len = json_measure_ex(x, opts);
	char *buf = (char *)malloc(preserialize_len);
	json_serialize_ex(buf, x, opts);
	json_builder_free(x);

	json_value *xx = json_string_new_nocopy((uint32_t)(preserialize_len - 1), buf);
	xx->type = json_pre_serialized;
	return xx;
#else
	return x;
#endif
}

#endif


text:
/**
 * AST node for function application.
 *
 * Also contains pointer to declaration location of the function.
 */
class Tfun extends Texp implements AST {
  Tident ident;                       // name of the function
  Texplist explist;                   // parameter list

  public Tfun(Tident i, Texplist e) {
    ident=i;
    explist=e;
  }

  public String toString() {
    return ident+"("+explist+")";
  }

  public void checkcontext(SymTab st) { // CoCo (DefFun,Arity)
    explist.checkcontext(st);
    SymtabEntry ste = st.lookup(ident.toString());
    if (ste==null)
      Main.error("function not defined: "+ident);
    else if (ste.kind() != SymtabEntry.FUN)
      Main.error("variable used as funktion: "+ident);
    else if (((STEfun)ste).arity() != explist.length())
      Main.error("wrong arity at function call: "+ident);
  }

  Tdekl fundekl;              // pointer to location of function declaration

  // set pointers and indices
  public void prepInterp(SymTab st) {
    fundekl = ((STEfun)st.lookup(ident.toString())).getDekl();
    explist.prepInterp(st);
  }

  public int interpret(int[] in, int[] par) {
    int[] newparams = new int[fundekl.arity()];
    explist.interpret(in,par,newparams,0);
    return fundekl.interpret(in,newparams);
  }
}

redpajama_set_name: RedPajamaGithub


text:
package sh.isaac.api.util;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * This class exists solely to work around a bug in the JDK implementation that breaks the exception handling contracts
 * of the Future get() methods.
 *
 * https://github.com/darmbrust/OracleBugs/blob/master/src/RunTest2.java
 *
 * @author Dan Armbrust
 */
public class ThreadPoolExecutorFixed extends ThreadPoolExecutor
{

	/**
	 * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue)}
	 */
	public ThreadPoolExecutorFixed(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
	{
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
	}

	/**
	 * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, RejectedExecutionHandler)}
	 */
	public ThreadPoolExecutorFixed(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
			RejectedExecutionHandler handler)
	{
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
	}

	/**
	 * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory)}
	 */
	public ThreadPoolExecutorFixed(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
			ThreadFactory threadFactory)
	{
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
	}

	/**
	 * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory, RejectedExecutionHandler)}
	 */
	public ThreadPoolExecutorFixed(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
			ThreadFactory threadFactory, RejectedExecutionHandler handler)
	{
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
	}

	@Override
	protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value)
	{
		if (runnable instanceof FutureTask)
		{
			//Don't wrap, cause the wrapper doesn't handle exceptions properly
			return (FutureTask<T>)runnable;
		}
		else
		{
			return super.newTaskFor(runnable, value);
		}
	}

	@Override
	protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable)
	{
		if (callable instanceof FutureTask)
		{
			//Don't wrap, cause the wrapper doesn't handle exceptions properly
			return (FutureTask<T>)callable;
		}
		else
		{
			return super.newTaskFor(callable);
		}
	}
}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycotaxon 29: 94 (1987)

#### Original name
Rhizoctonia cerealis E.P. Hoeven, 1977

### Remarks
null


text:
package com.zappos.json.data;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.zappos.json.ZapposJson;
import com.zappos.json.annot.JsonFormat;
import com.zappos.json.format.AbstractValueFormatter;
import com.zappos.json.format.ValueFormatter;

/**
 *
 * @author Hussachai Puripunpinyo
 *
 */
public class JsonFormatBean {

  public static class CustomDateFormatter extends AbstractValueFormatter<Date>{
    public static final String FIXED_DATE_STRING = "1998-01-01";
    public static final Date FIXED_DATE;
    static{
      try {
        FIXED_DATE = new SimpleDateFormat("yyyy-MM-dd").parse(FIXED_DATE_STRING);
      } catch (ParseException e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    public Date cast(Object obj) {
      return Date.class.cast(obj);
    }

    @Override
    public String format(ZapposJson zapposJson, Date object) {
      if(getPattern() != null){
        return toJsonValue(zapposJson, new SimpleDateFormat(getPattern()).format(object));
      }
      return toJsonValue(zapposJson, FIXED_DATE_STRING);
    }

    @Override
    public Date parse(ZapposJson zapposJson, String string) throws Exception {
      if(getPattern() != null){
        return new SimpleDateFormat(getPattern()).parse(string);
      }
      return FIXED_DATE;
    }

    @Override
    public ValueFormatter<Date> newInstance() {
      return new CustomDateFormatter();
    }

  }

  @JsonFormat("yyyy-MM-dd")
  private Date date = new Date();

  @JsonFormat(formatter=CustomDateFormatter.class)
  private Date fixedDate = new Date();

  @JsonFormat(value = "dd MMM yyyy", formatter = CustomDateFormatter.class)
  private Date date2 = new Date();

  public Date getDate() {
    return date;
  }

  public void setDate(Date date) {
    this.date = date;
  }

  public Date getFixedDate() {
    return fixedDate;
  }

  public void setFixedDate(Date fixedDate) {
    this.fixedDate = fixedDate;
  }

  public Date getDate2() {
    return date2;
  }

  public void setDate2(Date date2) {
    this.date2 = date2;
  }

}


text:
package org.apache.ibatis.type;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @author Clinton Begin
 */
public interface TypeHandler<T> {

  void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  T getResult(ResultSet rs, String columnName) throws SQLException;

  T getResult(ResultSet rs, int columnIndex) throws SQLException;

  T getResult(CallableStatement cs, int columnIndex) throws SQLException;

}


text:
using Hyperledger.Indy.Utils;
using System;
using System.Threading.Tasks;
using static Hyperledger.Indy.PoolApi.NativeMethods;
#if __IOS__
using ObjCRuntime;
#endif

namespace Hyperledger.Indy.PoolApi
{
    ///
    /// Represents a connection to a pool of ledger nodes and provides static methods for managing
    /// connections to pools.
    ///
    public sealed class Pool : IDisposable
    {
        ///
        /// Callback to use when a pool open command has completed.
        ///
#if __IOS__
        [MonoPInvokeCallback(typeof(OpenPoolLedgerCompletedDelegate))]
#endif
        private static void OpenPoolLedgerCallbackMethod(int command_handle, int err, int pool_handle)
        {
            var taskCompletionSource = PendingCommands.Remove<Pool>(command_handle);

            if (!CallbackHelper.CheckCallback(taskCompletionSource, err))
                return;

            taskCompletionSource.SetResult(new Pool(pool_handle));
        }
        private static OpenPoolLedgerCompletedDelegate OpenPoolLedgerCallback = OpenPoolLedgerCallbackMethod;

        ///
        /// Callback to use when list pools command has completed.
        ///
#if __IOS__
        [MonoPInvokeCallback(typeof(ListPoolsCompletedDelegate))]
#endif
        private static void ListPoolsCallbackMethod(int command_handle, int err, string pools)
        {
            var taskCompletionSource = PendingCommands.Remove<string>(command_handle);

            if (!CallbackHelper.CheckCallback(taskCompletionSource, err))
                return;

            taskCompletionSource.SetResult(pools);
        }
        private static ListPoolsCompletedDelegate ListPoolsCallback = ListPoolsCallbackMethod;

        ///
        /// Creates a new local pool configuration with the specified name that can be used later to open a connection to
        /// pool nodes.
        ///
        /// <remarks>
        /// <para>
        /// If the configuration specified in the <paramref name="config"/> parameter is null then the
        /// default configuration will be used, however if specified the value should adhere to the following
        /// JSON format:
        ///
        /// {
        ///     "genesis_txn": "path/to/genesis/transaction/file"
        /// }
        ///
        /// If the value of the <c>genesis_txn</c> key in the JSON is null then a default file will be
        /// used.  If the file specified does not exist it will be created.
        /// </para>
        /// </remarks>
        /// <seealso cref="OpenPoolLedgerAsync(string, string)"/>
        /// <seealso cref="DeletePoolLedgerConfigAsync(string)"/>
        /// <param name="configName">The name for the configuration.</param>
        /// <param name="config">Pool configuration json. if NULL, then default config will be used. Example:
        /// {
        ///     "genesis_txn": string (optional), A path to genesis transaction file. If NULL, then a default one will be used.
        ///                    If file doesn't exists default one will be created.
        /// }</param>
        /// <returns>An asynchronous <see cref="Task{T}"/> with no return value that completes when
        /// the configuration is created.</returns>
        public static Task CreatePoolLedgerConfigAsync(string configName, string config)
        {
            ParamGuard.NotNullOrWhiteSpace(configName, "configName");

            var taskCompletionSource = new TaskCompletionSource<bool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_create_pool_ledger_config(
                commandHandle,
                configName,
                config,
                CallbackHelper.TaskCompletingNoValueCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Deletes an existing pool configuration.
        ///
        /// <seealso cref="CreatePoolLedgerConfigAsync(string, string)"/>
        /// <param name="configName">The name of the configuration to delete.</param>
        /// <returns>An asynchronous <see cref="Task{T}"/> with no return value that completes when
        /// the configuration is deleted.</returns>
        public static Task DeletePoolLedgerConfigAsync(string configName)
        {
            ParamGuard.NotNullOrWhiteSpace(configName, "configName");

            var taskCompletionSource = new TaskCompletionSource<bool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_delete_pool_ledger_config(
                commandHandle,
                configName,
                CallbackHelper.TaskCompletingNoValueCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Opens a pool and connects to the ledger nodes.
        ///
        /// <remarks>
        /// A Pool cannot be opened unless the a pool configuration with the specified name was previously
        /// configured using the <see cref="CreatePoolLedgerConfigAsync(string, string)"/> method.
        ///
        /// When opening a pool the runtime configuration can be specified using the <paramref name="config"/>
        /// parameter, which expects a JSON string with the following format:
        ///
        ///
        /// {
        ///     "refresh_on_open": bool (optional), Forces pool ledger to be refreshed immediately after opening.
        ///                      Defaults to true.
        ///     "auto_refresh_time": int (optional), After this time in minutes pool ledger will be automatically refreshed.
        ///                        Use 0 to disable automatic refresh. Defaults to 24*60.
        ///     "network_timeout": int (optional), Network timeout for communication with nodes in milliseconds.
        ///                       Defaults to 20000.
        /// }
        ///
        ///
        /// If the <paramref name="config"/> parameter is null then the default configuration will be used.
        ///
        /// <note type="note">Attempting to open a pool with the same name more than once will result in an error.</note>
        /// </remarks>
        /// <param name="configName">The name of the pool configuration to use.</param>
        /// <param name="config">The runtime configuration to use.</param>
        /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a Pool instance once the pool is opened.</returns>
        public static Task<Pool> OpenPoolLedgerAsync(string configName, string config)
        {
            ParamGuard.NotNullOrWhiteSpace(configName, "configName");

            var taskCompletionSource = new TaskCompletionSource<Pool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_open_pool_ledger(
                commandHandle,
                configName,
                config,
                OpenPoolLedgerCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Lists names of created pool ledgers
        ///
        /// <returns>The pools json.</returns>
        public static Task<string> ListPoolsAsync()
        {
            var taskCompletionSource = new TaskCompletionSource<string>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_list_pools(
                commandHandle,
                ListPoolsCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Whether or not the close function has been called.
        ///
        private bool _requiresClose = false;

        ///
        /// Gets the handle for the pool.
        ///
        internal int Handle { get; }

        ///
        /// Initializes a new Pool instance with the specified handle.
        ///
        /// <param name="handle">The handle of the underlying unmanaged pool.</param>
        private Pool(int handle)
        {
            Handle = handle;
            _requiresClose = true;
        }

        ///
        /// Refreshes a local copy of the pool and updates the pool's node connections.
        ///
        /// <returns>An asynchronous <see cref="Task"/> that completes when the operation completes.</returns>
        public Task RefreshAsync()
        {
            var taskCompletionSource = new TaskCompletionSource<bool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_refresh_pool_ledger(
                commandHandle,
                Handle,
                CallbackHelper.TaskCompletingNoValueCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Closes the pool.
        ///
        /// <remarks>
        /// <note type="note">Once a Pool instance is closed it cannot be opened again.  Instead call the
        /// <see cref="OpenPoolLedgerAsync(string, string)"/> method to open a new Pool instance.</note>
        /// </remarks>
        /// <returns>An asynchronous <see cref="Task"/> that completes when the operation completes.</returns>
        public Task CloseAsync()
        {
            _requiresClose = false;

            var taskCompletionSource = new TaskCompletionSource<bool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_close_pool_ledger(
                commandHandle,
                Handle,
                CallbackHelper.TaskCompletingNoValueCallback
                );

            CallbackHelper.CheckResult(result);

            GC.SuppressFinalize(this);

            return taskCompletionSource.Task;
        }

        ///
        /// Set PROTOCOL_VERSION to specific version.
        ///
        /// There is a global property PROTOCOL_VERSION that used in every request to the pool and
        /// specified version of Indy Node which Libindy works.
        ///
        /// By default PROTOCOL_VERSION=1.
        ///
        /// <param name="protocolVersion">Protocol version will be used:
        /// <c>
        ///     1 - for Indy Node 1.3
        ///     2 - for Indy Node 1.4 and greater
        /// </c></param>
        public static Task SetProtocolVersionAsync(int protocolVersion)
        {
            var taskCompletionSource = new TaskCompletionSource<bool>();
            var commandHandle = PendingCommands.Add(taskCompletionSource);

            var result = NativeMethods.indy_set_protocol_version(
                commandHandle,
                protocolVersion,
                CallbackHelper.TaskCompletingNoValueCallback
                );

            CallbackHelper.CheckResult(result);

            return taskCompletionSource.Task;
        }

        ///
        /// Disposes of resources.
        ///
        public async void Dispose()
        {
            if (_requiresClose)
                await CloseAsync();
        }

        ///
        /// Finalizes the resource during GC if it hasn't been already.
        ///
        ~Pool()
        {
            if (_requiresClose)
            {
                NativeMethods.indy_close_pool_ledger(
                   -1,
                   Handle,
                   CallbackHelper.NoValueCallback
                );
            }
        }
    }
}


text:
from storjreports import send_storj_reports
from storjreports import register_server

def run_reports():
    send_storj_reports.main()

def register():
    register_server.gather_information()


text:
/* stb_ds.h - v0.4 - public domain data structures - Sean Barrett 2019

   This is a single-header-file library that provides easy-to-use
   dynamic arrays and hash tables for C (also works in C++).

   For a gentle introduction:
      http://nothings.org/stb_ds

   To use this library, do this in *one* C or C++ file:
      #define STB_DS_IMPLEMENTATION
      #include "stb_ds.h"

TABLE OF CONTENTS

  Table of Contents
  Compile-time options
  License
  Documentation
  Notes
  Credits

COMPILE-TIME OPTIONS

  #define STBDS_NO_SHORT_NAMES

     This flag needs to be set globally.

     By default stb_ds exposes shorter function names that are not qualified
     with the "stbds_" prefix. If these names conflict with the names in your
     code, define this flag.

  #define STBDS_SIPHASH_2_4

     This flag only needs to be set in the file containing #define STB_DS_IMPLEMENTATION.

     By default stb_ds.h hashes using a weaker variant of SipHash and a custom hash for
     4- and 8-byte keys. On 64-bit platforms, you can define the above flag to force
     stb_ds.h to use specification-compliant SipHash-2-4 for all keys. Doing so makes
     hash table insertion about 20% slower on 4- and 8-byte keys, 5% slower on
     64-byte keys, and 10% slower on 256-byte keys on my test computer.

LICENSE

  Placed in the public domain and also MIT licensed.
  See end of file for detailed license information.

DOCUMENTATION

  Dynamic Arrays

    Non-function interface:

      Declare an empty dynamic array of type T
        T* foo = NULL;

      Access the i'th item of a dynamic array 'foo' of type T, T* foo:
        foo[i]

    Functions (actually macros)

      arrfree:
        void arrfree(T*);
          Frees the array.

      arrlen:
        ptrdiff_t arrlen(T*);
          Returns the number of elements in the array.

      arrlenu:
        size_t arrlenu(T*);
          Returns the number of elements in the array as an unsigned type.

      arrpop:
        T arrpop(T* a)
          Removes the final element of the array and returns it.

      arrput:
        T arrput(T* a, T b);
          Appends the item b to the end of array a. Returns b.

      arrins:
        T arrins(T* a, int p, T b);
          Inserts the item b into the middle of array a, into a[p],
          moving the rest of the array over. Returns b.

      arrinsn:
        void arrins(T* a, int p, int n);
          Inserts n uninitialized items into array a starting at a[p],
          moving the rest of the array over.

      arrdel:
        void arrdel(T* a, int p);
          Deletes the element at a[p], moving the rest of the array over.

      arrdeln:
        void arrdel(T* a, int p, int n);
          Deletes n elements starting at a[p], moving the rest of the array over.

      arrdelswap:
        void arrdelswap(T* a, int p);
          Deletes the element at a[p], replacing it with the element from
          the end of the array. O(1) performance.

      arrsetlen:
        void arrsetlen(T* a, int n);
          Changes the length of the array to n. Allocates uninitialized
          slots at the end if necessary.

      arrsetcap:
        size_t arrsetcap(T* a, int n);
          Sets the length of allocated storage to at least n. It will not
          change the length of the array.

      arrcap:
        size_t arrcap(T* a);
          Returns the number of total elements the array can contain without
          needing to be reallocated.

NOTES

  * These data structures are realloc'd when they grow, and the macro "functions"
    write to the provided pointer. This means: (a) the pointer must be an lvalue,
    and (b) the pointer to the data structure is not stable, and you must maintain
    it the same as you would a realloc'd pointer. For example, if you pass a pointer
    to a dynamic array to a function which updates it, the function must return
    back the new pointer to the caller. This is the price of trying to do this in C.

  * You iterate over the contents of a dynamic array and a hashmap in exactly
    the same way, using arrlen/hmlen/shlen:

      for (i=0; i < arrlen(foo); ++i)
         ... foo[i] ...

  * All operations except arrins/arrdel are O(1) amortized, but individual
    operations can be slow, so these data structures may not be suitable
    for real time use. Dynamic arrays double in capacity as needed, so
    elements are copied an average of once. Hash tables double/halve
    their size as needed, with appropriate hysteresis to maintain O(1)
    performance.

NOTES - DYNAMIC ARRAY

  * If you know how long a dynamic array is going to be in advance, you can avoid
    extra memory allocations by using arrsetlen to allocate it to that length in
    advance and use foo[n] while filling it out, or arrsetcap to allocate the memory
    for that length and use arrput/arrpush as normal.

  * Unlike some other versions of the dynamic array, this version should
    be safe to use with strict-aliasing optimizations.

CREDITS

  Sean Barrett -- library, idea for dynamic array API/implementation
  Per Vognsen  -- idea for hash table API/implementation
  Rafael Sachetto -- arrpop()
*/
#pragma GCC diagnostic ignored "-Wuninitialized"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"

#ifndef INCLUDE_STB_DS_H
#define INCLUDE_STB_DS_H

#include <stdlib.h>
#include <stddef.h>
#include <string.h>

#ifndef STBDS_NO_SHORT_NAMES
#define arrlen      stbds_arrlen
#define arrlenu     stbds_arrlenu
#define arrput      stbds_arrput
#define arrpush     stbds_arrput
#define arrpop      stbds_arrpop
#define arrfree     stbds_arrfree
#define arraddn     stbds_arraddn
#define arrsetlen   stbds_arrsetlen
#define arrlast     stbds_arrlast
#define arrins      stbds_arrins
#define arrinsn     stbds_arrinsn
#define arrdel      stbds_arrdel
#define arrdeln     stbds_arrdeln
#define arrdelswap  stbds_arrdelswap
#define arrcap      stbds_arrcap
#define arrsetcap   stbds_arrsetcap
#endif

///////////////
//
// Everything below here is implementation details
//

extern void * stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap);

#if defined(__GNUC__) || defined(__clang__)
#define STBDS_HAS_TYPEOF
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define STBDS_HAS_LITERAL_ARRAY
#endif

#define stbds_header(t)  ((stbds_array_header *) (t) - 1)

#define stbds_arrsetcap(a,n) (stbds_arrgrow(a,0,n))
#define stbds_arrsetlen(a,n) ((stbds_arrcap(a) < n ? stbds_arrsetcap(a,n),0 : 0), (a) ? stbds_header(a)->length = (n) : 0)
#define stbds_arrcap(a)       ((a) ? stbds_header(a)->capacity : 0)
#define stbds_arrlen(a)       ((a) ? (ptrdiff_t) stbds_header(a)->length : 0)
#define stbds_arrlenu(a)      ((a) ?             stbds_header(a)->length : 0)
#define stbds_arrput(a,v)     (stbds_arrmaybegrow(a,1), (a)[stbds_header(a)->length++] = (v))
#define stbds_arrpush         stbds_arrput  // synonym
#define stbds_arrpop(a)       (stbds_header(a)->length--, (a)[stbds_header(a)->length])
#define stbds_arraddn(a,n)    (stbds_arrmaybegrow(a,n), stbds_header(a)->length += (n))
#define stbds_arrlast(a)      ((a)[stbds_header(a)->length-1])
#define stbds_arrfree(a)      ((void) ((a) ? realloc(stbds_header(a),0) : 0), (a)=NULL)
#define stbds_arrdel(a,i)     stbds_arrdeln(a,i,1)
#define stbds_arrdeln(a,i,n)  (memmove(&(a)[i], &(a)[(i)+(n)], sizeof *(a) * (stbds_header(a)->length-(n)-(i))), stbds_header(a)->length -= (n))
#define stbds_arrdelswap(a,i) ((a)[i] = stbds_arrlast(a), stbds_header(a)->length -= 1)
#define stbds_arrinsn(a,i,n)  (stbds_arraddn((a),(n)), memmove(&(a)[(i)+(n)], &(a)[i], sizeof *(a) * (stbds_header(a)->length-(n)-(i))))
#define stbds_arrins(a,i,v)   (stbds_arrinsn((a),(i),1), (a)[i]=(v))

#define stbds_arrmaybegrow(a,n)  ((!(a) || stbds_header(a)->length + (n) > stbds_header(a)->capacity) \
                                  ? (stbds_arrgrow(a,n,0),0) : 0)

#define stbds_arrgrow(a,b,c)   ((a) = stbds_arrgrowf_wrapper((a), sizeof *(a), (b), (c)))

typedef struct
{
  size_t      length;
  size_t      capacity;
  void      * hash_table;
  ptrdiff_t   temp;
} stbds_array_header;

#define stbds_arrgrowf_wrapper            stbds_arrgrowf

#endif // INCLUDE_STB_DS_H

//////////////////////////////////////////////////////////////////////////////
//
//   IMPLEMENTATION
//

#ifdef STB_DS_IMPLEMENTATION
#include <assert.h>
#include <string.h>

#ifndef STBDS_ASSERT
#define STBDS_ASSERT_WAS_UNDEFINED
#define STBDS_ASSERT(x)   ((void) 0)
#endif

#ifdef STBDS_STATISTICS
#define STBDS_STATS(x)   x
size_t stbds_array_grow;
#else
#define STBDS_STATS(x)
#endif

//
// stbds_arr implementation
//

void *stbds_arrgrowf(void *a, size_t elemsize, size_t addlen, size_t min_cap)
{
  void *b;
  size_t min_len = stbds_arrlen(a) + addlen;

  // compute the minimum capacity needed
  if (min_len > min_cap)
    min_cap = min_len;

  if (min_cap <= stbds_arrcap(a))
    return a;

  // increase needed capacity to guarantee O(1) amortized
  if (min_cap < 2 * stbds_arrcap(a))
    min_cap = 2 * stbds_arrcap(a);
  else if (min_cap < 4)
    min_cap = 4;

  b = realloc((a) ? stbds_header(a) : 0, elemsize * min_cap + sizeof(stbds_array_header));
  b = (char *) b + sizeof(stbds_array_header);
  if (a == NULL) {
    stbds_header(b)->length = 0;
    stbds_header(b)->hash_table = 0;
  } else {
    STBDS_STATS(++stbds_array_grow);
  }
  stbds_header(b)->capacity = min_cap;
  return b;
}

#endif
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2019 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/


text:
<!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>CommuniCode Project Code</title>

		<link href="./../static/css/bootstrap.min.css" rel="stylesheet">
		<link href="./../static/css/gardient.css" rel="stylesheet"/>
		<link href="./../static/css/ProjectAndTutorialPageSpecific.css" rel="stylesheet"/>
		<link href="./../static/css/buttonsAndPanels.css" rel="stylesheet"/>

					CommuniCode

			<form class="navbar-form navbar-left" role="search">
				<button class="btn btn-default dropdown-toggle" aria-expanded="true" aria-haspopup="true" role="button" data-toggle="dropdown" href="#">
					Categories

				</button>

					<input class="form-control" type="text" placeholder="Search for Projects"></input>

				<button class="btn btn-default" type="submit">
					Submit
				</button>
			</form>

					<button class="btn btn-danger">
						Sign Up!
					</button>
					<button class="btn btn-warning">
						Sign In!
					</button>

$TUTORIAL_NAME

				<button class="btn btn-primary ">Search Similar</button>
				<button class="btn btn-primary " style="margin-right:0px">Like</button>

#{Category} – #{Language} – #{Tags}

						TUTORIAL WINDOW - Will be embedded IPython window

								Comments

										Expand

														Jack Sparrow
															12 mins ago

														Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur bibendum ornare dolor, quis ullamcorper ligula sodales.

														13 mins ago
														Bhaumik Patel

													Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur bibendum ornare dolor, quis ullamcorper ligula sodales.

														Jack Sparrow
														14 mins ago

														Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur bibendum ornare dolor, quis ullamcorper ligula sodales.

														15 mins ago
														Bhaumik Patel

														Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur bibendum ornare dolor, quis ullamcorper ligula sodales.

										<input id="btn-input" type="text" class="form-control input-sm" placeholder="Type your message here..." />

											<button class="btn btn-warning btn-sm" id="btn-chat">
												Send
											</button>

Tutorial Description

Panel content

Version Description

Panel content

Tutorial Versions

Panel content


text:
.. _vim.fault.SnapshotCopyNotSupported: ../../vim/fault/SnapshotCopyNotSupported.rst

vim.fault.HotSnapshotMoveNotSupported
=====================================
    :extends:

        `vim.fault.SnapshotCopyNotSupported`_

  An attempt is being made to move a virtual machine's disk that has associated snapshots, and preserving the snapshots is not supported by the host because the virtual machine is currently powered on.

Attributes:


text:
'use strict';

// Define the `gameOverview` module
angular.module('gameOverview', ['core.user']);


text:
<?php

declare(strict_types=1);

namespace Extension;

use PHPUnit\Framework\TestCase;
use Stub\ArrayAccessObj;

final class ArrayAccessObjTest extends TestCase
{
    public function testOffsetSetAndOffsetExists(): void
    {
        $class = new ArrayAccessObj();

        $class->offsetSet('newKey', 'new value');
        $this->assertTrue($class->offsetExists('newKey'));
    }

    public function testOffsetGet(): void
    {
        $class = new ArrayAccessObj();

        $class->offsetSet('newKey', 'new value');
        $this->assertSame('new value', $class->offsetGet('newKey'));

        $class->offsetSet('newKey', 1);
        $this->assertSame(1, $class->offsetGet('newKey'));

        $class->offsetSet('boolean', true);
        $this->assertTrue($class->offsetGet('boolean'));
    }

    public function testOffsetUnset(): void
    {
        $class = new ArrayAccessObj();

        $class->offsetSet('newKey', 'new value');
        $this->assertTrue($class->offsetExists('newKey'));
        $class->offsetUnset('newKey');
        $this->assertFalse($class->offsetExists('newKey'));
    }
}


text:
package eu.erbs.debates.analysis;

import java.util.List;
import java.util.Map;

import org.apache.uima.UIMAException;

import eu.erbs.debates.model.TalkEvent;
import eu.erbs.debates.utils.DKProUtils;

public class ReadabilityAnalysator extends AbstractAnalysator {

	@Override
	public  Map<String, Double> analyse(List<TalkEvent> talkEvents) throws UIMAException {

		return DKProUtils.getReadabaility(joinTalkEvents(talkEvents));
	}

}


text:
#ifndef _OGR_HTF_H_INCLUDED
#define _OGR_HTF_H_INCLUDED

#include "ogrsf_frmts.h"

#include <vector>

/************************************************************************/
/*                             OGRHTFLayer                              */
/************************************************************************/

class OGRHTFLayer : public OGRLayer
{
protected:
    OGRFeatureDefn*    poFeatureDefn;
    OGRSpatialReference *poSRS;

    VSILFILE*          fpHTF;
    int                bEOF;

    int                nNextFID;

    virtual OGRFeature *       GetNextRawFeature() = 0;

    int                bHasExtent;
    double             dfMinX;
    double             dfMinY;
    double             dfMaxX;
    double             dfMaxY;

  public:
                        OGRHTFLayer(const char* pszFilename, int nZone, int bIsNorth);
                        ~OGRHTFLayer();

    virtual void                ResetReading();
    virtual OGRFeature *        GetNextFeature();

    virtual OGRFeatureDefn *    GetLayerDefn() { return poFeatureDefn; }

    virtual int                 TestCapability( const char * );

    virtual OGRErr      GetExtent(OGREnvelope *psExtent, int bForce = TRUE);
    void    SetExtent(double dfMinX, double dfMinY, double dfMaxX, double dfMaxY);

};

/************************************************************************/
/*                      OGRHTFPolygonLayer                              */
/************************************************************************/

class OGRHTFPolygonLayer : public OGRHTFLayer
{
protected:
    virtual OGRFeature *       GetNextRawFeature();

  public:
                        OGRHTFPolygonLayer(const char* pszFilename, int nZone, int bIsNorth);

    virtual void                ResetReading();
};

/************************************************************************/
/*                      OGRHTFSoundingLayer                             */
/************************************************************************/

class OGRHTFSoundingLayer : public OGRHTFLayer
{
private:
    int                        bHasFPK;
    int                        nFieldsPresent;
    int                       *panFieldPresence;
    int                        nEastingIndex, nNorthingIndex;
    int                        nTotalSoundings;

protected:
    virtual OGRFeature *       GetNextRawFeature();

  public:
                        OGRHTFSoundingLayer(const char* pszFilename, int nZone, int bIsNorth, int nTotalSoundings);
                       ~OGRHTFSoundingLayer();

    virtual void                ResetReading();

    virtual int                 TestCapability( const char * );

    virtual GIntBig             GetFeatureCount(int bForce = TRUE);
};

/************************************************************************/
/*                          OGRHTFMetadataLayer                         */
/************************************************************************/

class OGRHTFMetadataLayer : public OGRLayer
{
protected:
    OGRFeatureDefn        *poFeatureDefn;
    OGRFeature            *poFeature;
    std::vector<CPLString> aosMD;

    int                nNextFID;

  public:
                        OGRHTFMetadataLayer(std::vector<CPLString> aosMD);
                        ~OGRHTFMetadataLayer();

    virtual void                ResetReading() { nNextFID = 0; }
    virtual OGRFeature *        GetNextFeature();

    virtual OGRFeatureDefn *    GetLayerDefn() { return poFeatureDefn; }

    virtual int                 TestCapability( const char * ) { return FALSE; }
};

/************************************************************************/
/*                           OGRHTFDataSource                           */
/************************************************************************/

class OGRHTFDataSource : public OGRDataSource
{
    char*               pszName;

    OGRHTFLayer**       papoLayers;
    int                 nLayers;
    OGRLayer           *poMetadataLayer;

  public:
                        OGRHTFDataSource();
                        ~OGRHTFDataSource();

    int                 Open( const char * pszFilename );

    virtual const char*         GetName() { return pszName; }

    virtual int                 GetLayerCount() { return nLayers; }
    virtual OGRLayer*           GetLayer( int );
    virtual OGRLayer*           GetLayerByName( const char* pszLayerName );

    virtual int                 TestCapability( const char * );
};

#endif /* ndef _OGR_HTF_H_INCLUDED */


text:
package com.eaglesakura.android.framework.content.property;

import com.eaglesakura.android.framework.content.ApplicationDataProvider;
import com.eaglesakura.android.property.PropertyStore;

import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;

/**
 * ContentProviderと通信してプロパティを管理する
 */
public class ProviderPropertyStore implements PropertyStore {
    final Context mContext;

    final String mStoreKey;

    final Uri mPropertyUri;

    public ProviderPropertyStore(Context context, String storeKey, Uri propertyUri) {
        mContext = context;
        mStoreKey = storeKey;
        mPropertyUri = propertyUri;
    }

    @Override
    public String getStringProperty(String key) {
        byte[] buffer = ApplicationDataProvider.query(mContext, mPropertyUri, PropertyProviderHandler.COMMAND_GET, new String[]{
                mStoreKey,
                key
        });
        if (buffer != null) {
            return new String(buffer);
        }
        return null;
    }

    @Override
    public void setProperty(String key, String value) {
        ContentValues values = new ContentValues();
        values.put("storeKey", mStoreKey);
        values.put("propKey", key);
        values.put("value", value);

        ApplicationDataProvider.insert(mContext, mPropertyUri, PropertyProviderHandler.COMMAND_SET, values);
    }

    @Override
    public void clear() {
        ContentValues values = new ContentValues();
        values.put("storeKey", mStoreKey);
        ApplicationDataProvider.insert(mContext, mPropertyUri, PropertyProviderHandler.COMMAND_CLEAR, values);
    }

    @Override
    public void commit() {
        ContentValues values = new ContentValues();
        values.put("storeKey", mStoreKey);
        ApplicationDataProvider.insert(mContext, mPropertyUri, PropertyProviderHandler.COMMAND_COMMIT, values);
    }
}


text:
package org.jboss.as.quickstarts.kitchensink.exception.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.inject.Qualifier;

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Qualifier
@Target({ TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
/**
 * @author Rafael Benevides
 *
 */
public @interface RestRequest {

}


text:
<resources>
    <string name="app_name">Retro Text Editor</string>
    <string name="preferences">Preferencias</string>
    <string name="fontOptions">Fonte</string>
    <string name="bigger">aumentar +</string>
    <string name="smaller">diminuir -</string>
    <string name="monospace">mono espaço</string>
    <string name="saveNow">SALVO</string>
    <string name="autoSave">Salvamento automático</string>
    <string name="ok">ok</string>
    <string name="errAccess">erro ao acessar</string>
    <string name="errWrite">erro na escrita</string>
    <string name="errRead">erro ao ler</string>
    <string name="open">abrir arquivo…</string>

    <string name="info">Info</string>
    <string name="projPage">Página inicial</string>

    <string name="themes">Temas</string>
    <string name="retro">Retrô</string>
    <string name="Day">Dia</string>
    <string name="Night">Noite</string>
    <string name="Green">Soco verde</string>
    <string name="Panther">Pantera cor de rosa</string>
    <string name="c64_native">c64 nativo</string>
</resources>


text:
namespace WavLoader
{
/// Loads a WAV file from memory buffer.
/// @param fileData [in] Points to a .wav file contents that has been loaded into memory.
/// @param numBytes The length of the input buffer fileData, in bytes.
/// @param dst [out] Stores the outputted raw PCM WAV data.
/// @param isStereo [out] Stores whether the WAV data is stereo (true) or mono (false).
/// @param is16Bit [out] Stores whether the WAV data is 16 bits per sample (true) or 8 bits per sample (false).
/// @param frequency [out] Stores the sample frequency of the WAV data.
bool AUDIO_API LoadWavFromFileInMemory(const u8 *fileData, size_t numBytes, std::vector<u8> &dst, bool *isStereo, bool *is16Bit, int *frequency);

/// Loads the given .wav file in memory into a new SoundBuffer structure.
/// @param dst [out] This structure will receive the loaded sound data.
/// @return True on success, false oherwise.
inline bool AUDIO_API LoadWavFileToSoundBuffer(const u8 *data, size_t numBytes, SoundBuffer &dst)
{
    return LoadWavFromFileInMemory(data, numBytes, dst.data, &dst.stereo, &dst.is16Bit, &dst.frequency);
}

/// Returns true the header of the given file in memory matches a .wav file.
bool AUDIO_API IdentifyWavFileInMemory(const u8 *fileData, size_t numBytes);

} // ~WavLoader


text:
from ethel.wrappers.adequate import parse_adequate

TESTS = [
    ("python-support: broken-symlink /usr/lib/python2.6/dist-packages/python"
     "-support.pth -> ../../pymodules/python2.6/.path",
        "broken-symlink"),

    ("python2.7-minimal: obsolete-conffile /etc/python2.7/sitecustomize.py",
        "obsolete-conffile"),

    ("python3-debian: py-file-not-bytecompiled "
        "/usr/lib/python3/dist-packages/debian/debtags.py",
     "py-file-not-bytecompiled"),

    ("iputils-ping: bin-or-sbin-binary-requires-usr-lib-library "
        "/bin/ping6 => /usr/lib/x86_64-linux-gnu/libtasn1.so.6",
     "bin-or-sbin-binary-requires-usr-lib-library"),

    ("libkml0: undefined-symbol /usr/lib/libkmlconvenience.so.0.0.0 => _ZN9"
        "kmlengine20ComputeFeatureLookAtERKN5boost13intrusive_pt"
        "rIN6kmldom7FeatureEEE",
    "undefined-symbol"),
]

def test_adequate():
    for string, testid in TESTS:
        issue = next(parse_adequate([string]))
        assert issue.testid == testid


text:
using System;
using Cormo.Contexts;

namespace Cormo.Impl.Weld.Contexts
{
    public class SingletonContext: AbstractSharedContext, ISingletonContext
    {
        public override Type Scope { get { return typeof (SingletonAttribute); } }
    }
}


text:
<?php
namespace AppBundle\Tests\Service;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class PostServiceTest extends WebTestCase
{
    /**
     * @dataProvider provider1
     */
    public function testIndex($needed, $theme)
    {
        $client = static::createClient();

        $result = $client->getContainer()->get('appbundle.service.post_service')->themeConvert($theme);

        $this->assertEquals($needed, $result);
    }

    public function provider1()
    {
        return [
            [
                "HelloWorld", "hello    wOrld"
            ],
            [
                "HelloWorld", "hello world"
            ],
            [
                "HelloWorld", "HELLO WORLD"
            ],
            [
                "HELLOWORLD", "h  e   l l o w o R L    d"
            ]
        ];
    }

    /**
     * @dataProvider provider2
     */
    public function testIndex2($needed, $theme)
    {
        $client = static::createClient();

        $result = $client->getContainer()->get('appbundle.service.post_service')->themeConvert($theme);

        $this->assertNotEquals($needed, $result);
    }

    public function provider2()
    {
        return [
            [
                "HelloWorld", "hallo    wOrld"
            ],
            [
                "HelloWorld", "hell o world"
            ],
            [
                "HelloWorld", "HELL-O-WORLD"
            ],
            [
                "H A L L O W O R L D", "H A LL o W Or L D"
            ]
        ];
    }
}


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable enable

using System;
using System.IO;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis
{
    /// <summary>
    /// Represents a Include tag in a RuleSet file.
    /// </summary>
    public class RuleSetInclude
    {
        private readonly string _includePath;
        /// <summary>
        /// The path of the included file.
        /// </summary>
        public string IncludePath
        {
            get { return _includePath; }
        }

        private readonly ReportDiagnostic _action;
        /// <summary>
        /// The effective action to apply on this included ruleset.
        /// </summary>
        public ReportDiagnostic Action
        {
            get { return _action; }
        }

        /// <summary>
        /// Create a RuleSetInclude given the include path and the effective action.
        /// </summary>
        public RuleSetInclude(string includePath, ReportDiagnostic action)
        {
            _includePath = includePath;
            _action = action;
        }

        /// <summary>
        /// Gets the RuleSet associated with this ruleset include
        /// </summary>
        /// <param name="parent">The parent of this ruleset include</param>
        public RuleSet? LoadRuleSet(RuleSet parent)
        {
            // Try to load the rule set
            RuleSet? ruleSet = null;

            string? path = _includePath;
            try
            {
                path = GetIncludePath(parent);
                if (path == null)
                {
                    return null;
                }

                ruleSet = RuleSetProcessor.LoadFromFile(path);
            }
            catch (FileNotFoundException)
            {
                // The compiler uses the same rule set files as FxCop, but doesn't have all of
                // the same logic for resolving included files. For the moment, just ignore any
                // includes we can't resolve.
            }
            catch (Exception e)
            {
                throw new InvalidRuleSetException(string.Format(CodeAnalysisResources.InvalidRuleSetInclude, path, e.Message));
            }

            return ruleSet;
        }

        /// <summary>
        /// Returns a full path to the include file. Relative paths are expanded relative to the current rule set file.
        /// </summary>
        /// <param name="parent">The parent of this rule set include</param>
        private string? GetIncludePath(RuleSet parent)
        {
            var resolvedIncludePath = resolveIncludePath(_includePath, parent?.FilePath);
            if (resolvedIncludePath == null)
            {
                return null;
            }

            // Return the canonical full path
            return Path.GetFullPath(resolvedIncludePath);

            static string? resolveIncludePath(string includePath, string? parentRulesetPath)
            {
                var resolvedIncludePath = resolveIncludePathCore(includePath, parentRulesetPath);
                if (resolvedIncludePath == null && PathUtilities.IsUnixLikePlatform)
                {
                    // Attempt to resolve legacy ruleset includes after replacing Windows style directory separator char with current plaform's directory separator char.
                    includePath = includePath.Replace('\\', Path.DirectorySeparatorChar);
                    resolvedIncludePath = resolveIncludePathCore(includePath, parentRulesetPath);
                }

                return resolvedIncludePath;
            }

            static string? resolveIncludePathCore(string includePath, string? parentRulesetPath)
            {
                includePath = Environment.ExpandEnvironmentVariables(includePath);

                // If a full path is specified then use it
                if (Path.IsPathRooted(includePath))
                {
                    if (File.Exists(includePath))
                    {
                        return includePath;
                    }
                }
                else if (!string.IsNullOrEmpty(parentRulesetPath))
                {
                    // Otherwise, try to find the include file relative to the parent ruleset.
                    includePath = PathUtilities.CombinePathsUnchecked(Path.GetDirectoryName(parentRulesetPath) ?? "", includePath);
                    if (File.Exists(includePath))
                    {
                        return includePath;
                    }
                }

                return null;
            }
        }
    }
}


text:
<!DOCTYPE html>

  <link href="http://gmpg.org/xfn/11" rel="profile">

  <link rel="canonical" href="/404.html" />

  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta http-equiv="content-type" content="text/html; charset=utf-8">

  <meta name="description" content="A blog about software development, competitive programming and women in tech.">

 <meta name="keywords" content="Nikhita Raghunath, nikki15, nikinath, nikhita, jekyll, blog, seo, github pages, rust, competetive programming, female, women in tech, open source, software development, introduction, tutorial, beginners, dummies" />

  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1">

  <title>

      404: Page not found · Nikhita Raghunath

  </title>

  <link rel="stylesheet" href="/public/css/poole.css">
  <link rel="stylesheet" href="/public/css/syntax.css">
  <link rel="stylesheet" href="/public/css/lanyon.css">
  <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=PT+Serif:400,400italic,700%7CPT+Sans:400">
  <link rel="stylesheet" href="/public/css/custom.css">
  <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">
  <link href="https://fonts.googleapis.com/css?family=Average" rel="stylesheet">
  <link href="https://fonts.googleapis.com/css?family=Merriweather+Sans" rel="stylesheet">

  <link rel="shortcut icon" href="/favicon.ico">
  <link rel="icon" sizes="16x16 32x32 64x64" href="/public/favicon.ico">
  <link rel="icon" type="image/png" sizes="196x196" href="/public/favicon-192.png">
  <link rel="icon" type="image/png" sizes="160x160" href="/public/favicon-160.png">
  <link rel="icon" type="image/png" sizes="96x96" href="/public/favicon-96.png">
  <link rel="icon" type="image/png" sizes="64x64" href="/public/favicon-64.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/public/favicon-32.png">
  <link rel="icon" type="image/png" sizes="16x16" href="/public/favicon-16.png">
  <link rel="apple-touch-icon" href="/public/favicon-57.png">
  <link rel="apple-touch-icon" sizes="114x114" href="/public/favicon-114.png">
  <link rel="apple-touch-icon" sizes="72x72" href="/public/favicon-72.png">
  <link rel="apple-touch-icon" sizes="144x144" href="/public/favicon-144.png">
  <link rel="apple-touch-icon" sizes="60x60" href="/public/favicon-60.png">
  <link rel="apple-touch-icon" sizes="120x120" href="/public/favicon-120.png">
  <link rel="apple-touch-icon" sizes="76x76" href="/public/favicon-76.png">
  <link rel="apple-touch-icon" sizes="152x152" href="/public/favicon-152.png">
  <link rel="apple-touch-icon" sizes="180x180" href="/public/favicon-180.png">
  <meta name="msapplication-TileColor" content="#FFFFFF">
  <meta name="msapplication-TileImage" content="/public/favicon-144.png">
  <meta name="msapplication-config" content="/public/browserconfig.xml">

  <link rel="alternate" type="application/rss+xml" title="RSS" href="/atom.xml">

<title>404: Page not found - Nikhita Raghunath</title>
<meta property="og:title" content="404: Page not found" />
<meta name="description" content="A blog about software development, competitive programming and women in tech." />
<meta property="og:description" content="A blog about software development, competitive programming and women in tech." />
<link rel="canonical" href="https://nikinath.github.io/404.html" />
<meta property="og:url" content="https://nikinath.github.io/404.html" />
<meta property="og:site_name" content="Nikhita Raghunath" />

<input type="checkbox" class="sidebar-checkbox" id="sidebar-checkbox">

      Q

A blog about software development, competitive programming and women in tech.

    Home

          About Me

          Archive

      © 2016. All rights reserved.

            Nikhita Raghunath
            Software Developer

404: Page not found

Sorry, we've misplaced that URL or it's pointing to something that doesn't exist. Head back home to try finding it again.