text:
package org.apache.pulsar.broker.transaction.pendingack.impl;

import io.prometheus.client.Counter;
import io.prometheus.client.Summary;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.commons.lang3.StringUtils;
import org.apache.pulsar.broker.transaction.pendingack.PendingAckHandleStats;
import org.apache.pulsar.common.naming.TopicName;

public class PendingAckHandleStatsImpl implements PendingAckHandleStats {
    private static final AtomicBoolean INITIALIZED = new AtomicBoolean(false);
    private static Counter commitTxnCounter;
    private static Counter abortTxnCounter;
    private static Summary commitTxnLatency;
    private static boolean exposeTopicLevelMetrics0;

    private final String[] labelSucceed;
    private final String[] labelFailed;
    private final String[] commitLatencyLabel;

    public PendingAckHandleStatsImpl(String topic, String subscription, boolean exposeTopicLevelMetrics) {
        initialize(exposeTopicLevelMetrics);

        String namespace;
        if (StringUtils.isBlank(topic)) {
            namespace = topic = "unknown";
        } else {
            try {
                namespace = TopicName.get(topic).getNamespace();
            } catch (IllegalArgumentException ex) {
                namespace = "unknown";
            }
        }

        labelSucceed = exposeTopicLevelMetrics0
                ? new String[]{namespace, topic, subscription, "succeed"} : new String[]{namespace, "succeed"};
        labelFailed = exposeTopicLevelMetrics0
                ? new String[]{namespace, topic, subscription, "failed"} : new String[]{namespace, "failed"};
        commitLatencyLabel = exposeTopicLevelMetrics0
                ? new String[]{namespace, topic, subscription} : new String[]{namespace};
    }

    @Override
    public void recordCommitTxn(boolean success, long nanos) {
        String[] labels;
        if (success) {
            labels = labelSucceed;
            commitTxnLatency.labels(commitLatencyLabel).observe(TimeUnit.NANOSECONDS.toMicros(nanos));
        } else {
            labels = labelFailed;
        }
        commitTxnCounter.labels(labels).inc();
    }

    @Override
    public void recordAbortTxn(boolean success) {
        abortTxnCounter.labels(success ? labelSucceed : labelFailed).inc();
    }

    @Override
    public void close() {
        if (exposeTopicLevelMetrics0) {
            commitTxnCounter.remove(this.labelSucceed);
            commitTxnCounter.remove(this.labelFailed);
            abortTxnCounter.remove(this.labelFailed);
            abortTxnCounter.remove(this.labelFailed);
        }
    }

    static void initialize(boolean exposeTopicLevelMetrics) {
        if (INITIALIZED.compareAndSet(false, true)) {
            exposeTopicLevelMetrics0 = exposeTopicLevelMetrics;

            String[] labelNames = exposeTopicLevelMetrics
                    ? new String[]{"namespace", "topic", "subscription", "status"}
                    : new String[]{"namespace", "status"};

            commitTxnCounter = Counter
                    .build("pulsar_txn_tp_committed_count", "-")
                    .labelNames(labelNames)
                    .register();

            abortTxnCounter = Counter
                    .build("pulsar_txn_tp_aborted_count", "-")
                    .labelNames(labelNames)
                    .register();

            commitTxnLatency = Summary.build("pulsar_txn_tp_commit_latency", "-")
                    .quantile(0.5, 0.01)
                    .quantile(0.9, 0.01)
                    .quantile(0.99, 0.01)
                    .quantile(0.999, 0.01)
                    .labelNames(exposeTopicLevelMetrics
                            ? new String[]{"namespace", "topic", "subscription"} : new String[]{"namespace"})
                    .register();
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
from msrest.serialization import Model

class DictionaryWrapper(Model):

    _required = []

    _attribute_map = {
        'default_program': {'key': 'defaultProgram', 'type': '{str}'},
    }

    def __init__(self, *args, **kwargs):
        """DictionaryWrapper

        :param dict default_program
        """
        self.default_program = None

        super(DictionaryWrapper, self).__init__(*args, **kwargs)


text:
module ActsAsCsv

  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods
    def acts_as_csv
      include InstanceMethods
    end
  end

  module InstanceMethods
    attr_accessor :headers, :csv_contents

    def read
      @csv_contents = []
      filename = self.class.to_s.downcase + '.txt'
      file = File.new(filename)
      @headers = file.gets.chomp.split(', ')

      file.each do |row|
        @csv_contents << row.chomp.split(', ')
      end
    end

    def initialize
      read
    end
  end
end

class RubyCsv # mixed in, no inheritance
  include ActsAsCsv
  acts_as_csv
end

m = RubyCsv.new
puts m.headers.inspect
puts m.csv_contents.inspect


text:
#include <linux/netdevice.h>
#include <linux/ethtool.h>
#include <linux/delay.h>

#include "host.h"
#include "decl.h"
#include "defs.h"
#include "dev.h"
#include "join.h"
#include "wext.h"
static const char * mesh_stat_strings[]= {
			"drop_duplicate_bcast",
			"drop_ttl_zero",
			"drop_no_fwd_route",
			"drop_no_buffers",
			"fwded_unicast_cnt",
			"fwded_bcast_cnt",
			"drop_blind_table",
			"tx_failed_cnt"
};

static void libertas_ethtool_get_drvinfo(struct net_device *dev,
					 struct ethtool_drvinfo *info)
{
	wlan_private *priv = (wlan_private *) dev->priv;
	char fwver[32];

	libertas_get_fwversion(priv->adapter, fwver, sizeof(fwver) - 1);

	strcpy(info->driver, "libertas");
	strcpy(info->version, libertas_driver_version);
	strcpy(info->fw_version, fwver);
}

/* All 8388 parts have 16KiB EEPROM size at the time of writing.
 * In case that changes this needs fixing.
 */
#define LIBERTAS_EEPROM_LEN 16384

static int libertas_ethtool_get_eeprom_len(struct net_device *dev)
{
	return LIBERTAS_EEPROM_LEN;
}

static int libertas_ethtool_get_eeprom(struct net_device *dev,
                                  struct ethtool_eeprom *eeprom, u8 * bytes)
{
	wlan_private *priv = (wlan_private *) dev->priv;
	wlan_adapter *adapter = priv->adapter;
	struct wlan_ioctl_regrdwr regctrl;
	char *ptr;
	int ret;

	regctrl.action = 0;
	regctrl.offset = eeprom->offset;
	regctrl.NOB = eeprom->len;

	if (eeprom->offset + eeprom->len > LIBERTAS_EEPROM_LEN)
		return -EINVAL;

//      mutex_lock(&priv->mutex);

	adapter->prdeeprom =
		    (char *)kmalloc(eeprom->len+sizeof(regctrl), GFP_KERNEL);
	if (!adapter->prdeeprom)
		return -ENOMEM;
	memcpy(adapter->prdeeprom, &regctrl, sizeof(regctrl));

	/* +14 is for action, offset, and NOB in
	 * response */
	lbs_deb_ethtool("action:%d offset: %x NOB: %02x\n",
	       regctrl.action, regctrl.offset, regctrl.NOB);

	ret = libertas_prepare_and_send_command(priv,
				    cmd_802_11_eeprom_access,
				    regctrl.action,
				    cmd_option_waitforrsp, 0,
				    &regctrl);

	if (ret) {
		if (adapter->prdeeprom)
			kfree(adapter->prdeeprom);
		goto done;
	}

	mdelay(10);

	ptr = (char *)adapter->prdeeprom;

	/* skip the command header, but include the "value" u32 variable */
	ptr = ptr + sizeof(struct wlan_ioctl_regrdwr) - 4;

	/*
	 * Return the result back to the user
	 */
	memcpy(bytes, ptr, eeprom->len);

	if (adapter->prdeeprom)
		kfree(adapter->prdeeprom);
//	mutex_unlock(&priv->mutex);

	ret = 0;

done:
	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
        return ret;
}

static void libertas_ethtool_get_stats(struct net_device * dev,
				struct ethtool_stats * stats, u64 * data)
{
	wlan_private *priv = dev->priv;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	stats->cmd = ETHTOOL_GSTATS;
	BUG_ON(stats->n_stats != MESH_STATS_NUM);

        data[0] = priv->mstats.fwd_drop_rbt;
        data[1] = priv->mstats.fwd_drop_ttl;
        data[2] = priv->mstats.fwd_drop_noroute;
        data[3] = priv->mstats.fwd_drop_nobuf;
        data[4] = priv->mstats.fwd_unicast_cnt;
        data[5] = priv->mstats.fwd_bcast_cnt;
        data[6] = priv->mstats.drop_blind;
        data[7] = priv->mstats.tx_failed_cnt;

	lbs_deb_enter(LBS_DEB_ETHTOOL);
}

static int libertas_ethtool_get_stats_count(struct net_device * dev)
{
	int ret;
	wlan_private *priv = dev->priv;
	struct cmd_ds_mesh_access mesh_access;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	/* Get Mesh Statistics */
	ret = libertas_prepare_and_send_command(priv,
			cmd_mesh_access, cmd_act_mesh_get_stats,
			cmd_option_waitforrsp, 0, &mesh_access);

	if (ret) {
		ret = 0;
		goto done;
	}

        priv->mstats.fwd_drop_rbt = le32_to_cpu(mesh_access.data[0]);
        priv->mstats.fwd_drop_ttl = le32_to_cpu(mesh_access.data[1]);
        priv->mstats.fwd_drop_noroute = le32_to_cpu(mesh_access.data[2]);
        priv->mstats.fwd_drop_nobuf = le32_to_cpu(mesh_access.data[3]);
        priv->mstats.fwd_unicast_cnt = le32_to_cpu(mesh_access.data[4]);
        priv->mstats.fwd_bcast_cnt = le32_to_cpu(mesh_access.data[5]);
        priv->mstats.drop_blind = le32_to_cpu(mesh_access.data[6]);
        priv->mstats.tx_failed_cnt = le32_to_cpu(mesh_access.data[7]);

	ret = MESH_STATS_NUM;

done:
	lbs_deb_enter_args(LBS_DEB_ETHTOOL, "ret %d", ret);
	return ret;
}

static void libertas_ethtool_get_strings (struct net_device * dev,
					  u32 stringset,
					  u8 * s)
{
	int i;

	lbs_deb_enter(LBS_DEB_ETHTOOL);

	switch (stringset) {
        case ETH_SS_STATS:
		for (i=0; i < MESH_STATS_NUM; i++) {
			memcpy(s + i * ETH_GSTRING_LEN,
					mesh_stat_strings[i],
					ETH_GSTRING_LEN);
		}
		break;
        }
	lbs_deb_enter(LBS_DEB_ETHTOOL);
}

struct ethtool_ops libertas_ethtool_ops = {
	.get_drvinfo = libertas_ethtool_get_drvinfo,
	.get_eeprom =  libertas_ethtool_get_eeprom,
	.get_eeprom_len = libertas_ethtool_get_eeprom_len,
	.get_stats_count = libertas_ethtool_get_stats_count,
	.get_ethtool_stats = libertas_ethtool_get_stats,
	.get_strings = libertas_ethtool_get_strings,
};


text:
require_relative 'deliver/loader'
require_relative 'deliver/options'
require_relative 'deliver/commands_generator'
require_relative 'deliver/detect_values'
require_relative 'deliver/runner'
require_relative 'deliver/upload_metadata'
require_relative 'deliver/upload_screenshots'
require_relative 'deliver/upload_price_tier'
require_relative 'deliver/upload_assets'
require_relative 'deliver/submit_for_review'
require_relative 'deliver/app_screenshot'
require_relative 'deliver/html_generator'
require_relative 'deliver/generate_summary'

require_relative 'deliver/module'


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

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

        #region Component Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent() {
            this.label1 = new System.Windows.Forms.Label();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.panel1 = new System.Windows.Forms.Panel();
            this.panel1.SuspendLayout();
            this.SuspendLayout();
            //
            // label1
            //
            this.label1.Font = new System.Drawing.Font("Segoe UI", 10F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label1.Location = new System.Drawing.Point(0, 5);
            this.label1.Margin = new System.Windows.Forms.Padding(0);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(128, 28);
            this.label1.TabIndex = 1;
            this.label1.Text = "Edit Refresh Rate";
            this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            //
            // textBox1
            //
            this.textBox1.BorderStyle = System.Windows.Forms.BorderStyle.None;
            this.textBox1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.textBox1.Location = new System.Drawing.Point(2, 2);
            this.textBox1.Margin = new System.Windows.Forms.Padding(0);
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(124, 16);
            this.textBox1.TabIndex = 2;
            this.textBox1.Text = "Text Placeholder";
            this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);
            this.textBox1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBox1_KeyDown);
            //
            // panel1
            //
            this.panel1.BackColor = System.Drawing.Color.Silver;
            this.panel1.Controls.Add(this.textBox1);
            this.panel1.Location = new System.Drawing.Point(0, 38);
            this.panel1.Margin = new System.Windows.Forms.Padding(0, 0, 0, 10);
            this.panel1.Name = "panel1";
            this.panel1.Size = new System.Drawing.Size(128, 20);
            this.panel1.TabIndex = 3;
            //
            // TextEditor
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.BackColor = System.Drawing.Color.White;
            this.Controls.Add(this.panel1);
            this.Controls.Add(this.label1);
            this.Margin = new System.Windows.Forms.Padding(0);
            this.Name = "TextEditor";
            this.Size = new System.Drawing.Size(128, 70);
            this.panel1.ResumeLayout(false);
            this.panel1.PerformLayout();
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.Panel panel1;
    }
}


text:
#include <arch_helpers.h>
#include <assert.h>
#include <debug.h>
#include <gicv2.h>
#include <platform_def.h>
#include <platform.h>
#include <psci.h>

/*
 * The secure entry point to be used on warm reset.
 */
static unsigned long secure_entrypoint;

/* Make composite power state parameter till power level 0 */
#if PSCI_EXTENDED_STATE_ID

#define qemu_make_pwrstate_lvl0(lvl0_state, pwr_lvl, type) \
		(((lvl0_state) << PSTATE_ID_SHIFT) | \
		 ((type) << PSTATE_TYPE_SHIFT))
#else
#define qemu_make_pwrstate_lvl0(lvl0_state, pwr_lvl, type) \
		(((lvl0_state) << PSTATE_ID_SHIFT) | \
		 ((pwr_lvl) << PSTATE_PWR_LVL_SHIFT) | \
		 ((type) << PSTATE_TYPE_SHIFT))
#endif /* PSCI_EXTENDED_STATE_ID */

#define qemu_make_pwrstate_lvl1(lvl1_state, lvl0_state, pwr_lvl, type) \
		(((lvl1_state) << PLAT_LOCAL_PSTATE_WIDTH) | \
		 qemu_make_pwrstate_lvl0(lvl0_state, pwr_lvl, type))

/*
 *  The table storing the valid idle power states. Ensure that the
 *  array entries are populated in ascending order of state-id to
 *  enable us to use binary search during power state validation.
 *  The table must be terminated by a NULL entry.
 */
static const unsigned int qemu_pm_idle_states[] = {
	/* State-id - 0x01 */
	qemu_make_pwrstate_lvl1(PLAT_LOCAL_STATE_RUN, PLAT_LOCAL_STATE_RET,
				MPIDR_AFFLVL0, PSTATE_TYPE_STANDBY),
	/* State-id - 0x02 */
	qemu_make_pwrstate_lvl1(PLAT_LOCAL_STATE_RUN, PLAT_LOCAL_STATE_OFF,
				MPIDR_AFFLVL0, PSTATE_TYPE_POWERDOWN),
	/* State-id - 0x22 */
	qemu_make_pwrstate_lvl1(PLAT_LOCAL_STATE_OFF, PLAT_LOCAL_STATE_OFF,
				MPIDR_AFFLVL1, PSTATE_TYPE_POWERDOWN),
	0,
};

/*******************************************************************************
 * Platform handler called to check the validity of the power state
 * parameter. The power state parameter has to be a composite power state.
 ******************************************************************************/
static int qemu_validate_power_state(unsigned int power_state,
				psci_power_state_t *req_state)
{
	unsigned int state_id;
	int i;

	assert(req_state);

	/*
	 *  Currently we are using a linear search for finding the matching
	 *  entry in the idle power state array. This can be made a binary
	 *  search if the number of entries justify the additional complexity.
	 */
	for (i = 0; !!qemu_pm_idle_states[i]; i++) {
		if (power_state == qemu_pm_idle_states[i])
			break;
	}

	/* Return error if entry not found in the idle state array */
	if (!qemu_pm_idle_states[i])
		return PSCI_E_INVALID_PARAMS;

	i = 0;
	state_id = psci_get_pstate_id(power_state);

	/* Parse the State ID and populate the state info parameter */
	while (state_id) {
		req_state->pwr_domain_state[i++] = state_id &
						PLAT_LOCAL_PSTATE_MASK;
		state_id >>= PLAT_LOCAL_PSTATE_WIDTH;
	}

	return PSCI_E_SUCCESS;
}

/*******************************************************************************
 * Platform handler called to check the validity of the non secure
 * entrypoint.
 ******************************************************************************/
static int qemu_validate_ns_entrypoint(uintptr_t entrypoint)
{
	/*
	 * Check if the non secure entrypoint lies within the non
	 * secure DRAM.
	 */
	if ((entrypoint >= NS_DRAM0_BASE) &&
	    (entrypoint < (NS_DRAM0_BASE + NS_DRAM0_SIZE)))
		return PSCI_E_SUCCESS;
	return PSCI_E_INVALID_ADDRESS;
}

/*******************************************************************************
 * Platform handler called when a CPU is about to enter standby.
 ******************************************************************************/
static void qemu_cpu_standby(plat_local_state_t cpu_state)
{

	assert(cpu_state == PLAT_LOCAL_STATE_RET);

	/*
	 * Enter standby state
	 * dsb is good practice before using wfi to enter low power states
	 */
	dsb();
	wfi();
}

/*******************************************************************************
 * Platform handler called when a power domain is about to be turned on. The
 * mpidr determines the CPU to be turned on.
 ******************************************************************************/
static int qemu_pwr_domain_on(u_register_t mpidr)
{
	int rc = PSCI_E_SUCCESS;
	unsigned pos = plat_core_pos_by_mpidr(mpidr);
	uint64_t *hold_base = (uint64_t *)PLAT_QEMU_HOLD_BASE;

	hold_base[pos] = PLAT_QEMU_HOLD_STATE_GO;
	sev();

	return rc;
}

/*******************************************************************************
 * Platform handler called when a power domain is about to be turned off. The
 * target_state encodes the power state that each level should transition to.
 ******************************************************************************/
void qemu_pwr_domain_off(const psci_power_state_t *target_state)
{
	assert(0);
}

/*******************************************************************************
 * Platform handler called when a power domain is about to be suspended. The
 * target_state encodes the power state that each level should transition to.
 ******************************************************************************/
void qemu_pwr_domain_suspend(const psci_power_state_t *target_state)
{
	assert(0);
}

/*******************************************************************************
 * Platform handler called when a power domain has just been powered on after
 * being turned off earlier. The target_state encodes the low power state that
 * each level has woken up from.
 ******************************************************************************/
void qemu_pwr_domain_on_finish(const psci_power_state_t *target_state)
{
	assert(target_state->pwr_domain_state[MPIDR_AFFLVL0] ==
					PLAT_LOCAL_STATE_OFF);

	/* TODO: This setup is needed only after a cold boot */
	gicv2_pcpu_distif_init();

	/* Enable the gic cpu interface */
	gicv2_cpuif_enable();
}

/*******************************************************************************
 * Platform handler called when a power domain has just been powered on after
 * having been suspended earlier. The target_state encodes the low power state
 * that each level has woken up from.
 ******************************************************************************/
void qemu_pwr_domain_suspend_finish(const psci_power_state_t *target_state)
{
	assert(0);
}

/*******************************************************************************
 * Platform handlers to shutdown/reboot the system
 ******************************************************************************/
static void __dead2 qemu_system_off(void)
{
	ERROR("QEMU System Off: operation not handled.\n");
	panic();
}

static void __dead2 qemu_system_reset(void)
{
	ERROR("QEMU System Reset: operation not handled.\n");
	panic();
}

static const plat_psci_ops_t plat_qemu_psci_pm_ops = {
	.cpu_standby = qemu_cpu_standby,
	.pwr_domain_on = qemu_pwr_domain_on,
	.pwr_domain_off = qemu_pwr_domain_off,
	.pwr_domain_suspend = qemu_pwr_domain_suspend,
	.pwr_domain_on_finish = qemu_pwr_domain_on_finish,
	.pwr_domain_suspend_finish = qemu_pwr_domain_suspend_finish,
	.system_off = qemu_system_off,
	.system_reset = qemu_system_reset,
	.validate_power_state = qemu_validate_power_state,
	.validate_ns_entrypoint = qemu_validate_ns_entrypoint
};

int plat_setup_psci_ops(uintptr_t sec_entrypoint,
			const plat_psci_ops_t **psci_ops)
{
	uintptr_t *mailbox = (void *) PLAT_QEMU_TRUSTED_MAILBOX_BASE;

	*mailbox = sec_entrypoint;
	secure_entrypoint = (unsigned long) sec_entrypoint;
	*psci_ops = &plat_qemu_psci_pm_ops;

	return 0;
}


text:
class CFrustum
{
private:
	CLogger* logger;
	const int kNumberOfPlanes = 6;
public:
	CFrustum();
	~CFrustum();
public:
	void ConstructFrustum(float farClip, D3DXMATRIX projMatrix, D3DXMATRIX viewMatrix);
	bool CheckPoint(float x, float y, float z);
	bool CheckSphere(D3DXVECTOR3 position, float radius);
private:
	D3DXPLANE mPlanes[6];
};

#endif


text:
<?php declare(strict_types=1);

namespace Composer\Repository\Vcs;

use Composer\Config;
use Composer\IO\IOInterface;

/**
 * @author Jordi Boggiano <j.boggiano@seld.be>
 * @internal
 */
interface VcsDriverInterface
{
    /**
     * Initializes the driver (git clone, svn checkout, fetch info etc)
     */
    public function initialize(): void;

    /**
     * Return the composer.json file information
     *
     * @param  string  $identifier Any identifier to a specific branch/tag/commit
     * @return mixed[]|null Array containing all infos from the composer.json file, or null to denote that no file was present
     */
    public function getComposerInformation(string $identifier): ?array;

    /**
     * Return the content of $file or null if the file does not exist.
     */
    public function getFileContent(string $file, string $identifier): ?string;

    /**
     * Get the changedate for $identifier.
     */
    public function getChangeDate(string $identifier): ?\DateTimeImmutable;

    /**
     * Return the root identifier (trunk, master, default/tip ..)
     *
     * @return string Identifier
     */
    public function getRootIdentifier(): string;

    /**
     * Return list of branches in the repository
     *
     * @return array<int|string, string> Branch names as keys, identifiers as values
     */
    public function getBranches(): array;

    /**
     * Return list of tags in the repository
     *
     * @return array<int|string, string> Tag names as keys, identifiers as values
     */
    public function getTags(): array;

    /**
     * @param string $identifier Any identifier to a specific branch/tag/commit
     *
     * @return array{type: string, url: string, reference: string, shasum: string}|null
     */
    public function getDist(string $identifier): ?array;

    /**
     * @param string $identifier Any identifier to a specific branch/tag/commit
     *
     * @return array{type: string, url: string, reference: string}
     */
    public function getSource(string $identifier): array;

    /**
     * Return the URL of the repository
     */
    public function getUrl(): string;

    /**
     * Return true if the repository has a composer file for a given identifier,
     * false otherwise.
     *
     * @param  string $identifier Any identifier to a specific branch/tag/commit
     * @return bool   Whether the repository has a composer file for a given identifier.
     */
    public function hasComposerFile(string $identifier): bool;

    /**
     * Performs any cleanup necessary as the driver is not longer needed
     */
    public function cleanup(): void;

    /**
     * Checks if this driver can handle a given url
     *
     * @param  IOInterface $io     IO instance
     * @param  Config      $config current $config
     * @param  string      $url    URL to validate/check
     * @param  bool        $deep   unless true, only shallow checks (url matching typically) should be done
     */
    public static function supports(IOInterface $io, Config $config, string $url, bool $deep = false): bool;
}


text:
(function () {
    /**
     * Require Promise & fetch & assign polyfills
     */
    if ( typeof exports === 'object' ) {
        require('promise-polyfill');
        require('whatwg-fetch');
        require('es6-object-assign').polyfill();
    }

    /**
     * Utils
     */
    var objectAssign = Object.assign,
        isObject     = function (prop) {
            return prop && prop.toString() === "[object Object]"
        },
        isArray      = function (prop) {
            return prop && Object.prototype.toString.call(prop) === "[object Array]"
        };

    /**
     * @param {string} url
     * @param {object} options
     * @constructor
     */
    var API = function (url, options) {
        if ( !url ) {
            throw Error('URL is required');
        }

        options = options || {};

        this.url     = url;
        this.routes  = options.routes || {};
        this.domains = [];
        this.options = options.options || {};

        if ( isObject( options.domains ) ) {
            for ( var key in options.domains ) {
                if ( !isObject(options.domains[ key ]) ) {
                    throw Error('Expecting objects in domains');
                }
                if ( options.domains.hasOwnProperty(key) ) {
                    this.addDomain(key, options.domains[ key ]);
                }
            }
        }
    };

    /**
     * Alias of fetch
     * @param {string} method
     * @param {string} path
     * @param {object|null} data
     * @param {object|null} options
     * @returns {Promise}
     */
    API.prototype.ajax = function (method, path, data, options) {
        return this.fetch(method, path, data, options);
    };

    /**
     * Perform the call to the API
     * @param {string} method
     * @param {string} path
     * @param {object|null} data
     * @param {object|null} options
     * @returns {Promise}
     */
    API.prototype.fetch = function (method, path, data, options) {
        data    = data || {};
        options = options || {};

        var parseOptions = [ 'arrayBuffer', 'blob', 'formData', 'json', 'text' ];

        var body = new FormData();
        body.append("json", JSON.stringify(data));

        var combinedOptions = Object.assign({},
            this.options,
            options,
            {
                method: method,
                body:   body
            });

        var promise = fetch(this.url + path, combinedOptions);

        if ( combinedOptions.parse && parseOptions.indexOf(combinedOptions.parse) > -1 ) {
            return promise.then(function (response) {
                if( response[combinedOptions.parse] ) {
                    return response[ combinedOptions.parse ].apply(response);
                }
                throw Error('Could not parse the results with [' + combinedOptions.parse + ']');
            })
        }

        return promise;
    };

    /**
     * Shorthand POST call
     * @param {string} path
     * @param {object} data
     * @param {object} options
     * @returns {Promise}
     */
    API.prototype.post = function (path, data, options) {
        return this.fetch('POST', path, data, options);
    };

    /**
     * Shorthand GET call
     * @param {string} path
     * @param {object} data
     * @param {object} options
     * @returns {Promise}
     */
    API.prototype.get = function (path, data, options) {
        return this.fetch('GET', path, data, options);
    };

    /**
     * Shorthand PUT call
     * @param {string} path
     * @param {object} data
     * @param {object} options
     * @returns {Promise}
     */
    API.prototype.put = function (path, data, options) {
        return this.fetch('PUT', path, data, options);
    };

    /**
     * Shorthand DELETE call
     * @param {string} path
     * @param {object} data
     * @param {object} options
     * @returns {Promise}
     */
    API.prototype.delete = function (path, data, options) {
        return this.fetch('DELETE', path, data, options);
    };

    /**
     * Get a route from the collection and parse any variables in it from the data object
     * @param {string} key
     * @param {object} data
     * @returns {string}
     */
    API.prototype.getRoute = function (key, data) {
        data = data || {};

        if ( this.routes.hasOwnProperty(key) ) {
            var route  = this.routes[ key ],
                chunks = route.split(':');

            if ( chunks.length > 1 ) {
                if ( data.hasOwnProperty(chunks[ 1 ]) ) {
                    return route.replace(':' + chunks[ 1 ], data[ chunks[ 1 ] ]);
                }
            }

            return route;
        }

        throw Error('API Route [' + key + '] does not exist');
    };

    /**
     * Build a route based on the domain name and function being called
     * @param {string} domain
     * @param {string} fn
     * @param {object} data
     * @returns {string}
     */
    API.prototype.buildRoute = function (domain, fn, data) {
        var key = domain + '.' + fn;
        return this.getRoute(key, data);
    };

    /**
     * Add routes
     * @param {object} routes
     * @returns {API}
     */
    API.prototype.addRoutes = function (routes) {
        this.routes = objectAssign({}, this.routes, routes);

        return this;
    };

    /**
     * Overwrite the current routes with a new object
     * @param routes
     * @returns {API}
     */
    API.prototype.setRoutes = function (routes) {
        this.routes = routes;

        return this;
    };

    /**
     * Add one or more domain(s)
     * @param {...object} arguments
     * @returns {API}
     */
    API.prototype.add = function () {
        var args = arguments;

        if ( args.length === 0 ) {
            return this;
        }

        if ( args.length > 1 && args.length % 2 === 0 ) {
            // There is even amount of arguments & 2 or more
            for ( var i = 0; i < args.length; i += 2 ) {
                this.addDomain(args[ i ], args[ i + 1 ]);
            }
            return this;
        } else if ( isArray(args[ 0 ]) && args[ 0 ].length % 2 === 0 ) {
            // Is array and even amount of arguments
            for ( var y = 0; y < args[ 0 ].length; y += 2 ) {
                this.addDomain(args[ 0 ][ y ], args[ 0 ][ y + 1 ]);
            }
            return this;
        } else if ( isObject(args[ 0 ]) ) {
            // Is object
            for ( var key in args[ 0 ] ) {
                if ( args[ 0 ].hasOwnProperty(key) ) {
                    this.addDomain(key, args[ 0 ][ key ]);
                }
            }
            return this;
        }

        throw Error('Could not parse arguments', args);
    };

    /**
     * Add one domain and setup the properties
     * @param {string} name
     * @param {object} domainData
     * @returns {API}
     */
    API.prototype.addDomain = function (name, domainData) {
        var self     = this,
            reserved = [ 'get', 'post', 'put', 'delete' ];

        var domain = new Domain(name, this);

        for ( var key in domainData ) {
            if ( !domainData.hasOwnProperty(key) ) {
                throw Error('hasOwnProperty check not passed');
            }

            if ( reserved.indexOf(key) > -1 ) {
                throw Error('You can not define a function with the following reserved name: ' + key);
            }

            var prop = domainData[ key ];

            if ( isObject( prop ) ) {
                Object.defineProperty(domain, key, {
                    get: function (key, prop) {
                        return function (data) {
                            var path    = (prop.route)
                                    ? self.getRoute(prop.route, data)
                                    : self.buildRoute(name, key, data),
                                options = prop.options || {};

                            return self[ prop.method.toLowerCase() ].apply(self, [ path, data, options ]);
                        }
                    }.bind(this, key, prop),
                    set: function () {
                        throw Error('You can not directly set API functions');
                    }
                })
            }
        }

        this.domains[ name ] = domain;

        Object.defineProperty(this, name, {
            get: function () {
                return self.domains[ name ]
            },
            set: function () {
                throw Error('You can not directly set domains');
            }
        });

        return this;
    };

    /**
     * Small domain wrapper
     * @param {string} name
     * @param {API} API
     * @constructor
     */
    var Domain = function (name, API) {
        this.API   = API;
        this._name = name;
    };

    /**
     * Shorthand getRoute for domains
     * @param {string} key
     * @param {object} data
     * @returns {string}
     */
    Domain.prototype.getRoute = function (key, data) {
        return this.API.getRoute(key, data);
    };

    /**
     * Shorthand fetch functions
     */
    Domain.prototype.get = function (a, b, c) {
        return this.API.get(a, b, c)
    };
    Domain.prototype.post   = function (a, b, c) {
        return this.API.post(a, b, c)
    };
    Domain.prototype.put    = function (a, b, c) {
        return this.API.put(a, b, c)
    };
    Domain.prototype.delete = function (a, b, c) {
        return this.API.delete(a, b, c)
    };

    /**
     * Export to window or as module depending on environment
     * @type {API}
     */
    (function (factory) {
        if ( typeof exports === 'object' ) {
            module.exports = exports = factory;
        } else {
            window.easyAPI = factory;
        }
    })(API);
})();


text:
shadow :: De Mysteriis Dom Firefox
==================================

A new, extended (and renamed ;) version of the Firefox/jemalloc heap
exploitation swiss army knife.

**shadow** has been tested with the following:

* Windows 8.1 x86-64
* Windows 7 SP1 x86 and x86-64
* [WinDBG 6.3.9600.17200]
(https://msdn.microsoft.com/en-us/windows/hardware/hh852365.aspx)
x86 (since Firefox stable is x86-only currently)
* [pykd version 0.2.0.29](https://pykd.codeplex.com/releases/view/119220)
(the latest stable version at the time of development)
* Many different Firefox releases, but extensively with:
[31.7.0-esr](http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/31.7.0esr/),
[35.0.1](http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/35.0.1/),
[36.0.1](http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/36.0.1/),
[38.0.5](http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/38.0.5/).

*Note: If you work with a Firefox version older than 36.0 use the mozjs branch!*

Installation
------------

At first you need to setup WinDBG with [Mozilla's symbol server]
(https://developer.mozilla.org/en/docs/Using_the_Mozilla_symbol_server).
You also need to install [pykd version 0.2.0.29]
(https://pykd.codeplex.com/releases/view/119220). Then copy the **shadow**
directory you have cloned from GitHub to some path (e.g. C:\\tmp\\).

Finally, from within WinDBG issue the following commands:

```
!load pykd.pyd
!py c:\\tmp\\shadow\\pykd_driver help

[shadow] De Mysteriis Dom Firefox
[shadow] v1.0b

[shadow] jemalloc-specific commands:
[shadow]   jechunks                : dump info on all available chunks
[shadow]   jearenas                : dump info on jemalloc arenas
[shadow]   jerun <address>         : dump info on a single run
[shadow]   jeruns [-cs]            : dump info on jemalloc runs
[shadow]                                 -c: current runs only
[shadow]                    -s <size class>: runs for the given size class only
[shadow]   jebins                  : dump info on jemalloc bins
[shadow]   jeregions <size class>  : dump all current regions of the given size class
[shadow]   jesearch [-cqs] <hex>   : search the heap for the given hex dword
[shadow]                                 -c: current runs only
[shadow]                                 -q: quick search (less details)
[shadow]                    -s <size class>: regions of the given size only
[shadow]   jeinfo <address>        : display all available details for an address
[shadow]   jedump [filename]       : dump all available jemalloc info to screen (default) or file
[shadow]   jeparse                 : parse jemalloc structures from memory
[shadow] Firefox-specific commands:
[shadow]   nursery                 : display info on the SpiderMonkey GC nursery
[shadow]   symbol [-vjdx] <size>   : display all Firefox symbols of the given size
[shadow]                                 -v: only class symbols with vtable
[shadow]                                 -j: only symbols from SpiderMonkey
[shadow]                                 -d: only DOM symbols
[shadow]                                 -x: only non-SpiderMonkey symbols
[shadow]   pa <address> [<length>] : modify the ArrayObject's length (default new length 0x666)
[shadow] Generic commands:
[shadow]   version                 : output version number
[shadow]   help                    : this help message
```

If you don't see the above help message you have done something wrong ;)

Usage
-----

When you issue a jemalloc-specific command for the first time, **shadow** parses
all jemalloc metadata it knows about and saves them to a Python pickle file.
Subsequent commands use this pickle file instead of parsing the metadata from
memory again in order to be faster.

When you know that the state of jemalloc metadata has changed (for example when
you have made some allocations or have triggered a garbage collection), use the
**jeparse** command to re-parse the metadata and re-create the pickle file.

Support for symbols
-------------------

*Note: This feature is currently Windows-only!*

The **symbol** command allows you to search for SpiderMonkey and DOM classes (and
structures) of specific sizes. This is useful when you're trying to exploit
use-after-free bugs, or when you want to position interesting victim objects to
overwrite/corrupt.

In the "aux" directory you can find a small PDB parsing utility named **symhex**.
Run it on "xul.pdb" to generate the Python pickle file that **shadow** expects in
the "pdb" directory (as "pdb/xul.pdb.pkl"). Before running **symhex** make sure
you have registered "msdia90.dll"; for example on my Windows 8.1 x86-64
installation I did that with

*regsvr32 "c:\Program Files (x86)\Common Files\Microsoft Shared\VC\msdia90.dll"*

from an Administrator prompt. You also need the "comtypes" Python module; install
[pip](https://pip.pypa.io/en/latest/installing.html) and then do
*pip install comtypes*.

In order to get "xul.pdb" you have to setup WinDBG with [Mozilla's symbol server]
(https://developer.mozilla.org/en/docs/Using_the_Mozilla_symbol_server).

Design
------

I initially re-designed **unmask_jemalloc** with a modular design to support all
three main debuggers and platforms (WinDBG, GDB and LLDB). I renamed the tool to
**shadow** when I added Firefox/Windows/WinDBG-only features.

The following is an overview of the new design (read the arrows as "imports"). The
goal is, obviously, to have all debugger-dependent code in the *_driver and *_engine
modules.

    ---------------------------------------------------------------------------------------

                                                        debugger-required frontend (glue)

    +------------+     +-------------+     +-------------+
    | gdb_driver |     | lldb_driver |     | pykd_driver |
    +------------+     +-------------+     +-------------+
          ^                   ^                   ^
          |                   |                   |
    ------+-------------------+-------------------+----------------------------------------
          |                   |                   |
          |                   +--------+          |
          +------------------------    |    +-----+        core logic (debugger-agnostic)
                                  |    |    |
                                  |    |    |
                               +-----------------+
      +------+                 |                 |
      |      |---------------> |      shadow     |<-----+
      | util |        +------> |                 |      |
      |      |        |        +-----------------+      |
      +------+        |          ^  ^     ^    ^        |
        | | |         |          |  |     |    |        |   +--------+
        | | |   +-----+----------+  |     +----+--------+---| symbol |
        | | |   |     |             |          |        |   +--------+
      +-+ | |   |  +----------+     |          |        |   +---------+
      |   | |   |  | jemalloc |     |          +--------+---| nursery |
      |   | |   |  +----------+     |                   |   +---------+
      |   | |   |   ^    ^   ^      |                   |
      |   | |   |   |    |   |      |                   |
      |   | |   |   |    |   +------+--------+          |
      |   | |   |   |    |          |        |          |
      |   | +---+---+----+----------+--------+-----+    |
      |   |     |   |    |          |        |     |    |
      |   +-----+---+----+----+     |        |     |    |
      |         |   |    |    |     |        |     |    |
    --+---------+---+----+----+-----+--------+-----+----+----------------------------------
      |         |   |    |    |     |        |     |    |
      |         |   |    |    |     |        |     |    |       debugger-dependent APIs
      |         |   |    |    |     |        |     |    |
      |         |   |    |    |     |        |     |    |
      |         |   |    |    v     |        |     v    |
      |  +------------+  |  +-------------+  |  +-------------+
      +->| gdb_engine |  +--| lldb_engine |  +--| pykd_engine |
         +------------+     +-------------+     +-------------+
               ^                   ^                   ^
               |                   |                   |
           +---+         +---------+   +---------------+
           |             |             |
           |             |             |
    -------+-------------+-------------+---------------------------------------------------
           |             |             |
           |             |             |                        debugger-provided backend
           |             |             |
           |             |             |
        +-----+      +------+      +------+
        | gdb |      | lldb |      | pykd |
        +-----+      +------+      +------+

    ---------------------------------------------------------------------------------------

Feel free to fork and issue pull requests!


text:
When you run or debug your program in IDEA and some exception is traced in the console view you may easily navigate
to source code lines of this stack trace. Just click on highlighted source file name and line number in the console
to see the source in the editor.


text:
package jp.fieldnotes.hatunatu.util.convert;

import org.junit.Test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

/**
 * @author shinsuke
 *
 */
public class StringConversionUtilTest {

    @Test
    public void testFromWindowsMapping() throws Exception {
        assertNull(StringConversionUtil.fromWindowsMapping(null));
        assertEquals("", StringConversionUtil.fromWindowsMapping(""));
        assertEquals(
            "abc 123",
            StringConversionUtil.fromWindowsMapping("abc 123"));
        assertEquals(
            "abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2",
            StringConversionUtil
                .fromWindowsMapping("abc\u301C\u2016\u2212\u00A2\u00A3\u00AC"));
    }

    @Test
    public void testToWindowsMapping() throws Exception {
        assertNull(StringConversionUtil.toWindowsMapping(null));
        assertEquals("", StringConversionUtil.toWindowsMapping(""));
        assertEquals(
            "abc 123",
            StringConversionUtil.toWindowsMapping("abc 123"));
        assertEquals(
            "abc\u301C\u2016\u2212\u00A2\u00A3\u00AC",
            StringConversionUtil
                .toWindowsMapping("abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2"));
    }

}


text:
USING_NS_CC;

bool EditMyCourseLayer::init()
{
	if (!LayerColor::initWithColor(Color4B::BLACK))
		return false;

	m_AddCourse = ui::EditBox::create(Size(300, 100), "newEditBox.png");
	addBoxInit();
	this->addChild(m_AddCourse, 2);

	m_DeleteCourse = ui::EditBox::create(Size(300, 100), "deleteBox.png");
	deleteBoxInit();
	this->addChild(m_DeleteCourse, 2);

	auto backMenu = MenuItemImage::create("back.png", "back.png",
										  CC_CALLBACK_1(EditMyCourseLayer::backMenuEvent, this));

	backMenu->setScale(0.7f);
	backMenu->setPosition(Point(WINSIZE_WIDTH - backMenu->getContentSize().width / 2, WINSIZE_HEIGHT / 8));

	m_BackMenu = Menu::create(backMenu, NULL);
	m_BackMenu->setPosition(Point::ZERO);
	this->addChild(m_BackMenu, 1);

	return true;
}

void EditMyCourseLayer::editBoxReturn(cocos2d::ui::EditBox* editBox)
{
	SQLWCHAR editContens[100] = { 0, };
	const char* tmpText = editBox->getText();
	int len = strlen(tmpText);
	MultiByteToWideChar(0, 0, tmpText, len + 1, editContens, len + 1);
	if (editBox->getName() == "add")
	{
		GET_DBMANAGER()->updateMyCourse(editContens);
	}
	else
	{
		GET_DBMANAGER()->deleteMyCourse(editContens);

	}
}

void EditMyCourseLayer::addBoxInit()
{
	m_AddCourse->setPosition(Point(WINSIZE_WIDTH/ 2, WINSIZE_HEIGHT / 3 * 2));
	m_AddCourse->setFont("noto sans korean bold", 35);
	m_AddCourse->setFontColor(Color3B::BLACK);
	m_AddCourse->setPlaceHolder("Ãß°¡ °ú¸ñ ID ÀÔ·Â");
	m_AddCourse->setPlaceholderFontName("noto sans korean bold");
	m_AddCourse->setPlaceholderFontColor(Color3B::BLACK);
	m_AddCourse->setMaxLength(6);
	m_AddCourse->setReturnType(ui::EditBox::KeyboardReturnType::DONE);
	m_AddCourse->setDelegate(this);
	m_AddCourse->setName("add");
}

void EditMyCourseLayer::deleteBoxInit()
{
	m_DeleteCourse->setPosition(Point(WINSIZE_WIDTH / 2, WINSIZE_HEIGHT / 3));
	m_DeleteCourse->setFont("noto sans korean bold", 35);
	m_DeleteCourse->setFontColor(Color3B::BLACK);
	m_DeleteCourse->setPlaceHolder("»èÁ¦ °ú¸ñ ID ÀÔ·Â");
	m_DeleteCourse->setPlaceholderFontName("noto sans korean bold");
	m_DeleteCourse->setPlaceholderFontColor(Color3B::BLACK);
	m_DeleteCourse->setMaxLength(6);
	m_DeleteCourse->setReturnType(ui::EditBox::KeyboardReturnType::DONE);
	m_DeleteCourse->setDelegate(this);
	m_DeleteCourse->setName("delete");
}

void EditMyCourseLayer::backMenuEvent(cocos2d::Ref* psender)
{
	setVisible(false);
}


text:
class Member < ActiveRecord::Base

  has_many :posts, foreign_key: "author_id"
  has_many :prompts, foreign_key: "author_id"
  has_many :riffs, foreign_key: "author_id"
  has_many :bits, foreign_key: "author_id"
  has_many :invites, foreign_key: "owner_id"

  #adds password virtual attribute
  #adds confirmation validation on password
  has_secure_password

  EMAIL_RX = /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i

  validates_presence_of :first_name, message: "We'd love to get to know you on a first name basis. Our first name is Charlie."
  validates_length_of :first_name, maximum: 35
  validates_presence_of :last_name, message: "We need your last name. So we can make you sound professional."
  validates_length_of :last_name, maximum: 45
  validates_format_of :email, with: EMAIL_RX, message: "Please provide a valid email address."
  validates_confirmation_of :email, message: "Email confirmation must match"
  validates_numericality_of :invites_left, greater_than_or_equal_to: 0, only_integer: true
  validates_acceptance_of :terms_of_service # entirely virtual

  validates_with MemberUniqueEmailValidator

  def full_name
    return self.first_name + ' ' + self.last_name
  end

  include FriendlyId
  friendly_id :slug_candidates, :use => :slugged
  def slug_candidates
    [
      :full_name,
      [:full_name, :id]
    ]
  end

  def self.new_from_invite(invite)
    m = Member.new()
    m.first_name = invite.first_name
    m.last_name = invite.last_name
    m.email = invite.email
    return m
  end

end


text:
<?php

namespace Vinala\Kernel\Config\Exceptions;

use Vinala\Kernel\Logging\Exception;

/**
 * Classv Aliased Not Found Exception.
 */
class DatabaseDriverNotFoundException extends Exception
{
    //--------------------------------------------------------
    // Constructor
    //--------------------------------------------------------
    public function __construct($driver)
    {
        $this->message = "The driver '$driver' in database config file not found";
    }
}


text:
%\input{"../../Praeambel_prak.tex"}

%\begin{document}

\section{Auswertung}

Im Folgendem werden die Messergebnisse ausgewertet und in geeigneter
Weise visualisert.

\subsection{Grenzfrequenzen}

Die verwendete Apparatur hatte die folgenden Werte.

\begin{align}
  \label{L}
  L &= \SI{1,217}{\milli\henry}\\
  \label{C1}
  C_1 &= \SI{20,13}{\nano\farad}\\
  \label{C2}
  C_2 &= \SI{9,41}{\nano\farad}
\end{align}

Diese Daten wurden ohne Fehler angegeben und werden deshalb als fehlerfrei
angenommen. In der $LC$-Kettenschaltung wurde der Kondensator mit der
Kapazität $C_1$ verwendet.

Mittels \eqref{eqn:omega_C_grenz}, \eqref{eqn:omega_C_1_grenz} und
\eqref{eqn:omega_C_2_grenz_unten} ergeben sich die Werte:

\begin{align*}
  \omega_{Grenz,C} &= \num{404075}\si{\hertz}\\
  \omega_{Grenz,C_1C_2}^{akustisch} &= \num{285724}\si{\hertz}\\
  \omega_{Grenz,C_1C_2}^{optisch} &= \num{417902}\si{\hertz}.\\
\end{align*}

Mit Hilfe des $XY$-Scheibers wurden die Grenzfrequenzen der $LC$-Kettenschaltung
und der $LC_1C_2$-Kettenschaltung visualisiert. Die Diagramme sind
logarithmisch. Durch Ermitteln der Frequenzen an bestimmten Stellen der
Grafik kann eine exponentielle Regressionsrechnung gemacht werden.
Damit ist einen Zusammenhang zwischen den Messdaten und vom Generator durchlaufenden
Frequenzen bekannt.

Die Ausgleichsrechnung wurde mithilfe des \emph{Python}-Paketes
\emph{curve\_Fit} bewerkstelligt. Die Funktion hatte die Gestalt:

\begin{equation}
  \nu(t) = a\cdot e^{bx}+c.
\end{equation}

\begin{figure}
  \includegraphics[width=\textwidth]{Ceinzeln.pdf}
  \caption{Durchlasskurve einer Kettenschaltung mit einem Typ Kondensator}
  \label{fig:Ceinzeln}
\end{figure}

\begin{figure}
  \includegraphics[width=\textwidth]{C1C2.pdf}
  \caption{Durchlasskurve einer Kettenschaltung mit zwei verschiedenen Typen Kondensator}
  \label{fig:C1C2}
\end{figure}

Die Messungen der Durchlasskurve ergaben die folgenden Werte.

\FloatBarrier
\floatplacement{table}{htbp}
\begin{table}
 \centering
 \begin{tabular}[width=\textwidth]{S| S[table-format=4.0] S[table-format=5.0] S[table-format=5.0] S[table-format=5.0] S[table-format=5.0] S[table-format=5.0] S[table-format=5.0]}
    \midrule
    $\nu_C$ \text{\;in\;} $\si{\hertz}$ & 1338 & 2055 & 2843 & 3730 & 5023 & 6471 & 8624 \\
    $\nu_{C_1C_2}$ \text{\;in\;} $\si{\hertz}$ & 7345 & 10478 & 21072 & 30336 & 50353 & 79169 \\
    \bottomrule
\end{tabular}
  \caption{Messdaten der Durchlasskurve}
  \label{tab:Durchlasskurve}
\end{table}
\FloatBarrier

Es ergeben sich mittels der Messdaten der Tabelle \ref{tab:Durchlasskurve}
die folgenden Funktionen.

\begin{align}
  \label{eqn:Ausgleichsrechnung_exp_1}
  \nu_{C}(x) &= ((13984\pm 1701)\si{\hertz})\cdot e^{(0,08\pm 0,005)\frac{1}{\si{\centi\meter}}\cdot x} - (5155\pm 2006)\si{\hertz} \\
  \label{eqn:Ausgleichsrechnung_exp_2}
  \nu_{C_1C_2}(x) &= ((64117\pm 5474)\si{\hertz})\cdot e^{(0,15\pm 0,005)\frac{1}{\si{\centi\meter}}\cdot x}-(20547\pm 7703)\si{\hertz}
\end{align}

Anhand der Graphen kann die Grenzfrequenz abgelesen werden, indem der
Abstand vermessen wird. Die Messung wurde mit einem Lineal gemacht
und ergibt für die $LC$-Kettenschaltung einen Wert von ca.
$\SI{17,2}{\centi\meter}$. Die Messung der Grenzfrequenzen der
$LC_1C_2$-Kettenschaltung ergab für den akustischen Zweig eine
Grenzfrequenz bei $\SI{11}{\centi\meter}$ und für den optischen Zweig eine
Grenzfrequenz bei  $\SI{12,2}{\centi\meter}$.

Für die Grenzfrequenzen ergeben sich damit die Werte:

\begin{align}
  \omega_{Grenz,C} &= \num{50224,00}\si{\hertz}\\
  \omega_{Grenz,C_1C_2}^{akustisch} &= \num{311361,75}\si{\hertz}\\
  \omega_{Grenz,C_1C_2}^{optisch} &= \num{376566,51}\si{\hertz}
\end{align}

\subsection{Dispersionskurven}

Mit den Angaben \eqref{L}, \eqref{C1} und \eqref{C2} kann die Dispersionskurve
der $LC-Kette$ und der $LC_1C_2$-Kette über die Funktionen \eqref{eqn:RelationC}
und \eqref{eqn:RelationC1C2} bestimmt werden.
Die Messdaten wurden in das Diagramm mit eingetragen. Bei allen Werten die eine
Phasenverschiebung von über $\frac{\pi}{2}$ haben wurde die Phasenverschiebung
mit $\frac{\pi}{2}$ subtrahiert und an der $y$-Achse gespiegelt,
da die Dispersionskurve $\frac{\pi}{2}$-Periodisch ist.

\begin{figure}
  \includegraphics[width=\textwidth]{Dispersionskurve_C.pdf}
  \caption{Dispersionskurve der $LC$-Kettenschaltung}
  \label{fig:DispersionC}
\end{figure}

In Abb. \ref{fig:DispersionC} ist die Kreisfrequenz $\omega$ der Phasenverschiebung
pro Glied $\theta$ gegenüber aufgetragen. Die in dem Diagramm eingetragenen
Messdaten sind in Tabelle \ref{tab:Dispersionsrelation} in der Spalte
der $LC$-Kette dargestellt. An der Theoriekurve ist zu erkennen, dass die Kreizfrequenz
mit steigender Phasenverschiebung pro Glied sich der Grenzfrequenz asymptotisch
nähert. Grenzfrequenz ergibt sich aus dem folgendem Zusammenhang:

\begin{equation}
  \label{eqn:Grenzfrequenz}
  \omega_{Grenz} = \frac{2}{\sqrt{L\cdot C_1}}
\end{equation}

Die Messdaten liegen in guter Näherung auf der Theoriekurve.
Nur Werte bis zu einer Phasenverschiebung pro Glied von $\frac{\pi}{2}$
konnten gemessen werden. Alle Werte darüberhinaus waren nicht mehr messbar.

\begin{figure}
  \includegraphics[width=\textwidth]{Dispersionskurve_C1C2.pdf}
  \caption{Dispersionskurve der $LC_1C_2$-Kettenschaltung}
  \label{fig:DispersionC1C2}
\end{figure}

Das Diagramm \ref{fig:DispersionC1C2} zeigt die Dispersionskurve der $LC_1C_2$-Kette.
Tabelle \ref{tab:Dispersionsrelation} enthält in der Spalte zur $LC_1C_2$-Kette
die eingetragenen Messdaten. Der Theoriegraph besteht zum einen aus dem
optischen Ast und zum anderen aus dem akkusitschen Ast. Die Messdaten weichen deutlich
von den Theoriewerten ab. Auf diese Abweichung wird speziell nocheinmal in der
Diskussion eingegangen.

Die Messdaten der Dispersionsrelation sind in Tabelle \ref{tab:Dispersionsrelation}
dargestellt.

\floatplacement{table}{htbp}
\begin{table}
 \centering
 \sisetup{table-format=5.0}
 \begin{tabular}[width=\textwidth]{S S S}
     \toprule
      {Verschiebung} & {$\nu_C$} & {$\nu_{C_1C_2}$}\\
     \midrule
      0 & 0 & 0 \\
      1\pi & 7927 & 7158 \\
      2\pi & 15610 & 14188 \\
      3\pi & 23372 & 21078 \\
      4\pi & 30703 & 27714 \\
      5\pi & 38072 & 34188 \\
      6\pi & 43171 & 40094 \\
      7\pi & 49000 & 45378 \\
      8\pi & \text{--} & 50298 \\
      9\pi & \text{--} & 54295 \\
      10\pi & \text{--} & 57976 \\
      11\pi & \text{--} & 60550 \\
      12\pi & \text{--} & 62625 \\
      \bottomrule
\end{tabular}
  \caption{Messdaten der Dispersionsrelation}
  \label{tab:Dispersionsrelation}
\end{table}

\subsection{Phasengeschwindigkeit}

Anhand der Dispersionsrelation und der gemessenen Eigenfrequeunzen aus Tabelle
\ref{tab:Dispersionsrelation} lässt sich die Phasengeschwindigkeit über die
Formel \eqref{eqn:Phasengeschwindigkeit} berechnen.
Die Theoriekurve und die Werte, die sich aus den Messungen ergeben sind in
dem Diagramm \ref{fig:Phasengesch} dargestellt.
Die Phasenverschiebung pro Glied $\theta$ berechnet sich durch:

\begin{equation}
  \label{eqn:theta}
  \theta = \frac{\pi n_i}{n}, i = 0,...,14
\end{equation}

Dabei ist $n$ die Anzahl der Kettenglieder.

\FloatBarrier
%\tiny{
\floatplacement{table}{htbp}
\begin{table}
 \centering
 \sisetup{table-format=6.0}
 \begin{tabular}[width=\textwidth]{S| S S S S S S S S}
    \midrule
    $\theta$ & 0 & $\frac{\pi}{14}$ & $\frac{\pi}{7}$ & $\frac{3\pi}{14}$ & $\frac{2\pi}{7}$ & $\frac{5\pi}{14}$ & $\frac{3\pi}{7}$ & $\frac{\pi}{2}$ \\
    $v_{Ph}$\text{\,in\,}$\frac{1}{rad}$ & \text{\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,\,--} & 201524 & 200019 & 19412 & 193799 & 188791 & 184288 & 177700 \\
    \bottomrule
\end{tabular}
  \caption{Messdaten der Phasengeschwindigkeit}
  \label{tab:Phasengesch}
\end{table}
%}
\FloatBarrier

\begin{figure}
  \includegraphics[width=\textwidth]{Phasengesch.pdf}
  \caption{Phasengeschwindigkeit}
  \label{fig:Phasengesch}
\end{figure}

In Abb. \ref{fig:Phasengesch} ist die Phasengeschwindigkeit gegenüber der
Frequenz aufgetragen. Die Theoriekurve wurde nach Formel \ref{eqn:RelationC}
berechnet. Es ist erkenntlich, dass die gemessenen Werte mit denen der
Theorie im Rahmen der Messunsicherheit übereinstimmen.
Die eingetragenen Messdaten sind aus Tabelle \ref{tab:Phasengesch} entnommen.

\subsection{Stehende Wellen}

Beim Messen der Spannungsamplituden der offenen $LC$-Kette ergeben sich die Diagramme
\ref{fig:Messungd1}, \ref{fig:Messungd2} und \ref{fig:Messunge}.

\begin{figure}
  \includegraphics[width=\textwidth]{Messung_d_1.pdf}
  \caption{Erste Grundschwingung der offenen $LC$-Kettenschaltung bei $\nu = \SI{7133}{\hertz}$}
  \label{fig:Messungd1}
\end{figure}

Das Diagramm \ref{fig:Messungd1} zeigt die Messdaten der Spalte $\nu_C=\SI{7133}{\hertz}$
aus der Tabelle \ref{tab:stehendeWelle}. Die erste Grundschwigung ist deutlich
zu erkennen. Die Generatorfrequenz $\nu_C$ wurde auf die Frequenz
der ersten Eigenschwingung eingestellt, weshalb dieses Diagramm den Erwartungen
entspricht.

\FloatBarrier
\begin{figure}
  \includegraphics[width=\textwidth]{Messung_d_2.pdf}
  \caption{Zweite Grundschwingung der offenen $LC$-Kettenschaltung bei $\nu = \SI{14307}{\hertz}$}
  \label{fig:Messungd2}
\end{figure}

Die Darstellung der Werte aus Spalte $\nu_{C} = \SI{14307}{\hertz}$ von Tabelle \ref{tab:stehendeWelle}
ist in Diagramm \ref{fig:Messungd2} erfolgt. Die zweite Grundschwingung ist deutlich
erkennbar. Dies liegt daran, dass die Generatorfrequenz auf die zweite
Eigenfrequenz der Schaltung eingestellt wurde.

\FloatBarrier
\begin{figure}
  \includegraphics[width=\textwidth]{Messung_e.pdf}
  \caption{Abgeschlossene $LC-$Kettenschaltung bei $\nu = \SI{7337}{\hertz}$}
  \label{fig:Messunge}
\end{figure}

Das letzte Diagramm \ref{fig:Messunge} zeigt die Spannungsamplitunden
an den Kettengliedern bei der abgeschlossenen $LC$-Kette. Dafür wurden die
Daten der Tabelle \ref{tab:stehendeWelle} aus der Spalte von $\nu_{abge}$
bei einer Frequenz von $\SI{7337}{\hertz}$. Der Verlauf der Messdaten etspricht
den Erwartungen der Messung, da keine stehenden Welle erkenntlich sind.
Dies ergit sich auch aus den theoretischen Überlegungen über die
abgeschlossene Schaltung.

Die Messungen der Spannungsamplituden der offenen $LC$-Kettenschaltung, $LC_1C_2$-Kettenschaltung
und der abgeschlossenen $LC$-Kettenschaltung ergab die folgenden Werte. Die Angaben sind
in \si{\milli\volt}.

\FloatBarrier
\floatplacement{table}{htbp}
\begin{table}
 \centering
 \sisetup{table-format=1.3}
 \begin{tabular}[width=\textwidth]{S[table-format=1.0] S S S[table-format=2.0]}
     \toprule
      {Kettenglied} & {$\nu_C=\SI{7133}{\hertz}$} & {$\nu_{C} = \SI{14307}{\hertz}$} & {$\nu_{abge}=\SI{7337}{\hertz}$}\\
     \midrule
      1 & 1,55 & 0,925 & 25 \\
      2 & 1,425 & 0,65 & 25 \\
      3 & 1,2 & 0,25 & 25 \\
      4 & 0,95 & 0,2 & 25 \\
      5 & 0,66 & 0,61 & 25 \\
      6 & 0,3 & 0,9  & 25 \\
      7 & 0,027 & 1  & 25 \\
      8 & 0,3 & 0,98 & 25  \\
      9 & 0,95& 0,71  & 25 \\
      10 & 1,2 & 0,28 & 25 \\
      11 & 1,4 & 0,17 & 25 \\
      12 & 1,55 & 0,65 & 24,5 \\
      13 & 1,575 & 1 & 24,5 \\
    14 & \text{\,\,\,\,\,\,\,\,\,\,\,\,--} & 1,05 & 24,5 \\
      \bottomrule
\end{tabular}
  \caption{Messdaten der stehenden Welle}
  \label{tab:stehendeWelle}
\end{table}

\section{Diskussion}

Im Folgendem werden die Messergebnisse diskutiert.
Zunächst wird auf mögliche Fehlerquellen eingegangen, mit denen sich die Messungenauigkeiten
begründen lassen. Zum einen war das Einstellen des Wellenwiderstandes auf der
Eingangsseite (links) äußert unpräzise. Leichte Berührungen des Widerstandreglers
hatten schon enormen Einfluss auf den widergegebenen Widerstand.
Zudem konnten die gemessenen Frequenzen nur schwierig abgelesen werden, da der
Generator keine konstante Frequenz bereitgestellt hat. Die Frequenzen
können deshalb die Messergebnisse mit Fehlern behaftet haben.
Während des Zeichnens der Durchlasskurve durch den $XY$-Schreiber wurden Fixpunkte
an dem Diagramm gewählt, an denen die Frequenz zu bestimmen war. Die Abstandsmessung
der Fixpunkte wurde als fehlerfrei angenommen und das Messen der Frequenzen
erfolgte nicht parallel zum Zeichnen.
Insgesamt ist zu sagen, dass die verwendete Apparatur sehr alt ist und sehr
undurchsichtig wirkte.  Damit ist gemeint, dass nicht sichergestellt
war, ob alle angeschlossenen Bauteile funktionierten.
Die Induktivitäten und Kapazitäten der Apparatur wurden als fehlerfrei angenommen.\\
\\
Die Messergebnisse der Durchlasskurven sind in den Abbildungen \ref{fig:DispersionC}
und \ref{fig:DispersionC1C2} dargestellt. Es ist ersichtlich, dass
die Dispersionskurve der $LC$-Kette beinahe auf der Theoriekurve liegt.
Jedoch wird nicht die theoretische Grenzfrequenz in dem Aufbau erreicht.
Die Messung war nur bis zu einer relativen Phasenverschiebung pro Glied von
$\frac{\pi}{2}$ möglich. Die Lissajous-Figuren wurden bei allen höheren
Verschiebungen nicht mehr erkennbar. Die gemessene Dispersionskurve der
$LC_1C_2$-Kette ähnelt der Theoriekurve erkennbar, doch scheint sie um eine
Faktor verschoben zu sein. Es wird deutlich, dass der Anfang
der Kurve linear ist. Die Abweichungen der Messdaten von der Theoriekurve
sind durch die oben genannten Gründe erklärbar.\\ \\
Nun folgt eine Diskussion der Diagramme \ref{fig:Messungd1}, \ref{fig:Messungd2}
und \ref{fig:Messunge}. In den ersten Diagramm ist die 1. Eigenschwingung der
$LC$-Kettenschaltung zusehen. Die Gestalt der Eigenschwingung ist deutlich
zuerkennen. Abweichungen zu einer Theoriekurve der ersten Eigenschwingung
sind mit Frequenzschüben des Generators zu erklären.
Das zweite Diagramm zeigt die zweite Eigenschwingung des Systems, auch deren
Gestalt ist deutlich zu erkennen. Die beiden Knotenpunkte lassen sich erahnen.
Das an diesen Stellen keine wirklichen Knotenpunkte sitzen lässt sich wieder auf
Frequenzschübe des Generators zurückführen.
Das letzte Diagramm zeigt die abgeschlossenen $LC$-Kette bei einer Frequenz
von $\SI{7337}{\hertz}$. Es ist deutlich zuerkennen, dass sich keine sichtbare
Welle ausbreitet. Dies hängt damit zusammen, dass sich keine steheden Wellen
ausbilden. Die Abweichungen ab dem 11.
Kettenglied sind ebenfalls mit dem Wellenwiderstand zubegründen.

%\end{document}


text:
/** @file einspline_validation.cpp
 *
 * Test code to check the correctness of the einspline
 */
#include <SandBox/SplineTestBase.h>
#include <spline/einspline_util.hpp>
#include <Message/Communicate.h>
#include "Numerics/HDFNumericAttrib.h"
#include <io/hdf_archive.h>
#include <mpi/collectives.h>
#include <getopt.h>

//testing subgrid
qmcplusplus::TinyVector<double,3> lower(0.25,0.25,0.25);
qmcplusplus::TinyVector<double,3> upper(0.75,0.75,0.75);

namespace qmcplusplus
{
template<typename PT>
inline bool inbox(const PT& pos)
{
  return (pos[0]>lower[0] && pos[0]<upper[0]
          &&  pos[1]>lower[1] && pos[1]<upper[0]
          &&  pos[2]>lower[2] && pos[2]<upper[0]
         );
}

template<typename ENGT>
void SplineTest<ENGT>
::test(vector<TinyVector<typename SplineTest<ENGT>::real_type,3> >& coord)
{
  //read data from a file
  int ngx=160;
  int ngy=160;
  int ngz=160;
  Array<double,3> big(ngx,ngy,ngz),small(ngx/2,ngy/2,ngz/2);
  {
    hdf_archive h5f;
    h5f.open("sample.h5");
    h5f.read(big,"big_40");
    h5f.read(small,"small_40");
  }
  typedef TinyVector<real_type,3> pos_type;
  pos_type start(0.0);
  pos_type end(1.0);
  TinyVector<int,3> ng(ngx,ngy,ngz), ngh(ngx/2,ngy/2,ngz/2);
  //create/set UBspline_3d_X with the dense grid
  typename bspline_engine_traits<ENGT>::SingleSplineType* dense=0;
  dense=einspline::create(dense,start,end,ng,PERIODIC);
  einspline::set(dense,big.data());
  //create/set UBspline_3d_X with the coarse grid
  typename bspline_engine_traits<ENGT>::SingleSplineType* coarse=0;
  coarse=einspline::create(coarse,start,end,ngh,PERIODIC);
  einspline::set(coarse,small.data());
  //create/set multi_UBspline_3d as usual on the dense grid
  einspline_engine<ENGT> einspliner;
  einspliner.create(start,end,ng,PERIODIC,num_splines);
  for(int i=0; i<num_splines; ++i)
    einspliner.set(i,big);
  //create multi_UBspline_3d as usual on a truncated grid based on the dense grid
  einspline_engine<multi_UBspline_3d_d> newspline;
  GridConvert<real_type> gconv;
  gconv.create(newspline.spliner,dense,lower,upper,num_splines);
  for(int i=0; i<num_splines; ++i)
    einspline::set(newspline.spliner,i,dense,gconv.Offset,gconv.N);
  cout << "Original dense grid " << endl;
  print_spliner(einspliner.spliner);
  cout << "Truncated dense grid " << endl;
  print_spliner(newspline.spliner);
  Vector<value_type> psi(num_splines);
  Vector<real_type> psi_c(num_splines);
  accumulator_set<real_type> dv,ds,din,dout;
  int n_in=0;
  int n_out=0;
  for(int i=0; i<nsamples; ++i)
  {
    value_type v_dense, v_mixed;
    einspliner.evaluate(coord[i],psi);
    v_dense = einspline::evaluate(dense,coord[i]);
    ds(diff(v_dense,psi[0]));
    if(inbox(coord[i]))
    {
      n_in++;
      newspline.evaluate(coord[i],psi_c);
      v_mixed=psi_c[0];
      din(diff(v_mixed,v_dense));
    }
    else
    {
      n_out++;
      v_mixed = einspline::evaluate(coarse,coord[i]);
      dout(diff(v_mixed,v_dense));
    }
    dv(diff(v_dense,v_mixed));
    if(verbose)
    {
      cout << "At " << coord[i] << endl;
      cout << "Dense Grid " << v_dense
           <<  "\nMixed Grid " << v_mixed
           << endl << endl;
    }
  }
  app_log() << "Number of coords in the box       " << n_in << endl;
  app_log() << "Number of coords outside the box  " << n_out << endl;
  app_log() << "Average difference org-mixed grid " << dv.mean()
            << "\n\tInside  " << din.mean()
            << "\n\tOutside " << dout.mean()
            << "\n\tmulti-spline:single-spline ="  << ds.mean()
            << endl;
}
}
int main(int argc, char** argv)
{
  using namespace qmcplusplus;
  OHMMS::Controller->initialize(argc,argv);
  Communicate* mycomm=OHMMS::Controller;
  OhmmsInfo Welcome("einspline",mycomm->rank());
  Random.init(0,1,11);
  SplineTestBase param(argc,argv);
  typedef TinyVector<double,3> pos_type;
  vector<pos_type> coord(param.nsamples);
  for(int i=0; i<coord.size(); ++i)
    coord[i]=pos_type(Random(),Random(),Random());
//  for(int i=0; i<coord.size(); ++i)
//    coord[i]=pos_type((upper[0]-lower[0])*Random()+lower[0]
//        , (upper[1]-lower[1])*Random()+lower[1]
//        , (upper[2]-lower[2])*Random()+lower[2]
//        );
//
  vector<TinyVector<double,3> > coord_s(coord.size());
  for(int i=0; i<coord.size(); ++i)
    convert(coord[i],coord_s[i]);
  cout << "\nTesting einspline transformation" << endl;
  SplineTest<multi_UBspline_3d_d> test_d(param);
  test_d.test(coord);
  return 0;
}


text:
package org.openehealth.ipf.commons.ihe.xacml20.stub.xacml20.saml.assertion;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import org.herasaf.xacml.core.context.impl.RequestType;
import org.herasaf.xacml.core.context.impl.ResponseType;
import org.openehealth.ipf.commons.ihe.xacml20.stub.saml20.assertion.StatementAbstractType;

/**
 *
Java class for XACMLAuthzDecisionStatementType complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="XACMLAuthzDecisionStatementType">
 *   <complexContent>
 *     <extension base="{urn:oasis:names:tc:SAML:2.0:assertion}StatementAbstractType">
 *       <sequence>
 *         <element ref="{urn:oasis:names:tc:xacml:2.0:context:schema:os}Response"/>
 *         <element ref="{urn:oasis:names:tc:xacml:2.0:context:schema:os}Request" minOccurs="0"/>
 *       </sequence>
 *     </extension>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "XACMLAuthzDecisionStatementType", propOrder = {
    "response",
    "request"
})
public class XACMLAuthzDecisionStatementType
    extends StatementAbstractType
{

    @XmlElement(name = "Response", namespace = "urn:oasis:names:tc:xacml:2.0:context:schema:os", required = true)
    protected ResponseType response;
    @XmlElement(name = "Request", namespace = "urn:oasis:names:tc:xacml:2.0:context:schema:os")
    protected RequestType request;

    /**
     * Gets the value of the response property.
     *
     * @return
     *     possible object is
     *     {@link ResponseType }
     *
     */
    public ResponseType getResponse() {
        return response;
    }

    /**
     * Sets the value of the response property.
     *
     * @param value
     *     allowed object is
     *     {@link ResponseType }
     *
     */
    public void setResponse(ResponseType value) {
        this.response = value;
    }

    /**
     * Gets the value of the request property.
     *
     * @return
     *     possible object is
     *     {@link RequestType }
     *
     */
    public RequestType getRequest() {
        return request;
    }

    /**
     * Sets the value of the request property.
     *
     * @param value
     *     allowed object is
     *     {@link RequestType }
     *
     */
    public void setRequest(RequestType value) {
        this.request = value;
    }

}


text:
Some of my cmdlets

## Installation

    cd %USERPROFILE%\Documents
    git clone https://github.com/mac2000/WindowsPowerShell.git

## TODO: Publishing to PowerShell Gallery

    New-ModuleManifest -Path 'C:\Users\Alexandr\Documents\WindowsPowerShell\Modules\HelloWorld\HelloWorld.psd1'
    Publish-Module -Name HelloWorld -NuGetApiKey '********-****-****-****-************'
    Find-Module -Name HelloWorld
    Install-Module HelloWorld

# Modules

ConvertTo-Markdown
==================

ConvertTo-Markdown
------------------

Converts a PowerShell object to a Markdown table.

        $data | ConvertTo-Markdown
        ConvertTo-Markdown($data)

ConvertTo-TabbedList
====================

ConvertTo-TabbedList
--------------------

Converts a PowerShell object to a Tabbed list which can be copied to Excel.

        $data | ConvertTo-TabbedList | clip
        ConvertTo-TabbedList($data)

Generate-Readme
===============

Generate-Readme
---------------

Generate markdown readme with module descriptions and usage examples

        Generate-Readme

HelloWorld
==========

Say-Hello
---------

PowerShell Module StarterKit

        Say-Hello
        Say-Hello -To Alexandr

PasswordVault
=============

Get-VaultCredential
-------------------

Retrieves credentials stored in the current user's PasswordVault. It will either return all stored credentials
or a subset meeting the passed in criteria

        #get all credentials stored in the vault for the current user
        Get-VaultCredential -Resolve
        #get all credentials with the user name "fakeuser@microsoft.com" stored in the vault for the current user
        Get-VaultCredential -UserName "fakeuser@microsoft.com" -Resolve

Add-VaultCredential
-------------------

Adds a credential, associated with a particular resource, to the current user's PasswordVault.

        #Add a 100 test credentials to the PasswordVault, associated with an index numbered resource
        $added = 1..100 | Add-VaultCredential -UserName TestUser -Password (read-host -prompt Password -AsSecureString) -PassThrough
        #Visually verify the credentials have been stored
        Get-VaultCredential -UserName TestUser
        #Add a credential for a website login
        Add-VaultCredential -Resource "https://www.outlook.com" -UserName "fakeuser@microsoft.com"

Remove-VaultCredential
----------------------

Removes the specified credentials from the PasswordVault store

        #Add a 100 test credentials to the PasswordVault, associated with an index numbered resource
        $added = 1..100 | Add-VaultCredential -UserName TestUser -Password (read-host -prompt Password -AsSecureString) -PassThrough
        #visually verify that they have been stored
        Get-VaultCredential -UserName TestUser
        #Delete the newly created test credentials
        $added | Remove-VaultCredential

ConvertTo-Credential
--------------------

Converts a PasswordVault credential to a standard Powershell credential

        #Add a 100 test credentials to the PasswordVault, associated with an index numbered resource
        $added = 1..100 | Add-VaultCredential -UserName TestUser -Password (read-host -prompt Password -AsSecureString) -PassThrough
        #convert all new test PasswordVault credentials to Powershell credentials
        $added | ConvertTo-Credential
        #Get a credential from the PasswordVault that is associated with Powershell remoting and use it to execute a command on a remote host
        #Note the url protocol used as the resource name is fictitious and used solely for identification
        #The converted credential will have a Resource note property attached
        $credential = Get-VaultCredential -Resource "psrp://MyServer.microsoft.com" -UserName "fakeuser" | ConvertTo-Credential
        Invoke-Command -Credential $credential -ComputerName ($credential.Resource.split("//")[2]) -ScriptBlock { write-host -f green "Hello from $env:COMPUTERNAME" }

ConvertTo-VaultCredential
-------------------------

Converts a standard Powershell credential to a PasswordVault credential. An associated resource
must be specified for the credential if the credential was not created with the corresponding
command ConvertTo-Credential

        #Add a 100 test credentials to the PasswordVault, associated with an index numbered resource
        $added = 1..100 | Add-VaultCredential -UserName TestUser -Password (read-host -prompt Password -AsSecureString) -PassThrough
        #convert the PasswordVault credentials to standard Powershell credentials, and back again
        $added | ConvertTo-Credential | ConvertTo-VaultCredential


text:
package agent

import (
	"bytes"
	"github.com/gocd-contrib/gocd-golang-agent/stream"
	"io/ioutil"
	"net/http"
	"net/url"
	"time"
)

type BuildConsole struct {
	Url        *url.URL
	HttpClient *http.Client
	buffer     *bytes.Buffer
	stop       chan bool
	closed     chan bool
	write      chan []byte
}

func timestampPrefix() []byte {
	ts := time.Now().Format("15:04:05.000 ")
	return []byte(ts)
}

func MakeBuildConsole(httpClient *http.Client, url *url.URL) *BuildConsole {
	console := BuildConsole{
		HttpClient: httpClient,
		Url:        url,
		buffer:     bytes.NewBuffer(make([]byte, 0, 10*1024)),

		stop:   make(chan bool),
		closed: make(chan bool),
		write:  make(chan []byte),
	}
	go func() {
		defer func() {
			close(console.closed)
			LogInfo("build console closed")
		}()
		tw := stream.NewPrefixWriter(console.buffer, timestampPrefix)
		flushTick := time.NewTicker(5 * time.Second)
		defer flushTick.Stop()
		for {
			select {
			case log := <-console.write:
				tw.Write(log)
			case <-console.stop:
				console.Flush()
				return
			case <-flushTick.C:
				console.Flush()
			}
		}
	}()

	return &console
}

func (console *BuildConsole) Close() error {
	return closeAndWait(console.stop, console.closed, CancelCommandTimeout)
}

func (console *BuildConsole) Write(data []byte) (int, error) {
	console.write <- data
	return len(data), nil
}

func (console *BuildConsole) Flush() {
	if console.buffer.Len() == 0 {
		return
	}
	LogDebug("ConsoleLog: \n%v", console.buffer.String())

	req := http.Request{
		Method:        http.MethodPut,
		URL:           console.Url,
		Body:          ioutil.NopCloser(console.buffer),
		ContentLength: int64(console.buffer.Len()),
		Close:         true,
	}
	_, err := console.HttpClient.Do(&req)
	if err != nil {
		logger.Error.Printf("build console flush failed: %v", err)
	}
	console.buffer.Reset()
}


text:
This app was generated with the .NET Core CLI version 3.1.413 by running:
```
dotnet new mvc -o templated_runtime
```
The `RuntimeFrameworkVersion` was then added and templated in the `.csproj`
file:

```
<RuntimeFrameworkVersion><%= runtime_version %></RuntimeFrameworkVersion>
```


text:
'use strict'

exports.OFFLINE = true


text:
export declare function relativeToFile(name: string, file: string): string;
export declare function join(path1: string, path2: string): string;
export declare function buildQueryString(params?: Object, traditional?: boolean): string;
export declare function parseQueryString(queryString: string): Object;


text:
'use strict'

let webpack = require('webpack')
let HtmlWebpackPlugin = require('html-webpack-plugin')
let CopyWebpackPlugin = require('copy-webpack-plugin')

let vendorModules = /(node_modules|bower_components)/

let CompressionPlugin = require('compression-webpack-plugin')
let CleanPlugin = require('clean-webpack-plugin')

module.exports = {
  target: "web",
  entry: {
    app: "./app",
  },

  output: {
    path: './dist',
    filename: "app.js",
    pathinfo: true,
    publicPath: "",
  },

  module: {
    loaders: [
      {
        test: /\.js$/,
        exclude: vendorModules,
        loader: 'babel',
        query: {
          presets: ['es2015', 'es2017'],
          plugins: [
            'transform-runtime',
            'transform-es2015-destructuring',
            'transform-object-rest-spread',
            'transform-async-to-generator'
          ],
        },
      },
      { test: /\.css$/, loader: "style-loader!css-loader" },
      { test: /\.(woff|woff2|eot|ttf|svg)$/, loader: 'url-loader?limit=100000' },
      { test: /\.jpg$/, loader: "url-loader?mimetype=image/jpg" },
      { test: /\.bmp$/, loader: "url-loader?mimetype=image/bmp" },
      { test: /\.png$/, loader: "url-loader?mimetype=image/png" },
      { test: /\.scss$/, loaders: ["style", "css", "sass"] },
    ],
  },

  plugins: [
    new webpack.optimize.CommonsChunkPlugin("init.js"),
    new HtmlWebpackPlugin({
      title: 'App',
      minify: process.env.NODE_ENV === 'production' ? {
        removeComments: true,
        removeCommentsFromCDATA: true,
        collapseWhitespace: true,
        conservativeCollapse: false,
        collapseBooleanAttributes: true,
        removeAttributeQuotes: true,
        removeRedundantAttributes: true,
        preventAttributesEscaping: true,
        useShortDoctype: true,
        removeEmptyAttributes: true,
        removeScriptTypeAttributes: true,
        removeStyleLinkTypeAttributes: true,
      } : false,
      template: './index.html',
    }),
    new webpack.HotModuleReplacementPlugin(),
    new CleanPlugin(['./dist']),
    new CopyWebpackPlugin([{ from: 'assets', to: 'assets' }]),
    new webpack.NoErrorsPlugin(),
    new webpack.DefinePlugin({
      "process.env": {
        NODE_ENV: JSON.stringify(process.env.NODE_ENV),
        BROWSER: JSON.stringify(true),
      },
    }),
    new webpack.optimize.DedupePlugin(),
    new webpack.optimize.OccurenceOrderPlugin(true),
    process.env.NODE_ENV === 'production' ? new webpack.optimize.UglifyJsPlugin({
      compress: {
        warnings: false,
      },
      mangle: false,
      comments: /\@license|\@preserv/gi,
    }) : function(source) {
      return source
    },
    new CompressionPlugin({
      asset: "{file}.gz",
      algorithm: "gzip",
      regExp: new RegExp("\.(js|html|css|svg)$"),
      threshold: 10240,
      minRatio: 0.8,
    })
  ],
  debug: false,
  watch: false,
}


text:
package lifecycle

import (
	"github.com/lxc/lxd/shared/api"
	"github.com/lxc/lxd/shared/version"
)

// InstanceSnapshotAction represents a lifecycle event action for instance snapshots.
type InstanceSnapshotAction string

// All supported lifecycle events for instance snapshots.
const (
	InstanceSnapshotCreated = InstanceSnapshotAction(api.EventLifecycleInstanceSnapshotCreated)
	InstanceSnapshotDeleted = InstanceSnapshotAction(api.EventLifecycleInstanceSnapshotDeleted)
	InstanceSnapshotRenamed = InstanceSnapshotAction(api.EventLifecycleInstanceSnapshotRenamed)
	InstanceSnapshotUpdated = InstanceSnapshotAction(api.EventLifecycleInstanceSnapshotUpdated)
)

// Event creates the lifecycle event for an action on an instance snapshot.
func (a InstanceSnapshotAction) Event(inst instance, ctx map[string]any) api.EventLifecycle {
	parentName, snapName, _ := api.GetParentAndSnapshotName(inst.Name())

	u := api.NewURL().Path(version.APIVersion, "instances", parentName, "snapshots", snapName).Project(inst.Project())

	var requestor *api.EventLifecycleRequestor
	if inst.Operation() != nil {
		requestor = inst.Operation().Requestor()
	}

	return api.EventLifecycle{
		Action:    string(a),
		Source:    u.String(),
		Context:   ctx,
		Requestor: requestor,
	}
}


text:
namespace g{namespace Fuse{namespace Drawing{namespace Tesselation{struct Geom;}}}}
namespace g{namespace Fuse{namespace Drawing{namespace Tesselation{struct Vertex;}}}}

namespace g{
namespace Fuse{
namespace Drawing{
namespace Tesselation{

// internal static class Geom :125
// {
uClassType* Geom_typeof();
void Geom__EdgeEval_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w, float* __retval);
void Geom__EdgeSign_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w, float* __retval);
void Geom__Interpolate_fn(double* ai, double* x, double* bi, double* y, double* __retval);
void Geom__Intersect_fn(::g::Fuse::Drawing::Tesselation::Vertex* o1p, ::g::Fuse::Drawing::Tesselation::Vertex* d1p, ::g::Fuse::Drawing::Tesselation::Vertex* o2p, ::g::Fuse::Drawing::Tesselation::Vertex* d2p, ::g::Fuse::Drawing::Tesselation::Vertex** __retval);
void Geom__Swap_fn(::g::Fuse::Drawing::Tesselation::Vertex** a, ::g::Fuse::Drawing::Tesselation::Vertex** b);
void Geom__TransEval_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w, float* __retval);
void Geom__TransLeq_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, bool* __retval);
void Geom__TransSign_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w, float* __retval);
void Geom__VertCCW_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w, bool* __retval);
void Geom__VertL1dist_fn(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, double* __retval);

struct Geom : uObject
{
    static float EdgeEval(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w);
    static float EdgeSign(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w);
    static double Interpolate(double ai, double x, double bi, double y);
    static ::g::Fuse::Drawing::Tesselation::Vertex* Intersect(::g::Fuse::Drawing::Tesselation::Vertex* o1p, ::g::Fuse::Drawing::Tesselation::Vertex* d1p, ::g::Fuse::Drawing::Tesselation::Vertex* o2p, ::g::Fuse::Drawing::Tesselation::Vertex* d2p);
    static void Swap(::g::Fuse::Drawing::Tesselation::Vertex** a, ::g::Fuse::Drawing::Tesselation::Vertex** b);
    static float TransEval(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w);
    static bool TransLeq(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v);
    static float TransSign(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w);
    static bool VertCCW(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v, ::g::Fuse::Drawing::Tesselation::Vertex* w);
    static double VertL1dist(::g::Fuse::Drawing::Tesselation::Vertex* u, ::g::Fuse::Drawing::Tesselation::Vertex* v);
};
// }

}}}} // ::g::Fuse::Drawing::Tesselation


text:
var assert = require('chai').assert;

var bbop = require('bbop-core');
var us = require('underscore');
var each = us.each;

var amigo = require('..');

///
/// Start unit testing.
///

describe('extant tests for new system', function(){

    it('Try it with the real stuff', function(){

	var a = new amigo();
	var h = a.handler;

	// ...
	var aej = '{"relationship": {"relation": [{"id": "RO:0002315", "label": "results_in_acquisition_of_features_of"}], "id": "CL:0000136", "label": "fat cell"}}';
	//bbop.core.dump(h.string_to_function_map)
	var correct = 'results_in_acquisition_of_features_of fat cell';
	assert.equal(h.dispatch(aej,
				'annotation_extension_json',
				'bbop-widget-set.live_results'),
		     correct,
		     "got complicated rendering");

    });

    it('Try it trivially with play data', function(){

    	var bonus_dispatch = {
    	    'echo_test_field_01': {
    		'default': function(a){ return 'default_01'; },
    		'context': {
    		    'echo_test_context_01': function(a){ return 'context_01'; }
    		}
	    },
    	    'echo_test_field_02': {
		// No default
    		'context': {
    		    'echo_test_context_02': function(a){ return 'context_02'; }
    		}
    	    },
    	    'echo_test_field_03': {
	    }
    	};
    	var a = new amigo(bonus_dispatch);
    	var h = a.handler;

    	assert.equal(h.dispatch('', 'echo_test_field_01'), 'default_01',
    		     'default w/no context');
    	assert.equal(h.dispatch('', 'echo_test_field_01',
				'echo_test_context_01'), "context_01",
    		     'correct context');

	// Bad things.
    	assert.isNull(h.dispatch('', 'echo_test_field_03',
				 'echo_test_context_01'),
    		      'null in empty structure/bad field');
    	assert.equal(h.dispatch('', 'echo_test_field_01',
				'echo_test_context_03'),
		     'default_01',
    		     'good field but bad context sends to default');
    	assert.equal(h.dispatch('', 'echo_test_field_01',
				'echo_test_context_03',
				function(a){ return 'bleh'; }),
		     'default_01',
		     'prefer default context to fallback in bad structure');
	// Prefers default to fallback.
    	assert.equal(h.dispatch('', 'echo_test_field_02',
				'echo_test_context_03',
				function(a){ return 'bleg'; }),
		     "bleg",
    		     'good field, bad context, no default, goes to fallback');
    	assert.isNull(h.dispatch(null, 'echo_test_field_02'),
    		      'null in null out');
    });
});


text:
package matrix;

/**
 *
 * @author Bence Erős <crystal@cyclonephp.org>
 */
public enum Direction {

    VERTICAL, HORIZONTAL;

}


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
* @name: S15.3.4.3_A5_T4;
* @section: 15.3.4.3;
* @assertion: If thisArg is not null(defined) the called function is passed ToObject(thisArg) as the this value;
* @description: thisArg is function variable that return this;
*/

f = function(){this.touched= true; return this;};

retobj = f.apply(obj);

//CHECK#1
if (typeof obj !== "undefined") {
  $ERROR('#1: If thisArg is not null(defined) the called function is passed ToObject(thisArg) as the this value');
}

//CHECK#2
if (!(retobj["touched"])) {
  $ERROR('#2: If thisArg is not null(defined) the called function is passed ToObject(thisArg) as the this value');
}

var obj;


text:
class AddBeneficiarioIdToDepartamento < ActiveRecord::Migration
  def change
    add_column :departamentos, :beneficiario_id, :integer
  end
end


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.trino.metadata;

import io.trino.spi.type.TypeSignature;

import java.util.Optional;

import static com.google.common.base.MoreObjects.toStringHelper;
import static java.util.Objects.requireNonNull;

public class AggregationFunctionMetadata
{
    private final boolean orderSensitive;
    private final Optional<TypeSignature> intermediateType;

    public AggregationFunctionMetadata(boolean orderSensitive, Optional<TypeSignature> intermediateType)
    {
        this.orderSensitive = orderSensitive;
        this.intermediateType = requireNonNull(intermediateType, "intermediateType is null");
    }

    public boolean isOrderSensitive()
    {
        return orderSensitive;
    }

    public Optional<TypeSignature> getIntermediateType()
    {
        return intermediateType;
    }

    @Override
    public String toString()
    {
        return toStringHelper(this)
                .add("orderSensitive", orderSensitive)
                .add("intermediateType", intermediateType)
                .toString();
    }
}


text:
membership and user listing system with PHP. The system contains 2 parts. First part is backend, and second part is front-end. These parts communicate over REST API. Front-end and back-end must be isolated from each other.

# application/controllers/API

             public function index()
                {
                    //get json object
                    $input=(json_decode(file_get_contents("php://input")));
                    //get the right form of my json object "{action:"",data:""}"
                    try
                    {
                        if(empty($input->action))
                        {throw new Exception('json object error');}
                    }
                    catch (Exception $e)
                    {
                        print_r($e->getMessage());
                        die();
                    }
                    //switching between the types of the apis
                    switch ($input->action){
                        //login
                        case 'login':
                            $response=$this->login($input->data);
                            break;
                         //logout
                        case 'logout':
                            $member_id=$this->check_API_key();
                            $response=$this->logout($member_id);
                            break;
                        //user_list
                        case 'user_list':
                            $member_id=$this->check_API_key();
                            $response=$this->user_list();
                            break;
                        //user_get
                        case 'user_get':
                            $member_id=$this->check_API_key();
                            $response=$this->user_get($input->data);
                            break;
            default:
                $e=new Exception('so such action error');
                print_r($e->getMessage());
                die();

        }
        //return the result of the api request

        //print_r($response);// dumping the data in the array view for debugging
        print_r(json_encode($response));//send the api result in json form
        die();

    }

		#login api
		 function login($data)
    {
        try
        {
            if(empty($data->email)||empty($data->password))
            {throw new Exception('email or password error');}
        }
        catch (Exception $e)
        {
            print_r($e->getMessage());
            die();
        }
        $api_key=$this->data_model->login($data);
        $result['response']="success";
        $result['data']['API_key']=$api_key;
        return $result;
    }

		#logout api
		function logout($member_id)
    {
        $this->data_model->logout($member_id);
        $result['response']="success";
        $result['data']="";
        return $result;
    }

		#check the api key from the header
		function check_API_key()
    {
        try
        {
            if(empty(getallheaders()['API_key']))
            {throw new Exception('API key error');}
        }
        catch (Exception $e)
        {
            print_r($e->getMessage());
            die();
        }
        // get the member id if the key is true
        $member_id=$this->data_model->get_member_id(getallheaders()['API_key']);
        return $member_id;
    }

    #get all the users
    function user_list()
    {
       $data=$this->data_model->get_all_members();
       return $data;
    }

    #get single user
    function user_get($data)
    {
        try
        {
            if(empty($data->member_id))
            {throw new Exception('please select a user');}
        }
        catch (Exception $e)
        {
            print_r($e->getMessage());
            die();
        }
        $single_member=$this->data_model->get_member_data_by_id($data->member_id);
        $result['response']="success";
        $result['data']=$single_member;
        return $result;
    }


text:
package com.navercorp.nbasearc.confmaster.server.command;

import org.springframework.stereotype.Service;

@Service("faultInjectionService")
public class FaultInjectionService {

}


text:
import * as eta from "eta-lib";

import * as express from "express";

export class Model implements eta.Model {
    public render(req: express.Request, res: express.Response, callback: (env: { [key: string]: any }) => void): void {
        let os: string = eta.http.getUserAgent(req).os.family;
        if (os.indexOf("Android") !== -1 || os.indexOf("iOS") !== -1 || os.indexOf("Windows Phone") !== -1) {
            // mobile
            res.redirect("/office/schedule/availability/mobile");
        } else {
            // desktop
            res.redirect("/office/schedule/availability/desktop");
        }
    }
}


text:
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="48dp"
    android:height="48dp"
    android:viewportWidth="48"
    android:viewportHeight="48"
    android:tint="?attr/colorControlNormal">
  <path
      android:fillColor="@android:color/white"
      android:pathData="M24.1,34.05H27.5V13.95H20V17.35H24.1ZM43.15,43.1H4.9V4.85H43.15Z"/>
</vector>


text:
It is a project to develop akabeko.me.

## License

[MIT](LICENSE)

## Install

1. `git clone https://github.com/akabekobeko/akabeko.me.git`
2. `cd akabeko.me`
3. `npm i`

## Build

For deveopment.

```bash
npm start
```

For release.

```bash
npm run release
```

## Deploy

[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start/deploy?repository=https://github.com/gatsbyjs/gatsby-starter-default)

## Libraries & Resources

|Product|Type|License|
|---|---|---|
|[GatsbyJS](https://www.gatsbyjs.org/)|Static site generator|[MIT](https://github.com/gatsbyjs/gatsby/blob/master/LICENSE)|
|[Flat UI](http://designmodo.github.io/Flat-UI/)|Color scheme|[MIT](https://github.com/designmodo/Flat-UI/blob/master/LICENSE)|
|[Unicorn Giggles](https://mistifonts.com/unicorn-giggles/)|Font of site logo|[Free (personal use and non-profit use)](https://mistifonts.com/unicorn-giggles/)|
|[IcoMoon](https://icomoon.io/)|Icon font generator|Depends on icon packages|
|[Entypo+](http://www.entypo.com/)|Icon font|[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)|