text:
<?php

namespace CuboPolis;

/**
 * Description of Trx
 *
 * @author ctala
 */
class Trx {

    private $_CUBOPOLISAPIURL = "https://www.cubopolis.com/v1/api/";
    private $_access_token;
    private $_resource_token;
    public $nPedido;
    public $subTotal;
    public $descuentos;
    public $total;
    public $tipoTRX;
    public $fecha;

    function __construct($nPedido, $subTotal, $descuentos, $total, $tipoTRX, $fecha) {
        $this->nPedido = $nPedido;
        $this->subTotal = $subTotal;
        $this->descuentos = $descuentos;
        $this->total = $total;
        $this->tipoTRX = $tipoTRX;
        $this->fecha = $fecha;
    }

    function set_CUBOPOLISAPIURL($_CUBOPOLISAPIURL) {
        $this->_CUBOPOLISAPIURL = $_CUBOPOLISAPIURL;
    }

    function set_access_token($_access_token) {
        $this->_access_token = $_access_token;
    }

    function set_resource_token($_resource_token) {
        $this->_resource_token = $_resource_token;
    }

    function sendToServer($returnTransfer = true) {
        $fields = array(
            "nPedido" => intval($this->nPedido),
            "subTotal" => intval($this->subTotal),
            "descuentos" => intval($this->descuentos),
            "total" => intval($this->total),
            "tipoTRX" => $this->tipoTRX,
            "fecha" => $this->fecha,

        );

        $postUrl = $this->_CUBOPOLISAPIURL . "create" . "?access-token=" . $this->_access_token."&resource-token=".$this->_resource_token;

        $fieldsString = "";
        foreach ($fields as $key => $value) {
            $fieldsString.=$key . "=" . $value . "&";
        }
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $postUrl);
        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $fieldsString);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, $returnTransfer);
        $server_output = curl_exec($ch);

        curl_close($ch);
        echo '\n ';
        echo '\n ';
        return $server_output;
    }

}


text:
Classes to performs differentaion of equations and various utility classes.
The main class is
{@link org.lsmp.djep.djep.DifferentiationVisitor DifferentiationVisitor}
which performs the differentation by repeated applications
of the chain, product and quotient rules.
Typically the result of differentation should be simplified
to remove occurences of reduant expresions (for example
<tt>diff(x^2.0,x)</tt> is <tt>2.0*x^1.0*1.0</tt> which is simplified to <tt>2.0*x</tt>).

For each function a rule is used to specify how to differentiate it.
For example the differative of <tt>sin</tt> is specified using

addDiffRule(new MacroDiffRules(Jep,"sin","cos(x)"))

There are various classes of differentation rule which
all implement {@link org.lsmp.djep.djep.DiffRulesI DiffRulesI} and have special behavious.

Variables can also be differentiated, and the derivative of
<tt>y</tt> with respect to <tt>x</tt> will be represented
by the {@link org.lsmp.djep.djep.PartialDerivative PartialDerivative} <tt>dy/dx</tt>.
To allow this the {@link org.lsmp.djep.djep.DVariable DVariable} is used to represent
variable and
{@link org.lsmp.djep.djep.DSymbolTable DSymbolTable} and
{@link org.lsmp.djep.djep.DVariableFactory DVariableFactory} are used to control
the look up of variables and the creation of new variables.

Sub-packages

org.lsmp.djep.djep.diffRules
Classes defining how to perform differentation of given functions.

redpajama_set_name: RedPajamaGithub


text:
package com.evolveum.midpoint.web.page.admin.users.component;

import com.evolveum.midpoint.model.api.ModelExecuteOptions;
import com.evolveum.midpoint.web.security.MidPointApplication;
import com.evolveum.midpoint.xml.ns._public.common.common_3.SystemConfigurationType;
import com.evolveum.midpoint.xml.ns._public.common.common_3.TracingProfileType;
import org.jetbrains.annotations.NotNull;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * @author lazyman
 */
public class ExecuteChangeOptionsDto implements Serializable {

    public static final String F_FORCE = "force";
    public static final String F_RECONCILE = "reconcile";
    public static final String F_RECONCILE_AFFECTED = "reconcileAffected";
    public static final String F_EXECUTE_AFTER_ALL_APPROVALS = "executeAfterAllApprovals";
    public static final String F_KEEP_DISPLAYING_RESULTS = "keepDisplayingResults";
    public static final String F_TRACING = "tracing";
    public static final String F_TRACING_CHOICES = "tracingChoices";

    private boolean force;
    private boolean reconcile;
    private boolean reconcileAffected;
    private boolean executeAfterAllApprovals = true;
    private boolean keepDisplayingResults;
    private TracingProfileType tracing;
    private List<TracingProfileType> tracingChoices;

    public ExecuteChangeOptionsDto() {
    }

    public static ExecuteChangeOptionsDto createFromSystemConfiguration() {
        return new ExecuteChangeOptionsDto(MidPointApplication.get().getSystemConfigurationIfAvailable());
    }

    private ExecuteChangeOptionsDto(SystemConfigurationType config) {
        if (config != null && config.getRoleManagement() != null && config.getRoleManagement().isDefaultExecuteAfterAllApprovals() != null) {
            executeAfterAllApprovals = config.getRoleManagement().isDefaultExecuteAfterAllApprovals();
        }
        tracingChoices = new ArrayList<>();
        if (config != null && config.getInternals() != null && config.getInternals().getTracing() != null) {
            for (TracingProfileType profile : config.getInternals().getTracing().getProfile()) {
                if (!Boolean.FALSE.equals(profile.isVisible())) {
                    tracingChoices.add(profile.clone());
                }
            }
        }
        if (tracingChoices.isEmpty()) {
            tracingChoices.add(new TracingProfileType(MidPointApplication.get().getPrismContext()).name("Minimal"));
        }
    }

    public boolean isForce() {
        return force;
    }

    public void setForce(boolean force) {
        this.force = force;
    }

    public boolean isReconcile() {
        return reconcile;
    }

    public void setReconcile(boolean reconcile) {
        this.reconcile = reconcile;
    }

    public boolean isReconcileAffected() {
        return reconcileAffected;
    }

    public void setReconcileAffected(boolean reconcileAffected) {
        this.reconcileAffected = reconcileAffected;
    }

    public boolean isExecuteAfterAllApprovals() {
        return executeAfterAllApprovals;
    }

    public void setExecuteAfterAllApprovals(boolean executeAfterAllApprovals) {
        this.executeAfterAllApprovals = executeAfterAllApprovals;
    }

    public boolean isKeepDisplayingResults() {
        return keepDisplayingResults;
    }

    public void setKeepDisplayingResults(boolean keepDisplayingResults) {
        this.keepDisplayingResults = keepDisplayingResults;
    }

    public TracingProfileType getTracing() {
        return tracing;
    }

    public void setTracing(TracingProfileType tracing) {
        this.tracing = tracing;
    }

    public List<TracingProfileType> getTracingChoices() {
        return tracingChoices;
    }

    public void setTracingChoices(List<TracingProfileType> tracingChoices) {
        this.tracingChoices = tracingChoices;
    }

    @NotNull
    public ModelExecuteOptions createOptions() {
        ModelExecuteOptions options = new ModelExecuteOptions();
        options.setForce(isForce());
        options.setReconcile(isReconcile());
        options.setReconcileAffected(isReconcileAffected());
        options.setExecuteImmediatelyAfterApproval(!isExecuteAfterAllApprovals());
        options.setTracingProfile(tracing);
        return options;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Options{force=").append(isForce());
        builder.append(",reconcile=").append(isReconcile());
        builder.append(",reconcileAffected=").append(isReconcileAffected());
        builder.append(",keepDisplayingResults=").append(isKeepDisplayingResults());
        builder.append(",tracing=").append(tracing);
        builder.append('}');

        return builder.toString();
    }
}


text:
package com.itellity.sys.type.query;

import com.itellity.sys.entity.Entity;
import com.itellity.sys.type.AbstractImmutableValue;
import com.itellity.sys.type.PrimitiveValue;
import com.itellity.sys.util.CollectionUtilities;
import com.itellity.sys.util.StringUtilities;

import java.util.Collection;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Query;

/**
 * Encapsulates an EQL based Query. Provides methdos for Generation of EQL Queiry Objects
 * and autogeneration of AND - connectd where clauses.
 *
 * @author erik
 *
 * @param <T>
 */
public class QueryStatement<T extends Entity> extends AbstractImmutableValue {

    public static final String ENTITY_ALIAS = "p";
    public static final String FIELD_PREFIX = ENTITY_ALIAS + ".";

    private static final long serialVersionUID = 6238720419758687426L;

    private final Class<T> entityInterfaceClass;
    private final Class<?> entityImplClass;
    private final String whereClause;
    private final String joinClause;
    private final List<QueryParameter<?>> parameters;
    private final Integer fetchOffset;
    private final Integer fetchAmount;
    private final boolean undefined;

    public QueryStatement(Class<T> entityClass, List<QueryParameter<?>> parameters, Integer fetchOffset, Integer fetchAmount) {
        this(entityClass, entityClass, parameters, QuerySortCriteria.UNDEFINED, fetchOffset, fetchAmount);
    }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, List<QueryParameter<?>> parameters, Integer fetchOffset, Integer fetchAmount) {
        this(entityClass, entityImplClass, parameters, QuerySortCriteria.UNDEFINED, fetchOffset, fetchAmount);
    }

    public QueryStatement(Class<T> entityClass, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
            Integer fetchAmount) {
    	this(entityClass, entityClass, parameters, sortCriteria, fetchOffset, fetchAmount, null);

    }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
            Integer fetchAmount) {
    	this(entityClass, entityImplClass, parameters, sortCriteria, fetchOffset, fetchAmount, null);

    }

    /**
     * Constructs an EQL Statement for a given Entity with the givene parameters, sortcriteria and appendWhereCondition,
     * limited to the offset and amout passed.
     *
     *
     * @param entityClass the entity to be queried
     * @param parameters the query parameters
     * @param sortCriteria the sortation order
     * @param fetchOffset offset for LIMIT()
     * @param fetchAmount amoun for LIMIT(), i.e pagination
     * @param appendedWhereConditon additional condition passed as string
     */
    public QueryStatement(Class<T> entityClass, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
        Integer fetchAmount, String appendedWhereConditon) {
    	this(entityClass, entityClass, "", parameters, sortCriteria, fetchOffset, fetchAmount, appendedWhereConditon);
    }

    /**
     * Constructs an EQL Statement for a given Entity with the givene parameters, sortcriteria and appendWhereCondition,
     * limited to the offset and amout passed.
     *
     *
     * @param entityClass the entity to be queried
     * @param parameters the query parameters
     * @param sortCriteria the sortation order
     * @param fetchOffset offset for LIMIT()
     * @param fetchAmount amoun for LIMIT(), i.e pagination
     * @param appendedWhereConditon additional condition passed as string
     */
    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
        Integer fetchAmount, String appendedWhereConditon) {
    	this(entityClass, entityImplClass, "", parameters, sortCriteria, fetchOffset, fetchAmount, appendedWhereConditon);
    }

    /**
     * Constructs an EQL Statement for a given Entity with the givene parameters, sortcriteria and appendWhereCondition,
     * limited to the offset and amout passed.
     *
     *
     * @param entityClass the entity to be queried
     * @param parameters the query parameters
     * @param sortCriteria the sortation order
     * @param fetchOffset offset for LIMIT()Interface
     * @param fetchAmount amoun for LIMIT(), i.e pagination
     * @param appendedWhereConditon additional condition passed as string
     */
    public QueryStatement(Class<T> entityClass, String joinClause, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
            Integer fetchAmount, String appendedWhereConditon) {
    	this(entityClass, entityClass,  joinClause, parameters, sortCriteria, fetchOffset, fetchAmount, appendedWhereConditon);
    }

    /**
     * Constructs an EQL Statement for a given Entity with the givene parameters, sortcriteria and appendWhereCondition,
     * limited to the offset and amout passed.
     *
     *
     * @param entityInterfaceClass the entity to be queried
     * @param entityImplClass the entity to be queried
     * @param parameters the query parameters
     * @param sortCriteria the sortation order
     * @param fetchOffset offset for LIMIT()Interface
     * @param fetchAmount amoun for LIMIT(), i.e pagination
     * @param appendedWhereConditon additional condition passed as string
     */
     public QueryStatement(Class<T> entityInterfaceClass, Class<?> entityImplClass, String joinClause, List<QueryParameter<?>> parameters, QuerySortCriteria sortCriteria, Integer fetchOffset,
                Integer fetchAmount, String appendedWhereConditon) {

        super();
        this.entityInterfaceClass = entityInterfaceClass;
        this.entityImplClass = entityImplClass;
        this.joinClause = joinClause;

        String whereClause = "";

        if (!parameters.isEmpty()) {
            whereClause = "where ";

            for (QueryParameter<?> param : parameters) {
            	if (param.isCollectionParameter() && !CollectionUtilities.isNullOrEmpty((Collection<?>) param.getParameter())) {
            		whereClause += " " + FIELD_PREFIX + param.getKey() + " in (:" + param.getKey() + ") and ";
            	} else if (param.hasQueryParameterOption()) {
            		QueryParameterOption queryParameterOption = ((QueryParameterOption) param.getOption());
					if (QueryParameterOption.IN_ELEMENTS.equals(queryParameterOption)) {
						whereClause += " :"  + param.getKey() + QueryParameterOption.IN_ELEMENTS.getName() + "elements(" + FIELD_PREFIX + param.getKey() + ") and ";
					} else {
						whereClause += " " + (queryParameterOption.isUseElementsKeyword() ? "elements(" + param.getKey() + ") " : FIELD_PREFIX + param.getKey() + " ") + queryParameterOption.getName() + " and ";
					}
            	} else {
            		whereClause += FIELD_PREFIX + param.getKey() + (param.isLikeQueryParameter() ? " like " : " = ") + ":" + param.getKey() + " and ";
            	}
            }

            whereClause = whereClause.substring(0, whereClause.length() - 4);
        }
        if (!StringUtilities.isNullOrEmpty(appendedWhereConditon)) {
        	appendedWhereConditon = StringUtilities.isNullOrEmpty(whereClause) ? "where " +
        			(appendedWhereConditon.trim().startsWith("and") ? appendedWhereConditon.trim().substring(3) : appendedWhereConditon)
        			: appendedWhereConditon.trim().startsWith("and") ? appendedWhereConditon : " and " + appendedWhereConditon;
        }

        this.whereClause = (whereClause + (StringUtilities.isNullOrEmpty(appendedWhereConditon) ? "" : appendedWhereConditon) + " " +sortCriteria.toString()).trim();
        this.parameters = parameters;
        this.fetchOffset = fetchOffset;
        this.fetchAmount = fetchAmount;
        this.undefined = false;
    }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, String whereClause, List<QueryParameter<?>> parameters, Integer fetchOffset, Integer fetchAmount) {
    	 this(entityClass, entityImplClass, "", whereClause, parameters, fetchOffset, fetchAmount);
    }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, String joinClause, String whereClause, List<QueryParameter<?>> parameters, Integer fetchOffset, Integer fetchAmount) {
        super();
        this.entityInterfaceClass = entityClass;
        this.entityImplClass = entityImplClass;
        this.joinClause = joinClause;
        this.whereClause = whereClause;
        this.parameters = parameters;
        this.fetchOffset = fetchOffset;
        this.fetchAmount = fetchAmount;
        this.undefined = false;
    }

    public QueryStatement(Class<T> entityClass,  String whereClause, List<QueryParameter<?>> parameters, QuerySortCriteria criteria,
            Integer fetchOffset, Integer fetchAmount) {
       	 this(entityClass,entityClass, "", whereClause, parameters, criteria, fetchOffset, fetchAmount);
        }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, String whereClause, List<QueryParameter<?>> parameters, QuerySortCriteria criteria,
        Integer fetchOffset, Integer fetchAmount) {
   	 this(entityClass,entityImplClass, "", whereClause, parameters, criteria, fetchOffset, fetchAmount);
    }

    public QueryStatement(Class<T> entityClass, Class<?> entityImplClass, String joinClause, String whereClause, List<QueryParameter<?>> parameters, QuerySortCriteria criteria,
            Integer fetchOffset, Integer fetchAmount) {
        super();
        this.entityInterfaceClass = entityClass;
        this.entityImplClass = entityImplClass;
        this.joinClause = "";
        this.whereClause = whereClause + criteria.toString();
        this.parameters = parameters;
        this.fetchOffset = fetchOffset;
        this.fetchAmount = fetchAmount;
        this.undefined = false;
    }

    /**
     * Returns the EQL Query for teh give entity, where condition and aparameter list
     *
     * @param entityManager
     * @return the query
     */
    public Query getSelectQuery(EntityManager entityManager) {
        Query q = entityManager.createQuery("from " + entityImplClass.getName() + " " + ENTITY_ALIAS + " " + getJoinClause() + " " + getWhereClause());

        setQueryParameters(q);

        if (fetchAmount != null) {
            q.setFirstResult((int) getFetchOffset());
            q.setMaxResults(getFetchAmount());
        }

        return q;
    }

    /**
     * Returns the EQL Query to count the amount of results for the give entity, where condition and aparameter list
     *
     * @param entityManager
     * @return the query
     */
    public Query getCountQuery(EntityManager entityManager) {
        Query q = entityManager.createQuery("select count(*) from " + entityImplClass.getName() + " " + ENTITY_ALIAS + " " + getJoinClause()  + " " + getWhereClause());

        setQueryParameters(q);

        return q;
    }

	private void setQueryParameters(Query q) {
		for (QueryParameter<?> param : getParameters()) {
        	if (param.getParameter() != null && (!param.hasQueryParameterOption() || (param.hasQueryParameterOption() &&
        			param.getOption().isRequiresParameterBinding()))) {
        		q.setParameter(param.getKey(), param.getParameter());
        	}
        }
	}

    public boolean isUndefined() {
        return undefined;
    }

    public Class<T> getEntityInterfaceClass() {
        return entityInterfaceClass;
    }

    public String getWhereClause() {
        return whereClause;
    }

    public List<QueryParameter<?>> getParameters() {
        return parameters;
    }

    public Integer getFetchOffset() {
        return fetchOffset;
    }

    public Integer getFetchAmount() {
        return fetchAmount;
    }

    @Override public int hashCode() {
        final int prime = 31;
        int result = 42;
        result = (prime * result) + ((entityInterfaceClass == null) ? 0 : entityInterfaceClass.hashCode());
        result = (prime * result) + ((fetchAmount == null) ? 0 : fetchAmount.hashCode());
        result = (prime * result) + ((fetchOffset == null) ? 0 : fetchOffset.hashCode());
        result = (prime * result) + ((parameters == null) ? 0 : parameters.hashCode());
        result = (prime * result) + (undefined ? 1231 : 1237);
        result = (prime * result) + ((whereClause == null) ? 0 : whereClause.hashCode());

        return result;
    }

    @Override public boolean doEquals(PrimitiveValue obj) {

        final QueryStatement<?> other = (QueryStatement<?>) obj;

        if (entityInterfaceClass == null) {

            if (other.entityInterfaceClass != null)
                return false;
        } else if (!entityInterfaceClass.equals(other.entityInterfaceClass))
            return false;

        if (fetchAmount == null) {

            if (other.fetchAmount != null)
                return false;
        } else if (!fetchAmount.equals(other.fetchAmount))
            return false;

        if (fetchOffset == null) {

            if (other.fetchOffset != null)
                return false;
        } else if (!fetchOffset.equals(other.fetchOffset))
            return false;

        if (parameters == null) {

            if (other.parameters != null)
                return false;
        } else if (!parameters.equals(other.parameters))
            return false;

        if (undefined != other.undefined)
            return false;

        if (whereClause == null) {

            if (other.whereClause != null)
                return false;
        } else if (!whereClause.equals(other.whereClause))
            return false;

        return true;
    }

	public String getJoinClause() {
		return joinClause;
	}

	public Class<?> getEntityImplClass() {
		return entityImplClass;
	}

}


text:
#ifndef __mod_h2__h2_proxy_util__
#define __mod_h2__h2_proxy_util__

/*******************************************************************************
 * some debugging/format helpers
 ******************************************************************************/
struct h2_proxy_request;
struct nghttp2_frame;

int h2_proxy_util_frame_print(const nghttp2_frame *frame, char *buffer, size_t maxlen);

/*******************************************************************************
 * ihash - hash for structs with int identifier
 ******************************************************************************/
typedef struct h2_proxy_ihash_t h2_proxy_ihash_t;
typedef int h2_proxy_ihash_iter_t(void *ctx, void *val);

/**
 * Create a hash for structures that have an identifying int member.
 * @param pool the pool to use
 * @param offset_of_int the offsetof() the int member in the struct
 */
h2_proxy_ihash_t *h2_proxy_ihash_create(apr_pool_t *pool, size_t offset_of_int);

size_t h2_proxy_ihash_count(h2_proxy_ihash_t *ih);
int h2_proxy_ihash_empty(h2_proxy_ihash_t *ih);
void *h2_proxy_ihash_get(h2_proxy_ihash_t *ih, int id);

/**
 * Iterate over the hash members (without defined order) and invoke
 * fn for each member until 0 is returned.
 * @param ih the hash to iterate over
 * @param fn the function to invoke on each member
 * @param ctx user supplied data passed into each iteration call
 * @return 0 if one iteration returned 0, otherwise != 0
 */
int h2_proxy_ihash_iter(h2_proxy_ihash_t *ih, h2_proxy_ihash_iter_t *fn, void *ctx);

void h2_proxy_ihash_add(h2_proxy_ihash_t *ih, void *val);
void h2_proxy_ihash_remove(h2_proxy_ihash_t *ih, int id);
void h2_proxy_ihash_remove_val(h2_proxy_ihash_t *ih, void *val);
void h2_proxy_ihash_clear(h2_proxy_ihash_t *ih);

size_t h2_proxy_ihash_shift(h2_proxy_ihash_t *ih, void **buffer, size_t max);
size_t h2_proxy_ihash_ishift(h2_proxy_ihash_t *ih, int *buffer, size_t max);

/*******************************************************************************
 * iqueue - sorted list of int with user defined ordering
 ******************************************************************************/
typedef struct h2_proxy_iqueue {
    int *elts;
    int head;
    int nelts;
    int nalloc;
    apr_pool_t *pool;
} h2_proxy_iqueue;

/**
 * Comparator for two int to determine their order.
 *
 * @param i1 first int to compare
 * @param i2 second int to compare
 * @param ctx provided user data
 * @return value is the same as for strcmp() and has the effect:
 *    == 0: s1 and s2 are treated equal in ordering
 *     < 0: s1 should be sorted before s2
 *     > 0: s2 should be sorted before s1
 */
typedef int h2_proxy_iq_cmp(int i1, int i2, void *ctx);

/**
 * Allocate a new queue from the pool and initialize.
 * @param id the identifier of the queue
 * @param pool the memory pool
 */
h2_proxy_iqueue *h2_proxy_iq_create(apr_pool_t *pool, int capacity);

/**
 * Return != 0 iff there are no tasks in the queue.
 * @param q the queue to check
 */
int h2_proxy_iq_empty(h2_proxy_iqueue *q);

/**
 * Return the number of int in the queue.
 * @param q the queue to get size on
 */
int h2_proxy_iq_count(h2_proxy_iqueue *q);

/**
 * Add a stream id to the queue.
 *
 * @param q the queue to append the task to
 * @param sid the stream id to add
 * @param cmp the comparator for sorting
 * @param ctx user data for comparator
 */
void h2_proxy_iq_add(h2_proxy_iqueue *q, int sid, h2_proxy_iq_cmp *cmp, void *ctx);

/**
 * Remove the stream id from the queue. Return != 0 iff task
 * was found in queue.
 * @param q the task queue
 * @param sid the stream id to remove
 * @return != 0 iff task was found in queue
 */
int h2_proxy_iq_remove(h2_proxy_iqueue *q, int sid);

/**
 * Remove all entries in the queue.
 */
void h2_proxy_iq_clear(h2_proxy_iqueue *q);

/**
 * Sort the stream idqueue again. Call if the task ordering
 * has changed.
 *
 * @param q the queue to sort
 * @param cmp the comparator for sorting
 * @param ctx user data for the comparator
 */
void h2_proxy_iq_sort(h2_proxy_iqueue *q, h2_proxy_iq_cmp *cmp, void *ctx);

/**
 * Get the first stream id from the queue or NULL if the queue is empty.
 * The task will be removed.
 *
 * @param q the queue to get the first task from
 * @return the first stream id of the queue, 0 if empty
 */
int h2_proxy_iq_shift(h2_proxy_iqueue *q);

/*******************************************************************************
 * common helpers
 ******************************************************************************/
/* h2_proxy_log2(n) iff n is a power of 2 */
unsigned char h2_proxy_log2(int n);

/*******************************************************************************
 * HTTP/2 header helpers
 ******************************************************************************/
void h2_proxy_util_camel_case_header(char *s, size_t len);
int h2_proxy_res_ignore_header(const char *name, size_t len);

/*******************************************************************************
 * nghttp2 helpers
 ******************************************************************************/
typedef struct h2_proxy_ngheader {
    nghttp2_nv *nv;
    apr_size_t nvlen;
} h2_proxy_ngheader;
h2_proxy_ngheader *h2_proxy_util_nghd_make_req(apr_pool_t *p,
                                               const struct h2_proxy_request *req);

/*******************************************************************************
 * h2_proxy_request helpers
 ******************************************************************************/
typedef struct h2_proxy_request h2_proxy_request;

struct h2_proxy_request {
    const char *method; /* pseudo header values, see ch. 8.1.2.3 */
    const char *scheme;
    const char *authority;
    const char *path;

    apr_table_t *headers;

    apr_time_t request_time;

    unsigned int chunked : 1;   /* iff requst body needs to be forwarded as chunked */
    unsigned int serialize : 1; /* iff this request is written in HTTP/1.1 serialization */
};

h2_proxy_request *h2_proxy_req_create(int id, apr_pool_t *pool, int serialize);
apr_status_t h2_proxy_req_make(h2_proxy_request *req, apr_pool_t *pool,
                               const char *method, const char *scheme,
                               const char *authority, const char *path,
                               apr_table_t *headers);

/*******************************************************************************
 * reverse mapping for link headers
 ******************************************************************************/
const char *h2_proxy_link_reverse_map(request_rec *r,
                                      proxy_dir_conf *conf,
                                      const char *real_server_uri,
                                      const char *proxy_server_uri,
                                      const char *s);

/*******************************************************************************
 * FIFO queue
 ******************************************************************************/

/**
 * A thread-safe FIFO queue with some extra bells and whistles, if you
 * do not need anything special, better use 'apr_queue'.
 */
typedef struct h2_proxy_fifo h2_proxy_fifo;

/**
 * Create a FIFO queue that can hold up to capacity elements. Elements can
 * appear several times.
 */
apr_status_t h2_proxy_fifo_create(h2_proxy_fifo **pfifo, apr_pool_t *pool, int capacity);

/**
 * Create a FIFO set that can hold up to capacity elements. Elements only
 * appear once. Pushing an element already present does not change the
 * queue and is successful.
 */
apr_status_t h2_proxy_fifo_set_create(h2_proxy_fifo **pfifo, apr_pool_t *pool, int capacity);

apr_status_t h2_proxy_fifo_term(h2_proxy_fifo *fifo);
apr_status_t h2_proxy_fifo_interrupt(h2_proxy_fifo *fifo);

int h2_proxy_fifo_capacity(h2_proxy_fifo *fifo);
int h2_proxy_fifo_count(h2_proxy_fifo *fifo);

/**
 * Push en element into the queue. Blocks if there is no capacity left.
 *
 * @param fifo the FIFO queue
 * @param elem the element to push
 * @return APR_SUCCESS on push, APR_EAGAIN on try_push on a full queue,
 *         APR_EEXIST when in set mode and elem already there.
 */
apr_status_t h2_proxy_fifo_push(h2_proxy_fifo *fifo, void *elem);
apr_status_t h2_proxy_fifo_try_push(h2_proxy_fifo *fifo, void *elem);

apr_status_t h2_proxy_fifo_pull(h2_proxy_fifo *fifo, void **pelem);
apr_status_t h2_proxy_fifo_try_pull(h2_proxy_fifo *fifo, void **pelem);

/**
 * Remove the elem from the queue, will remove multiple appearances.
 * @param elem  the element to remove
 * @return APR_SUCCESS iff > 0 elems were removed, APR_EAGAIN otherwise.
 */
apr_status_t h2_proxy_fifo_remove(h2_proxy_fifo *fifo, void *elem);

#endif /* defined(__mod_h2__h2_proxy_util__) */


text:
  Godisson est
       un village
       géographiquement positionné dans le département de l'Orne en Basse-Normandie. On dénombrait 107 habitants en 2008.

À coté de Godisson sont situées les villes de
Chailloué située à 5 km, 515 habitants,
Saint-Léonard-des-Parcs localisée à 4 km, 66 habitants,
Marmouillé à 3 km, 123 habitants,
Ménil-Froger située à 6 km, 65 habitants,
La Genevraie à 4 km, 105 habitants,
Neuville-près-Sées localisée à 4 km, 122 habitants,
 entre autres. De plus, Godisson est située à seulement 21 km de Argentan.

Si vous pensez demenager à Godisson, vous pourrez facilement trouver une maison à acheter.

Le nombre de logements, à Godisson, était réparti en 2011 en zero appartements et 56 maisons soit
 un marché relativement équilibré.

La commune offre quelques  aménagements, elle dispose, entre autres, de une boucle de randonnée.


text:
MIME-Version: 1.0
Server: CERN/3.0
Date: Tuesday, 07-Jan-97 15:16:55 GMT
Content-Type: text/html
Content-Length: 2664
Last-Modified: Wednesday, 21-Feb-96 21:38:19 GMT

<TITLE>Abraham Silberschatz</TITLE>

<!WA0><!WA0>

Abraham Silberschatz

Professorship in Computer Sciences

M.S. (1973), Ph.D. (1976), S.U.N.Y. at Stony Brook

Honors, Awards, and Professional Service

IEEE Computer Society Outstanding Paper Award, IEEE-TSE journal paper,
1978

Advisory Committee, National Science Foundation Division of Information,
Robotics, and Intelligent Systems 1990-1993

General Conference Chair, Seventh and Eighth ACM Sigact/Sigmod Symposium
on Principles of Database Systems (PODS), 1988-1989

Organizer (with J. Ullman), NSF Invitational Workshop on the Future
of Database Systems Research, 1990, 1995

Program Chair: PODS 1986, IEEE Symposium on Parallel and Distributed
Systems 1988, International Conference on Knowledge Management 1995

Areas of Interest

Database systems, operating systems, distributed systems, and  knowledge-based
systems

Summary of Research

My main area of specialization is concurrent processing. My most recent
research has been concentrated in the areas of multidatabase transaction
management, parallel processing of knowledge-based systems, real-time database
systems, multiresolution database systems, continuous-media storage servers,
and high-performance transaction systems.

Selected Recent Publications

S. Ganguly, A. Silberschatz, and S. Tsur, "Mapping datalog program
execution to networks of processors," IEEE Transactions on Knowledge
and Data Engineering, no. 7, vol. 3, pp. 351-361, June 1995.

H. Jagadish, D. Lieuwen, R. Rastogi, A. Silberschatz, and S. Sudarshan,
"Dali: a high performance main memory storage manager," International
Conference on Very Large Databases, September 1994.

B. Ozden, A. Biliris, R. Rastogi, A. Silberschatz, "A low-cost storage
server for movie on demand databases," International Conference on
Very Large Databases, September 1994.

B. Ozden, R. Rastogi, and A. Silberschatz, "A framework for the storage
and retrieval of continuous media data," IEEE International Conference
on Multimedia Computing and Systems, May 1995.

R. Read, D. Fussell, and A. Silberschatz, "A multi-resolution relational
data model," International Conference on Very Large Databases, August
1992.

Additional information can be obtained from
<!WA1><!WA1>individual faculty members'
home pages.

<!WA2><!WA2><!WA3><!WA3>Back to List of Faculty Profiles


text:
package bdv.tools.boundingbox;

import static bdv.tools.boundingbox.TransformedBoxOverlay.BoxDisplayMode.FULL;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Ellipse2D;
import java.awt.geom.GeneralPath;

import net.imglib2.Interval;
import net.imglib2.RealInterval;
import net.imglib2.realtransform.AffineTransform3D;
import bdv.viewer.OverlayRenderer;
import bdv.viewer.TransformListener;

import org.scijava.listeners.ChangeListener;
import org.scijava.listeners.ListenableVar;

/**
 * A BDV {@link OverlayRenderer} showing a {@link TransformedBox}. Displays a
 * wireframe box and/or intersection with current viewer slice, with various
 * adjustable parameters.
 */
public class TransformedBoxOverlay implements OverlayRenderer, TransformListener< AffineTransform3D >
{
	private static final double DISTANCE_TOLERANCE = 20.;

	private static final double HANDLE_RADIUS = DISTANCE_TOLERANCE / 2.;

	/**
	 * Specifies whether to show 3D wireframe box ({@code FULL}), or only
	 * intersection with viewer plane ({@code SECTION}).
	 */
	public enum BoxDisplayMode
	{
		FULL, SECTION;
	}

	public interface HighlightedCornerListener
	{
		void highlightedCornerChanged();
	}

	private final TransformedBox bbSource;

	private final Color backColor = new Color( 0x00994499 );

	private final Color frontColor = Color.GREEN;

	private final Stroke normalStroke = new BasicStroke();

	private final Stroke intersectionStroke = new BasicStroke( 1f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1f, new float[] { 10f, 10f }, 0f );

	private final Color intersectionColor = Color.WHITE.darker();

	private Color intersectionFillColor = new Color( 0x88994499, true );

	private final AffineTransform3D viewerTransform;

	private final AffineTransform3D transform;

	final RenderBoxHelper renderBoxHelper;

	private final CornerHighlighter cornerHighlighter;

	private double sourceSize = 5000;

	private double perspective = 0.5;

	private int canvasWidth;

	private int canvasHeight;

	private final ListenableVar< BoxDisplayMode, ChangeListener > displayMode = ListenableVar.create( FULL );

	private boolean showCornerHandles = true;

	private boolean fillIntersection = true;

	private int cornerId = -1;

	private HighlightedCornerListener highlightedCornerListener;

	public TransformedBoxOverlay( final Interval interval )
	{
		this( new TransformedBox()
		{
			@Override
			public Interval getInterval()
			{
				return interval;
			}

			@Override
			public void getTransform( final AffineTransform3D transform )
			{
				transform.identity();
			}
		} );
	}

	public TransformedBoxOverlay( final TransformedBox bbSource )
	{
		this.bbSource = bbSource;

		viewerTransform = new AffineTransform3D();
		transform = new AffineTransform3D();
		renderBoxHelper = new RenderBoxHelper();
		cornerHighlighter = new CornerHighlighter( DISTANCE_TOLERANCE );
	}

	/**
	 * Sets the perspective value. {@code perspective < 0} means parallel
	 * projection.
	 *
	 * @param perspective
	 *            the perspective value.
	 */
	public void setPerspective( final double perspective )
	{
		this.perspective = perspective;
	}

	public void showCornerHandles( final boolean showCornerHandles )
	{
		this.showCornerHandles = showCornerHandles;
	}

	public void fillIntersection( final boolean fillIntersection )
	{
		this.fillIntersection = fillIntersection;
	}

	public boolean getFillIntersection()
	{
		return fillIntersection;
	}

	public void setIntersectionFillColor( final Color intersectionFillColor )
	{
		this.intersectionFillColor = intersectionFillColor;
	}

	@Override
	public void drawOverlays( final Graphics g )
	{
		final Graphics2D graphics = ( Graphics2D ) g;

		final GeneralPath front = new GeneralPath();
		final GeneralPath back = new GeneralPath();
		final GeneralPath intersection = new GeneralPath();

		final RealInterval interval = bbSource.getInterval();
		final double ox = canvasWidth / 2;
		final double oy = canvasHeight / 2;
		synchronized ( viewerTransform )
		{
			bbSource.getTransform( transform );
			transform.preConcatenate( viewerTransform );
		}
		renderBoxHelper.setPerspectiveProjection( perspective > 0 );
		renderBoxHelper.setDepth( perspective * sourceSize );
		renderBoxHelper.setOrigin( ox, oy );
		renderBoxHelper.setScale( 1 );
		renderBoxHelper.renderBox( interval, transform, front, back, intersection );

		graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );

		if ( displayMode.get() == FULL )
		{
			graphics.setStroke( normalStroke );
			graphics.setPaint( backColor );
			graphics.draw( back );
		}

		if ( fillIntersection )
		{
			graphics.setPaint( intersectionFillColor );
			graphics.fill( intersection );
		}

		graphics.setPaint( intersectionColor );
		graphics.setStroke( intersectionStroke );
		graphics.draw( intersection );

		if ( displayMode.get() == FULL )
		{
			graphics.setStroke( normalStroke );
			graphics.setPaint( frontColor );
			graphics.draw( front );

			if ( showCornerHandles )
			{
				final int id = getHighlightedCornerIndex();
				if ( id >= 0 )
				{
					final double[] p = renderBoxHelper.projectedCorners[ id ];
					final Ellipse2D cornerHandle = new Ellipse2D.Double(
							p[ 0 ] - HANDLE_RADIUS,
							p[ 1 ] - HANDLE_RADIUS,
							2 * HANDLE_RADIUS, 2 * HANDLE_RADIUS );
					final double z = renderBoxHelper.corners[ cornerId ][ 2 ];
					final Color cornerColor = ( z > 0 ) ? backColor : frontColor;

					graphics.setColor( cornerColor );
					graphics.fill( cornerHandle );
					graphics.setColor( cornerColor.darker().darker() );
					graphics.draw( cornerHandle );
				}
			}
		}
	}

	@Override
	public void setCanvasSize( final int width, final int height )
	{
		this.canvasWidth = width;
		this.canvasHeight = height;
	}

	@Override
	public void transformChanged( final AffineTransform3D t )
	{
		synchronized ( viewerTransform )
		{
			viewerTransform.set( t );
		}
	}

	/**
	 * Get/set {@code BoxDisplayMode}, which specifies whether to show 3D
	 * wireframe box ({@code FULL}), or only intersection with viewer plane
	 * ({@code SECTION}).
	 */
	public ListenableVar< BoxDisplayMode, ChangeListener > boxDisplayMode()
	{
		return displayMode;
	}

	/**
	 * Get the transformation from the local coordinate frame of the
	 * {@link TransformedBox} to viewer coordinates.
	 *
	 * @param t is set to the box-to-viewer transform.
	 */
	public void getBoxToViewerTransform( final AffineTransform3D t )
	{
		synchronized ( viewerTransform ) // not a typo, all transform modifications synchronize on viewerTransform
		{
			t.set( transform );
		}
	}

	/**
	 * Get the index of the highlighted corner (if any).
	 *
	 * @return corner index or {@code -1} if no corner is highlighted
	 */
	public int getHighlightedCornerIndex()
	{
		return cornerId;
	}

	/**
	 * Returns a {@code MouseMotionListener} that can be installed into a bdv
	 * (see {@code ViewerPanel.getDisplay().addHandler(...)}). If installed, it
	 * will notify a {@code HighlightedCornerListener} (see
	 * {@link #setHighlightedCornerListener(HighlightedCornerListener)}) when
	 * the mouse is over a corner of the box (with some tolerance)/
	 *
	 * @return a {@code MouseMotionListener} implementing mouse-over for box
	 *         corners
	 */
	public MouseMotionListener getCornerHighlighter()
	{
		return cornerHighlighter;
	}

	public void setHighlightedCornerListener( final HighlightedCornerListener highlightedCornerListener )
	{
		this.highlightedCornerListener = highlightedCornerListener;
	}

	/**
	 * Set the index of the highlighted corner.
	 *
	 * @param id
	 *            corner index, {@code -1} means that no corner is highlighted.
	 */
	private void setHighlightedCorner( final int id )
	{
		final int oldId = cornerId;
		cornerId = ( id >= 0 && id < RenderBoxHelper.numCorners ) ? id : -1;
		if ( cornerId != oldId && highlightedCornerListener != null && displayMode.get() == FULL )
			highlightedCornerListener.highlightedCornerChanged();
	}

	/**
	 * Sets the source size (estimated maximum dimension) in global coordinates.
	 * Used for setting up perspective projection.
	 *
	 * @param sourceSize
	 *            estimated source size in global coordinates
	 */
	public void setSourceSize( final double sourceSize )
	{
		this.sourceSize = sourceSize;
	}

	private class CornerHighlighter extends MouseMotionAdapter
	{
		private final double squTolerance;

		CornerHighlighter( final double tolerance )
		{
			squTolerance = tolerance * tolerance;
		}

		@Override
		public void mouseMoved( final MouseEvent e )
		{
			final int x = e.getX();
			final int y = e.getY();
			for ( int i = 0; i < RenderBoxHelper.numCorners; i++ )
			{
				final double[] corner = renderBoxHelper.projectedCorners[ i ];
				final double dx = x - corner[ 0 ];
				final double dy = y - corner[ 1 ];
				final double dr2 = dx * dx + dy * dy;
				if ( dr2 < squTolerance )
				{
					setHighlightedCorner( i );
					return;
				}
			}
			setHighlightedCorner( -1 );
		}
	}
}


text:
'use strict';

var ExtractTextPlugin = require('extract-text-webpack-plugin');

module.exports = {
  entry: "./app/app.js",
  output: {
    filename: "app.bundle.js",
    path: __dirname + "/public/js"
  },

  // Enable sourcemaps for debugging webpack's output.
  devtool: "source-map",

  resolve: {
    extensions: [".js", ".json"]
  },

  module: {
    rules: [
      {
        test: /\.scss?/,
        use: ExtractTextPlugin.extract({
          fallback: 'style-loader',
          use: 'css-loader!sass-loader'
        })
      }
    ]
  },

  plugins: [
    new ExtractTextPlugin('../css/app.bundle.css')
  ],

  // When importing a module whose path matches one of the following, just
  // assume a corresponding global variable exists and use that instead.
  // This is important because it allows us to avoid bundling all of our
  // dependencies, which allows browsers to cache those libraries between builds.
  externals: {
    "angular": "angular"
  }
};


text:
@interface UISwipeGestureRecognizer (RecordingAdditions)
- (id)_automationName;
@end


text:
angular.module('IssueTracker.currentProject',[
    'IssueTracker.currentProject.service'
])

    .config(['$routeProvider', function($routeProvider) {
        $routeProvider.when('/projects/:Id',{
            templateUrl: 'app/projectPage/projectPage.html',
            controller: 'currentProjectCtrl'
        })
    }])

    .controller('currentProjectCtrl',[
        '$scope',
        '$routeParams',
        'currentProjectService',
        function($scope,$routeParams,currentProjectService) {

            $scope.viewProjectIssues = function(id) {
                currentProjectService.viewProjectIssues(id)
                    .then(function(data) {
                        $scope.projectIssues = data.data;
                        console.log(data.data);
                        console.log(data.data[0].Id);
                        console.log($scope.projectIssues[0].Id);
                    }, function (err) {
                        console.log(err);
                    });
            };

            $scope.viewProjectIssues($routeParams.Id);
        }
    ]);


text:
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { Field, reduxForm } from 'redux-form';
import { register } from '../../actions/auth';

const form = reduxForm({
  form: 'register',
  validate,
});

const renderField = field => (

    <input className="form-control" {...field.input} />
    {field.touched && field.error &&
{field.error}
}

);

function validate(formProps) {
  const errors = {};

  if (!formProps.firstName) {
    errors.firstName = 'Please enter a first name';
  }

  if (!formProps.lastName) {
    errors.lastName = 'Please enter a last name';
  }

  if (!formProps.email) {
    errors.email = 'Please enter an email';
  }

  if (!formProps.password) {
    errors.password = 'Please enter a password';
  }

  return errors;
}

class Register extends Component {
  handleFormSubmit(formProps) {
    this.props.register(formProps);
  }

  renderAlert() {
    if (this.props.errorMessage) {
      return (

          Error! {this.props.errorMessage}

      );
    }
  }

  render() {
    const { handleSubmit } = this.props;

    return (
      <form onSubmit={handleSubmit(this.handleFormSubmit.bind(this))}>
        {this.renderAlert()}

          User:

            First Name
            <Field name="firstName" className="form-control" component={renderField} type="text" />

            Last Name
            <Field name="lastName" className="form-control" component={renderField} type="text" />

            Email
            <Field name="email" className="form-control" component={renderField} type="text" />

            Password
            <Field name="password" className="form-control" component={renderField} type="password" />

          Character:

            First Name
            <Field name="characterFirstName" className="form-control" component={renderField} type="text" />

            Last Name
            <Field name="characterLastName" className="form-control" component={renderField} type="text" />

        <button type="submit" className="btn btn-primary">Register</button>
      </form>
    );
  }
}

function mapStateToProps(state) {
  return {
    errorMessage: state.auth.error,
    message: state.auth.message,
    authenticated: state.auth.authenticated,
  };
}

export default connect(mapStateToProps, { register })(form(Register));


text:
<!DOCTYPE html>

	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<meta name="generator" content="ApiGen 2.8.0">
	<meta name="robots" content="noindex">

	<title>File Datatype/DatatypeAbstract.php</title>

	<link rel="stylesheet" type="text/css" media="all" href="resources/style.css?3505392360">

		Overview

Namespaces

PHP

SitecRESA

Datatype

Exception

WS

Classes

AccesResolver

AccesResolverList

Adresse

Cgv

Client

ConditionRetenue

ConditionTarifaire

DatatypeAbstract

DisponibiliteProduit

Equipement

Erreur

ErreurValidation

FichePrestataire

FichePrestation

GarantieReservation

ModePaiement

ObjectList

Panier

Pension

PeriodeCalendar

Periodes

PeriodeTarifaires

Photo

PlanTarifaire

PositionGPS

PrestationPanier

PrixPlancher

Reservation

SavableDatatypeAbstract

Tarif

TypeEquipment

Interfaces

Fetchable

	<form id="search">
		<input type="hidden" name="cx" value="">
		<input type="hidden" name="ie" value="UTF-8">
		<input type="text" name="q" class="text">
		<input type="submit" value="Search">
	</form>

				Overview

				Namespace

				Class

				Tree

  1: <?php
  2:
  3: namespace SitecRESA\Datatype;
  4:
  5: use SitecRESA\Exception\Api;
  6: use SitecRESA\Datatype\AccesResolver;
  7:
  8: /**
  9:  * Datatype manipulées par le WS.
 10:  *
 11:  * @author Marc
 12:  */
 13: abstract class DatatypeAbstract {
 14:     /**
 15:      * @var SitecRESA\WS\Client
 16:      */
 17:     protected $_apiClient;
 18:
 19:     /**
 20:      *
 21:      * @var string
 22:      */
 23:     protected $_datatype;
 24:
 25:     /**
 26:      *
 27:      * @param SitecRESA\WS\Client $apiClient
 28:      * @param array $array
 29:      */
 30:     public function __construct($apiClient, $array = null) {
 31:         $this->_apiClient = $apiClient;
 32:         if (is_array($array)) {
 33:           // Initialize the model with the array's contents.
 34:           $this->mapTypes($array);
 35:         }
 36:     }
 37:
 38:     public function __get($name) {
 39:         $attribut = "_".$name;
 40:
 41:         //pas une propriété de $this
 42:         if(!property_exists($this, $attribut)){
 43:             throw new Api("la propriété $name n'existe pas pour ".get_class($this));
 44:         }
 45:
 46:         //attribut simple
 47:         if(!$this->$attribut instanceof AccesResolver){
 48:             return $this->$attribut;
 49:         }
 50:
 51:         //accès WS nécessaire
 52:         $valeurAttribut = $this->$attribut->resolve();
 53:         $this->$attribut = $valeurAttribut;
 54:         return $this->$attribut;
 55:     }
 56:
 57:    /**
 58:     * Initialize this object's properties from an array.
 59:     *
 60:     * @param array Used to seed this object's properties.
 61:     * @return void
 62:     */
 63:     private function mapTypes(array $array) {
 64:         foreach ($array as $key => $val) {
 65:             $key = "_".$key;
 66:             $this->$key = $val;
 67:             if($this->isAssociativeArray($val)){
 68:                 $this->$key = self::createObjectFromArray($this->_apiClient, $val);
 69:             }elseif (is_array($val)) {
 70:                 $arrayObject = array();
 71:                 foreach ($val as $arrayIndex => $arrayItem) {
 72:                     if(is_array($arrayItem)){
 73:                         $arrayObject[$arrayIndex] = self::createObjectFromArray($this->_apiClient, $arrayItem);//$this->mapTypes($arrayItem);
 74:                     } else {
 75:                         $arrayObject[$arrayIndex] = $arrayItem;
 76:                     }
 77:                 }
 78:                 $this->$key = $arrayObject;
 79:             }
 80:         }
 81:     }
 82:
 83:    /**
 84:     * Returns true only if the array is associative.
 85:     * @param array $array
 86:     * @return bool True if the array is associative.
 87:     */
 88:     private function isAssociativeArray($array) {
 89:         if (!is_array($array)) {
 90:           return false;
 91:         }
 92:         $keys = array_keys($array);
 93:         foreach($keys as $key) {
 94:           if (is_string($key)) {
 95:             return true;
 96:           }
 97:         }
 98:         return false;
 99:     }
100:
101:    /**
102:     * Given a variable name, discover its type.
103:     *
104:     * @param $name
105:     * @param $item
106:     * @return object The object from the item.
107:     */
108:     public static function createObjectFromArray($apiClient, array $array) {
109:         if(isset($array["datatype"])){
110:             $className = "SitecRESA\\Datatype\\".$array["datatype"];
111:             return new $className($apiClient, $array);
112:         }  else {
113:             throw new Api("impossible de créer une entité à partir d'un tableau qui n'a pas de clé 'datatype'");
114:         }
115:     }
116: }

		 API documentation generated by ApiGen 2.8.0


text:
@interface APViewController ()

@end

@implementation APViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view, typically from a nib.

}

- (IBAction)feedback_Push:(id)sender;

{

    APFeedTableViewController *fd = [[APFeedTableViewController alloc]init];
    fd.developer_LogFile=YES;
    fd.mailHTML=YES;
    [self.navigationController pushViewController:fd animated:YES];

}

- (IBAction)feedback_modal:(id)sender

{

    APFeedTableViewController *fd = [[APFeedTableViewController alloc]init];
    UINavigationController *navController = [[UINavigationController alloc] initWithRootViewController:fd];
    navController.modalTransitionStyle = UIModalTransitionStyleCrossDissolve;
    [self presentViewController:navController animated:YES completion:nil];

}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>A - 索引 (android API)</title>
<meta name="date" content="2019-04-22">
<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">

您的浏览器已禁用 JavaScript。

跳过导航链接

概览

程序包

类

树

已过时

索引

帮助

上一个字母

下一个字母

框架

无框架

所有类

A B C D E F G H I J L M N O P R S T U V W

A

acceptGroupApproval(String, String, BasicCallback) - 类 中的方法cn.jpush.im.android.api.event.GroupApprovalEvent

入群审批同意,操作成功后,群内所有成员包括被审批人自己都会收到一个包含群成员变化的EventNotification类型的消息

acceptGroupApprovalInBatch(Collection<GroupApprovalEvent>, boolean, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.event.GroupApprovalEvent

批量同意审批事件内所有成员进群.

acceptInvitation(String, String, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.ContactManager

接受对方的好友请求,操作成功后,对方会出现在自己的好友列表中,双方建立起好友关系。

addChatRoomAdmin(long, List<UserInfo>, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.ChatRoomManager

将指定用户设置为聊天室的房管,只有房主有此权限,房管可设置聊天室的黑名单

addChatRoomBlacklist(long, List<UserInfo>, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.ChatRoomManager

将用户添加至聊天室黑名单,只有聊天室的房主和房管有此权限, 被设置黑名单用户会被立即踢出聊天室。

addChatRoomSilence(long, Collection<UserInfo>, long, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.ChatRoomManager

将指定用户添加进聊天室的禁言列表(批量设置一次最多500个),禁言时间下限5分钟,上限1年
 聊天室owner或者管理员可以禁言聊天室成员,管理员或owner不能被禁言, 重复调用此接口将根据当前时间重新计算结束时间。

addGroupBlacklist(List<UserInfo>, BasicCallback) - 类 中的方法cn.jpush.im.android.api.model.GroupInfo

将用户加到群组黑名单,只有群主和管理员有此权限, 被加入黑名单的用户如果在群内会被踢出群组,黑名单中的用户无法再加入群组

 操作成功后群内成员将收到群黑名单变更事件GroupBlackListChangedEvent

addGroupKeeper(List<UserInfo>, BasicCallback) - 类 中的方法cn.jpush.im.android.api.model.GroupInfo

添加群管理员,管理员可以移除、禁言普通群成员,并且在公开群组里可以直接添加群成员和审核入群审批GroupApprovalEvent.

addGroupMembers(long, List<String>, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

向群组中添加成员。

addGroupMembers(long, String, List<String>, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

向群组中添加成员,通过指定appKey可以实现跨应用添加其他appKey下用户进群组

addGroupMembers(long, String, List<String>, String, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

向群组中添加成员,通过指定appKey可以实现跨应用添加其他appKey下用户进群组,公开群JMessageClient.createPublicGroup(String, String, CreateGroupCallback)
 可以指定邀请入群的理由,群主和管理员审批入群GroupApprovalEvent时可以看到理由

addGroupSilenceWithTime(Collection<UserInfo>, long, BasicCallback) - 类 中的方法cn.jpush.im.android.api.model.GroupInfo

设置群成员禁言(可设置禁言时间,批量设置一次最多500个),群主和管理员可以禁言普通群成员,
 群主和管理员不能被禁言,重复调用此接口将根据当前时间重新计算结束时间。

addUsersToBlacklist(List<String>, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

将用户加入黑名单,对方用户将无法给你发消息。

addUsersToBlacklist(List<String>, String, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

将用户添加进黑名单,对方将无法给你发消息。

adminDissolveGroup(long, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

解散指定的群组,只有群的群主有权限解散。

applyJoinGroup(long, String, BasicCallback) - 类 中的静态方法cn.jpush.im.android.api.JMessageClient

申请加入群组,只有公开群组(公开群组定义参考JMessageClient.createPublicGroup(String, String, CreateGroupCallback)),
 才能发送入群申请

autoDownloadWhenMsgReceived(Message, DownloadCompletionCallback) - 类 中的方法cn.jpush.im.android.api.content.CompoundContent

SDK内部使用,上层无需关心

autoDownloadWhenMsgReceived(Message, DownloadCompletionCallback) - 类 中的方法cn.jpush.im.android.api.content.VideoContent

A B C D E F G H I J L M N O P R S T U V W

跳过导航链接

概览

程序包

类

树

已过时

索引

帮助

上一个字母

下一个字母

框架

无框架

所有类


text:
package com.cognifide.aet.runner.processing.data;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertNull;

import com.cognifide.aet.communication.api.metadata.Step;
import com.cognifide.aet.communication.api.metadata.Suite;
import com.cognifide.aet.communication.api.metadata.Test;
import com.cognifide.aet.communication.api.metadata.Url;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.googlecode.zohhak.api.Configure;
import com.googlecode.zohhak.api.TestWith;
import com.googlecode.zohhak.api.runners.ZohhakRunner;
import java.io.IOException;
import java.util.List;
import org.apache.commons.io.IOUtils;
import org.junit.runner.RunWith;

@RunWith(ZohhakRunner.class)
@Configure(separator = ";")
public class SuiteMergeStrategyTest {

  private static final Gson GSON = new Gson();

  @TestWith({"conversion/pattern.json;conversion/current.json"})
  public void merge_checkVersionIncrement(String patternResource, String currentResource)
      throws Exception {
    final Suite pattern = readSuite(patternResource);
    final Suite current = readSuite(currentResource);
    final Suite merged = SuiteMergeStrategy.merge(current, pattern);
    assertThat(merged.getVersion(), is(2L));
  }

  @TestWith({"conversion/pattern.json;conversion/current.json"})
  public void merge_checkPatternsRewritten(String patternResource, String currentResource)
      throws Exception {
    final Suite pattern = readSuite(patternResource);
    final Suite current = readSuite(currentResource);
    final Suite merged = SuiteMergeStrategy.merge(current, pattern);

    final Test test = merged.getTests().get(0);
    final Url url = test.getUrls().iterator().next();
    final Step desktopScreenStep = url.getSteps().get(2);

    assertThat(desktopScreenStep.getPattern(), is("56ebbed87346a042e67ef462"));
  }

  @TestWith({"conversion/current.json"})
  public void merge_checkVersionSetAtFirstRun(String currentResource) throws Exception {
    final Suite current = readSuite(currentResource);
    final Suite merged = SuiteMergeStrategy.merge(current, null);

    assertThat(merged.getVersion(), is(1L));
  }

  @TestWith({"conversion/pattern.json;conversion/current.json"})
  public void merge_checkNewCollectStepAddedAndOldRemoved(String patternResource,
      String currentResource)
      throws Exception {
    final Suite pattern = readSuite(patternResource);
    final Suite current = readSuite(currentResource);
    final Suite merged = SuiteMergeStrategy.merge(current, pattern);

    final Test test = merged.getTests().get(0);
    final Url url = test.getUrls().iterator().next();

    final List<Step> steps = url.getSteps();
    assertThat(steps.size(), is(5));

    final Step desktopMobileNewStep = steps.get(4);
    assertThat(desktopMobileNewStep.getType(), is("screen"));
    assertNull(desktopMobileNewStep.getPattern());
  }

  private Suite readSuite(String resource) throws IOException {
    ClassLoader classLoader = getClass().getClassLoader();
    String json = IOUtils.toString(classLoader.getResourceAsStream(resource));
    return GSON.fromJson(json, new TypeToken<Suite>() {
    }.getType());
  }
}


text:
//
//  RKFetchRequestManagedObjectCache.m
//  RestKit
//
//  Created by Jeff Arena on 1/24/12.
//  Copyright (c) 2009-2012 RestKit. All rights reserved.
//
//  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.
//

#import <RestKit/CoreData/RKFetchRequestManagedObjectCache.h>
#import <RestKit/CoreData/RKPropertyInspector+CoreData.h>
#import <RestKit/ObjectMapping/RKObjectUtilities.h>
#import <RestKit/ObjectMapping/RKPropertyInspector.h>
#import <RestKit/Support/RKLog.h>

// Set Logging Component
#undef RKLogComponent
#define RKLogComponent RKlcl_cRestKitCoreData

/*
 This function computes a cache key given a dictionary of attribute values. Each attribute name is used as a fragment within the aggregate cache key. A suffix qualifier is appended that differentiates singular vs. collection attribute values so that '==' and 'IN' predicates are computed appropriately.
 */
static NSString *RKPredicateCacheKeyForAttributeValues(NSDictionary *attributesValues)
{
    NSArray *sortedKeys = [[attributesValues allKeys] sortedArrayUsingSelector:@selector(compare:)];
    NSMutableArray *keyFragments = [NSMutableArray array];
    for (NSString *attributeName in sortedKeys) {
        id value = attributesValues[attributeName];
        NSString *suffix = [value respondsToSelector:@selector(count)] ? @"+" : @".";
        [keyFragments addObject:[attributeName stringByAppendingString:suffix]];
    }
    return [keyFragments componentsJoinedByString:@":"];
}

// NOTE: We build a dynamic format string here because `NSCompoundPredicate` does not support use of substiution variables
static NSPredicate *RKPredicateWithSubsitutionVariablesForAttributeValues(NSDictionary *attributeValues)
{
    NSArray *attributeNames = [attributeValues allKeys];
    NSMutableArray *formatFragments = [NSMutableArray arrayWithCapacity:[attributeNames count]];
    [attributeValues enumerateKeysAndObjectsUsingBlock:^(NSString *attributeName, id value, BOOL *stop) {
        NSString *formatFragment = RKObjectIsCollection(value)
                                 ? [NSString stringWithFormat:@"%@ IN $%@", attributeName, attributeName]
                                 : [NSString stringWithFormat:@"%@ = $%@", attributeName, attributeName];
        [formatFragments addObject:formatFragment];
    }];

    return [NSPredicate predicateWithFormat:[formatFragments componentsJoinedByString:@" AND "]];
}

@interface RKFetchRequestManagedObjectCache ()
@property (nonatomic, strong) NSMutableDictionary *predicateCache;
#if OS_OBJECT_USE_OBJC
@property (nonatomic, strong) dispatch_queue_t cacheQueue;
#else
@property (nonatomic, assign) dispatch_queue_t cacheQueue;
#endif
@end

@implementation RKFetchRequestManagedObjectCache

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.predicateCache = [NSMutableDictionary dictionary];
        self.cacheQueue = dispatch_queue_create("org.restkit.core-data.fetch-request-cache-queue", DISPATCH_QUEUE_CONCURRENT);
    }
    return self;
}

- (void)dealloc
{
#if !OS_OBJECT_USE_OBJC
    if (_cacheQueue) dispatch_release(_cacheQueue);
#endif
    _cacheQueue = NULL;
}

- (NSSet *)managedObjectsWithEntity:(NSEntityDescription *)entity
                    attributeValues:(NSDictionary *)attributeValues
             inManagedObjectContext:(NSManagedObjectContext *)managedObjectContext
{
    NSAssert(entity, @"Cannot find existing managed object without a target class");
    NSAssert(attributeValues, @"Cannot retrieve cached objects without attribute values to identify them with.");
    NSAssert(managedObjectContext, @"Cannot find existing managed object with a nil context");

    if ([attributeValues count] == 0) return [NSSet set];

    NSString *predicateCacheKey = RKPredicateCacheKeyForAttributeValues(attributeValues);

    __block NSPredicate *substitutionPredicate;
    dispatch_sync(self.cacheQueue, ^{
        substitutionPredicate = (self.predicateCache)[predicateCacheKey];
    });

    if (! substitutionPredicate) {
        substitutionPredicate = RKPredicateWithSubsitutionVariablesForAttributeValues(attributeValues);
        dispatch_barrier_async(self.cacheQueue, ^{
            (self.predicateCache)[predicateCacheKey] = substitutionPredicate;
        });
    }

    NSFetchRequest *fetchRequest = [NSFetchRequest fetchRequestWithEntityName:[entity name]];
    fetchRequest.predicate = [substitutionPredicate predicateWithSubstitutionVariables:attributeValues];
    __block NSError *error = nil;
    __block NSArray *objects = nil;
    [managedObjectContext performBlockAndWait:^{
        objects = [managedObjectContext executeFetchRequest:fetchRequest error:&error];
    }];
    if (! objects) {
        RKLogError(@"Failed to execute fetch request due to error: %@", error);
    }
    RKLogDebug(@"Found objects '%@' using fetchRequest '%@'", objects, fetchRequest);

    return [NSSet setWithArray:objects];
}

@end


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Enum DiagnosticSeverity
   </title>
    <meta name="viewport" content="width=device-width">
    <meta name="title" content="Enum DiagnosticSeverity
   ">
    <meta name="generator" content="docfx 2.30.0.0">

    <link rel="shortcut icon" href="../favicon.ico">
    <link rel="stylesheet" href="../styles/docfx.vendor.css">
    <link rel="stylesheet" href="../styles/docfx.css">
    <link rel="stylesheet" href="../styles/main.css">
    <meta property="docfx:navrel" content="../toc.html">
    <meta property="docfx:tocrel" content="toc.html">

              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
                Toggle navigation

              </button>

              <form class="navbar-form navbar-right" role="search" id="search">

                  <input type="text" class="form-control" id="search-query" placeholder="Search" autocomplete="off">

              </form>

          Show / Hide Table of Contents

Enum DiagnosticSeverity

Namespace: Swigged.LLVM

Assembly: swigged.llvm.dll

Syntax

public enum DiagnosticSeverity : int

Fields

        Name
        Description

        DSError

        DSNote

        DSRemark

        DSWarning

              Back to top

            Copyright © 2015-2017 Microsoft
Generated by DocFX


text:
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Xml
{
  class XmlNode;
} // namespace Xml
} // namespace Utils
namespace AutoScaling
{
namespace Model
{

  /**
   *
Describes a filter.

See Also:
   AWS
   * API Reference

   */
  class AWS_AUTOSCALING_API Filter
  {
  public:
    Filter();
    Filter(const Aws::Utils::Xml::XmlNode& xmlNode);
    Filter& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);

    void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
    void OutputToStream(Aws::OStream& oStream, const char* location) const;

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline const Aws::String& GetName() const{ return m_name; }

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline Filter& WithName(const Aws::String& value) { SetName(value); return *this;}

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline Filter& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}

    /**
     *
The name of the filter. The valid values are:
     * "auto-scaling-group", "key", "value", and
     * "propagate-at-launch".

     */
    inline Filter& WithName(const char* value) { SetName(value); return *this;}

    /**
     *
The value of the filter.

     */
    inline const Aws::Vector<Aws::String>& GetValues() const{ return m_values; }

    /**
     *
The value of the filter.

     */
    inline void SetValues(const Aws::Vector<Aws::String>& value) { m_valuesHasBeenSet = true; m_values = value; }

    /**
     *
The value of the filter.

     */
    inline void SetValues(Aws::Vector<Aws::String>&& value) { m_valuesHasBeenSet = true; m_values = std::move(value); }

    /**
     *
The value of the filter.

     */
    inline Filter& WithValues(const Aws::Vector<Aws::String>& value) { SetValues(value); return *this;}

    /**
     *
The value of the filter.

     */
    inline Filter& WithValues(Aws::Vector<Aws::String>&& value) { SetValues(std::move(value)); return *this;}

    /**
     *
The value of the filter.

     */
    inline Filter& AddValues(const Aws::String& value) { m_valuesHasBeenSet = true; m_values.push_back(value); return *this; }

    /**
     *
The value of the filter.

     */
    inline Filter& AddValues(Aws::String&& value) { m_valuesHasBeenSet = true; m_values.push_back(std::move(value)); return *this; }

    /**
     *
The value of the filter.

     */
    inline Filter& AddValues(const char* value) { m_valuesHasBeenSet = true; m_values.push_back(value); return *this; }

  private:
    Aws::String m_name;
    bool m_nameHasBeenSet;
    Aws::Vector<Aws::String> m_values;
    bool m_valuesHasBeenSet;
  };

} // namespace Model
} // namespace AutoScaling
} // namespace Aws


text:
#ifndef SHALLOW2D_H
#define SHALLOW2D_H

//ldoc on
/**
 * # Shallow water equations
 *
 * ## Physics picture
 *
 * The shallow water equations treat water as incompressible and
 * inviscid, and assume that the horizontal velocity remains constant
 * in any vertical column of water.  The unknowns at each point are
 * the water height and the total horizontal momentum in a water
 * column; the equations describe conservation of mass (fluid is
 * neither created nor destroyed) and conservation of linear momentum.
 * We will solve these equations with a numerical method that also
 * exactly conserves mass and momentum (up to rounding error), though
 * it only approximately conserves energy.
 *
 * The basic variables are water height ($h$), and the velocity components
 * ($u, v$).  We write the governing equations in the form
 * $$
 *   U_t = F(U)_x + G(U)_y
 * $$
 * where
 * $$
 *   U = \begin{bmatrix} h \\ hu \\ hv \end{bmatrix},
 *   F = \begin{bmatrix} hu \\ h^2 u + gh^2/2 \\ huv \end{bmatrix}
 *   G = \begin{bmatrix} hv \\ huv \\ h^2 v + gh^2/2 \end{bmatrix}
 * $$
 * The functions $F$ and $G$ are called *fluxes*, and describe how the
 * conserved quantities (volume and momentum) enter and exit a region
 * of space.
 *
 * Note that we also need a bound on the characteristic wave speeds
 * for the problem in order to ensure that our method doesn't explode;
 * we use this to control the Courant-Friedrichs-Levy (CFL) number
 * relating wave speeds, time steps, and space steps.  For the shallow
 * water equations, the characteristic wave speed is $\sqrt{g h}$
 * where $g$ is the gravitational constant and $h$ is the height of the
 * water; in addition, we have to take into account the velocity of
 * the underlying flow.
 *
 * ## Interface
 *
 * To provide a general interface, we make the flux and speed functions
 * take arrays that consist of the `h`, `hu`, and `hv` components
 * in sequential arrays separated by `field_stride`: for example,
 * the start of the height field data is at `U`, the start of
 * the $x$ momentum is at `U+field_stride`, and the start of the
 * $y$ momentum is at `U+2*field_stride`.
 */

void shallow2d_flux(float* FU, float* GU, const float* U,
                    int ncell, int field_stride);
void shallow2d_speed(float* cxy, const float* U,
                     int ncell, int field_stride);

//ldoc off
#endif /* SHALLOW2D_H */


text:
<?php
/**
 * Base class for form fields.
 * @author gizmore
 */
abstract class GWF_FormsField
{
	private $error;

	/**
	 * @var GWF_Forms
	 */
	private $form;

	private $name;
	private $label;
	private $value;
	private $tooltip;
	private $validator;

	public function __construct($name, $label=null, $value=null)
	{
		$this->name = $name;
		$this->label = $label;
		$this->value = $value;
		$this->validator = array($this, 'validate');
	}

	public function getError() { return $this->error; }
	public function setError($error) { $this->error = $error; }

	public function setForm(GWF_Forms $form) { $this->form = $form; }
	public function getForm() { return $this->form; }
	public function getAction() { return $this->form->getAction(); }

	public function getName() { return $this->name; }
	public function setName($name) { $this->name = $name; }
	public function getLabel() { return $this->label; }
	public function setLabel($label) { $this->label = $label; }
	public function getValue() { return $this->value; }
	public function setValue($value) { $this->value = $value; }
	public function getTooltip() { return $this->tooltip; }
	public function setTooltip($tooltip) { $this->tooltip = $tooltip; }
	public function getValidator() { return $this->validator; }
	public function setValidator($validator) { $this->validator = $validator; }

	public function displayError() { return htmlspecialchars($this->getError()); }
	public function displayLabel() { return htmlspecialchars($this->getLabel()); }
	public function displayValue() { return htmlspecialchars($this->getValue()); }

	public function onFlowUpload() {}
	public function onCleanup() {}

	public function errorFieldName()
	{
		$label = $this->getLabel();
		return empty($label) ? $this->getName() : $label;
	}

	public function renderInput()
	{
		return $this->hiddenInput();
	}

	public function hiddenInput()
	{
		return sprintf('<input type="hidden" name="%s" value="%s">', $this->getName(), htmlspecialchars($this->getValue()));
	}

	public function renderLabel()
	{
		return sprintf('%s', $this->getName(), htmlspecialchars($this->label));
	}

	public function render()
	{
		return sprintf('
%s

%s
', $this->renderLabel(), $this->renderInput());
	}

	public function validate($name)
	{
		$this->value = Common::getRequestString($name);
	}

	public function getFormValue()
	{
		return $this->value;
	}
}


text:
require "connection_pool"

require_relative "bench"

dalli = ConnectionPool.new(:size => Bench::NUM_THREADS + 1) do
  Dalli::Client.new nil, :threadsafe => false
end

Bench.new(dalli).bench


text:
set -x

wait_network() {

    echo "Start rabbit node. Waiting network is up ..."
    sleep 5

    RABBIT_HOST=`echo $RABBITMQ_NODENAME | cut -d'@' -f 2`

    if [ -z "$RABBIT_HOST" ]; then
        echo "Wrong $RABBITMQ_NODENAME"
        exit 1
    fi

    n=1
    while [[ $(drill $RABBIT_HOST | grep $RABBIT_HOST | tail -n +2 | awk '{print $5}' | grep '^10.0' | wc -c) -eq 0 ]] && [[ $n -le 10 ]]
    do
         n=$(( n+1 ))
         sleep 5
    done

    if [ $n -gt 10 ]; then
        echo "Problem to resolv IP for $RABBITMQ_NODENAME"
        exit 1
    fi

    IP_RESOLV=$(drill $RABBIT_HOST | grep $RABBIT_HOST | tail -n +2 | awk '{print $5}')

    echo "Rabbit IP $IP_RESOLV for Rabbit nodename $RABBITMQ_NODENAME"

}

setup_cluster() {

    if [ -z "$CLUSTER_WITH" ]; then
    echo "Setup single node ${RABBITMQ_NODENAME} in High Availability at the first starting"
        # Check when pid of rabbitmq-server is created; first node only sets HA policy
        rabbitmqctl wait /var/lib/rabbitmq/mnesia/$RABBITMQ_NODENAME.pid && sleep 20 && \
        rabbitmqctl set_policy ha-all '^(?!amq\.|springCloudBus\.).*' '{"ha-mode": "all", "ha-sync-mode": "automatic"}' &
    else
        echo "Setup Cluster with $CLUSTER_WITH for node ${RABBITMQ_NODENAME}"
        # Check when pid of rabbitmq-server is created; this node must to cluster with others node; if this node ($RABBITMQ_NODENAME) is alone, stop app, joins in the cluster with ($CLUSTER_WITH) and start app.
        rabbitmqctl wait /var/lib/rabbitmq/mnesia/$RABBITMQ_NODENAME.pid && sleep 20 && \
        [ $(rabbitmqctl cluster_status |  grep -oE '\{disc,\[(.*)\]' | grep $RABBITMQ_NODENAME |cut -d"[" -f2 | cut -d"]" -f1 | cut -d"," -f1- --output-delimiter=' ' | wc -w) -eq 1 ] && \
        rabbitmqctl stop_app && \
        rabbitmqctl join_cluster ${CLUSTER_WITH} && \
        rabbitmqctl start_app &
    fi

}

wait_network

setup_cluster

# run rabbitmq-server
/docker-entrypoint.sh rabbitmq-server