text:
function Get-vROAPIEndpoint {
<#
    .SYNOPSIS
    Lists the available top-level service entry points.

    .DESCRIPTION
    Lists the available top-level service entry points.

    .INPUTS
    None

    .OUTPUTS
    System.Management.Automation.PSObject.

    .EXAMPLE
    Get-vROApiServiceEntryPoint
#>
[CmdletBinding()][OutputType('System.Management.Automation.PSObject')]

    Param ()

    try {

        $URI = "/vco/api/"
        $Response = Invoke-vRORestMethod -URI $URI -Method GET

        foreach ($Service in $Response.service) {

            [pscustomobject] @{

                Href = $Service.href
                Description = $Service.description

            }

        }

    }
    catch [Exception]{

        throw $_.Exception.Message

    }

}


text:
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.IO;
using System.Text;
using OrigoDB.Core;
using ProtoBuf;
using ProtoBuf.Meta;
using OrigoDB.Core.Utilities;

namespace OrigoDB.Modules.ProtoBuf
{
    /// <summary>
    /// Provides functionality for formatting serialized objects
    /// using ProtoBuf serialization.
    /// </summary>
    public class ProtoBufFormatter : IFormatter
    {
        readonly RuntimeTypeModel _typeModel;

        /// <summary>
        /// Prefix each serialized object with its assembly qualified name
        /// </summary>
        public readonly bool IncludeTypeName;

        /// <summary>
        /// Write the length of the serialized object as part of the header.
        /// Necessary when sending multiple objects to the same stream,
        /// avoid for large graphs because they must be buffered in memory
        /// in order to figure out the size.
        /// </summary>
        public readonly bool UseLengthPrefix;

        /// <summary>
        /// The associated serialization binder.
        /// </summary>
        public SerializationBinder Binder
        {
            get;
            set;
        }

        /// <summary>
        /// The associated streaming context.
        /// </summary>
        public StreamingContext Context
        {
            get;
            set;
        }

        /// <summary>
        /// The associated surrogate selector.
        /// </summary>
        public ISurrogateSelector SurrogateSelector
        {
            get { return null; }
            set { /* Do nothing here since it's not used. */; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="OrigoDB.Modules.ProtoBuf.ProtoBufFormatter"/> class.
        /// </summary>
        public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool includeTypeName = true, bool useLengthPrefix = false)
        {
            IncludeTypeName = includeTypeName;
            UseLengthPrefix = useLengthPrefix;
            _typeModel = typeModel ?? TypeModel.Create();
            Context = new StreamingContext(StreamingContextStates.Persistence);
        }

        /// <summary>
        /// Deserializes the data on the provided stream and
        /// reconstitutes the graph of objects.
        /// </summary>
        /// <param name="stream">The stream that contains the data to deserialize.</param>
        /// <returns>The top object of the deserialized graph.</returns>
        public object Deserialize(Stream stream)
        {
            Ensure.NotNull(stream, "stream");

            var type = GetType(stream);

            return UseLengthPrefix
                ? _typeModel.DeserializeWithLengthPrefix(stream, null, type, PrefixStyle.Base128, 0)
                : _typeModel.Deserialize(stream, null, type);
        }

        /// <summary>
        /// Serializes an object, or graph of objects with the given root to the provided stream.
        /// </summary>
        /// <param name="stream">The stream where the formatter puts the serialized data. This stream can
        /// reference a variety of backing stores (such as files, network, memory, and so on).</param>
        /// <param name="graph">The object, or root of the object graph, to serialize.
        /// All child objects of this root object are automatically serialized.</param>
        public void Serialize(Stream stream, object graph)
        {
            Ensure.NotNull(stream, "stream");
            Ensure.NotNull(graph, "graph");

            if (IncludeTypeName)
                new BinaryWriter(stream, Encoding.UTF8)
                .Write(graph.GetType().AssemblyQualifiedName);

            if (UseLengthPrefix)
                _typeModel.SerializeWithLengthPrefix(stream, graph, graph.GetType(), PrefixStyle.Base128, 0);
            else
                _typeModel.Serialize(stream, graph);
        }

        /// <summary>
        /// Determine what type to read when deserializing by reading the type name from the stream
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        protected virtual Type GetType(Stream stream)
        {
            Type result = null;
            if (IncludeTypeName)
            {
                var typeName = new BinaryReader(stream, Encoding.UTF8).ReadString();
                result = Type.GetType(typeName);
            }
            return result;
        }

        /// <summary>
        /// Modify the given configuration to use ProtoBuf formatting to clone results
        /// </summary>
        /// <param name="config"></param>
        /// <param name="typeModel">An optional typemodel</param>
        public static void ConfigureResultCloning(EngineConfiguration config, RuntimeTypeModel typeModel = null)
        {
            config.SetFormatterFactory((cfg, fu) => new ProtoBufFormatter(typeModel, true, true), FormatterUsage.Results);
        }

        /// <summary>
        /// Modify the given configuration to use ProtoBuf formatting for snapshots of type T.
        /// </summary>
        /// <typeparam name="T">The concrete type of the model</typeparam>
        public static void ConfigureSnapshots<T>(EngineConfiguration config, RuntimeTypeModel typeModel = null) where T : Model
        {
            config.SetFormatterFactory((cfg, fu) => new ProtoBufFormatter<T>(typeModel), FormatterUsage.Snapshot);
        }

        /// <summary>
        /// Modify the given EngineConfiguration to use ProtoBuf for journaling. Pass unique ints for each type of command.
        /// The id's must be maintained across versions of your assembly.
        /// </summary>
        public static void ConfigureJournaling(EngineConfiguration config, IDictionary<Type, int> commandTypeTags, RuntimeTypeModel typeModel = null)
        {
            config.SetFormatterFactory((cfg, fu) =>
            {
                var formatter = new ProtoBufFormatter<JournalEntry>(typeModel, includeTypeName: false, useLengthPrefix: true);
                typeModel.RegisterCommandSubTypes(commandTypeTags);
                return formatter;
            },
            FormatterUsage.Journal);
        }
    }

    /// <summary>
    /// ProtoBuf IFormatter implementation which serializes/deserializes object of type T
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class ProtoBufFormatter<T> : ProtoBufFormatter
    {
        /// <summary>
        /// Create a typed formatter. Type name won't be prepended to the stream because the type is known.
        /// </summary>
        public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool useLengthPrefix = false, bool includeTypeName = false)
            : base(includeTypeName: includeTypeName, typeModel: typeModel, useLengthPrefix: useLengthPrefix)
        { }

        /// <summary>
        /// Derive the type from the generic type parameter as opposed to reading the type name from the stream
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        protected override Type GetType(Stream stream)
        {
            return typeof(T);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package java.awt.image;

import java.util.Hashtable;
import java.util.Vector;

/**
 * An image producer that delivers image data from an array.
 */
public class MemoryImageSource implements ImageProducer
{
  private boolean animated = false;
  private boolean fullbuffers = false;
  private int[] pixeli;
  private int width;
  private int height;
  private int offset;
  private int scansize;
  private byte[] pixelb;
  private ColorModel cm;
  private Hashtable props = new Hashtable();
  private Vector consumers = new Vector();

  /**
   * Construct an image producer that reads image data from a byte
   * array.
   *
   * @param w width of image
   * @param h height of image
   * @param cm the color model used to represent pixel values
   * @param pix a byte array of pixel values
   * @param off the offset into the array at which the first pixel is stored
   * @param scan the number of array elements that represents a single pixel row
   */
  public MemoryImageSource(int w, int h, ColorModel cm, byte[] pix, int off,
                           int scan)
  {
    this(w, h, cm, pix, off, scan, null);
  }

  /**
   * Constructs an ImageProducer from memory.
   *
   * @param w  the image width.
   * @param h  the image height.
   * @param cm  the color model.
   * @param pix  the image data.
   * @param off  the offset to the first pixel in the array.
   * @param scan  the number of array elements from a pixel on one row to the
   *     corresponding pixel on the next row.
   * @param props  image properties (null permitted).
   */
  public MemoryImageSource(int w, int h, ColorModel cm, byte[] pix, int off,
                           int scan, Hashtable<?,?> props)
  {
    width = w;
    height = h;
    this.cm = cm;
    offset = off;
    scansize = scan;
    this.props = props;
    int max = ((scansize > width) ? scansize : width);
    pixelb = pix;
  }

  /**
   * Construct an image producer that reads image data from an
   * integer array.
   *
   * @param w width of image
   * @param h height of image
   * @param cm the color model used to represent pixel values
   * @param pix an integer array of pixel values
   * @param off the offset into the array at which the first pixel is stored
   * @param scan the number of array elements that represents a single pixel row
   */
  public MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off,
                           int scan)
  {
    this(w, h, cm, pix, off, scan, null);
  }

  /**
   * Constructs an ImageProducer from memory
   *
   * @param w  the image width.
   * @param h  the image height.
   * @param cm  the color model.
   * @param pix  the image data.
   * @param off  the offset to the first pixel in the array.
   * @param scan  the number of array elements from a pixel on one row to the
   *     corresponding pixel on the next row.
   * @param props  image properties (null permitted).
   */
  public MemoryImageSource(int w, int h, ColorModel cm, int[] pix, int off,
                           int scan, Hashtable<?,?> props)
  {
    width = w;
    height = h;
    this.cm = cm;
    offset = off;
    scansize = scan;
    this.props = props;
    int max = ((scansize > width) ? scansize : width);
    pixeli = pix;
  }

  /**
   * Constructs an ImageProducer from memory using the default RGB ColorModel.
   *
   * @param w  the image width.
   * @param h  the image height.
   * @param pix  the image data.
   * @param off  the offset to the first pixel in the array.
   * @param scan  the number of array elements from a pixel on one row to the
   *     corresponding pixel on the next row.
   * @param props  image properties (null permitted).

   */
  public MemoryImageSource(int w, int h, int[] pix, int off, int scan,
                           Hashtable<?,?> props)
  {
    this(w, h, ColorModel.getRGBdefault(), pix, off, scan, props);
  }

  /**
   * Constructs an ImageProducer from memory using the default RGB ColorModel.
   *
   * @param w  the image width.
   * @param h  the image height.
   * @param pix  the image data.
   * @param off  the offset to the first pixel in the array.
   * @param scan  the number of array elements from a pixel on one row to the
   *     corresponding pixel on the next row.
   */
  public MemoryImageSource(int w, int h, int[] pix, int off, int scan)
  {
    this(w, h, ColorModel.getRGBdefault(), pix, off, scan, null);
  }

  /**
   * Used to register an ImageConsumer with this
   * ImageProducer.
   *
   * @param ic  the image consumer.
   */
  public synchronized void addConsumer(ImageConsumer ic)
  {
    if (consumers.contains(ic))
      return;

    consumers.addElement(ic);
  }

  /**
   * Used to determine if the given ImageConsumer is
   * already registered with this ImageProducer.
   *
   * @param ic  the image consumer.
   */
  public synchronized boolean isConsumer(ImageConsumer ic)
  {
    if (consumers.contains(ic))
      return true;
    return false;
  }

  /**
   * Used to remove an ImageConsumer from the list of
   * registered consumers for this ImageProducer.
   *
   * @param ic  the image consumer.
   */
  public synchronized void removeConsumer(ImageConsumer ic)
  {
    consumers.removeElement(ic);
  }

  /**
   * Used to register an ImageConsumer with this
   * ImageProducer and then immediately start
   * reconstruction of the image data to be delivered to all
   * registered consumers.
   */
  public void startProduction(ImageConsumer ic)
  {
    if (! (consumers.contains(ic)))
      consumers.addElement(ic);

    Vector list = (Vector) consumers.clone();
    for (int i = 0; i < list.size(); i++)
      {
        ic = (ImageConsumer) list.elementAt(i);
        sendPicture(ic);
        if (animated)
          ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
        else
          ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
      }
  }

  /**
   * Used to register an ImageConsumer with this
   * ImageProducer and then request that this producer
   * resend the image data in the order top-down, left-right.
   *
   * @param ic  the image consumer.
   */
  public void requestTopDownLeftRightResend(ImageConsumer ic)
  {
    startProduction(ic);
  }

  /**
   * Changes a flag to indicate whether this MemoryImageSource supports
   * animations.
   *
   * @param animated A flag indicating whether this class supports animations
   */
  public synchronized void setAnimated(boolean animated)
  {
    this.animated = animated;
  }

  /**
   * A flag to indicate whether or not to send full buffer updates when
   * sending animation. If this flag is set then full buffers are sent
   * in the newPixels methods instead of just regions.
   *
   * @param fullbuffers a flag indicating whether to send the full buffers
   */
  public synchronized void setFullBufferUpdates(boolean fullbuffers)
  {
    this.fullbuffers = fullbuffers;
  }

  /**
   * Send an animation frame to the image consumers.
   */
  public void newPixels()
  {
    if (animated == true)
      {
        ImageConsumer ic;
        Vector list = (Vector) consumers.clone();
        for (int i = 0; i < list.size(); i++)
          {
            ic = (ImageConsumer) list.elementAt(i);
            sendPicture(ic);
            ic.imageComplete(ImageConsumer.SINGLEFRAME);
          }
      }
  }

  private void sendPicture(ImageConsumer ic)
  {
    ic.setHints(ImageConsumer.TOPDOWNLEFTRIGHT);
    if (props != null)
      ic.setProperties(props);
    ic.setDimensions(width, height);
    ic.setColorModel(cm);
    if (pixeli != null)
      ic.setPixels(0, 0, width, height, cm, pixeli, offset, scansize);
    else
      ic.setPixels(0, 0, width, height, cm, pixelb, offset, scansize);
  }

  /**
   * Send an animation frame to the image consumers containing the specified
   * pixels unless setFullBufferUpdates is set.
   *
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   * @param w  the width.
   * @param h  the height.
   */
  public synchronized void newPixels(int x, int y, int w, int h)
  {
    if (animated == true)
      {
        if (fullbuffers)
          newPixels();
        else
          {
            ImageConsumer ic;
            Vector list = (Vector) consumers.clone();
            for (int i = 0; i < list.size(); i++)
              {
                ic = (ImageConsumer) list.elementAt(i);
                ic.setHints(ImageConsumer.TOPDOWNLEFTRIGHT);
                if (props != null)
                  ic.setProperties(props);
                if (pixeli != null)
                  {
                    int[] pixelbuf = new int[w * h];
                    for (int row = y; row < y + h; row++)
                      System.arraycopy(pixeli, row * scansize + x + offset,
                                       pixelbuf, 0, w * h);
                    ic.setPixels(x, y, w, h, cm, pixelbuf, 0, w);
                  }
                else
                  {
                    byte[] pixelbuf = new byte[w * h];
                    for (int row = y; row < y + h; row++)
                      System.arraycopy(pixelb, row * scansize + x + offset,
                                       pixelbuf, 0, w * h);

                    ic.setPixels(x, y, w, h, cm, pixelbuf, 0, w);
                  }
                ic.imageComplete(ImageConsumer.SINGLEFRAME);
              }
          }
      }
  }

  /**
   * Send an animation frame to the image consumers containing the specified
   * pixels unless setFullBufferUpdates is set.
   *
   * If framenotify is set then a notification is sent when the frame
   * is sent otherwise no status is sent.
   *
   * @param x  the x-coordinate.
   * @param y  the y-coordinate.
   * @param w  the width.
   * @param h  the height.
   * @param framenotify  send notification?
   */
  public synchronized void newPixels(int x, int y, int w, int h,
                                     boolean framenotify)
  {
    if (animated == true)
      {
        if (fullbuffers)
          newPixels();
        else
          {
            ImageConsumer ic;
            Vector list = (Vector) consumers.clone();
            for (int i = 0; i < list.size(); i++)
              {
                ic = (ImageConsumer) list.elementAt(i);
                ic.setHints(ImageConsumer.TOPDOWNLEFTRIGHT);
                if (props != null)
                  ic.setProperties(props);
                if (pixeli != null)
                  {
                    int[] pixelbuf = new int[w * h];
                    for (int row = y; row < y + h; row++)
                      System.arraycopy(pixeli, row * scansize + x + offset,
                                       pixelbuf, 0, w * h);
                    ic.setPixels(x, y, w, h, cm, pixelbuf, 0, w);
                  }
                else
                  {
                    byte[] pixelbuf = new byte[w * h];
                    for (int row = y; row < y + h; row++)
                      System.arraycopy(pixelb, row * scansize + x + offset,
                                       pixelbuf, 0, w * h);
                    ic.setPixels(x, y, w, h, cm, pixelbuf, 0, w);
                  }
                if (framenotify == true)
                  ic.imageComplete(ImageConsumer.SINGLEFRAME);
              }
          }
      }
  }

  public synchronized void newPixels(byte[] newpix, ColorModel newmodel,
                                     int offset, int scansize)
  {
    pixeli = null;
    pixelb = newpix;
    cm = newmodel;
    this.offset = offset;
    this.scansize = scansize;
    if (animated == true)
      newPixels();
  }

  public synchronized void newPixels(int[] newpix, ColorModel newmodel,
                                     int offset, int scansize)
  {
    pixelb = null;
    pixeli = newpix;
    cm = newmodel;
    this.offset = offset;
    this.scansize = scansize;
    if (animated == true)
      newPixels();
  }
}


text:
title: Contact Form
menu: Contact
lead: I am not actively seeking new fulltime opportunities, but occasionally have space for some fun projects. Do you have an opportunity for us to work together to build something great? Use the form below to get in touch with me!
widgets:
---


text:
BSLS_IDENT_RCSID(baljsn_datumdecoderoptions_cpp,"$Id$ $CSID$")

#include <baljsn_encodingstyle.h>

#include <bsl_cstring.h>
#include <bsl_iomanip.h>
#include <bsl_limits.h>
#include <bsl_ostream.h>

#include <bslim_printer.h>

#include <bsls_assert.h>
#include <bsls_review.h>

///Implementation Note
///- - - - - - - - - -
// This file was generated from a script and was subsequently modified to add
// documentation and to make other changes.  The steps to generate and update
// this file can be found in the 'doc/generating_codec_options.txt' file.

namespace BloombergLP {
namespace baljsn {

                         // -------------------------
                         // class DatumDecoderOptions
                         // -------------------------
// CONSTANTS

const int DatumDecoderOptions::s_DEFAULT_INITIALIZER_MAX_NESTED_DEPTH = 64;

// CREATORS

DatumDecoderOptions::DatumDecoderOptions()
: d_maxNestedDepth(s_DEFAULT_INITIALIZER_MAX_NESTED_DEPTH)
{
}

DatumDecoderOptions::DatumDecoderOptions(const DatumDecoderOptions& original)
: d_maxNestedDepth(original.d_maxNestedDepth)
{
}

DatumDecoderOptions::~DatumDecoderOptions()
{
    BSLS_ASSERT(0 < d_maxNestedDepth);
}

// MANIPULATORS

DatumDecoderOptions&
DatumDecoderOptions::operator=(const DatumDecoderOptions& rhs)
{
    if (this != &rhs) {
        d_maxNestedDepth = rhs.d_maxNestedDepth;
    }

    return *this;
}

void DatumDecoderOptions::reset()
{
    d_maxNestedDepth = s_DEFAULT_INITIALIZER_MAX_NESTED_DEPTH;
}

// ACCESSORS

                                  // Aspects

bsl::ostream& DatumDecoderOptions::print(bsl::ostream& stream,
                                         int           level,
                                         int           spacesPerLevel) const
{
    bslim::Printer printer(&stream, level, spacesPerLevel);
    printer.start();
    printer.printAttribute("maxNestedDepth", d_maxNestedDepth);
    printer.end();
    return stream;
}

}  // close package namespace
}  // close enterprise namespace

// ----------------------------------------------------------------------------
// Copyright 2020 Bloomberg Finance L.P.
//
// 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.
// ----------------------------- END-OF-FILE ----------------------------------


text:
def normalize(request=None):
    """
    Normalize request to prevent bugs.

    :param request:
    :return:
    """

    request['headers'] = request['headers'] if 'headers' in request else {}
    return request


text:
package com.ansteel.common.model.domain;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.ansteel.core.constant.Constants;
import com.ansteel.core.domain.BaseEntity;
import com.ansteel.common.prentmodel.domain.FieldsQuery;

/**
 * 创 建 人:gugu
 * 创建日期:2015-06-11
 * 修 改 人:
 * 修改日 期:
 * 描   述:实体模型字段查询实体类。
 */
@Entity
@Table(name = Constants.G_TABLE_PREFIX +  "fields_query")
public class EntityFieldsQuery extends FieldsQuery{
	/**
	 *
	 */
	private static final long serialVersionUID = 3033101258110465361L;

	@ManyToOne(cascade={CascadeType.REFRESH, CascadeType.MERGE}, optional=true,
			fetch=FetchType.EAGER)
	@JoinColumn(name = "fcid", nullable = true)
	@JsonIgnore
	EntityFieldsCategory fieldsCategory=new EntityFieldsCategory();

	public EntityFieldsCategory getFieldsCategory() {
		return fieldsCategory;
	}
	public void setFieldsCategory(EntityFieldsCategory fieldsCategory) {
		this.fieldsCategory = fieldsCategory;
	}

}


text:
title: "S08: Produire des rapports d'analyse"
subtitle: "Analyse de données quantitatives avec R"
author: Samuel Coavoux
output:
  beamer_presentation:
    toc: true
    colortheme: beaver
    highlight: tango
    theme: Copenhagen
    includes:
      in_header: header.tex
---

# Knitr

### Knitr

Markdown est un langage dit *markup* (HTML, \LaTeX) conçu pour l'écriture web, et notamment pour les blogs. Il a donc vocation à être transformé en HTML. Son principe est d'être facile à lire. Le formatage est réduit au minimum, et toutes les instructions de format sont des signes de ponctuation.

Pandoc est un convertisseur universel de documents. Il est notamment employé pour transformer des documents markdown en d'autres formats, en particulier HTML, docx, et tex/pdf. Pandoc définit sa propre version de markdown, la plus adaptée à l'écriture universitaire (John McFarlane, son créateur, est professeur de philosophie à Berkeley).

Knitr est un package R qui emploie pandoc pour faciliter l'écriture de compte-rendu d'analyse statistique directement dans R.

### Schéma

Un document Rmarkdown est composé de:

+ un YAML front matter: un ensemble d'options;
+ du texte écrit au format markdown;
+ du code R écrit soit directement dans le texte, soit dans des *chunks*, des paragraphes séparés.

Knitr prend ce document, exécute l'ensemble du code R et remplace ce code par les résultats, sauvegarde ce document intermédiaire au format markdown, puis execute pandoc, qui transforme ce document au format docx, pdf ou html.

### Articuler scripts et rmarkdown

Quand utiliser des scripts, et quand utiliser rmarkdown?

Rmarkdown est intéressant pour deux choses:

+ au moment de l'exploration de données, permet de mettre en forme des analyses pour pouvoir les interpréter;
+ au moment de l'écriture pour publication.

Pour la programmation proprement dite, mieux vaut préférer les scripts R.

Dans tous les cas, lorsque des points de programmation sont longs et/ou complexe, il est préférable de les laisser dans un script à part et de l'appeler depuis le document Rmarkdown avec `source()`.

## Chunks

### Principe

Les chunks sont des paragraphes contenant du code R. Knitr va executer ce code et ajouter le résultat au document avant de le transformer vers son format final.

Syntaxiquement, un chunk est encadré de deux lignes signifiant son début et sa fin. Dans Rstudio, il apparaît avec un fond gris.

    ```{r}
    # contenu du chunk
    ```

Pour insérer un chunk dans Rstudio, on emploie le raccourci ctrl+alt+i.

### Attributs

La ligne ouvrant le chunk comprend plusieurs informations

    ```{engine titre, opt1="opt1", ...}

+ engine: il s'agit le plus souvent de r; knitr comprend d'autres langages, comme python;
+ titre: il est séparé de engine par une espace; il s'agit du titre du chunk, employé pour le retrouver facilement dans la table des matières (dans la barre d'état de Rstudio);
+ options: des couples nom de l'option = valeur de l'option.

### Chunk options

Il existe de très nombreuses options. Les plus utiles sont:

+ eval: TRUE par défaut; le code est évalué;
+ echo: TRUE par défaut; le code du chunk est répété dans le document;
+ message: TRUE par défaut; renvoie les messages produits par les fonctions;
+ warning: TRUE par défaut; renvoie les messages warnings produits par les fonctions du chunk;
+ results: "markup" par défaut. Controle la façon dont s'affichent les résultats;
+ dpi: 72 par défaut; controle la résolution des images (passer à 300 est habituellement une bonne idée).

### Chunk options

Les options de chunk peuvent être précisées à chaque chunk. Si l'on souhaite changer le défaut dans tout le document, il suffit d'ajouter au document un premier chunk les spécifiant avec `knitr::opts_chunk$set()`

    ```{r}
    library(knitr)
    opts_chunk$set(echo = FALSE, message = FALSE,
                   warning = FALSE, dpi = 300)
    ```

### Chunk: évaluation

Lorsque l'on appuie sur le bouton knit (ou que l'on emploie la fonction `rmarkdown::render()`), les chunks sont évalués dans l'ordre dans lequel ils apparaissent, et dans un nouvel environnement.

Cela signifie qu'un document rmarkdown doit être **entièrement autosuffisant**. Il doit inclure une importation de données, des fonctions library() pour charger les packages, etc. Lorsque l'on écrit un document markdown, il faut garder à l'esprit que toutes les commande que l'on écrit directement dans la console ne seront pas reproduites lors de la compilation du document.

### Chunk: écriture

En pratique, lors de l'écriture d'un document rmarkdown, on peut s'assurer de la cohérence du code en executant les chunks un par un. Pour cela, on peut soit:

+ utiliser ctrl+entrée qui envoie la ligne dans la console comme dans un script R normal;
+ utiliser ctrl+alt+c qui execute l'ensemble du chunk actuel;
+ utiliser ctrl+alt+n qui execute l'ensemble du prochain chunk (en répétant cette commande depuis le début du document, on execute tout);
+ cliquer sur la flèche vers le bas, en haut à droite de chaque chunk, pour executer tous les chunks précédents.

### Inline code

Outre les chunks, on peut également employer du code R "inline". La syntaxe à adopter, alors, est de mettre entre backtick r puis la commande à executer. Cela permet en particulier d'intégrer des résultats de calculs directement dans un texte au format markdown.

    ```{r}
    x <- rnorm(100)
    ```
    La moyenne de x est `r mean(x)`

## Markdown

### Principe

Markdown est donc un langage markup: il sert à écrire des documents avec une logique "what you see is what you mean" (par opposition aux traitements de texte "what you see is what you get"). Markdown emploie des signes de ponctuation pour donner une signification aux différents éléments d'un document.

### Paragraphes
Tous les paragraphes pour lesquels il n'y a aucun marqueur particulier sont des paragraphes normaux. Ils doivent commencer nécessairement en début de ligne (pas d'espace ou de tabulation).

Il faut sauter deux lignes pour changer de paragraphe.

    Voici un paragraphe qui continue ici :
    ce ne sont pas deux lignes différentes

    Voici un second paragraphe

### Titres

Un titre est une ligne commençant par un à six `#`

    # Voici un titre de niveau 1

    ## Et un titre de niveau 2

### Citations

Une citation est un paragraphe qui commence par un >

    > Voici une citation.

Il apparaîtra dans un style différent des paragraphes normaux.

> Voici une citation formattée

### Gras et italique

+ Italique (emphasis) : il suffit d'encadrer le passage en italique de `*` ou de `_`

        Voici *un passage en italique* et _un autre_

+ Gras (strong) : il suffit d'encadrer le passage en italique de `**` ou de `__`

        Voici **un passage en gras** et __un autre__

### Listes
Comme en HTML, les listes sont ordonnées ou non-ordonnées.

Les listes ordonnées sont des paragraphes commençant par -, +, ou *

    + premier item (on peut remplacer + par - ou *)
    + second item

Les listes non-ordonnées commencent par un chiffre et un point (n'importe quel chiffre : la liste est numérotée plus tard)

    1. premier élément
    1. deuxième élément (le 1. deviendra 2.
        à la compilation)

### Listes et paragraphes
Si un item de liste fait plusieurs lignes, la deuxième ligne doit commencer par une tabulation.

Cet exemple produit un élément de liste :

    1. premier élément avec un texte
        un peu long

Alors que celui-ci produira un élément et un paragraphe indépendant.

    1. premier élément avec un texte
    un peu long

### Liens
Pour ajouter des liens urls (balise '<a>' en HTML), on met le texte du lien (le texte qui s'affiche et que l'on peut cliquer) entre [] et l'adresse du lien, immédiatement après, entre (). Par exemple :

    Chercher sur [google](http://www.google.fr)

Il est également possible de donner l'adresse du lien après le paragraphe. Dans ce cas, on mettra le texte du lien entre [], suivi d'un renvoi entre []

    Chercher sur [google][1] ou [yahoo][y]

    [1]: http://www.google.fr
    [y]: http://www.yahoo.fr

### Images
Les images fonctionnent presque exactement comme les liens. Elles comportent trois éléments : un !, un texte entre [] (qui correspond à l'attribut alt en HTML), l'adresse de l'image entre () (attribut href)

    ![logo](./logo_ens.png)

Comme les liens, on peut renvoyer l'adresse de l'image en dehors du paragraphe

    ![logo][1]

    [1]: ./logo_ens.png

### Notes de bas de page

Il existe deux types de notes, les notes inline et les notes pleines.

    Texte normal^[texte de la note de bas de page].

    Texte normal[^appel_note].

    [^appel_note]: texte de la note de bas de page.

### Références

Pandoc markdown et knitr comprennent les références bibliographiques. Pour cela, il faut lier un fichier au format bibtex (format bibliographique de \LaTeX) dans l'option bibliography du YAML front matter. Ensuite, on appel des références de la manière suivante:

    Dans *La distinction* [@bourdieu1979]

Qui se transformera en:

    Dans *La distinction* (Bourdieu, 1979)

Par défaut, les citations sont compilées selon le style Chicago, que l'on peut changer avec l'option `csl`.

### Tableau

Il existe de nombreuses manières de faire des tableaux, qui nous concernent peu parce que nous allons les produire automatiquement. Voir l'aide en ligne de pandoc pour les syntaxes précises:  <http://pandoc.org/MANUAL.html#tables>

### Mathématiques

Markdown supporte l'écriture de formules mathématiques avec la syntaxe de \LaTeX. Tout ce qui se trouve entouré d'un signe `$` est considéré comme une formule mathématique ; et de deux signes `$$`, comme une équation écrite sur une ligne à part

    L'erreur-standard est $z\frac{\sigma}{\sqrt{n}}$

## YAML front matter

### YAML front matter

Le YAML front matter est la première partie d'un document Rmarkdown. Elle est automatiquement générée lorsque l'on crée un nouveau document en employant New File -> Rmarkdown/Rnotebook dans Rstudio. On peut également l'éditer à la main.

Cette partie commence et se termine par une ligne composée seulement de trois tirets. Entre ces deux lignes, le code doit respecter les contraintes du format YAML. On y trouve d'abord des métadonnées sous la forme de couples `clé: valeur`.

    ---
    title: "Titre de mon analyse"
    author: "Samuel Coavoux"
    ---

### YAML front matter

Outre le format clé: valeur, on peut écrire des listes. Le format le plus simple de liste dans YAML est le suivant:

    author:
    - "Pierre Bourdieu"
    - "Jean-Claude Passeron"

### YAML front matter

Le front matter contient également des instructions de formatage pour knitr. La plus importante est l'option `output` qui est nécessaire pour pouvoir compiler le document directement dans rstudio, en cliquant sur knit. Les principales possibilités sont:

+ html_document: le résultat est une page HTML, publiable sur le web;
+ word_document: le résultat est un document au format docx;
+ pdf_document: le résultat est un document pdf, en passant par \LaTeX;
+ beamer_presentation: le résultat est un fichier de slides au format pdf, en passant par beamer (classe de \LaTeX).

### YAML front matter

Souvent, ces formats sont eux-mêmes suivis d'options spécifiques, qui varient d'un format à l'autre. Elles se définissent dans une liste après le format.

    ---
    output:
      pdf_document:
        toc: true
    ---

### YAML front matter

On trouve enfin des options globales, qui s'appliquent quel que soit le format de sortie. Les plus importantes sont celles qui concernent la bibliographie employée:

    ---
    bibliography: "/chemin/vers/fichier/biblio.bib"
    csl: /chemin/vers/fichier/style/bibliographique
    ---

# Adapter les résultats pour publication

### Rmarkdown et résultats formattés

On peut employer Rmarkdown avec les mêmes packages que l'on emploie avec des scripts. Sans personnalisation, les résultats sont un peu bruts: chaque ligne de résultat commence par `##`, les résultats sont présentés dans une fixed-font width, et sont exactement ceux de la console R.

On peut au contraire utiliser Rmarkdown pour produire des résultats publiables. Dans ce cas, la plupart du temps, le code sera caché (avec `echo=FALSE`), et l'on veillera à ce que chaque chunk produise un retour correctement formatté.

### Graphiques

Pour les graphiques, aucune personnalisation n'est nécessaire. Les graphiques produits dans un chunk prendront sa place dans le document.

Il est cependant conseillé de ne produire qu'un seul graphique par chunk, pour simplifier la mise en page. Il existe des fonctions pour combiner plusieurs graphiques en un si nécessaire (en base-R, cf. l'argument `mfrow` de la fonction `par()`; avec ggplot, cf. `grid.arrange()` dans le package `grid.extra`).

L'option de chunk `fig.cap` permet de donner un titre au graphique produit. (`fig.cap = "Titre du graphique"`).

### Tableaux

Pour les tableaux, l'opération est un peu plus compliquée que pour les graphiques. Par défaut, les tableaux (objets de classe table ou data.frame) ne sont pas très faciles à lire. On utilise habituellement un package qui transforme ces tableaux au format R en des objets au format markdown, html, ou \LaTeX (selon le type de document que l'on produit).

Le point commun de tous ces packages est qu'il nécessite l'option de chunk `results = "asis"`. Habituellement, on met cette option par défaut dans le premier chunk avec `opts_chunk$set(results = "asis)`.

### Présenter des modèles: stargazer

Il existe de nombreux packages pour présenter des tableaux. Pour les résultats de modèles de régression, le plus souvent utilisé est `stargazer`.

`stargazer(modele)` s'adapte au type de modèle (selon la fonction par laquelle il a été construit). `?stargazer_models` liste les modèles compatibles.

L'argument `type` permet de contrôler si la sortie doit être "\LaTeX" (par défaut), "html" (lorsque l'on produit un document html) ou "text" (utile lorsque l'on utilise stargazer dans un script plutôt que dans un document Rmarkdown).

### Présenter un modèle linéaire: stargazer

Avec un modèle linéaire, stargazer renvoie par défaut un tableau contenant les coefficients, leur erreur standard, le résultat d'un test de nullité sous la forme d'étoiles, le nombre d'observations, le R^2^, le R^2^ ajusté. Cf. les options de stargazer pour personnaliser cette sortie. Habituellement, ça n'est pas nécessaire.

### Présenter un modèle logistique: stargazer

Pour les modèles logit, stargazer renvoie également les coefficients et leur erreur standard, le résultat d'un test de nullité sous la forme d'étoiles, la log-vraisemblance et l'AIC.

Souvent, on souhaitera transformer les coefficients en odds ratio. Il est alors préférable de rapporter l'intervalle de confiance de l'OR. On peut spécifier les odds.ratio en modifiant l'argument `coef` et l'intervalle de confiance avec `ci = TRUE` et l'argument `ci.custom`. Dans ce cas, mieux vaut rapporter les p.values à la main également. On peut utiliser ce code de la slide suivante pour cela.

###

    sg_or <- function(mod){
      OR <- lapply(mod, function(x) {
        as.data.frame(questionr::odds.ratio(x)))
      }
      re <- list(
        or = lapply(OR, `[[`, "OR"),
        ci = lapply(OR, `[`, 2:3),
        p  = lapply(OR, `[[`, "p")
      )
      return(re)
    }
    x <- sg_or(mod)
    stargazer(mod, type = "text", ci = TRUE,
    coef = x$or, ci.custom = x$ci, p = x$p)

### Présenter plusieurs modèles

stargazer accepte également plusieurs modèles en arguments. Dans ce cas, il produit un seul tableau mêlant ces modèles, en confondant les lignes pour lesquels les prédicteurs sont les mêmes.

### Personnaliser un tableau produit par stargazer

+ column.labels : vecteur caractère avec le nom de chacun des modèles (lorsque plusieurs modèles sont présentés);
+ covariate.labels : vecteur caractère spécifiant le nom de chacune des variables (par défaut, le nom du vecteur);
+ dep.var.labels : un vecteur caractère avec le nom de la variable modélisée (par défaut, le nom du vecteur);
+ model.names : vecteur logique indiquant s'il faut indiquer le type de modèle (OLS, logit, probit, etc.);
+ no.space : vecteur logique controlant les saut de lignes entre deux variables (FALSE par défaut).

### Présenter un tableau croisé

Pour les autres types de tableau, on peut utiliser une fonction du package `knitr` appellée `kable()`.

    kable(cprop(table(df$var1, df$var2)),
          cap = "Titre du tableau")

Il existe également d'autres packages spécialisés, dont `pander` et `xtable`. `kable` et `pander` produisent des sorties au format markdown, qui ne supportent pas les tables complexes (par exemple, avec des cellules fusionnées entre deux lignes ou deux colonnes). Dans ce cas, on peut écrire ces tables directement en \LaTeX avec `xtable`.

# Aller plus loin avec knitr

## Écrire des slides

### Moteurs de slides

Pandoc est capable d'écrire des slides au format \LaTeX ou html:

+ \LaTeX : avec le package beamer;
+ html: au format ioslides ou slidy

Ici, nous allons voir les slides au format beamer.

### Beamer

Il faut commencer par définir le type de document dans le YAML front matter:

---
output: beamer_presentation
---

### Slides

Ensuite, le document s'écrit comme un document normal. Pour commencer une nouvelle slide, il suffit de mettre un titre. Un titre vide produit une slide sans titre.

    ### Une slide

    + avec des bulletpoints
    + avec des bulletpoints

    ###

    + autre bulletpoint

### Slides-levels

Pandoc commence par déterminer quel niveau de titre correspond à un titre de slide. Les titres de niveau supérieur feront des sections, les titres de niveau inférieur des sous-titres dans une slide.

Pour cela, pandoc considère que le niveau de titre le plus élevé après lequel on trouve autre chose qu'un autre titre est celui des slides.

### Slides levels

Ici, pandoc considérera que les titres de niveau 2 sont les titres de slide.

    # Section

    ## Slide

    Du texte

### Slides levels

Ici, pandoc considérera que les titres de niveau 1 sont les titres de slide ; les titres de niveau 2 seront des sous-titres.

    # Section

    du texte

    ## Slide

    Du texte

### Slides levels: conseil

Habituellement, la convention suivante fonctionne bien avec les styles beamer, qui acceptent des sections et des sous-sections dans les slides:

+ titre de niveau 1: sections
+ titre de niveau 2: sous-sections
+ titre de niveau 3: slide

### Aide

<http://rmarkdown.rstudio.com/>

<http://stackoverflow.com/questions/tagged/rmarkdown>


text:
package org.n52.sos.ds.hibernate.entities;

import java.util.Set;

import org.n52.sos.ds.hibernate.entities.HibernateRelations.HasParentChilds;
import org.n52.sos.ds.hibernate.entities.HibernateRelations.HasValidProcedureTimes;

import com.google.common.collect.Sets;

/**
 * @author Carsten Hollmann
 *
 * @since 4.0.0
 */
public class TProcedure extends Procedure implements HasValidProcedureTimes, HasParentChilds<Procedure, TProcedure> {

    private static final long serialVersionUID = 3307492687846686350L;

    public static final String VALID_PROCEDURE_TIME = "validProcedureTimes";

    private Set<ValidProcedureTime> validProcedureTimes = Sets.newHashSet();

    private Set<Procedure> childs = Sets.newHashSet();

    private Set<Procedure> parents = Sets.newHashSet();

    public TProcedure() {
        super();
    }

    @Override
    public Set<ValidProcedureTime> getValidProcedureTimes() {
        return validProcedureTimes;
    }

    @Override
    public TProcedure setValidProcedureTimes(final Set<ValidProcedureTime> validProcedureTimes) {
        this.validProcedureTimes = validProcedureTimes;
        return this;
    }

    @Override
    public Set<Procedure> getParents() {
        return parents;
    }

    @Override
    public TProcedure setParents(final Set<Procedure> parents) {
        this.parents = parents;
        return this;
    }

    @Override
    public Set<Procedure> getChilds() {
        return childs;
    }

    @Override
    public TProcedure setChilds(final Set<Procedure> childs) {
        this.childs = childs;
        return this;
    }

}


text:
layout: post
title: "Sarah Guyot au garde à vous"
modified: 2016-03-02
tags: [people, course en ligne, equipe de france, media]
comments: true
---
On a tous dans notre entourage quelqu'un qui a changé de vie et qui a passé un CAP pâtisserie après avoir regardé le duo Mercotte Cyril Lignac sur M6... Maintenant on connait tous quelqu'un qui a décidé de s'engager dans l'armée de Terre après une soirée copines devant Garde à vous, retour au service militaire : la nouvelle émission événement de M6!

Les filles, cette année la mode aux piges c'est coupe en brosse et treillis!

#JeRêveDM6

{% capture images %}
/images/facebook/12814165_847792015348694_1612006232761687662_n.jpg
/images/facebook/12814428_847792005348695_6640773412455630414_n.jpg
{% endcapture %}
{% include gallery images=images cols=2 %}


text:
package com.palantir.atlasdb.stream;

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
import com.google.common.io.ByteStreams;
import com.google.common.io.CountingInputStream;
import com.google.protobuf.ByteString;
import com.palantir.atlasdb.encoding.PtBytes;
import com.palantir.atlasdb.protos.generated.StreamPersistence.Status;
import com.palantir.atlasdb.protos.generated.StreamPersistence.StreamMetadata;
import com.palantir.atlasdb.transaction.api.Transaction;
import com.palantir.atlasdb.transaction.api.TransactionManager;
import com.palantir.atlasdb.transaction.api.TransactionTask;
import com.palantir.atlasdb.transaction.impl.TxTask;
import com.palantir.common.base.Throwables;
import com.palantir.common.compression.StreamCompression;
import com.palantir.common.streams.KeyedStream;
import com.palantir.logsafe.SafeArg;
import com.palantir.util.Pair;
import com.palantir.util.crypto.Sha256Hash;
import java.io.IOException;
import java.io.InputStream;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nullable;

public abstract class AbstractPersistentStreamStore extends AbstractGenericStreamStore<Long>
        implements PersistentStreamStore {
    private final StreamStoreBackoffStrategy backoffStrategy;
    private final StreamCompression compression;

    protected AbstractPersistentStreamStore(TransactionManager txManager, StreamCompression compression) {
        this(txManager, compression, () -> StreamStorePersistenceConfigurations.DEFAULT_CONFIG);
    }

    protected AbstractPersistentStreamStore(
            TransactionManager txManager,
            StreamCompression compression,
            Supplier<StreamStorePersistenceConfiguration> persistenceConfiguration) {
        super(txManager, compression);
        this.compression = compression;
        this.backoffStrategy = StandardPeriodicBackoffStrategy.create(persistenceConfiguration);
    }

    protected final void storeMetadataAndIndex(final long streamId, final StreamMetadata metadata) {
        com.palantir.logsafe.Preconditions.checkNotNull(txnMgr, "Transaction manager must not be null");
        txnMgr.runTaskThrowOnConflict((TxTask) tx -> {
            putMetadataAndHashIndexTask(tx, streamId, metadata);
            return null;
        });
    }

    private Long lookupStreamIdByHash(Transaction tx, Sha256Hash hash) {
        Map<Sha256Hash, Long> hashToId = lookupStreamIdsByHash(tx, Sets.newHashSet(hash));
        if (hashToId.isEmpty()) {
            return null;
        }
        return Iterables.getOnlyElement(hashToId.entrySet()).getValue();
    }

    @Override
    public final long getByHashOrStoreStreamAndMarkAsUsed(
            Transaction tx, Sha256Hash hash, InputStream stream, byte[] reference) {
        Long streamId = lookupStreamIdByHash(tx, hash);
        if (streamId != null) {
            markStreamsAsUsed(
                    tx,
                    ImmutableMap.<Long, byte[]>builder()
                            .put(streamId, reference)
                            .buildOrThrow());
            return streamId;
        }
        Pair<Long, Sha256Hash> pair = storeStream(stream);
        Preconditions.checkArgument(
                hash.equals(pair.rhSide), "passed hash: %s does not equal stream hash: %s", hash, pair.rhSide);
        markStreamsAsUsedInternal(
                tx,
                ImmutableMap.<Long, byte[]>builder().put(pair.lhSide, reference).buildOrThrow());
        return pair.lhSide;
    }

    @Override
    public void unmarkStreamAsUsed(Transaction tx, long streamId, byte[] reference) {
        unmarkStreamsAsUsed(
                tx,
                ImmutableMap.<Long, byte[]>builder().put(streamId, reference).buildOrThrow());
    }

    @Override
    public void markStreamAsUsed(Transaction tx, long streamId, byte[] reference) {
        markStreamsAsUsed(
                tx,
                ImmutableMap.<Long, byte[]>builder().put(streamId, reference).buildOrThrow());
    }

    @Override
    public void markStreamsAsUsed(Transaction tx, Map<Long, byte[]> streamIdsToReference) {
        touchMetadataWhileMarkingUsedForConflicts(tx, streamIdsToReference.keySet());
        markStreamsAsUsedInternal(tx, streamIdsToReference);
    }

    protected long storeEmptyMetadata() {
        com.palantir.logsafe.Preconditions.checkNotNull(txnMgr, "Transaction manager must not be null");
        return txnMgr.runTaskThrowOnConflict(tx -> {
            putMetadataAndHashIndexTask(tx, tx.getTimestamp(), getEmptyMetadata());
            return tx.getTimestamp();
        });
    }

    @Override
    public Pair<Long, Sha256Hash> storeStream(InputStream stream) {
        // Store empty metadata before doing anything
        long id = storeEmptyMetadata();

        StreamMetadata metadata = storeBlocksAndGetFinalMetadata(null, id, stream);
        storeMetadataAndIndex(id, metadata);
        return Pair.create(id, new Sha256Hash(metadata.getHash().toByteArray()));
    }

    @Override
    public Map<Long, Sha256Hash> storeStreams(final Transaction tx, final Map<Long, InputStream> streams) {
        if (streams.isEmpty()) {
            return ImmutableMap.of();
        }

        Map<Long, StreamMetadata> idsToEmptyMetadata =
                KeyedStream.stream(streams).map($ -> getEmptyMetadata()).collectToMap();
        putMetadataAndHashIndexTask(tx, idsToEmptyMetadata);

        Map<Long, StreamMetadata> idsToMetadata = KeyedStream.stream(streams)
                .map((id, stream) -> storeBlocksAndGetFinalMetadata(tx, id, stream))
                .collectToMap();
        putMetadataAndHashIndexTask(tx, idsToMetadata);

        return KeyedStream.stream(idsToMetadata)
                .map(metadata -> new Sha256Hash(metadata.getHash().toByteArray()))
                .collectToMap();
    }

    // This method is overridden in generated code. Changes to this method may have unintended consequences.
    protected StreamMetadata storeBlocksAndGetFinalMetadata(@Nullable Transaction tx, long id, InputStream stream) {
        MessageDigest digest = Sha256Hash.getMessageDigest();
        try (InputStream hashingStream = new DigestInputStream(stream, digest);
                InputStream compressingStream = compression.compress(hashingStream)) {
            StreamMetadata metadata = storeBlocksAndGetHashlessMetadata(tx, id, compressingStream);
            return StreamMetadata.newBuilder(metadata)
                    .setHash(ByteString.copyFrom(digest.digest()))
                    .build();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    protected final StreamMetadata storeBlocksAndGetHashlessMetadata(
            @Nullable Transaction tx, long id, InputStream stream) {
        CountingInputStream countingStream = new CountingInputStream(stream);

        // Try to store the bytes in the stream and get length
        try {
            storeBlocksFromStream(tx, id, countingStream);
        } catch (IOException e) {
            long length = countingStream.getCount();
            StreamMetadata metadata = StreamMetadata.newBuilder()
                    .setStatus(Status.FAILED)
                    .setLength(length)
                    .setHash(ByteString.EMPTY)
                    .build();
            storeMetadataAndIndex(id, metadata);
            log.error(
                    "Could not store stream {}. Failed after {} bytes.",
                    SafeArg.of("stream", id),
                    SafeArg.of("length", length),
                    e);
            throw Throwables.rewrapAndThrowUncheckedException("Failed to store stream.", e);
        }

        long length = countingStream.getCount();
        return StreamMetadata.newBuilder()
                .setStatus(Status.STORED)
                .setLength(length)
                .setHash(ByteString.EMPTY)
                .build();
    }

    private void storeBlocksFromStream(@Nullable Transaction tx, long id, InputStream stream) throws IOException {
        long blockNumber = 0;

        while (true) {
            byte[] bytesToStore = new byte[BLOCK_SIZE_IN_BYTES];
            int length = ByteStreams.read(stream, bytesToStore, 0, BLOCK_SIZE_IN_BYTES);
            // Store only relevant data if it only filled a partial block
            if (length == 0) {
                break;
            }
            if (length < BLOCK_SIZE_IN_BYTES) {
                // This is the last block.
                storeBlockWithNonNullTransaction(tx, id, blockNumber, PtBytes.head(bytesToStore, length));
                break;
            } else {
                // Store a full block.
                storeBlockWithNonNullTransaction(tx, id, blockNumber, bytesToStore);
            }
            blockNumber++;
            if (!streamOperationIsTransactional(tx)) {
                backoffStrategy.accept(blockNumber);
            }
        }
    }

    private boolean streamOperationIsTransactional(@Nullable Transaction tx) {
        // TODO (jkong): I'm using tx == null as a proxy for whether the entire operation should be done
        // transactionally or not (null implies nontransactional).
        // This is not ideal, but was done in the interest of time.
        return tx != null;
    }

    protected void storeBlockWithNonNullTransaction(
            @Nullable Transaction tx, final long id, final long blockNumber, final byte[] bytesToStore) {
        if (tx != null) {
            storeBlock(tx, id, blockNumber, bytesToStore);
        } else {
            com.palantir.logsafe.Preconditions.checkNotNull(txnMgr, "Transaction manager must not be null");
            txnMgr.runTaskThrowOnConflict((TransactionTask<Void, RuntimeException>) t1 -> {
                storeBlock(t1, id, blockNumber, bytesToStore);
                return null;
            });
        }
    }

    private void putMetadataAndHashIndexTask(Transaction tx, Long streamId, StreamMetadata metadata) {
        putMetadataAndHashIndexTask(
                tx,
                ImmutableMap.<Long, StreamMetadata>builder()
                        .put(streamId, metadata)
                        .buildOrThrow());
    }

    protected abstract void putMetadataAndHashIndexTask(Transaction tx, Map<Long, StreamMetadata> streamIdsToMetadata);

    protected abstract void storeBlock(Transaction tx, long id, long blockNumber, byte[] block);

    protected abstract void touchMetadataWhileMarkingUsedForConflicts(Transaction tx, Iterable<Long> ids)
            throws StreamCleanedException;

    protected abstract void markStreamsAsUsedInternal(Transaction tx, Map<Long, byte[]> streamIdsToReference);
}


text:
package redis.clients.jedis;

import static redis.clients.jedis.Protocol.toByteArray;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLSocketFactory;

import redis.clients.jedis.commands.Commands;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.params.MigrateParams;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.params.ZAddParams;
import redis.clients.jedis.params.ZIncrByParams;
import redis.clients.jedis.util.SafeEncoder;

public class Client extends BinaryClient implements Commands {

  public Client() {
    super();
  }

  public Client(final String host) {
    super(host);
  }

  public Client(final String host, final int port) {
    super(host, port);
  }

  public Client(final String host, final int port, final boolean ssl) {
    super(host, port, ssl);
  }

  public Client(final String host, final int port, final boolean ssl,
      final SSLSocketFactory sslSocketFactory, final SSLParameters sslParameters,
      final HostnameVerifier hostnameVerifier) {
    super(host, port, ssl, sslSocketFactory, sslParameters, hostnameVerifier);
  }

  @Override
  public void ping(final String message) {
    ping(SafeEncoder.encode(message));
  }

  @Override
  public void set(final String key, final String value) {
    set(SafeEncoder.encode(key), SafeEncoder.encode(value));
  }

  @Override
  public void set(final String key, final String value, final SetParams params) {
    set(SafeEncoder.encode(key), SafeEncoder.encode(value), params);
  }

  @Override
  public void get(final String key) {
    get(SafeEncoder.encode(key));
  }

  @Override
  public void exists(final String... keys) {
    exists(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void del(final String... keys) {
    del(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void unlink(final String... keys) {
    unlink(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void type(final String key) {
    type(SafeEncoder.encode(key));
  }

  @Override
  public void keys(final String pattern) {
    keys(SafeEncoder.encode(pattern));
  }

  @Override
  public void rename(final String oldkey, final String newkey) {
    rename(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
  }

  @Override
  public void renamenx(final String oldkey, final String newkey) {
    renamenx(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
  }

  @Override
  public void expire(final String key, final int seconds) {
    expire(SafeEncoder.encode(key), seconds);
  }

  @Override
  public void expireAt(final String key, final long unixTime) {
    expireAt(SafeEncoder.encode(key), unixTime);
  }

  @Override
  public void ttl(final String key) {
    ttl(SafeEncoder.encode(key));
  }

  @Override
  public void pttl(final String key) {
    pttl(SafeEncoder.encode(key));
  }

  @Override
  public void touch(final String... keys) {
    touch(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void move(final String key, final int dbIndex) {
    move(SafeEncoder.encode(key), dbIndex);
  }

  @Override
  public void getSet(final String key, final String value) {
    getSet(SafeEncoder.encode(key), SafeEncoder.encode(value));
  }

  @Override
  public void mget(final String... keys) {
    mget(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void setnx(final String key, final String value) {
    setnx(SafeEncoder.encode(key), SafeEncoder.encode(value));
  }

  @Override
  public void setex(final String key, final int seconds, final String value) {
    setex(SafeEncoder.encode(key), seconds, SafeEncoder.encode(value));
  }

  @Override
  public void mset(final String... keysvalues) {
    mset(SafeEncoder.encodeMany(keysvalues));
  }

  @Override
  public void msetnx(final String... keysvalues) {
    msetnx(SafeEncoder.encodeMany(keysvalues));
  }

  @Override
  public void decrBy(final String key, final long decrement) {
    decrBy(SafeEncoder.encode(key), decrement);
  }

  @Override
  public void decr(final String key) {
    decr(SafeEncoder.encode(key));
  }

  @Override
  public void incrBy(final String key, final long increment) {
    incrBy(SafeEncoder.encode(key), increment);
  }

  @Override
  public void incr(final String key) {
    incr(SafeEncoder.encode(key));
  }

  @Override
  public void append(final String key, final String value) {
    append(SafeEncoder.encode(key), SafeEncoder.encode(value));
  }

  @Override
  public void substr(final String key, final int start, final int end) {
    substr(SafeEncoder.encode(key), start, end);
  }

  @Override
  public void hset(final String key, final String field, final String value) {
    hset(SafeEncoder.encode(key), SafeEncoder.encode(field), SafeEncoder.encode(value));
  }

  @Override
  public void hset(final String key, final Map<String, String> hash) {
    final Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(hash.size());
    for (final Entry<String, String> entry : hash.entrySet()) {
      bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder.encode(entry.getValue()));
    }
    hset(SafeEncoder.encode(key), bhash);
  }

  @Override
  public void hget(final String key, final String field) {
    hget(SafeEncoder.encode(key), SafeEncoder.encode(field));
  }

  @Override
  public void hsetnx(final String key, final String field, final String value) {
    hsetnx(SafeEncoder.encode(key), SafeEncoder.encode(field), SafeEncoder.encode(value));
  }

  @Override
  public void hmset(final String key, final Map<String, String> hash) {
    final Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(hash.size());
    for (final Entry<String, String> entry : hash.entrySet()) {
      bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder.encode(entry.getValue()));
    }
    hmset(SafeEncoder.encode(key), bhash);
  }

  @Override
  public void hmget(final String key, final String... fields) {
    hmget(SafeEncoder.encode(key), SafeEncoder.encodeMany(fields));
  }

  @Override
  public void hincrBy(final String key, final String field, final long value) {
    hincrBy(SafeEncoder.encode(key), SafeEncoder.encode(field), value);
  }

  @Override
  public void hexists(final String key, final String field) {
    hexists(SafeEncoder.encode(key), SafeEncoder.encode(field));
  }

  @Override
  public void hdel(final String key, final String... fields) {
    hdel(SafeEncoder.encode(key), SafeEncoder.encodeMany(fields));
  }

  @Override
  public void hlen(final String key) {
    hlen(SafeEncoder.encode(key));
  }

  @Override
  public void hkeys(final String key) {
    hkeys(SafeEncoder.encode(key));
  }

  @Override
  public void hvals(final String key) {
    hvals(SafeEncoder.encode(key));
  }

  @Override
  public void hgetAll(final String key) {
    hgetAll(SafeEncoder.encode(key));
  }

  @Override
  public void rpush(final String key, final String... string) {
    rpush(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
  }

  @Override
  public void lpush(final String key, final String... string) {
    lpush(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
  }

  @Override
  public void llen(final String key) {
    llen(SafeEncoder.encode(key));
  }

  @Override
  public void lrange(final String key, final long start, final long stop) {
    lrange(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void ltrim(final String key, final long start, final long stop) {
    ltrim(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void lindex(final String key, final long index) {
    lindex(SafeEncoder.encode(key), index);
  }

  @Override
  public void lset(final String key, final long index, final String value) {
    lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
  }

  @Override
  public void lrem(final String key, final long count, final String value) {
    lrem(SafeEncoder.encode(key), count, SafeEncoder.encode(value));
  }

  @Override
  public void lpop(final String key) {
    lpop(SafeEncoder.encode(key));
  }

  @Override
  public void rpop(final String key) {
    rpop(SafeEncoder.encode(key));
  }

  @Override
  public void rpoplpush(final String srckey, final String dstkey) {
    rpoplpush(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey));
  }

  @Override
  public void sadd(final String key, final String... members) {
    sadd(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
  }

  @Override
  public void smembers(final String key) {
    smembers(SafeEncoder.encode(key));
  }

  @Override
  public void srem(final String key, final String... members) {
    srem(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
  }

  @Override
  public void spop(final String key) {
    spop(SafeEncoder.encode(key));
  }

  @Override
  public void spop(final String key, final long count) {
    spop(SafeEncoder.encode(key), count);
  }

  @Override
  public void smove(final String srckey, final String dstkey, final String member) {
    smove(SafeEncoder.encode(srckey), SafeEncoder.encode(dstkey), SafeEncoder.encode(member));
  }

  @Override
  public void scard(final String key) {
    scard(SafeEncoder.encode(key));
  }

  @Override
  public void sismember(final String key, final String member) {
    sismember(SafeEncoder.encode(key), SafeEncoder.encode(member));
  }

  @Override
  public void sinter(final String... keys) {
    sinter(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sinterstore(final String dstkey, final String... keys) {
    sinterstore(SafeEncoder.encode(dstkey), SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sunion(final String... keys) {
    sunion(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sunionstore(final String dstkey, final String... keys) {
    sunionstore(SafeEncoder.encode(dstkey), SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sdiff(final String... keys) {
    sdiff(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sdiffstore(final String dstkey, final String... keys) {
    sdiffstore(SafeEncoder.encode(dstkey), SafeEncoder.encodeMany(keys));
  }

  @Override
  public void srandmember(final String key) {
    srandmember(SafeEncoder.encode(key));
  }

  @Override
  public void zadd(final String key, final double score, final String member) {
    zadd(SafeEncoder.encode(key), score, SafeEncoder.encode(member));
  }

  @Override
  public void zadd(final String key, final double score, final String member,
      final ZAddParams params) {
    zadd(SafeEncoder.encode(key), score, SafeEncoder.encode(member), params);
  }

  @Override
  public void zadd(final String key, final Map<String, Double> scoreMembers) {
    HashMap<byte[], Double> binaryScoreMembers = convertScoreMembersToBinary(scoreMembers);
    zadd(SafeEncoder.encode(key), binaryScoreMembers);
  }

  @Override
  public void zadd(final String key, final Map<String, Double> scoreMembers, final ZAddParams params) {
    HashMap<byte[], Double> binaryScoreMembers = convertScoreMembersToBinary(scoreMembers);
    zadd(SafeEncoder.encode(key), binaryScoreMembers, params);
  }

  @Override
  public void zrange(final String key, final long start, final long stop) {
    zrange(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void zrem(final String key, final String... members) {
    zrem(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
  }

  @Override
  public void zincrby(final String key, final double increment, final String member) {
    zincrby(SafeEncoder.encode(key), increment, SafeEncoder.encode(member));
  }

  @Override
  public void zincrby(final String key, final double increment, final String member, final ZIncrByParams params) {
    zincrby(SafeEncoder.encode(key), increment, SafeEncoder.encode(member), params);
  }

  @Override
  public void zrank(final String key, final String member) {
    zrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
  }

  @Override
  public void zrevrank(final String key, final String member) {
    zrevrank(SafeEncoder.encode(key), SafeEncoder.encode(member));
  }

  @Override
  public void zrevrange(final String key, final long start, final long stop) {
    zrevrange(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void zrangeWithScores(final String key, final long start, final long stop) {
    zrangeWithScores(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void zrevrangeWithScores(final String key, final long start, final long stop) {
    zrevrangeWithScores(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void zcard(final String key) {
    zcard(SafeEncoder.encode(key));
  }

  @Override
  public void zscore(final String key, final String member) {
    zscore(SafeEncoder.encode(key), SafeEncoder.encode(member));
  }

  @Override
  public void watch(final String... keys) {
    watch(SafeEncoder.encodeMany(keys));
  }

  @Override
  public void sort(final String key) {
    sort(SafeEncoder.encode(key));
  }

  @Override
  public void sort(final String key, final SortingParams sortingParameters) {
    sort(SafeEncoder.encode(key), sortingParameters);
  }

  @Override
  public void blpop(final String[] args) {
    blpop(SafeEncoder.encodeMany(args));
  }

  public void blpop(final int timeout, final String... keys) {
    final int size = keys.length + 1;
    List<String> args = new ArrayList<String>(size);
    for (String arg : keys) {
      args.add(arg);
    }
    args.add(String.valueOf(timeout));
    blpop(args.toArray(new String[size]));
  }

  @Override
  public void sort(final String key, final SortingParams sortingParameters, final String dstkey) {
    sort(SafeEncoder.encode(key), sortingParameters, SafeEncoder.encode(dstkey));
  }

  @Override
  public void sort(final String key, final String dstkey) {
    sort(SafeEncoder.encode(key), SafeEncoder.encode(dstkey));
  }

  @Override
  public void brpop(final String[] args) {
    brpop(SafeEncoder.encodeMany(args));
  }

  public void brpop(final int timeout, final String... keys) {
    final int size = keys.length + 1;
    List<String> args = new ArrayList<String>(size);
    for (String arg : keys) {
      args.add(arg);
    }
    args.add(String.valueOf(timeout));
    brpop(args.toArray(new String[size]));
  }

  @Override
  public void zcount(final String key, final double min, final double max) {
    zcount(SafeEncoder.encode(key), toByteArray(min), toByteArray(max));
  }

  @Override
  public void zcount(final String key, final String min, final String max) {
    zcount(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  @Override
  public void zrangeByScore(final String key, final double min, final double max) {
    zrangeByScore(SafeEncoder.encode(key), toByteArray(min), toByteArray(max));
  }

  @Override
  public void zrangeByScore(final String key, final String min, final String max) {
    zrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  @Override
  public void zrangeByScore(final String key, final double min, final double max, final int offset,
      final int count) {
    zrangeByScore(SafeEncoder.encode(key), toByteArray(min), toByteArray(max), offset, count);
  }

  @Override
  public void zrangeByScoreWithScores(final String key, final double min, final double max) {
    zrangeByScoreWithScores(SafeEncoder.encode(key), toByteArray(min), toByteArray(max));
  }

  @Override
  public void zrangeByScoreWithScores(final String key, final double min, final double max,
      final int offset, final int count) {
    zrangeByScoreWithScores(SafeEncoder.encode(key), toByteArray(min), toByteArray(max), offset,
      count);
  }

  @Override
  public void zrevrangeByScore(final String key, final double max, final double min) {
    zrevrangeByScore(SafeEncoder.encode(key), toByteArray(max), toByteArray(min));
  }

  @Override
  public void zrangeByScore(final String key, final String min, final String max, final int offset,
      final int count) {
    zrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max),
      offset, count);
  }

  @Override
  public void zrangeByScoreWithScores(final String key, final String min, final String max) {
    zrangeByScoreWithScores(SafeEncoder.encode(key), SafeEncoder.encode(min),
      SafeEncoder.encode(max));
  }

  @Override
  public void zrangeByScoreWithScores(final String key, final String min, final String max,
      final int offset, final int count) {
    zrangeByScoreWithScores(SafeEncoder.encode(key), SafeEncoder.encode(min),
      SafeEncoder.encode(max), offset, count);
  }

  @Override
  public void zrevrangeByScore(final String key, final String max, final String min) {
    zrevrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min));
  }

  @Override
  public void zrevrangeByScore(final String key, final double max, final double min,
      final int offset, final int count) {
    zrevrangeByScore(SafeEncoder.encode(key), toByteArray(max), toByteArray(min), offset, count);
  }

  @Override
  public void zrevrangeByScore(final String key, final String max, final String min,
      final int offset, final int count) {
    zrevrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min),
      offset, count);
  }

  @Override
  public void zrevrangeByScoreWithScores(final String key, final double max, final double min) {
    zrevrangeByScoreWithScores(SafeEncoder.encode(key), toByteArray(max), toByteArray(min));
  }

  @Override
  public void zrevrangeByScoreWithScores(final String key, final String max, final String min) {
    zrevrangeByScoreWithScores(SafeEncoder.encode(key), SafeEncoder.encode(max),
      SafeEncoder.encode(min));
  }

  @Override
  public void zrevrangeByScoreWithScores(final String key, final double max, final double min,
      final int offset, final int count) {
    zrevrangeByScoreWithScores(SafeEncoder.encode(key), toByteArray(max), toByteArray(min), offset,
      count);
  }

  @Override
  public void zrevrangeByScoreWithScores(final String key, final String max, final String min,
      final int offset, final int count) {
    zrevrangeByScoreWithScores(SafeEncoder.encode(key), SafeEncoder.encode(max),
      SafeEncoder.encode(min), offset, count);
  }

  @Override
  public void zremrangeByRank(final String key, final long start, final long stop) {
    zremrangeByRank(SafeEncoder.encode(key), start, stop);
  }

  @Override
  public void zremrangeByScore(final String key, final double min, final double max) {
    zremrangeByScore(SafeEncoder.encode(key), toByteArray(min), toByteArray(max));
  }

  @Override
  public void zremrangeByScore(final String key, final String min, final String max) {
    zremrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  @Override
  public void zunionstore(final String dstkey, final String... sets) {
    zunionstore(SafeEncoder.encode(dstkey), SafeEncoder.encodeMany(sets));
  }

  @Override
  public void zunionstore(final String dstkey, final ZParams params, final String... sets) {
    zunionstore(SafeEncoder.encode(dstkey), params, SafeEncoder.encodeMany(sets));
  }

  @Override
  public void zinterstore(final String dstkey, final String... sets) {
    zinterstore(SafeEncoder.encode(dstkey), SafeEncoder.encodeMany(sets));
  }

  @Override
  public void zinterstore(final String dstkey, final ZParams params, final String... sets) {
    zinterstore(SafeEncoder.encode(dstkey), params, SafeEncoder.encodeMany(sets));
  }

  public void zlexcount(final String key, final String min, final String max) {
    zlexcount(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  public void zrangeByLex(final String key, final String min, final String max) {
    zrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  public void zrangeByLex(final String key, final String min, final String max, final int offset,
      final int count) {
    zrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max), offset,
      count);
  }

  public void zrevrangeByLex(final String key, final String max, final String min) {
    zrevrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min));
  }

  public void zrevrangeByLex(final String key, final String max, final String min, final int offset, final int count) {
    zrevrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min),
      offset, count);
  }

  public void zremrangeByLex(final String key, final String min, final String max) {
    zremrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max));
  }

  @Override
  public void strlen(final String key) {
    strlen(SafeEncoder.encode(key));
  }

  @Override
  public void lpushx(final String key, final String... string) {
    lpushx(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
  }

  @Override
  public void persist(final String key) {
    persist(SafeEncoder.encode(key));
  }

  @Override
  public void rpushx(final String key, final String... string) {
    rpushx(SafeEncoder.encode(key), SafeEncoder.encodeMany(string));
  }

  @Override
  public void echo(final String string) {
    echo(SafeEncoder.encode(string));
  }

  @Override
  public void linsert(final String key, final ListPosition where, final String pivot,
      final String value) {
    linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot), SafeEncoder.encode(value));
  }

  @Override
  public void brpoplpush(final String source, final String destination, final int timeout) {
    brpoplpush(SafeEncoder.encode(source), SafeEncoder.encode(destination), timeout);
  }

  @Override
  public void setbit(final String key, final long offset, final boolean value) {
    setbit(SafeEncoder.encode(key), offset, value);
  }

  @Override
  public void setbit(final String key, final long offset, final String value) {
    setbit(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
  }

  @Override
  public void getbit(final String key, final long offset) {
    getbit(SafeEncoder.encode(key), offset);
  }

  public void bitpos(final String key, final boolean value, final BitPosParams params) {
    bitpos(SafeEncoder.encode(key), value, params);
  }

  @Override
  public void setrange(final String key, final long offset, final String value) {
    setrange(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
  }

  @Override
  public void getrange(final String key, final long startOffset, final long endOffset) {
    getrange(SafeEncoder.encode(key), startOffset, endOffset);
  }

  public void publish(final String channel, final String message) {
    publish(SafeEncoder.encode(channel), SafeEncoder.encode(message));
  }

  public void unsubscribe(final String... channels) {
    unsubscribe(SafeEncoder.encodeMany(channels));
  }

  public void psubscribe(final String... patterns) {
    psubscribe(SafeEncoder.encodeMany(patterns));
  }

  public void punsubscribe(final String... patterns) {
    punsubscribe(SafeEncoder.encodeMany(patterns));
  }

  public void subscribe(final String... channels) {
    subscribe(SafeEncoder.encodeMany(channels));
  }

  public void pubsubChannels(final String pattern) {
    pubsub(Protocol.PUBSUB_CHANNELS, pattern);
  }

  public void pubsubNumPat() {
    pubsub(Protocol.PUBSUB_NUM_PAT);
  }

  public void pubsubNumSub(final String... channels) {
    pubsub(Protocol.PUBSUB_NUMSUB, channels);
  }

  @Override
  public void configSet(final String parameter, final String value) {
    configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value));
  }

  @Override
  public void configGet(final String pattern) {
    configGet(SafeEncoder.encode(pattern));
  }

  public void eval(final String script, final int keyCount, final String... params) {
    eval(SafeEncoder.encode(script), toByteArray(keyCount), SafeEncoder.encodeMany(params));
  }

  public void evalsha(final String sha1, final int keyCount, final String... params) {
    evalsha(SafeEncoder.encode(sha1), toByteArray(keyCount), SafeEncoder.encodeMany(params));
  }

  public void scriptExists(final String... sha1) {
    scriptExists(SafeEncoder.encodeMany(sha1));
  }

  public void scriptLoad(final String script) {
    scriptLoad(SafeEncoder.encode(script));
  }

  @Override
  public void objectRefcount(final String key) {
    objectRefcount(SafeEncoder.encode(key));
  }

  @Override
  public void objectIdletime(final String key) {
    objectIdletime(SafeEncoder.encode(key));
  }

  @Override
  public void objectEncoding(final String key) {
    objectEncoding(SafeEncoder.encode(key));
  }

  @Override
  public void bitcount(final String key) {
    bitcount(SafeEncoder.encode(key));
  }

  @Override
  public void bitcount(final String key, final long start, final long end) {
    bitcount(SafeEncoder.encode(key), start, end);
  }

  @Override
  public void bitop(final BitOP op, final String destKey, final String... srcKeys) {
    bitop(op, SafeEncoder.encode(destKey), SafeEncoder.encodeMany(srcKeys));
  }

  public void sentinel(final String... args) {
    sentinel(SafeEncoder.encodeMany(args));
  }

  @Override
  public void dump(final String key) {
    dump(SafeEncoder.encode(key));
  }

  @Override
  public void restore(final String key, final int ttl, final byte[] serializedValue) {
    restore(SafeEncoder.encode(key), ttl, serializedValue);
  }

  @Override
  public void restoreReplace(final String key, final int ttl, final byte[] serializedValue) {
    restoreReplace(SafeEncoder.encode(key), ttl, serializedValue);
  }

  public void pexpire(final String key, final long milliseconds) {
    pexpire(SafeEncoder.encode(key), milliseconds);
  }

  public void pexpireAt(final String key, final long millisecondsTimestamp) {
    pexpireAt(SafeEncoder.encode(key), millisecondsTimestamp);
  }

  @Override
  public void incrByFloat(final String key, final double increment) {
    incrByFloat(SafeEncoder.encode(key), increment);
  }

  public void psetex(final String key, final long milliseconds, final String value) {
    psetex(SafeEncoder.encode(key), milliseconds, SafeEncoder.encode(value));
  }

  public void srandmember(final String key, final int count) {
    srandmember(SafeEncoder.encode(key), count);
  }

  public void clientKill(final String ipPort) {
    clientKill(SafeEncoder.encode(ipPort));
  }

  public void clientSetname(final String name) {
    clientSetname(SafeEncoder.encode(name));
  }

  @Override
  public void migrate(final String host, final int port, final String key,
      final int destinationDb, final int timeout) {
    migrate(host, port, SafeEncoder.encode(key), destinationDb, timeout);
  }

  @Override
  public void migrate(final String host, final int port, final int destinationDB,
      final int timeout, final MigrateParams params, String... keys) {
    migrate(host, port, destinationDB, timeout, params, SafeEncoder.encodeMany(keys));
  }

  @Override
  public void hincrByFloat(final String key, final String field, final double increment) {
    hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field), increment);
  }

  @Override
  public void scan(final String cursor, final ScanParams params) {
    scan(SafeEncoder.encode(cursor), params);
  }

  @Override
  public void hscan(final String key, final String cursor, final ScanParams params) {
    hscan(SafeEncoder.encode(key), SafeEncoder.encode(cursor), params);
  }

  @Override
  public void sscan(final String key, final String cursor, final ScanParams params) {
    sscan(SafeEncoder.encode(key), SafeEncoder.encode(cursor), params);
  }

  @Override
  public void zscan(final String key, final String cursor, final ScanParams params) {
    zscan(SafeEncoder.encode(key), SafeEncoder.encode(cursor), params);
  }

  public void cluster(final String subcommand, final int... args) {
    final byte[][] arg = new byte[args.length + 1][];
    for (int i = 1; i < arg.length; i++) {
      arg[i] = toByteArray(args[i - 1]);
    }
    arg[0] = SafeEncoder.encode(subcommand);
    cluster(arg);
  }

  public void pubsub(final String subcommand, final String... args) {
    final byte[][] arg = new byte[args.length + 1][];
    for (int i = 1; i < arg.length; i++) {
      arg[i] = SafeEncoder.encode(args[i - 1]);
    }
    arg[0] = SafeEncoder.encode(subcommand);
    pubsub(arg);
  }

  public void cluster(final String subcommand, final String... args) {
    final byte[][] arg = new byte[args.length + 1][];
    for (int i = 1; i < arg.length; i++) {
      arg[i] = SafeEncoder.encode(args[i - 1]);
    }
    arg[0] = SafeEncoder.encode(subcommand);
    cluster(arg);
  }

  public void cluster(final String subcommand) {
    final byte[][] arg = new byte[1][];
    arg[0] = SafeEncoder.encode(subcommand);
    cluster(arg);
  }

  public void clusterNodes() {
    cluster(Protocol.CLUSTER_NODES);
  }

  public void clusterMeet(final String ip, final int port) {
    cluster(Protocol.CLUSTER_MEET, ip, String.valueOf(port));
  }

  public void clusterReset(final ClusterReset resetType) {
    cluster(Protocol.CLUSTER_RESET, resetType.name());
  }

  public void clusterAddSlots(final int... slots) {
    cluster(Protocol.CLUSTER_ADDSLOTS, slots);
  }

  public void clusterDelSlots(final int... slots) {
    cluster(Protocol.CLUSTER_DELSLOTS, slots);
  }

  public void clusterInfo() {
    cluster(Protocol.CLUSTER_INFO);
  }

  public void clusterGetKeysInSlot(final int slot, final int count) {
    final int[] args = new int[] { slot, count };
    cluster(Protocol.CLUSTER_GETKEYSINSLOT, args);
  }

  public void clusterSetSlotNode(final int slot, final String nodeId) {
    cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_NODE, nodeId);
  }

  public void clusterSetSlotMigrating(final int slot, final String nodeId) {
    cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_MIGRATING,
      nodeId);
  }

  public void clusterSetSlotImporting(final int slot, final String nodeId) {
    cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_IMPORTING,
      nodeId);
  }

  public void pfadd(final String key, final String... elements) {
    pfadd(SafeEncoder.encode(key), SafeEncoder.encodeMany(elements));
  }

  public void pfcount(final String key) {
    pfcount(SafeEncoder.encode(key));
  }

  public void pfcount(final String... keys) {
    pfcount(SafeEncoder.encodeMany(keys));
  }

  public void pfmerge(final String destkey, final String... sourcekeys) {
    pfmerge(SafeEncoder.encode(destkey), SafeEncoder.encodeMany(sourcekeys));
  }

  public void clusterSetSlotStable(final int slot) {
    cluster(Protocol.CLUSTER_SETSLOT, String.valueOf(slot), Protocol.CLUSTER_SETSLOT_STABLE);
  }

  public void clusterForget(final String nodeId) {
    cluster(Protocol.CLUSTER_FORGET, nodeId);
  }

  public void clusterFlushSlots() {
    cluster(Protocol.CLUSTER_FLUSHSLOT);
  }

  public void clusterKeySlot(final String key) {
    cluster(Protocol.CLUSTER_KEYSLOT, key);
  }

  public void clusterCountKeysInSlot(final int slot) {
    cluster(Protocol.CLUSTER_COUNTKEYINSLOT, String.valueOf(slot));
  }

  public void clusterSaveConfig() {
    cluster(Protocol.CLUSTER_SAVECONFIG);
  }

  public void clusterReplicate(final String nodeId) {
    cluster(Protocol.CLUSTER_REPLICATE, nodeId);
  }

  public void clusterSlaves(final String nodeId) {
    cluster(Protocol.CLUSTER_SLAVES, nodeId);
  }

  public void clusterFailover() {
    cluster(Protocol.CLUSTER_FAILOVER);
  }

  public void clusterSlots() {
    cluster(Protocol.CLUSTER_SLOTS);
  }

  public void geoadd(final String key, final double longitude, final double latitude, final String member) {
    geoadd(SafeEncoder.encode(key), longitude, latitude, SafeEncoder.encode(member));
  }

  public void geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
    geoadd(SafeEncoder.encode(key), convertMemberCoordinateMapToBinary(memberCoordinateMap));
  }

  public void geodist(final String key, final String member1, final String member2) {
    geodist(SafeEncoder.encode(key), SafeEncoder.encode(member1), SafeEncoder.encode(member2));
  }

  public void geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
    geodist(SafeEncoder.encode(key), SafeEncoder.encode(member1), SafeEncoder.encode(member2), unit);
  }

  public void geohash(final String key, final String... members) {
    geohash(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
  }

  public void geopos(final String key, final String[] members) {
    geopos(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
  }

  public void georadius(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit) {
    georadius(SafeEncoder.encode(key), longitude, latitude, radius, unit);
  }

  public void georadiusReadonly(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit) {
    georadiusReadonly(SafeEncoder.encode(key), longitude, latitude, radius, unit);
  }

  public void georadius(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    georadius(SafeEncoder.encode(key), longitude, latitude, radius, unit, param);
  }

  public void georadiusReadonly(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    georadiusReadonly(SafeEncoder.encode(key), longitude, latitude, radius, unit, param);
  }

  public void georadiusByMember(final String key, final String member, final double radius, final GeoUnit unit) {
    georadiusByMember(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit);
  }

  public void georadiusByMemberReadonly(final String key, final String member, final double radius, final GeoUnit unit) {
    georadiusByMemberReadonly(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit);
  }

  public void georadiusByMember(final String key, final String member, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    georadiusByMember(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit, param);
  }

  public void georadiusByMemberReadonly(final String key, final String member, final double radius, final GeoUnit unit,
      final GeoRadiusParam param) {
    georadiusByMemberReadonly(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit, param);
  }

  public void moduleLoad(final String path) {
    moduleLoad(SafeEncoder.encode(path));
  }

  public void moduleUnload(final String name) {
    moduleUnload(SafeEncoder.encode(name));
  }

  private HashMap<byte[], Double> convertScoreMembersToBinary(final Map<String, Double> scoreMembers) {
    HashMap<byte[], Double> binaryScoreMembers = new HashMap<byte[], Double>();
    for (Entry<String, Double> entry : scoreMembers.entrySet()) {
      binaryScoreMembers.put(SafeEncoder.encode(entry.getKey()), entry.getValue());
    }
    return binaryScoreMembers;
  }

  private HashMap<byte[], GeoCoordinate> convertMemberCoordinateMapToBinary(
      final Map<String, GeoCoordinate> memberCoordinateMap) {
    HashMap<byte[], GeoCoordinate> binaryMemberCoordinateMap = new HashMap<byte[], GeoCoordinate>();
    for (Entry<String, GeoCoordinate> entry : memberCoordinateMap.entrySet()) {
      binaryMemberCoordinateMap.put(SafeEncoder.encode(entry.getKey()), entry.getValue());
    }
    return binaryMemberCoordinateMap;
  }

  @Override
  public void bitfield(final String key, final String... arguments) {
    bitfield(SafeEncoder.encode(key), SafeEncoder.encodeMany(arguments));
  }

  @Override
  public void hstrlen(final String key, final String field) {
    hstrlen(SafeEncoder.encode(key), SafeEncoder.encode(field));
  }

  @Override
  public void xadd(final String key, final  StreamEntryID id, final Map<String, String> hash, long maxLen, boolean approximateLength) {
    final Map<byte[], byte[]> bhash = new HashMap<>(hash.size());
    for (final Entry<String, String> entry : hash.entrySet()) {
      bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder.encode(entry.getValue()));
    }
    xadd(SafeEncoder.encode(key), SafeEncoder.encode(id==null ? "*" : id.toString()), bhash, maxLen, approximateLength);
  }

  @Override
  public void xlen(final String key) {
	  xlen(SafeEncoder.encode(key));
  }

  @Override
  public void xrange(final String key, final StreamEntryID start, final  StreamEntryID end, final long count) {
	  xrange(SafeEncoder.encode(key), SafeEncoder.encode(start==null ? "-" : start.toString()), SafeEncoder.encode(end==null ? "+" : end.toString()), count);
  }

  @Override
  public void xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
    xrevrange(SafeEncoder.encode(key), SafeEncoder.encode(end==null ? "+" : end.toString()), SafeEncoder.encode(start==null ? "-" : start.toString()), count);
  }

  @Override
  public void xread(final int count, final long block, final Entry<String, StreamEntryID>... streams) {
    final Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(streams.length);
    for (final Entry<String, StreamEntryID> entry : streams) {
      bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder.encode(entry.getValue()==null ? "0-0" : entry.getValue().toString()));
    }
    xread(count, block, bhash);
  }

  @Override
  public void xack(final String key, final String group, final StreamEntryID... ids) {
    final byte[][] bids = new byte[ids.length][];
    for (int i=0 ; i< ids.length; ++i ) {
      StreamEntryID id = ids[i];
      bids[i] = SafeEncoder.encode(id==null ? "0-0" : id.toString());
    }
    xack(SafeEncoder.encode(key), SafeEncoder.encode(group), bids);
  }

  @Override
  public void xgroupCreate(String key, String groupname, StreamEntryID id, boolean makeStream) {
    xgroupCreate(SafeEncoder.encode(key), SafeEncoder.encode(groupname), SafeEncoder.encode(id==null ? "0-0" : id.toString()), makeStream);
  }

  @Override
  public void xgroupSetID(String key, String groupname, StreamEntryID id) {
    xgroupSetID(SafeEncoder.encode(key), SafeEncoder.encode(groupname), SafeEncoder.encode(id==null ? "0-0" : id.toString()));
  }

  @Override
  public void xgroupDestroy(String key, String groupname) {
    xgroupDestroy(SafeEncoder.encode(key), SafeEncoder.encode(groupname));
  }

  @Override
  public void xgroupDelConsumer(String key, String groupname, String consumerName) {
    xgroupDelConsumer(SafeEncoder.encode(key), SafeEncoder.encode(groupname), SafeEncoder.encode(consumerName));
  }

  @Override
  public void xdel(final String key, final StreamEntryID... ids) {
    final byte[][] bids = new byte[ids.length][];
    for (int i=0 ; i< ids.length; ++i ) {
      StreamEntryID id = ids[i];
      bids[i] = SafeEncoder.encode(id==null ? "0-0" : id.toString());
    }
    xdel(SafeEncoder.encode(key), bids);
  }

  @Override
  public void xtrim(String key, long maxLen, boolean approximateLength) {
    xtrim(SafeEncoder.encode(key), maxLen, approximateLength);
  }

  @Override
  public void xreadGroup(String groupname, String consumer, int count, long block, boolean noAck, Entry<String, StreamEntryID>... streams) {
    final Map<byte[], byte[]> bhash = new HashMap<>(streams.length);
    for (final Entry<String, StreamEntryID> entry : streams) {
      bhash.put(SafeEncoder.encode(entry.getKey()), SafeEncoder.encode(entry.getValue()==null ? ">" : entry.getValue().toString()));
    }
    xreadGroup(SafeEncoder.encode(groupname), SafeEncoder.encode(consumer), count, block, noAck, bhash);
  }

  @Override
  public void xpending(String key, String groupname, StreamEntryID start, StreamEntryID end, int count, String consumername) {
    xpending(SafeEncoder.encode(key), SafeEncoder.encode(groupname), SafeEncoder.encode(start==null ? "-" : start.toString()),
        SafeEncoder.encode(end==null ? "+" : end.toString()), count, consumername == null? null : SafeEncoder.encode(consumername));
  }

  @Override
  public void xclaim(String key, String group, String consumername, long minIdleTime, long newIdleTime, int retries,
      boolean force, StreamEntryID... ids) {

    final byte[][] bids = new byte[ids.length][];
    for (int i = 0; i < ids.length; i++) {
      bids[i] = SafeEncoder.encode(ids[i].toString());
    }
    xclaim(SafeEncoder.encode(key), SafeEncoder.encode(group), SafeEncoder.encode(consumername), minIdleTime, newIdleTime, retries, force, bids);
  }

}