text:
package org.yeastrc.ms.dao.protinfer.proteinProphet;

import java.util.List;

import org.yeastrc.ms.dao.ibatis.BaseSqlMapDAO;
import org.yeastrc.ms.dao.protinfer.GenericProteinferRunDAO;
import org.yeastrc.ms.dao.protinfer.ibatis.ProteinferRunDAO;
import org.yeastrc.ms.domain.protinfer.GenericProteinferRun;
import org.yeastrc.ms.domain.protinfer.ProteinferInput;
import org.yeastrc.ms.domain.protinfer.proteinProphet.ProteinProphetRun;
import org.yeastrc.ms.domain.search.Program;

import com.ibatis.sqlmap.client.SqlMapClient;

public class ProteinProphetRunDAO extends BaseSqlMapDAO implements GenericProteinferRunDAO<ProteinferInput, ProteinProphetRun> {

    private static final String sqlMapNameSpace = "ProteinProphetRun";

    private final ProteinferRunDAO runDao;

    public ProteinProphetRunDAO(SqlMapClient sqlMap, ProteinferRunDAO runDao) {
        super(sqlMap);
        this.runDao = runDao;
    }

    @Override
    public ProteinProphetRun loadProteinferRun(int proteinferId) {
        return (ProteinProphetRun) queryForObject(sqlMapNameSpace+".select", proteinferId);
    }

    @Override
    public void delete(int pinferId) {
        runDao.delete(pinferId);
    }

    @Override
    public List<Integer> loadProteinferIdsForInputIds(List<Integer> inputIds) {
        return runDao.loadProteinferIdsForInputIds(inputIds);
    }

    @Override
    public List<Integer> loadProteinferIdsForInputIds(List<Integer> inputIds, Program inputGenerator) {
        return runDao.loadProteinferIdsForInputIds(inputIds, inputGenerator);
    }

    @Override
    public List<Integer> loadSearchIdsForProteinferRun(int pinferId) {
        return runDao.loadSearchIdsForProteinferRun(pinferId);
    }

    @Override
    public int save(GenericProteinferRun<?> run) {
        return runDao.save(run);
    }

    public int saveProteinProphetRun(ProteinProphetRun run) {
        int runId = runDao.save(run);
        run.setId(runId);
        super.save(sqlMapNameSpace+".insert", run);
        return runId;
    }

    @Override
    public void update(GenericProteinferRun<?> run) {
        runDao.update(run);
    }

    @Override
    public int getMaxProteinHitCount(int proteinferId) {
        return runDao.getMaxProteinHitCount(proteinferId);
    }

    @Override
	public List<Integer> loadProteinferIdsForExperiment(int experimentId) {
		return runDao.loadProteinferIdsForExperiment(experimentId);
	}
}

redpajama_set_name: RedPajamaGithub


text:
<?php
// Heading
$_['heading_title']			 = 'BluePay Redirect (Requires SSL)';

// Text
$_['text_extension']		 = 'Extensions';
$_['text_success']			 = 'Success: You have modified BluePay Redirect account details!';
$_['text_edit']              = 'Edit BluePay Redirect (Requires SSL)';
$_['text_bluepay_redirect']	 = '';
$_['text_sim']				 = 'Simulator';
$_['text_test']				 = 'Test';
$_['text_live']				 = 'Live';
$_['text_sale']				 = 'Sale';
$_['text_authenticate']		 = 'Authorize';
$_['text_release_ok']		 = 'Release was successful';
$_['text_release_ok_order']	 = 'Release was successful';
$_['text_rebate_ok']		 = 'Rebate was successful';
$_['text_rebate_ok_order']	 = 'Rebate was successful, order status updated to rebated';
$_['text_void_ok']			 = 'Void was successful, order status updated to voided';
$_['text_payment_info']		 = 'Payment information';
$_['text_release_status']	 = 'Payment released';
$_['text_void_status']		 = 'Payment voided';
$_['text_rebate_status']	 = 'Payment rebated';
$_['text_order_ref']		 = 'Order ref';
$_['text_order_total']		 = 'Total authorised';
$_['text_total_released']	 = 'Total released';
$_['text_transactions']		 = 'Transactions';
$_['text_column_amount']	 = 'Amount';
$_['text_column_type']		 = 'Type';
$_['text_column_date_added'] = 'Created';
$_['text_confirm_void']		 = 'Are you sure you want to void the payment?';
$_['text_confirm_release']	 = 'Are you sure you want to release the payment?';
$_['text_confirm_rebate']	 = 'Are you sure you want to rebate the payment?';

// Entry
$_['entry_vendor']			 = 'Account ID';
$_['entry_secret_key']		 = 'Secret Key';
$_['entry_test']			 = 'Transaction Mode';
$_['entry_transaction']		 = 'Transaction Method';
$_['entry_total']			 = 'Total';
$_['entry_order_status']	 = 'Order Status';
$_['entry_geo_zone']		 = 'Geo Zone';
$_['entry_status']			 = 'Status';
$_['entry_sort_order']		 = 'Sort Order';
$_['entry_debug']			 = 'Debug logging';
$_['entry_card']			 = 'Store Cards';

// Help
$_['help_total']			 = 'The checkout total the order must reach before this payment method becomes active.';
$_['help_debug']			 = 'Enabling debug will write sensitive data to a log file. You should always disable unless instructed otherwise';
$_['help_transaction']		 = 'Sale will charge customer immediately. Authorization will put funds on hold for future capture.';
$_['help_cron_job_token']	 = 'Make this long and hard to guess';
$_['help_cron_job_url']		 = 'Set a cron job to call this URL';

// Button
$_['button_release']		 = 'Release';
$_['button_rebate']			 = 'Rebate / refund';
$_['button_void']			 = 'Void';

// Error
$_['error_permission']		 = 'Warning: You do not have permission to modify payment BluePay!';
$_['error_account_id']		 = 'Account ID Required!';
$_['error_secret_key']		 = 'Secret Key Required!';


text:
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.notifications.permissions;

import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

import org.chromium.chrome.browser.notifications.NotificationUmaTracker;

/**
 * A {@link android.content.BroadcastReceiver} that detects when our App level notifications are
 * blocked or unblocked via the settings menu. When this happens we record a metric.
 */
public class NotificationPermissionChangeReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        if (action == null) return;

        if (action.equals(NotificationManager.ACTION_APP_BLOCK_STATE_CHANGED)
                && intent.hasExtra(NotificationManager.EXTRA_BLOCKED_STATE)) {
            boolean blockedState =
                    intent.getBooleanExtra(NotificationManager.EXTRA_BLOCKED_STATE, false);
            NotificationUmaTracker.getInstance().onNotificationPermissionSettingChange(
                    blockedState);
        }
    }
}


text:
module WordpressClient
  # @private
  class PostParser
    include RestParser

    def self.parse(data)
      new(data).to_post
    end

    def initialize(data)
      @data = data
      @embedded = data.fetch("_embedded", {})
    end

    def to_post
      post = Post.new
      assign_basic(post)
      assign_dates(post)
      assign_rendered(post)
      assign_categories(post)
      assign_tags(post)
      assign_featured_media(post)
      post
    end

    private
    attr_reader :data, :embedded

    def assign_basic(post)
      post.id = data["id"]
      post.slug = data["slug"]
      post.url = data["link"]
      post.status = data["status"]
      post.meta = data["meta"]
      post.category_ids = data["categories"]
      post.tag_ids = data["tags"]
      post.featured_media_id = data["featured_media"]
    end

    def assign_dates(post)
      post.updated_at = read_date("modified")
      post.date = read_date("date")
    end

    def assign_rendered(post)
      post.guid = rendered("guid")
      post.title_html = rendered("title")
      post.excerpt_html = rendered("excerpt")
      post.content_html = rendered("content")
    end

    def assign_categories(post)
      post.categories = embedded_terms("category").map do |category|
        Category.parse(category)
      end
    end

    def assign_tags(post)
      post.tags = embedded_terms("post_tag").map do |tag|
        Tag.parse(tag)
      end
    end

    def assign_featured_media(post)
      featured_id = data["featured_media"]
      if featured_id
        features = (embedded["wp:featuredmedia"] || []).flatten
        media = features.detect { |feature| feature["id"] == featured_id }
        if media
          post.featured_media = Media.parse(media)
        end
      end
    end

    def embedded_terms(type)
      term_collections = embedded["wp:term"] || embedded["https://api.w.org/term"] || []

      # term_collections is an array of arrays with terms in them. We can see
      # the type of the "collection" by inspecting the first child's taxonomy.
      term_collections.detect { |terms|
        terms.size > 0 && terms.is_a?(Array) && terms.first["taxonomy"] == type
      } || []
    end

  end
end


text:
package by.salin.apps.jems.sample;

import android.content.Intent;
import android.support.v4.app.Fragment;
import android.support.v7.app.ActionBar;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.FrameLayout;
import by.salin.apps.jems.JEMS;
import by.salin.apps.jems.impl.Event;
import by.salin.apps.jems.sample.base.BaseActivity;
import by.salin.apps.jems.sample.events.ChangeColorEvent;
import by.salin.apps.jems.sample.events.DefaultEvent;
import by.salin.apps.jems.sample.events.FinishEvent;
import by.salin.apps.jems.sample.tasks.ChangeColorRunnable;
import by.salin.apps.jems.sample.utils.ColorGenUtils;
import org.androidannotations.annotations.*;

/**
 * @author Alexandr.Salin (salin.alexandr@gmail.com)
 */
@OptionsMenu(R.menu.sample)
@EActivity(R.layout.ac_sample)
public class SampleActivity extends BaseActivity
{
	private static final String LEFT_FRAGMENT = "Left fragment";
	private static final String RIGHT_FRAGMENT = "Right fragment";
	@ViewById(R.id.container)
	protected FrameLayout container;

	@ViewById(R.id.start)
	protected Button button;

	@InstanceState
	protected boolean isStarted = false;

	@AfterViews
	void init()
	{
		Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.left);
		if (fragment == null)
		{
			getSupportFragmentManager().beginTransaction()
					.add(R.id.left, new SampleFragment().newInstance(LEFT_FRAGMENT))
					.add(R.id.right, new SampleFragment().newInstance(RIGHT_FRAGMENT))
					.commit();
		}
		updateButtonState();
	}

	@Override
	public void onEvent(Event event)
	{
		if (event instanceof ChangeColorEvent)
		{
			container.setBackgroundColor(ColorGenUtils.generateColor());
		}else if (event instanceof FinishEvent){
			isStarted=false;
			updateButtonState();
		}
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch (item.getItemId())
		{
			case R.id.action_settings:
				Intent intent = new Intent(this, PopupActivity_.class);
				this.startActivity(intent);
				return true;
			case R.id.action_finish:
				JEMS.dispatcher().sendEvent(new FinishEvent());
				return true;
			case R.id.action_default:
				JEMS.dispatcher().sendEvent(new DefaultEvent());
				return true;
			default:
				return super.onOptionsItemSelected(item);
		}
	}

	@Click(R.id.start)
	protected void  startClick(){
		new Thread(new ChangeColorRunnable()).start();
		isStarted = true;
		updateButtonState();
	}

	private void updateButtonState()
	{
		button.setEnabled(!isStarted);
	}

	@Override
	public void onBackPressed()
	{
		JEMS.dispatcher().sendEvent(new FinishEvent());
		super.onBackPressed();
	}
}


text:
from __future__ import unicode_literals

import json

from django import forms
from django.template.loader import render_to_string
from django.utils.encoding import smart_text
from django.utils.translation import pgettext_lazy
from django_prices.templatetags.prices_i18n import gross

from ..cart.forms import AddToCartForm

class VariantChoiceField(forms.ModelChoiceField):
    discounts = None

    def label_from_instance(self, obj):
        variant_label = smart_text(obj)
        label = pgettext_lazy(
            'Variant choice field label',
            '%(variant_label)s - %(price)s') % {
                'variant_label': variant_label,
                'price': gross(obj.get_price(discounts=self.discounts))}
        return label

class ProductForm(AddToCartForm):
    variant = VariantChoiceField(queryset=None)

    def __init__(self, *args, **kwargs):
        super(ProductForm, self).__init__(*args, **kwargs)
        variant_field = self.fields['variant']
        variant_field.queryset = self.product.variants
        variant_field.discounts = self.cart.discounts
        variant_field.empty_label = None
        images_map = {variant.pk: [vi.image.image.url
                                   for vi in variant.variant_images.all()]
                      for variant in self.product.variants.all()}
        variant_field.widget.attrs['data-images'] = json.dumps(images_map)

    def get_variant(self, cleaned_data):
        return cleaned_data.get('variant')

class ProductVariantInline(forms.models.BaseInlineFormSet):
    error_no_items = pgettext_lazy(
        'Product admin error', 'You have to create at least one variant')

    def clean(self):
        count = 0
        for form in self.forms:
            if form.cleaned_data:
                count += 1
        if count < 1:
            raise forms.ValidationError(self.error_no_items)

class ImageInline(ProductVariantInline):
    error_no_items = pgettext_lazy(
        'Product admin error', 'You have to add at least one image')

def get_form_class_for_product(product):
    from ..product.models import Product
    if isinstance(product, Product):
        return ProductForm
    raise NotImplementedError


text:
import React from 'react'
import { createStore } from 'redux'
import { Provider } from 'react-redux'
import { mount } from 'enzyme'

import { ADD_REDUCER, REMOVE_REDUCER, transientEnhancer } from '../src/transient-enhancer'
import { withReducer } from '../src/withReducer'

describe('withReducer', () => {
  const reducers = {
    original: jest.fn(v => v),
    transient: jest.fn(v => v),
    counter: jest.fn(v => ++v),
  }

  const getStore = () => createStore(reducers.original, 0, transientEnhancer)

  const DumbComponent = () => (
Content
)
  const ConnectedComponent = withReducer(reducers.transient)(DumbComponent)

  const build = children => {
    const store = getStore()

    return {
      store,
      App: mount(<Provider store={ store }>{ children }</Provider>),
    }
  }

  beforeEach(jest.clearAllMocks)

  it('should add transient reducers', () => {
    build(<ConnectedComponent />)
    expect(reducers.original).toHaveBeenCalledTimes(2)
    expect(reducers.original).toHaveProperty('mock.calls.1.1.type', ADD_REDUCER)
  })

  it('should execute transient reducers on actions', () => {
    const { store } = build(<ConnectedComponent />)
    expect(reducers.transient).toHaveBeenCalledTimes(0)
    store.dispatch({ type: 'any-action' })
    expect(reducers.transient).toHaveBeenCalledTimes(1)
  })

  it('should remove transient reducers on unmount', () => {
    const { store, App } = build(<ConnectedComponent />)
    store.dispatch({ type: 'any-action' })
    expect(reducers.transient).toHaveBeenCalledTimes(1)

    App.unmount()
    expect(reducers.original).toHaveProperty('mock.calls.3.1.type', REMOVE_REDUCER)

    store.dispatch({ type: 'any-action' })
    expect(reducers.transient).toHaveBeenCalledTimes(1)
  })

  it('should execute transient reducers with state, actions, and passed props', () => {
    const { store, App } = build(<ConnectedComponent foo='bar' />)
    const state = store.getState()
    const action = { type: 'any-action' }

    const WithReducer = App.find(ConnectedComponent).find('WithReducer')

    store.dispatch(action)
    expect(reducers.transient).toHaveBeenCalledWith(state, action, WithReducer.props())
  })

  it('should add multiple transient reducers', () => {
    const { store } = build((

        <ConnectedComponent foo={ 'a' } />
        <ConnectedComponent foo={ 'b' } />
        <ConnectedComponent foo={ 'c' } />

    ))

    expect(reducers.original).toHaveBeenCalledTimes(4)
    expect(reducers.transient).toHaveBeenCalledTimes(3)

    // When 'b' was added, called 'a'.
    expect(reducers.transient).toHaveProperty('mock.calls.0.2.foo', 'a')

    // When 'c' was added, called 'a' and 'b'.
    expect(reducers.transient).toHaveProperty('mock.calls.1.2.foo', 'a')
    expect(reducers.transient).toHaveProperty('mock.calls.2.2.foo', 'b')

    // When another action is fired, call all 3.
    store.dispatch({ type: 'any-action' })
    expect(reducers.transient).toHaveBeenCalledTimes(6)
    expect(reducers.transient).toHaveProperty('mock.calls.3.2.foo', 'a')
    expect(reducers.transient).toHaveProperty('mock.calls.4.2.foo', 'b')
    expect(reducers.transient).toHaveProperty('mock.calls.5.2.foo', 'c')
  })
})


text:
<?php

namespace App\UserdirectoryBundle\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\UserdirectoryBundle\Repository\ResearchLabRepository")
 * @ORM\Table(name="user_researchLab")
 */
class ResearchLab extends ListAbstract  //extends BaseUserAttributes
{

    /**
     * @ORM\OneToMany(targetEntity="BuildingList", mappedBy="original", cascade={"persist"})
     **/
    protected $synonyms;

    /**
     * @ORM\ManyToOne(targetEntity="BuildingList", inversedBy="synonyms", cascade={"persist"})
     * @ORM\JoinColumn(name="original_id", referencedColumnName="id", nullable=true)
     **/
    protected $original;

    /**
     * @ORM\OneToOne(targetEntity="App\UserdirectoryBundle\Entity\Institution")
     * @ORM\JoinColumn(name="institution_id", referencedColumnName="id")
     */
    private $institution;

    /**
     * @ORM\ManyToMany(targetEntity="User", mappedBy="researchLabs")
     **/
    private $user;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    private $foundedDate;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    private $dissolvedDate;

    /**
     * @ORM\ManyToOne(targetEntity="Location")
     * @ORM\JoinColumn(name="location", referencedColumnName="id", nullable=true)
     **/
    private $location;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $weblink;

    /**
     * @ORM\OneToMany(targetEntity="ResearchLabComment", mappedBy="researchLab", cascade={"persist","remove"})
     **/
    private $comments;
    private $commentDummy;

    /**
     * @ORM\OneToMany(targetEntity="ResearchLabPI", mappedBy="researchLab", cascade={"persist","remove"})
     **/
    private $pis;
    private $piDummy;

    public function __construct($creator=null) {

        $this->comments = new ArrayCollection();
        $this->pis = new ArrayCollection();

        $this->user = new ArrayCollection();
        $this->synonyms = new ArrayCollection();

        //set mandatory list attributes
        $this->setName("");
        $this->setType('user-added');
        $this->setCreatedate(new \DateTime());
        $this->setOrderinlist(-1);

        if( $creator ) {
            $this->setCreator($creator);
        }

//        //add comment
//        $comment = new ResearchLabComment();
//        $this->addComment($comment);
//
//        //add pi
//        $pi = new ResearchLabPI();
//        $this->addPi($pi);
    }

    /**
     * @return mixed
     */
    public function getInstitution()
    {
        return $this->institution;
    }

    /**
     * @param mixed $institution
     */
    public function setInstitution($institution)
    {
        $this->institution = $institution;
        if( $institution ) {
            $this->setName($institution->getName() . "");
        }
    }

    public function getComments()
    {
        return $this->comments;
    }
    public function addComment($comment)
    {
        if( !$this->comments->contains($comment) ) {
            $this->comments->add($comment);
            $comment->setResearchLab($this);
        }
        return $this;
    }
    public function removeComment($comment)
    {
        $this->comments->removeElement($comment);
    }

    public function getPis()
    {
        return $this->pis;
    }
    public function addPi($pi)
    {
        if( !$this->pis->contains($pi) ) {
            $this->pis->add($pi);
            $pi->setResearchLab($this);
        }
        return $this;
    }
    public function removePi($pi)
    {
        $this->pis->removeElement($pi);
    }

    /**
     * @param mixed $dissolvedDate
     */
    public function setDissolvedDate($dissolvedDate)
    {
        $this->dissolvedDate = $dissolvedDate;
    }

    /**
     * @return mixed
     */
    public function getDissolvedDate()
    {
        return $this->dissolvedDate;
    }

    /**
     * @param mixed $foundedDate
     */
    public function setFoundedDate($foundedDate)
    {
        $this->foundedDate = $foundedDate;
    }

    /**
     * @return mixed
     */
    public function getFoundedDate()
    {
        return $this->foundedDate;
    }

    /**
     * @param mixed $location
     */
    public function setLocation($location)
    {
        $this->location = $location;
    }

    /**
     * @return mixed
     */
    public function getLocation()
    {
        return $this->location;
    }

    public function addUser($user)
    {
        if( !$this->user->contains($user) ) {
            $this->user->add($user);
            //$user->addResearchLab($this);
        }

        return $this;
    }
    public function removeUser($user)
    {
        $this->user->removeElement($user);
    }
    public function getUser()
    {
        return $this->user;
    }

    /**
     * @param mixed $weblink
     */
    public function setWeblink($weblink)
    {
        $this->weblink = $weblink;
    }

    /**
     * @return mixed
     */
    public function getWeblink()
    {
        return $this->weblink;
    }

    /**
     * @param mixed $commentDummy
     */
    public function setCommentDummy($commentDummy)
    {
        $this->commentDummy = $commentDummy;
    }

    /**
     * @return mixed
     */
    public function getCommentDummy()
    {
        return $this->commentDummy;
    }

    /**
     * @param mixed $piDummy
     */
    public function setPiDummy($piDummy)
    {
        $this->piDummy = $piDummy;
    }

    /**
     * @return mixed
     */
    public function getPiDummy()
    {
        return $this->piDummy;
    }

    public function setComment($text,$user)
    {
        if( $text && $text != "" ) {
            $comment = new ResearchLabComment();
            $comment->setComment($text);
            $comment->setAuthor($user);
            $this->addComment($comment);
        }
    }
    public function setPiUser($user)
    {
        if( $user ) {
            $pi = new ResearchLabPI();
            $pi->setPi($user);
            $this->addPi($pi);
        }
    }

    //TODO: not used???
    public function removeDependents($user) {
        exit('ResearchLab: removeDependents');
        //remove user's comments
        foreach( $this->getComments() as $comment ) {
            if( $comment->getAuthor()->getId() == $user->getId() ) {
                $this->removeComment($comment);
            }
        }
        //remove user's pi
        foreach( $this->getPis() as $pi ) {
            if( $pi->getPi()->getId() == $user->getId() ) {
                $this->removePi($pi);
            }
        }
    }

    //interface function
    public function getAuthor()
    {
        return $this->getCreator();
    }
    public function setAuthor($author)
    {
        return $this->setCreator($author);
    }
    public function getUpdateAuthor()
    {
        return $this->getUpdatedby();
    }
    public function setUpdateAuthor($author)
    {
        return $this->setUpdatedby($author);
    }

//    public function __toString() {
//        //return "Research Lab"." name=".$this->getName().", id=".$this->getId();
//        return $this->getName();
//    }

}


text:
namespace Services.Packages.Debug
{
    using System;
    using System.Collections.Generic;
    using System.Threading;
    using Chains.Play.Web;
    using Services.Communication.Protocol;
    using Services.Management.Administration.Worker;
    using Services.Packages.Admin;
    using Services.Packages.Update;

    public sealed class CreateRandomAdminPackageAndUpdatePackage
    {
        private readonly string localHostname;

        private readonly int localPort;

        private readonly string remoteHostname;

        private readonly int remotePort;

        private readonly WorkUnitContext workUnitContext;

        private readonly Random random = new Random();

        public CreateRandomAdminPackageAndUpdatePackage(
            string localHostname,
            int localPort,
            string remoteHostname,
            int remotePort,
            WorkUnitContext workUnitContext)
        {
            this.localHostname = localHostname;
            this.localPort = localPort;
            this.remoteHostname = remoteHostname;
            this.remotePort = remotePort;
            this.workUnitContext = workUnitContext;
            ThreadPool.QueueUserWorkItem(DoWork);
        }

        private void DoWork(object state)
        {
            while (true)
            {
                workUnitContext.LogLine("Getting package from {0}:{1}", remoteHostname, remotePort);

                CheckPackagesForUpdateReturnData checkPackagesForUpdateReturnData = null;

                using (var connectionToOtherServer = new Client(remoteHostname, remotePort).Do(new OpenConnection()))
                {
                    workUnitContext.LogLine("Checking for packages to be updated (fixed to download the last versions)");

                    checkPackagesForUpdateReturnData =
                        connectionToOtherServer.Do(
                            new Send<CheckPackagesForUpdateReturnData>(
                                new CheckPackagesForUpdate(
                                    new CheckPackagesForUpdateData
                                    {
                                        Packages = new List<PackageDescription>
                                                   {
                                                       new PackageDescription
                                                       {
                                                           Id = 0,
                                                           PackageName =
                                                               WatchForAdminUpdate.ServicesExecutionerPackageName,
                                                       },

                                                       new PackageDescription
                                                       {
                                                           Id = 0,
                                                           PackageName = "Services.Update",
                                                       },
                                                   }
                                    })));

                    workUnitContext.LogLine(
                        "Done! {0} packages found!",
                        checkPackagesForUpdateReturnData.Packages.Count);

                    using (
                        var connectionToLocalServer =
                            new Client(localHostname, localPort).Do(new WaitUntilClientConnects()))
                    {
                        foreach (var package in checkPackagesForUpdateReturnData.Packages)
                        {
                            var randomMillisecondsBetweenPackages = random.Next(60000);

                            workUnitContext.LogLine("Waiting random {0}ms between packages...", randomMillisecondsBetweenPackages);
                            workUnitContext.ReportToAdmin();

                            Thread.Sleep(randomMillisecondsBetweenPackages);

                            workUnitContext.LogLine(
                                "Downloading {0} v {1} package...",
                                package.PackageName,
                                package.VersionLabel);

                            var downloadPackageReturnData =
                                connectionToOtherServer.Do(
                                    new Send<DownloadPackageReturnData>(
                                        new DownloadPackage(
                                            new DownloadPackageData
                                            {
                                                PackageRequested = package,
                                            })));

                            workUnitContext.LogLine(
                                "Uploading {0} v {1} package...",
                                package.PackageName,
                                package.VersionLabel);

                            var packageUploadData = new UploadPackageData
                                                    {
                                                        PackageToUpload = package,
                                                        ZipData = downloadPackageReturnData.ZipFile,
                                                    };

                            connectionToLocalServer.Do(new Send(new UploadPackage(packageUploadData)));
                        }
                    }
                }

                workUnitContext.LogLine("Upload done!");

                var randomMilliseconds = random.Next(120000) + 120000;

                workUnitContext.LogLine("Waiting {0}ms", randomMilliseconds);
                workUnitContext.ReportToAdmin();

                Thread.Sleep(randomMilliseconds);
            }
        }
    }
}


text:
#include "stdfx.h"
#include "tfxparam.h"
#include "ttzpimagefx.h"
#include "trop.h"
#include "texturefxP.h"

//===================================================================

class TextureFx final : public TStandardRasterFx {
  FX_PLUGIN_DECLARATION(TextureFx)

  TRasterFxPort m_input;
  TRasterFxPort m_texture;
  TStringParamP m_string;
  TIntEnumParamP m_keep;
  // TIntEnumParamP m_type;
  TIntEnumParamP m_mode;
  TDoubleParamP m_value;

public:
  TextureFx()
      : m_string(L"1,2,3")
      , m_keep(new TIntEnumParam(0, "Delete"))
      //, m_type(new TIntEnumParam(0, "Lines & Areas"))
      , m_mode(new TIntEnumParam(SUBSTITUTE, "Texture"))
      , m_value(100) {
    addInputPort("Source", m_input);
    addInputPort("Texture", m_texture);
    bindParam(this, "indexes", m_string);
    bindParam(this, "keep", m_keep);
    bindParam(this, "mode", m_mode);
    // bindParam(this,"type",  m_type);
    bindParam(this, "value", m_value);
    m_value->setValueRange(0, 100);
    m_keep->addItem(1, "Keep");
    // m_type->addItem(1, "Lines");
    // m_type->addItem(2, "Areas");
    m_mode->addItem(PATTERNTYPE, "Pattern");
    m_mode->addItem(ADD, "Add");
    m_mode->addItem(SUBTRACT, "Subtract");
    m_mode->addItem(MULTIPLY, "Multiply");
    m_mode->addItem(LIGHTEN, "Lighten");
    m_mode->addItem(DARKEN, "Darken");
  }

  ~TextureFx(){};

  bool doGetBBox(double frame, TRectD &bBox,
                 const TRenderSettings &info) override {
    if (m_input.isConnected()) {
      bool ret = m_input->doGetBBox(frame, bBox, info);
      return ret;
    } else {
      bBox = TRectD();
      return false;
    }
  }

  void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;
  void doDryCompute(TRectD &rect, double frame,
                    const TRenderSettings &info) override;

  bool allowUserCacheOnPort(int port) override { return port != 0; }

  int getMemoryRequirement(const TRectD &rect, double frame,
                           const TRenderSettings &info) override;
  bool canHandle(const TRenderSettings &info, double frame) override {
    return true;
  }
};

//-------------------------------------------------------------------

void TextureFx::doDryCompute(TRectD &rect, double frame,
                             const TRenderSettings &info) {
  if (!m_input.isConnected()) return;

  std::vector<std::string> items;
  std::string indexes = ::to_string(m_string->getValue());
  parseIndexes(indexes, items);
  TRenderSettings ri2(info);
  PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;
  insertIndexes(items, PaletteFilterData);
  PaletteFilterData->m_keep = (bool)(m_keep->getValue() == 1);

  ri2.m_data.push_back(PaletteFilterData);
  ri2.m_userCachable = false;

  // First child compute: part of output that IS NOT texturized
  m_input->dryCompute(rect, frame, ri2);

  if (!m_texture.isConnected()) return;

  bool isSwatch                = ri2.m_isSwatch;
  if (isSwatch) ri2.m_isSwatch = false;
  PaletteFilterData->m_keep    = !(m_keep->getValue());

  // Second child compute: part of output that IS to be texturized
  m_input->dryCompute(rect, frame, ri2);

  // Third child compute: texture
  m_texture->dryCompute(rect, frame, info);
}

//-------------------------------------------------------------------

void TextureFx::doCompute(TTile &tile, double frame,
                          const TRenderSettings &ri) {
  if (!m_input.isConnected()) return;

  TTile invertMaskTile;

  // carico il vettore items con gli indici dei colori
  std::vector<std::string> items;
  std::string indexes = ::to_string(m_string->getValue());
  parseIndexes(indexes, items);

  // genero il tile il cui raster contiene l'immagine in input a cui sono stati
  // tolti i pixel
  // colorati con gli indici contenuti nel vettore items
  TRenderSettings ri2(ri);
  PaletteFilterFxRenderData *PaletteFilterData = new PaletteFilterFxRenderData;
  PaletteFilterData->m_keep                    = !!(m_keep->getValue());
  insertIndexes(items, PaletteFilterData);

  ri2.m_data.push_back(PaletteFilterData);
  ri2.m_userCachable = false;

  m_input->allocateAndCompute(invertMaskTile, tile.m_pos,
                              tile.getRaster()->getSize(), tile.getRaster(),
                              frame, ri2);

  if (!m_texture.isConnected()) {
    tile.getRaster()->copy(invertMaskTile.getRaster());
    return;
  }

  // genero il tile il cui raster contiene l'immagine in input a cui sono stati
  // tolti i pixel
  // colorati con indici diversi da quelli contenuti nel vettore items
  bool isSwatch                = ri2.m_isSwatch;
  if (isSwatch) ri2.m_isSwatch = false;
  PaletteFilterData->m_keep    = !(m_keep->getValue());
  m_input->compute(tile, frame, ri2);
  if (isSwatch) ri2.m_isSwatch = true;

  // controllo se ho ottenuto quaclosa su cui si possa lavorare.
  TRect box;
  TRop::computeBBox(tile.getRaster(), box);
  if (box.isEmpty()) {
    m_input->compute(tile, frame, ri);  // Could the invertMask be copied??
    return;
  }

  // Then, generate the texture tile
  TTile textureTile;
  TDimension size = tile.getRaster()->getSize();
  TPointD pos     = tile.m_pos;
  m_texture->allocateAndCompute(textureTile, pos, size, tile.getRaster(), frame,
                                ri);

  // And copy the part corresponding to mask tile
  /*TDimension dim = tile.getRaster()->getSize();
TRasterP appRas = tile.getRaster()->create(dim.lx,dim.ly);
  appRas->clear();
  appRas->copy(textureTile.getRaster(),convert(textureTile.m_pos-tile.m_pos));
  textureTile.setRaster(appRas);*/

  double v = m_value->getValue(frame);
  if (ri.m_bpp == 32) {
    TRaster32P witheCard;

    myOver32(tile.getRaster(), invertMaskTile.getRaster(),
             &makeOpaque<TPixel32>, v);

    switch (m_mode->getValue()) {
    case SUBSTITUTE:
      myOver32(tile.getRaster(), textureTile.getRaster(), &substitute<TPixel32>,
               v);
      break;
    case PATTERNTYPE:
      witheCard = TRaster32P(textureTile.getRaster()->getSize());
      witheCard->fill(TPixel32::White);
      TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());
      myOver32(tile.getRaster(), textureTile.getRaster(), &pattern32, v);
      break;
    case ADD:
      myOver32(tile.getRaster(), textureTile.getRaster(), &textureAdd<TPixel32>,
               v / 100.0);
      break;
    case SUBTRACT:
      myOver32(tile.getRaster(), textureTile.getRaster(), &textureSub<TPixel32>,
               v / 100.0);
      break;
    case MULTIPLY:
      myOver32(tile.getRaster(), textureTile.getRaster(),
               &textureMult<TPixel32>, v);
      break;
    case DARKEN:
      myOver32(tile.getRaster(), textureTile.getRaster(),
               &textureDarken<TPixel32>, v);
      break;
    case LIGHTEN:
      myOver32(tile.getRaster(), textureTile.getRaster(),
               &textureLighten<TPixel32>, v);
      break;
    default:
      assert(0);
      break;
    }
  } else {
    TRaster64P witheCard;

    myOver64(tile.getRaster(), invertMaskTile.getRaster(),
             &makeOpaque<TPixel64>, v);

    switch (m_mode->getValue()) {
    case SUBSTITUTE:
      myOver64(tile.getRaster(), textureTile.getRaster(), &substitute<TPixel64>,
               v);
      break;
    case PATTERNTYPE:
      witheCard = TRaster64P(textureTile.getRaster()->getSize());
      witheCard->fill(TPixel64::White);
      TRop::over(textureTile.getRaster(), witheCard, textureTile.getRaster());
      myOver64(tile.getRaster(), textureTile.getRaster(), &pattern64, v);
      break;
    case ADD:
      myOver64(tile.getRaster(), textureTile.getRaster(), &textureAdd<TPixel64>,
               v / 100.0);
      break;
    case SUBTRACT:
      myOver64(tile.getRaster(), textureTile.getRaster(), &textureSub<TPixel64>,
               v / 100.0);
      break;
    case MULTIPLY:
      myOver64(tile.getRaster(), textureTile.getRaster(),
               &textureMult<TPixel64>, v);
      break;
    case DARKEN:
      myOver64(tile.getRaster(), textureTile.getRaster(),
               &textureDarken<TPixel64>, v);
      break;
    case LIGHTEN:
      myOver64(tile.getRaster(), textureTile.getRaster(),
               &textureLighten<TPixel64>, v);
      break;
    default:
      assert(0);
    }
  }

  TRop::over(tile.getRaster(), invertMaskTile.getRaster());
}

//------------------------------------------------------------------

int TextureFx::getMemoryRequirement(const TRectD &rect, double frame,
                                    const TRenderSettings &info) {
  return TRasterFx::memorySize(rect, info.m_bpp);
}

//------------------------------------------------------------------

FX_PLUGIN_IDENTIFIER(TextureFx, "textureFx");


text:
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/reldatefmt.h"

#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_BREAK_ITERATION

#include <cmath>
#include <functional>
#include "unicode/dtfmtsym.h"
#include "unicode/ucasemap.h"
#include "unicode/ureldatefmt.h"
#include "unicode/udisplaycontext.h"
#include "unicode/unum.h"
#include "unicode/localpointer.h"
#include "unicode/plurrule.h"
#include "unicode/simpleformatter.h"
#include "unicode/decimfmt.h"
#include "unicode/numfmt.h"
#include "unicode/brkiter.h"
#include "unicode/simpleformatter.h"
#include "uresimp.h"
#include "unicode/ures.h"
#include "cstring.h"
#include "ucln_in.h"
#include "mutex.h"
#include "charstr.h"
#include "uassert.h"
#include "quantityformatter.h"
#include "resource.h"
#include "sharedbreakiterator.h"
#include "sharedpluralrules.h"
#include "sharednumberformat.h"
#include "standardplural.h"
#include "unifiedcache.h"
#include "util.h"
#include "number_stringbuilder.h"
#include "number_utypes.h"
#include "number_modifiers.h"
#include "formattedval_impl.h"
#include "number_utils.h"

// Copied from uscript_props.cpp

U_NAMESPACE_BEGIN

// RelativeDateTimeFormatter specific data for a single locale
class RelativeDateTimeCacheData: public SharedObject {
public:
    RelativeDateTimeCacheData() : combinedDateAndTime(nullptr) {
        // Initialize the cache arrays
        for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
            for (int32_t relUnit = 0; relUnit < UDAT_REL_UNIT_COUNT; ++relUnit) {
                for (int32_t pl = 0; pl < StandardPlural::COUNT; ++pl) {
                    relativeUnitsFormatters[style][relUnit][0][pl] = nullptr;
                    relativeUnitsFormatters[style][relUnit][1][pl] = nullptr;
                }
            }
        }
        for (int32_t i = 0; i < UDAT_STYLE_COUNT; ++i) {
          fallBackCache[i] = -1;
        }
    }
    virtual ~RelativeDateTimeCacheData();

    // no numbers: e.g Next Tuesday; Yesterday; etc.
    UnicodeString absoluteUnits[UDAT_STYLE_COUNT][UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT];

    // SimpleFormatter pointers for relative unit format,
    // e.g., Next Tuesday; Yesterday; etc. For third index, 0
    // means past, e.g., 5 days ago; 1 means future, e.g., in 5 days.
    SimpleFormatter *relativeUnitsFormatters[UDAT_STYLE_COUNT]
        [UDAT_REL_UNIT_COUNT][2][StandardPlural::COUNT];

    const UnicodeString& getAbsoluteUnitString(int32_t fStyle,
                                               UDateAbsoluteUnit unit,
                                               UDateDirection direction) const;
    const SimpleFormatter* getRelativeUnitFormatter(int32_t fStyle,
                                                    UDateRelativeUnit unit,
                                                    int32_t pastFutureIndex,
                                                    int32_t pluralUnit) const;
    const SimpleFormatter* getRelativeDateTimeUnitFormatter(int32_t fStyle,
                                                    URelativeDateTimeUnit unit,
                                                    int32_t pastFutureIndex,
                                                    int32_t pluralUnit) const;

    const UnicodeString emptyString;

    // Mappping from source to target styles for alias fallback.
    int32_t fallBackCache[UDAT_STYLE_COUNT];

    void adoptCombinedDateAndTime(SimpleFormatter *fmtToAdopt) {
        delete combinedDateAndTime;
        combinedDateAndTime = fmtToAdopt;
    }
    const SimpleFormatter *getCombinedDateAndTime() const {
        return combinedDateAndTime;
    }

private:
    SimpleFormatter *combinedDateAndTime;
    RelativeDateTimeCacheData(const RelativeDateTimeCacheData &other);
    RelativeDateTimeCacheData& operator=(
            const RelativeDateTimeCacheData &other);
};

RelativeDateTimeCacheData::~RelativeDateTimeCacheData() {
    // clear out the cache arrays
    for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
        for (int32_t relUnit = 0; relUnit < UDAT_REL_UNIT_COUNT; ++relUnit) {
            for (int32_t pl = 0; pl < StandardPlural::COUNT; ++pl) {
                delete relativeUnitsFormatters[style][relUnit][0][pl];
                delete relativeUnitsFormatters[style][relUnit][1][pl];
            }
        }
    }
    delete combinedDateAndTime;
}

// Use fallback cache for absolute units.
const UnicodeString& RelativeDateTimeCacheData::getAbsoluteUnitString(
        int32_t fStyle, UDateAbsoluteUnit unit, UDateDirection direction) const {
    int32_t style = fStyle;
    do {
        if (!absoluteUnits[style][unit][direction].isEmpty()) {
            return absoluteUnits[style][unit][direction];
        }
        style = fallBackCache[style];
    } while (style != -1);
    return emptyString;
}

 const SimpleFormatter* RelativeDateTimeCacheData::getRelativeUnitFormatter(
        int32_t fStyle,
        UDateRelativeUnit unit,
        int32_t pastFutureIndex,
        int32_t pluralUnit) const {
   URelativeDateTimeUnit rdtunit = UDAT_REL_UNIT_COUNT;
   switch (unit) {
       case UDAT_RELATIVE_YEARS:   rdtunit = UDAT_REL_UNIT_YEAR; break;
       case UDAT_RELATIVE_MONTHS:  rdtunit = UDAT_REL_UNIT_MONTH; break;
       case UDAT_RELATIVE_WEEKS:   rdtunit = UDAT_REL_UNIT_WEEK; break;
       case UDAT_RELATIVE_DAYS:    rdtunit = UDAT_REL_UNIT_DAY; break;
       case UDAT_RELATIVE_HOURS:   rdtunit = UDAT_REL_UNIT_HOUR; break;
       case UDAT_RELATIVE_MINUTES: rdtunit = UDAT_REL_UNIT_MINUTE; break;
       case UDAT_RELATIVE_SECONDS: rdtunit = UDAT_REL_UNIT_SECOND; break;
       default: // a unit that the above method does not handle
            return nullptr;
   }

   return getRelativeDateTimeUnitFormatter(fStyle, rdtunit, pastFutureIndex, pluralUnit);
 }

 // Use fallback cache for SimpleFormatter relativeUnits.
 const SimpleFormatter* RelativeDateTimeCacheData::getRelativeDateTimeUnitFormatter(
        int32_t fStyle,
        URelativeDateTimeUnit unit,
        int32_t pastFutureIndex,
        int32_t pluralUnit) const {
    while (true) {
        int32_t style = fStyle;
        do {
            if (relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit] != nullptr) {
                return relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit];
            }
            style = fallBackCache[style];
        } while (style != -1);

        if (pluralUnit == StandardPlural::OTHER) {
            break;
        }
        pluralUnit = StandardPlural::OTHER;
    }
    return nullptr;  // No formatter found.
 }

static UBool getStringWithFallback(
        const UResourceBundle *resource,
        const char *key,
        UnicodeString &result,
        UErrorCode &status) {
    int32_t len = 0;
    const UChar *resStr = ures_getStringByKeyWithFallback(
        resource, key, &len, &status);
    if (U_FAILURE(status)) {
        return FALSE;
    }
    result.setTo(TRUE, resStr, len);
    return TRUE;
}

static UBool getStringByIndex(
        const UResourceBundle *resource,
        int32_t idx,
        UnicodeString &result,
        UErrorCode &status) {
    int32_t len = 0;
    const UChar *resStr = ures_getStringByIndex(
            resource, idx, &len, &status);
    if (U_FAILURE(status)) {
        return FALSE;
    }
    result.setTo(TRUE, resStr, len);
    return TRUE;
}

namespace {

/**
 * Sink for enumerating all of the measurement unit display names.
 *
 * More specific bundles (en_GB) are enumerated before their parents (en_001, en, root):
 * Only store a value if it is still missing, that is, it has not been overridden.
 */
struct RelDateTimeFmtDataSink : public ResourceSink {

    /**
     * Sink for patterns for relative dates and times. For example,
     * fields/relative/...
     */

    // Generic unit enum for storing Unit info.
    typedef enum RelAbsUnit {
        INVALID_UNIT = -1,
        SECOND,
        MINUTE,
        HOUR,
        DAY,
        WEEK,
        MONTH,
        QUARTER,
        YEAR,
        SUNDAY,
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY
    } RelAbsUnit;

    static int32_t relUnitFromGeneric(RelAbsUnit genUnit) {
        // Converts the generic units to UDAT_RELATIVE version.
        switch (genUnit) {
            case SECOND:
                return UDAT_REL_UNIT_SECOND;
            case MINUTE:
                return UDAT_REL_UNIT_MINUTE;
            case HOUR:
                return UDAT_REL_UNIT_HOUR;
            case DAY:
                return UDAT_REL_UNIT_DAY;
            case WEEK:
                return UDAT_REL_UNIT_WEEK;
            case MONTH:
                return UDAT_REL_UNIT_MONTH;
            case QUARTER:
                return UDAT_REL_UNIT_QUARTER;
            case YEAR:
                return UDAT_REL_UNIT_YEAR;
            case SUNDAY:
                return UDAT_REL_UNIT_SUNDAY;
            case MONDAY:
                return UDAT_REL_UNIT_MONDAY;
            case TUESDAY:
                return UDAT_REL_UNIT_TUESDAY;
            case WEDNESDAY:
                return UDAT_REL_UNIT_WEDNESDAY;
            case THURSDAY:
                return UDAT_REL_UNIT_THURSDAY;
            case FRIDAY:
                return UDAT_REL_UNIT_FRIDAY;
            case SATURDAY:
                return UDAT_REL_UNIT_SATURDAY;
            default:
                return -1;
        }
    }

    static int32_t absUnitFromGeneric(RelAbsUnit genUnit) {
        // Converts the generic units to UDAT_RELATIVE version.
        switch (genUnit) {
            case DAY:
                return UDAT_ABSOLUTE_DAY;
            case WEEK:
                return UDAT_ABSOLUTE_WEEK;
            case MONTH:
                return UDAT_ABSOLUTE_MONTH;
            case QUARTER:
                return UDAT_ABSOLUTE_QUARTER;
            case YEAR:
                return UDAT_ABSOLUTE_YEAR;
            case SUNDAY:
                return UDAT_ABSOLUTE_SUNDAY;
            case MONDAY:
                return UDAT_ABSOLUTE_MONDAY;
            case TUESDAY:
                return UDAT_ABSOLUTE_TUESDAY;
            case WEDNESDAY:
                return UDAT_ABSOLUTE_WEDNESDAY;
            case THURSDAY:
                return UDAT_ABSOLUTE_THURSDAY;
            case FRIDAY:
                return UDAT_ABSOLUTE_FRIDAY;
            case SATURDAY:
                return UDAT_ABSOLUTE_SATURDAY;
            case HOUR:
                return UDAT_ABSOLUTE_HOUR;
            case MINUTE:
                return UDAT_ABSOLUTE_MINUTE;
            default:
                return -1;
        }
    }

    static int32_t keyToDirection(const char* key) {
        if (uprv_strcmp(key, "-2") == 0) {
            return UDAT_DIRECTION_LAST_2;
        }
        if (uprv_strcmp(key, "-1") == 0) {
            return UDAT_DIRECTION_LAST;
        }
        if (uprv_strcmp(key, "0") == 0) {
            return UDAT_DIRECTION_THIS;
        }
        if (uprv_strcmp(key, "1") == 0) {
            return UDAT_DIRECTION_NEXT;
        }
        if (uprv_strcmp(key, "2") == 0) {
            return UDAT_DIRECTION_NEXT_2;
        }
        return -1;
    }

    // Values kept between levels of parsing the CLDR data.
    int32_t pastFutureIndex;  // 0 == past or 1 ==  future
    UDateRelativeDateTimeFormatterStyle style;  // {LONG, SHORT, NARROW}
    RelAbsUnit genericUnit;

    RelativeDateTimeCacheData &outputData;

    // Constructor
    RelDateTimeFmtDataSink(RelativeDateTimeCacheData& cacheData)
        : outputData(cacheData) {
        // Clear cacheData.fallBackCache
        cacheData.fallBackCache[UDAT_STYLE_LONG] = -1;
        cacheData.fallBackCache[UDAT_STYLE_SHORT] = -1;
        cacheData.fallBackCache[UDAT_STYLE_NARROW] = -1;
    }

    ~RelDateTimeFmtDataSink();

    // Utility functions
    static UDateRelativeDateTimeFormatterStyle styleFromString(const char *s) {
        int32_t len = static_cast<int32_t>(uprv_strlen(s));
        if (len >= 7 && uprv_strcmp(s + len - 7, "-narrow") == 0) {
            return UDAT_STYLE_NARROW;
        }
        if (len >= 6 && uprv_strcmp(s + len - 6, "-short") == 0) {
            return UDAT_STYLE_SHORT;
        }
        return UDAT_STYLE_LONG;
    }

    static int32_t styleSuffixLength(UDateRelativeDateTimeFormatterStyle style) {
        switch (style) {
            case UDAT_STYLE_NARROW:
                return 7;
            case UDAT_STYLE_SHORT:
                return 6;
            default:
                return 0;
        }
    }

    // Utility functions
    static UDateRelativeDateTimeFormatterStyle styleFromAliasUnicodeString(UnicodeString s) {
        static const UChar narrow[7] = {0x002D, 0x006E, 0x0061, 0x0072, 0x0072, 0x006F, 0x0077};
        static const UChar sshort[6] = {0x002D, 0x0073, 0x0068, 0x006F, 0x0072, 0x0074,};
        if (s.endsWith(narrow, 7)) {
            return UDAT_STYLE_NARROW;
        }
        if (s.endsWith(sshort, 6)) {
            return UDAT_STYLE_SHORT;
        }
        return UDAT_STYLE_LONG;
    }

    static RelAbsUnit unitOrNegativeFromString(const char* keyword, int32_t length) {
        // Quick check from string to enum.
        switch (length) {
            case 3:
                if (uprv_strncmp(keyword, "day", length) == 0) {
                    return DAY;
                } else if (uprv_strncmp(keyword, "sun", length) == 0) {
                    return SUNDAY;
                } else if (uprv_strncmp(keyword, "mon", length) == 0) {
                    return MONDAY;
                } else if (uprv_strncmp(keyword, "tue", length) == 0) {
                    return TUESDAY;
                } else if (uprv_strncmp(keyword, "wed", length) == 0) {
                    return WEDNESDAY;
                } else if (uprv_strncmp(keyword, "thu", length) == 0) {
                    return THURSDAY;
                } else if (uprv_strncmp(keyword, "fri", length) == 0) {
                    return FRIDAY;
                } else if (uprv_strncmp(keyword, "sat", length) == 0) {
                    return SATURDAY;
                }
                break;
            case 4:
                if (uprv_strncmp(keyword, "hour", length) == 0) {
                    return HOUR;
                } else if (uprv_strncmp(keyword, "week", length) == 0) {
                    return WEEK;
                } else if (uprv_strncmp(keyword, "year", length) == 0) {
                    return YEAR;
                }
                break;
            case 5:
                if (uprv_strncmp(keyword, "month", length) == 0) {
                    return MONTH;
                }
                break;
            case 6:
                if (uprv_strncmp(keyword, "minute", length) == 0) {
                    return MINUTE;
                } else if (uprv_strncmp(keyword, "second", length) == 0) {
                    return SECOND;
                }
                break;
            case 7:
                if (uprv_strncmp(keyword, "quarter", length) == 0) {
                    return QUARTER;  // TODO: Check @provisional
                  }
                break;
            default:
                break;
        }
        return INVALID_UNIT;
    }

    void handlePlainDirection(ResourceValue &value, UErrorCode &errorCode) {
        // Handle Display Name for PLAIN direction for some units.
        if (U_FAILURE(errorCode)) { return; }

        int32_t absUnit = absUnitFromGeneric(genericUnit);
        if (absUnit < 0) {
          return;  // Not interesting.
        }

        // Store displayname if not set.
        if (outputData.absoluteUnits[style]
            [absUnit][UDAT_DIRECTION_PLAIN].isEmpty()) {
            outputData.absoluteUnits[style]
                [absUnit][UDAT_DIRECTION_PLAIN].fastCopyFrom(value.getUnicodeString(errorCode));
            return;
        }
    }

    void consumeTableRelative(const char *key, ResourceValue &value, UErrorCode &errorCode) {
        ResourceTable unitTypesTable = value.getTable(errorCode);
        if (U_FAILURE(errorCode)) { return; }

        for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
            if (value.getType() == URES_STRING) {
                int32_t direction = keyToDirection(key);
                if (direction < 0) {
                  continue;
                }

                int32_t relUnitIndex = relUnitFromGeneric(genericUnit);
                if (relUnitIndex == UDAT_REL_UNIT_SECOND && uprv_strcmp(key, "0") == 0 &&
                    outputData.absoluteUnits[style][UDAT_ABSOLUTE_NOW][UDAT_DIRECTION_PLAIN].isEmpty()) {
                    // Handle "NOW"
                    outputData.absoluteUnits[style][UDAT_ABSOLUTE_NOW]
                        [UDAT_DIRECTION_PLAIN].fastCopyFrom(value.getUnicodeString(errorCode));
                }

                int32_t absUnitIndex = absUnitFromGeneric(genericUnit);
                if (absUnitIndex < 0) {
                    continue;
                }
                // Only reset if slot is empty.
                if (outputData.absoluteUnits[style][absUnitIndex][direction].isEmpty()) {
                    outputData.absoluteUnits[style][absUnitIndex]
                        [direction].fastCopyFrom(value.getUnicodeString(errorCode));
                }
            }
        }
    }

    void consumeTimeDetail(int32_t relUnitIndex,
                           const char *key, ResourceValue &value, UErrorCode &errorCode) {
        ResourceTable unitTypesTable = value.getTable(errorCode);
        if (U_FAILURE(errorCode)) { return; }

          for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
            if (value.getType() == URES_STRING) {
                int32_t pluralIndex = StandardPlural::indexOrNegativeFromString(key);
                if (pluralIndex >= 0) {
                    SimpleFormatter **patterns =
                        outputData.relativeUnitsFormatters[style][relUnitIndex]
                        [pastFutureIndex];
                    // Only set if not already established.
                    if (patterns[pluralIndex] == nullptr) {
                        patterns[pluralIndex] = new SimpleFormatter(
                            value.getUnicodeString(errorCode), 0, 1, errorCode);
                        if (patterns[pluralIndex] == nullptr) {
                            errorCode = U_MEMORY_ALLOCATION_ERROR;
                        }
                    }
                }
            }
        }
    }

    void consumeTableRelativeTime(const char *key, ResourceValue &value, UErrorCode &errorCode) {
        ResourceTable relativeTimeTable = value.getTable(errorCode);
        if (U_FAILURE(errorCode)) { return; }

        int32_t relUnitIndex = relUnitFromGeneric(genericUnit);
        if (relUnitIndex < 0) {
            return;
        }
        for (int32_t i = 0; relativeTimeTable.getKeyAndValue(i, key, value); ++i) {
            if (uprv_strcmp(key, "past") == 0) {
                pastFutureIndex = 0;
            } else if (uprv_strcmp(key, "future") == 0) {
                pastFutureIndex = 1;
            } else {
                // Unknown key.
                continue;
            }
            consumeTimeDetail(relUnitIndex, key, value, errorCode);
        }
    }

    void consumeAlias(const char *key, const ResourceValue &value, UErrorCode &errorCode) {

        UDateRelativeDateTimeFormatterStyle sourceStyle = styleFromString(key);
        const UnicodeString valueStr = value.getAliasUnicodeString(errorCode);
        if (U_FAILURE(errorCode)) { return; }

        UDateRelativeDateTimeFormatterStyle targetStyle =
            styleFromAliasUnicodeString(valueStr);

        if (sourceStyle == targetStyle) {
            errorCode = U_INVALID_FORMAT_ERROR;
            return;
        }
        if (outputData.fallBackCache[sourceStyle] != -1 &&
            outputData.fallBackCache[sourceStyle] != targetStyle) {
            errorCode = U_INVALID_FORMAT_ERROR;
            return;
        }
        outputData.fallBackCache[sourceStyle] = targetStyle;
    }

    void consumeTimeUnit(const char *key, ResourceValue &value, UErrorCode &errorCode) {
        ResourceTable unitTypesTable = value.getTable(errorCode);
        if (U_FAILURE(errorCode)) { return; }

        for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
            // Handle display name.
            if (uprv_strcmp(key, "dn") == 0 && value.getType() == URES_STRING) {
                handlePlainDirection(value, errorCode);
            }
            if (value.getType() == URES_TABLE) {
                if (uprv_strcmp(key, "relative") == 0) {
                    consumeTableRelative(key, value, errorCode);
                } else if (uprv_strcmp(key, "relativeTime") == 0) {
                    consumeTableRelativeTime(key, value, errorCode);
                }
            }
        }
    }

    virtual void put(const char *key, ResourceValue &value,
                     UBool /*noFallback*/, UErrorCode &errorCode) {
        // Main entry point to sink
        ResourceTable table = value.getTable(errorCode);
        if (U_FAILURE(errorCode)) { return; }
        for (int32_t i = 0; table.getKeyAndValue(i, key, value); ++i) {
            if (value.getType() == URES_ALIAS) {
                consumeAlias(key, value, errorCode);
            } else {
                style = styleFromString(key);
                int32_t unitSize = static_cast<int32_t>(uprv_strlen(key)) - styleSuffixLength(style);
                genericUnit = unitOrNegativeFromString(key, unitSize);
                if (style >= 0 && genericUnit != INVALID_UNIT) {
                    consumeTimeUnit(key, value, errorCode);
                }
            }
        }
    }

};

// Virtual destructors must be defined out of line.
RelDateTimeFmtDataSink::~RelDateTimeFmtDataSink() {}
} // namespace

static const DateFormatSymbols::DtWidthType styleToDateFormatSymbolWidth[UDAT_STYLE_COUNT] = {
  DateFormatSymbols::WIDE, DateFormatSymbols::SHORT, DateFormatSymbols::NARROW
};

// Get days of weeks from the DateFormatSymbols class.
static void loadWeekdayNames(UnicodeString absoluteUnits[UDAT_STYLE_COUNT]
                                 [UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT],
                             const char* localeId,
                             UErrorCode& status) {
    if (U_FAILURE(status)) {
        return;
    }
    Locale locale(localeId);
    DateFormatSymbols dfSym(locale, status);
    if (U_FAILURE(status)) {
        return;
    }
    for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
        DateFormatSymbols::DtWidthType dtfmtWidth = styleToDateFormatSymbolWidth[style];
        int32_t count;
        const UnicodeString* weekdayNames =
            dfSym.getWeekdays(count, DateFormatSymbols::STANDALONE, dtfmtWidth);
        for (int32_t dayIndex = UDAT_ABSOLUTE_SUNDAY;
                dayIndex <= UDAT_ABSOLUTE_SATURDAY; ++ dayIndex) {
            int32_t dateSymbolIndex = (dayIndex - UDAT_ABSOLUTE_SUNDAY) + UCAL_SUNDAY;
            absoluteUnits[style][dayIndex][UDAT_DIRECTION_PLAIN].fastCopyFrom(
                weekdayNames[dateSymbolIndex]);
        }
    }
}

static UBool loadUnitData(
        const UResourceBundle *resource,
        RelativeDateTimeCacheData &cacheData,
        const char* localeId,
        UErrorCode &status) {

    RelDateTimeFmtDataSink sink(cacheData);

    ures_getAllItemsWithFallback(resource, "fields", sink, status);
    if (U_FAILURE(status)) {
        return false;
    }

    // Get the weekday names from DateFormatSymbols.
    loadWeekdayNames(cacheData.absoluteUnits, localeId, status);
    return U_SUCCESS(status);
}

static UBool getDateTimePattern(
        const UResourceBundle *resource,
        UnicodeString &result,
        UErrorCode &status) {
    UnicodeString defaultCalendarName;
    if (!getStringWithFallback(
            resource,
            "calendar/default",
            defaultCalendarName,
            status)) {
        return FALSE;
    }
    CharString pathBuffer;
    pathBuffer.append("calendar/", status)
            .appendInvariantChars(defaultCalendarName, status)
            .append("/DateTimePatterns", status);
    LocalUResourceBundlePointer topLevel(
            ures_getByKeyWithFallback(
                    resource, pathBuffer.data(), nullptr, &status));
    if (U_FAILURE(status)) {
        return FALSE;
    }
    int32_t size = ures_getSize(topLevel.getAlias());
    if (size <= 8) {
        // Oops, size is too small to access the index that we want, fallback
        // to a hard-coded value.
        result = UNICODE_STRING_SIMPLE("{1} {0}");
        return TRUE;
    }
    return getStringByIndex(topLevel.getAlias(), 8, result, status);
}

template<> U_I18N_API
const RelativeDateTimeCacheData *LocaleCacheKey<RelativeDateTimeCacheData>::createObject(const void * /*unused*/, UErrorCode &status) const {
    const char *localeId = fLoc.getName();
    LocalUResourceBundlePointer topLevel(ures_open(nullptr, localeId, &status));
    if (U_FAILURE(status)) {
        return nullptr;
    }
    LocalPointer<RelativeDateTimeCacheData> result(
            new RelativeDateTimeCacheData());
    if (result.isNull()) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return nullptr;
    }
    if (!loadUnitData(
            topLevel.getAlias(),
            *result,
            localeId,
            status)) {
        return nullptr;
    }
    UnicodeString dateTimePattern;
    if (!getDateTimePattern(topLevel.getAlias(), dateTimePattern, status)) {
        return nullptr;
    }
    result->adoptCombinedDateAndTime(
            new SimpleFormatter(dateTimePattern, 2, 2, status));
    if (U_FAILURE(status)) {
        return nullptr;
    }
    result->addRef();
    return result.orphan();
}

static constexpr number::impl::Field kRDTNumericField
    = number::impl::NumFieldUtils::compress<UFIELD_CATEGORY_RELATIVE_DATETIME, UDAT_REL_NUMERIC_FIELD>();

static constexpr number::impl::Field kRDTLiteralField
    = number::impl::NumFieldUtils::compress<UFIELD_CATEGORY_RELATIVE_DATETIME, UDAT_REL_LITERAL_FIELD>();

class FormattedRelativeDateTimeData : public FormattedValueNumberStringBuilderImpl {
public:
    FormattedRelativeDateTimeData() : FormattedValueNumberStringBuilderImpl(kRDTNumericField) {}
    virtual ~FormattedRelativeDateTimeData();
};

FormattedRelativeDateTimeData::~FormattedRelativeDateTimeData() = default;

UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedRelativeDateTime)

RelativeDateTimeFormatter::RelativeDateTimeFormatter(UErrorCode& status) :
        fCache(nullptr),
        fNumberFormat(nullptr),
        fPluralRules(nullptr),
        fStyle(UDAT_STYLE_LONG),
        fContext(UDISPCTX_CAPITALIZATION_NONE),
        fOptBreakIterator(nullptr) {
    init(nullptr, nullptr, status);
}

RelativeDateTimeFormatter::RelativeDateTimeFormatter(
        const Locale& locale, UErrorCode& status) :
        fCache(nullptr),
        fNumberFormat(nullptr),
        fPluralRules(nullptr),
        fStyle(UDAT_STYLE_LONG),
        fContext(UDISPCTX_CAPITALIZATION_NONE),
        fOptBreakIterator(nullptr),
        fLocale(locale) {
    init(nullptr, nullptr, status);
}

RelativeDateTimeFormatter::RelativeDateTimeFormatter(
        const Locale& locale, NumberFormat *nfToAdopt, UErrorCode& status) :
        fCache(nullptr),
        fNumberFormat(nullptr),
        fPluralRules(nullptr),
        fStyle(UDAT_STYLE_LONG),
        fContext(UDISPCTX_CAPITALIZATION_NONE),
        fOptBreakIterator(nullptr),
        fLocale(locale) {
    init(nfToAdopt, nullptr, status);
}

RelativeDateTimeFormatter::RelativeDateTimeFormatter(
        const Locale& locale,
        NumberFormat *nfToAdopt,
        UDateRelativeDateTimeFormatterStyle styl,
        UDisplayContext capitalizationContext,
        UErrorCode& status) :
        fCache(nullptr),
        fNumberFormat(nullptr),
        fPluralRules(nullptr),
        fStyle(styl),
        fContext(capitalizationContext),
        fOptBreakIterator(nullptr),
        fLocale(locale) {
    if (U_FAILURE(status)) {
        return;
    }
    if ((capitalizationContext >> 8) != UDISPCTX_TYPE_CAPITALIZATION) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    if (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE) {
        BreakIterator *bi = BreakIterator::createSentenceInstance(locale, status);
        if (U_FAILURE(status)) {
            return;
        }
        init(nfToAdopt, bi, status);
    } else {
        init(nfToAdopt, nullptr, status);
    }
}

RelativeDateTimeFormatter::RelativeDateTimeFormatter(
        const RelativeDateTimeFormatter& other)
        : UObject(other),
          fCache(other.fCache),
          fNumberFormat(other.fNumberFormat),
          fPluralRules(other.fPluralRules),
          fStyle(other.fStyle),
          fContext(other.fContext),
          fOptBreakIterator(other.fOptBreakIterator),
          fLocale(other.fLocale) {
    fCache->addRef();
    fNumberFormat->addRef();
    fPluralRules->addRef();
    if (fOptBreakIterator != nullptr) {
      fOptBreakIterator->addRef();
    }
}

RelativeDateTimeFormatter& RelativeDateTimeFormatter::operator=(
        const RelativeDateTimeFormatter& other) {
    if (this != &other) {
        SharedObject::copyPtr(other.fCache, fCache);
        SharedObject::copyPtr(other.fNumberFormat, fNumberFormat);
        SharedObject::copyPtr(other.fPluralRules, fPluralRules);
        SharedObject::copyPtr(other.fOptBreakIterator, fOptBreakIterator);
        fStyle = other.fStyle;
        fContext = other.fContext;
        fLocale = other.fLocale;
    }
    return *this;
}

RelativeDateTimeFormatter::~RelativeDateTimeFormatter() {
    if (fCache != nullptr) {
        fCache->removeRef();
    }
    if (fNumberFormat != nullptr) {
        fNumberFormat->removeRef();
    }
    if (fPluralRules != nullptr) {
        fPluralRules->removeRef();
    }
    if (fOptBreakIterator != nullptr) {
        fOptBreakIterator->removeRef();
    }
}

const NumberFormat& RelativeDateTimeFormatter::getNumberFormat() const {
    return **fNumberFormat;
}

UDisplayContext RelativeDateTimeFormatter::getCapitalizationContext() const {
    return fContext;
}

UDateRelativeDateTimeFormatterStyle RelativeDateTimeFormatter::getFormatStyle() const {
    return fStyle;
}

// To reduce boilerplate code, we use a helper function that forwards variadic
// arguments to the formatImpl function.

template<typename F, typename... Args>
UnicodeString& RelativeDateTimeFormatter::doFormat(
        F callback,
        UnicodeString& appendTo,
        UErrorCode& status,
        Args... args) const {
    FormattedRelativeDateTimeData output;
    (this->*callback)(std::forward<Args>(args)..., output, status);
    if (U_FAILURE(status)) {
        return appendTo;
    }
    UnicodeString result = output.getStringRef().toUnicodeString();
    return appendTo.append(adjustForContext(result));
}

template<typename F, typename... Args>
FormattedRelativeDateTime RelativeDateTimeFormatter::doFormatToValue(
        F callback,
        UErrorCode& status,
        Args... args) const {
    if (!checkNoAdjustForContext(status)) {
        return FormattedRelativeDateTime(status);
    }
    LocalPointer<FormattedRelativeDateTimeData> output(
        new FormattedRelativeDateTimeData(), status);
    if (U_FAILURE(status)) {
        return FormattedRelativeDateTime(status);
    }
    (this->*callback)(std::forward<Args>(args)..., *output, status);
    output->getStringRef().writeTerminator(status);
    return FormattedRelativeDateTime(output.orphan());
}

UnicodeString& RelativeDateTimeFormatter::format(
        double quantity,
        UDateDirection direction,
        UDateRelativeUnit unit,
        UnicodeString& appendTo,
        UErrorCode& status) const {
    return doFormat(
        &RelativeDateTimeFormatter::formatImpl,
        appendTo,
        status,
        quantity,
        direction,
        unit);
}

FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
        double quantity,
        UDateDirection direction,
        UDateRelativeUnit unit,
        UErrorCode& status) const {
    return doFormatToValue(
        &RelativeDateTimeFormatter::formatImpl,
        status,
        quantity,
        direction,
        unit);
}

void RelativeDateTimeFormatter::formatImpl(
        double quantity,
        UDateDirection direction,
        UDateRelativeUnit unit,
        FormattedRelativeDateTimeData& output,
        UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }
    if (direction != UDAT_DIRECTION_LAST && direction != UDAT_DIRECTION_NEXT) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    int32_t bFuture = direction == UDAT_DIRECTION_NEXT ? 1 : 0;

    StandardPlural::Form pluralForm;
    QuantityFormatter::formatAndSelect(
        quantity,
        **fNumberFormat,
        **fPluralRules,
        output.getStringRef(),
        pluralForm,
        status);
    if (U_FAILURE(status)) {
        return;
    }

    const SimpleFormatter* formatter =
        fCache->getRelativeUnitFormatter(fStyle, unit, bFuture, pluralForm);
    if (formatter == nullptr) {
        // TODO: WARN - look at quantity formatter's action with an error.
        status = U_INVALID_FORMAT_ERROR;
        return;
    }

    number::impl::SimpleModifier modifier(*formatter, kRDTLiteralField, false);
    modifier.formatAsPrefixSuffix(
        output.getStringRef(), 0, output.getStringRef().length(), status);
}

UnicodeString& RelativeDateTimeFormatter::formatNumeric(
        double offset,
        URelativeDateTimeUnit unit,
        UnicodeString& appendTo,
        UErrorCode& status) const {
    return doFormat(
        &RelativeDateTimeFormatter::formatNumericImpl,
        appendTo,
        status,
        offset,
        unit);
}

FormattedRelativeDateTime RelativeDateTimeFormatter::formatNumericToValue(
        double offset,
        URelativeDateTimeUnit unit,
        UErrorCode& status) const {
    return doFormatToValue(
        &RelativeDateTimeFormatter::formatNumericImpl,
        status,
        offset,
        unit);
}

void RelativeDateTimeFormatter::formatNumericImpl(
        double offset,
        URelativeDateTimeUnit unit,
        FormattedRelativeDateTimeData& output,
        UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }
    UDateDirection direction = UDAT_DIRECTION_NEXT;
    if (std::signbit(offset)) { // needed to handle -0.0
        direction = UDAT_DIRECTION_LAST;
        offset = -offset;
    }
    if (direction != UDAT_DIRECTION_LAST && direction != UDAT_DIRECTION_NEXT) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }
    int32_t bFuture = direction == UDAT_DIRECTION_NEXT ? 1 : 0;

    StandardPlural::Form pluralForm;
    QuantityFormatter::formatAndSelect(
        offset,
        **fNumberFormat,
        **fPluralRules,
        output.getStringRef(),
        pluralForm,
        status);
    if (U_FAILURE(status)) {
        return;
    }

    const SimpleFormatter* formatter =
        fCache->getRelativeDateTimeUnitFormatter(fStyle, unit, bFuture, pluralForm);
    if (formatter == nullptr) {
        // TODO: WARN - look at quantity formatter's action with an error.
        status = U_INVALID_FORMAT_ERROR;
        return;
    }

    number::impl::SimpleModifier modifier(*formatter, kRDTLiteralField, false);
    modifier.formatAsPrefixSuffix(
        output.getStringRef(), 0, output.getStringRef().length(), status);
}

UnicodeString& RelativeDateTimeFormatter::format(
        UDateDirection direction,
        UDateAbsoluteUnit unit,
        UnicodeString& appendTo,
        UErrorCode& status) const {
    return doFormat(
        &RelativeDateTimeFormatter::formatAbsoluteImpl,
        appendTo,
        status,
        direction,
        unit);
}

FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
        UDateDirection direction,
        UDateAbsoluteUnit unit,
        UErrorCode& status) const {
    return doFormatToValue(
        &RelativeDateTimeFormatter::formatAbsoluteImpl,
        status,
        direction,
        unit);
}

void RelativeDateTimeFormatter::formatAbsoluteImpl(
        UDateDirection direction,
        UDateAbsoluteUnit unit,
        FormattedRelativeDateTimeData& output,
        UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }
    if (unit == UDAT_ABSOLUTE_NOW && direction != UDAT_DIRECTION_PLAIN) {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return;
    }

    // Get string using fallback.
    output.getStringRef().append(
        fCache->getAbsoluteUnitString(fStyle, unit, direction),
        kRDTLiteralField,
        status);
}

UnicodeString& RelativeDateTimeFormatter::format(
        double offset,
        URelativeDateTimeUnit unit,
        UnicodeString& appendTo,
        UErrorCode& status) const {
    return doFormat(
        &RelativeDateTimeFormatter::formatRelativeImpl,
        appendTo,
        status,
        offset,
        unit);
}

FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
        double offset,
        URelativeDateTimeUnit unit,
        UErrorCode& status) const {
    return doFormatToValue(
        &RelativeDateTimeFormatter::formatRelativeImpl,
        status,
        offset,
        unit);
}

void RelativeDateTimeFormatter::formatRelativeImpl(
        double offset,
        URelativeDateTimeUnit unit,
        FormattedRelativeDateTimeData& output,
        UErrorCode& status) const {
    if (U_FAILURE(status)) {
        return;
    }
    // TODO:
    // The full implementation of this depends on CLDR data that is not yet available,
    // see: http://unicode.org/cldr/trac/ticket/9165 Add more relative field data.
    // In the meantime do a quick bring-up by calling the old format method; this
    // leaves some holes (even for data that is currently available, such as quarter).
    // When the new CLDR data is available, update the data storage accordingly,
    // rewrite this to use it directly, and rewrite the old format method to call this
    // new one; that is covered by http://bugs.icu-project.org/trac/ticket/12171.
    UDateDirection direction = UDAT_DIRECTION_COUNT;
    if (offset > -2.1 && offset < 2.1) {
        // Allow a 1% epsilon, so offsets in -1.01..-0.99 map to LAST
        double offsetx100 = offset * 100.0;
        int32_t intoffset = (offsetx100 < 0)? (int32_t)(offsetx100-0.5) : (int32_t)(offsetx100+0.5);
        switch (intoffset) {
            case -200/*-2*/: direction = UDAT_DIRECTION_LAST_2; break;
            case -100/*-1*/: direction = UDAT_DIRECTION_LAST; break;
            case    0/* 0*/: direction = UDAT_DIRECTION_THIS; break;
            case  100/* 1*/: direction = UDAT_DIRECTION_NEXT; break;
            case  200/* 2*/: direction = UDAT_DIRECTION_NEXT_2; break;
            default: break;
    	}
    }
    UDateAbsoluteUnit absunit = UDAT_ABSOLUTE_UNIT_COUNT;
    switch (unit) {
        case UDAT_REL_UNIT_YEAR:    absunit = UDAT_ABSOLUTE_YEAR; break;
        case UDAT_REL_UNIT_QUARTER: absunit = UDAT_ABSOLUTE_QUARTER; break;
        case UDAT_REL_UNIT_MONTH:   absunit = UDAT_ABSOLUTE_MONTH; break;
        case UDAT_REL_UNIT_WEEK:    absunit = UDAT_ABSOLUTE_WEEK; break;
        case UDAT_REL_UNIT_DAY:     absunit = UDAT_ABSOLUTE_DAY; break;
        case UDAT_REL_UNIT_SECOND:
            if (direction == UDAT_DIRECTION_THIS) {
                absunit = UDAT_ABSOLUTE_NOW;
                direction = UDAT_DIRECTION_PLAIN;
            }
            break;
        case UDAT_REL_UNIT_SUNDAY:  absunit = UDAT_ABSOLUTE_SUNDAY; break;
        case UDAT_REL_UNIT_MONDAY:  absunit = UDAT_ABSOLUTE_MONDAY; break;
        case UDAT_REL_UNIT_TUESDAY:  absunit = UDAT_ABSOLUTE_TUESDAY; break;
        case UDAT_REL_UNIT_WEDNESDAY:  absunit = UDAT_ABSOLUTE_WEDNESDAY; break;
        case UDAT_REL_UNIT_THURSDAY:  absunit = UDAT_ABSOLUTE_THURSDAY; break;
        case UDAT_REL_UNIT_FRIDAY:  absunit = UDAT_ABSOLUTE_FRIDAY; break;
        case UDAT_REL_UNIT_SATURDAY:  absunit = UDAT_ABSOLUTE_SATURDAY; break;
        case UDAT_REL_UNIT_HOUR:  absunit = UDAT_ABSOLUTE_HOUR; break;
        case UDAT_REL_UNIT_MINUTE:  absunit = UDAT_ABSOLUTE_MINUTE; break;
        default: break;
    }
    if (direction != UDAT_DIRECTION_COUNT && absunit != UDAT_ABSOLUTE_UNIT_COUNT) {
        formatAbsoluteImpl(direction, absunit, output, status);
        if (output.getStringRef().length() != 0) {
            return;
        }
    }
    // otherwise fallback to formatNumeric
    formatNumericImpl(offset, unit, output, status);
}

UnicodeString& RelativeDateTimeFormatter::combineDateAndTime(
        const UnicodeString& relativeDateString, const UnicodeString& timeString,
        UnicodeString& appendTo, UErrorCode& status) const {
    return fCache->getCombinedDateAndTime()->format(
            timeString, relativeDateString, appendTo, status);
}

UnicodeString& RelativeDateTimeFormatter::adjustForContext(UnicodeString &str) const {
    if (fOptBreakIterator == nullptr
        || str.length() == 0 || !u_islower(str.char32At(0))) {
        return str;
    }

    // Must guarantee that one thread at a time accesses the shared break
    // iterator.
    static icu::UMutex *gBrkIterMutex = new icu::UMutex();
    Mutex lock(gBrkIterMutex);
    str.toTitle(
            fOptBreakIterator->get(),
            fLocale,
            U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
    return str;
}

UBool RelativeDateTimeFormatter::checkNoAdjustForContext(UErrorCode& status) const {
    // This is unsupported because it's hard to keep fields in sync with title
    // casing. The code could be written and tested if there is demand.
    if (fOptBreakIterator != nullptr) {
        status = U_UNSUPPORTED_ERROR;
        return FALSE;
    }
    return TRUE;
}

void RelativeDateTimeFormatter::init(
        NumberFormat *nfToAdopt,
        BreakIterator *biToAdopt,
        UErrorCode &status) {
    LocalPointer<NumberFormat> nf(nfToAdopt);
    LocalPointer<BreakIterator> bi(biToAdopt);
    UnifiedCache::getByLocale(fLocale, fCache, status);
    if (U_FAILURE(status)) {
        return;
    }
    const SharedPluralRules *pr = PluralRules::createSharedInstance(
            fLocale, UPLURAL_TYPE_CARDINAL, status);
    if (U_FAILURE(status)) {
        return;
    }
    SharedObject::copyPtr(pr, fPluralRules);
    pr->removeRef();
    if (nf.isNull()) {
       const SharedNumberFormat *shared = NumberFormat::createSharedInstance(
               fLocale, UNUM_DECIMAL, status);
        if (U_FAILURE(status)) {
            return;
        }
        SharedObject::copyPtr(shared, fNumberFormat);
        shared->removeRef();
    } else {
        SharedNumberFormat *shared = new SharedNumberFormat(nf.getAlias());
        if (shared == nullptr) {
            status = U_MEMORY_ALLOCATION_ERROR;
            return;
        }
        nf.orphan();
        SharedObject::copyPtr(shared, fNumberFormat);
    }
    if (bi.isNull()) {
        SharedObject::clearPtr(fOptBreakIterator);
    } else {
        SharedBreakIterator *shared = new SharedBreakIterator(bi.getAlias());
        if (shared == nullptr) {
            status = U_MEMORY_ALLOCATION_ERROR;
            return;
        }
        bi.orphan();
        SharedObject::copyPtr(shared, fOptBreakIterator);
    }
}

U_NAMESPACE_END

// Plain C API

U_NAMESPACE_USE

// Magic number: "FRDT" (FormattedRelativeDateTime) in ASCII
UPRV_FORMATTED_VALUE_CAPI_AUTO_IMPL(
    FormattedRelativeDateTime,
    UFormattedRelativeDateTime,
    UFormattedRelativeDateTimeImpl,
    UFormattedRelativeDateTimeApiHelper,
    ureldatefmt,
    0x46524454)

U_CAPI URelativeDateTimeFormatter* U_EXPORT2
ureldatefmt_open( const char*          locale,
                  UNumberFormat*       nfToAdopt,
                  UDateRelativeDateTimeFormatterStyle width,
                  UDisplayContext      capitalizationContext,
                  UErrorCode*          status )
{
    if (U_FAILURE(*status)) {
        return nullptr;
    }
    LocalPointer<RelativeDateTimeFormatter> formatter(new RelativeDateTimeFormatter(Locale(locale),
                                                              (NumberFormat*)nfToAdopt, width,
                                                              capitalizationContext, *status), *status);
    if (U_FAILURE(*status)) {
        return nullptr;
    }
    return (URelativeDateTimeFormatter*)formatter.orphan();
}

U_CAPI void U_EXPORT2
ureldatefmt_close(URelativeDateTimeFormatter *reldatefmt)
{
    delete (RelativeDateTimeFormatter*)reldatefmt;
}

U_CAPI int32_t U_EXPORT2
ureldatefmt_formatNumeric( const URelativeDateTimeFormatter* reldatefmt,
                    double                offset,
                    URelativeDateTimeUnit unit,
                    UChar*                result,
                    int32_t               resultCapacity,
                    UErrorCode*           status)
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if (result == nullptr ? resultCapacity != 0 : resultCapacity < 0) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString res;
    if (result != nullptr) {
        // nullptr destination for pure preflighting: empty dummy string
        // otherwise, alias the destination buffer (copied from udat_format)
        res.setTo(result, 0, resultCapacity);
    }
    ((RelativeDateTimeFormatter*)reldatefmt)->formatNumeric(offset, unit, res, *status);
    if (U_FAILURE(*status)) {
        return 0;
    }
    return res.extract(result, resultCapacity, *status);
}

U_STABLE void U_EXPORT2
ureldatefmt_formatNumericToResult(
        const URelativeDateTimeFormatter* reldatefmt,
        double                            offset,
        URelativeDateTimeUnit             unit,
        UFormattedRelativeDateTime*       result,
        UErrorCode*                       status) {
    if (U_FAILURE(*status)) {
        return;
    }
    auto* fmt = reinterpret_cast<const RelativeDateTimeFormatter*>(reldatefmt);
    auto* resultImpl = UFormattedRelativeDateTimeApiHelper::validate(result, *status);
    resultImpl->fImpl = fmt->formatNumericToValue(offset, unit, *status);
}

U_CAPI int32_t U_EXPORT2
ureldatefmt_format( const URelativeDateTimeFormatter* reldatefmt,
                    double                offset,
                    URelativeDateTimeUnit unit,
                    UChar*                result,
                    int32_t               resultCapacity,
                    UErrorCode*           status)
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if (result == nullptr ? resultCapacity != 0 : resultCapacity < 0) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString res;
    if (result != nullptr) {
        // nullptr destination for pure preflighting: empty dummy string
        // otherwise, alias the destination buffer (copied from udat_format)
        res.setTo(result, 0, resultCapacity);
    }
    ((RelativeDateTimeFormatter*)reldatefmt)->format(offset, unit, res, *status);
    if (U_FAILURE(*status)) {
        return 0;
    }
    return res.extract(result, resultCapacity, *status);
}

U_DRAFT void U_EXPORT2
ureldatefmt_formatToResult(
        const URelativeDateTimeFormatter* reldatefmt,
        double                            offset,
        URelativeDateTimeUnit             unit,
        UFormattedRelativeDateTime*       result,
        UErrorCode*                       status) {
    if (U_FAILURE(*status)) {
        return;
    }
    auto* fmt = reinterpret_cast<const RelativeDateTimeFormatter*>(reldatefmt);
    auto* resultImpl = UFormattedRelativeDateTimeApiHelper::validate(result, *status);
    resultImpl->fImpl = fmt->formatToValue(offset, unit, *status);
}

U_CAPI int32_t U_EXPORT2
ureldatefmt_combineDateAndTime( const URelativeDateTimeFormatter* reldatefmt,
                    const UChar *     relativeDateString,
                    int32_t           relativeDateStringLen,
                    const UChar *     timeString,
                    int32_t           timeStringLen,
                    UChar*            result,
                    int32_t           resultCapacity,
                    UErrorCode*       status )
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if (result == nullptr ? resultCapacity != 0 : resultCapacity < 0 ||
            (relativeDateString == nullptr ? relativeDateStringLen != 0 : relativeDateStringLen < -1) ||
            (timeString == nullptr ? timeStringLen != 0 : timeStringLen < -1)) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    UnicodeString relDateStr((UBool)(relativeDateStringLen == -1), relativeDateString, relativeDateStringLen);
    UnicodeString timeStr((UBool)(timeStringLen == -1), timeString, timeStringLen);
    UnicodeString res(result, 0, resultCapacity);
    ((RelativeDateTimeFormatter*)reldatefmt)->combineDateAndTime(relDateStr, timeStr, res, *status);
    if (U_FAILURE(*status)) {
        return 0;
    }
    return res.extract(result, resultCapacity, *status);
}

#endif /* !UCONFIG_NO_FORMATTING */


text:
module Support
  module ControllerMacros
    def logged_out
      before :each do
        @request.env['devise.mapping'] = Devise.mappings[:admin_user]
      end
    end

    def logged_in
      before :each do
        @request.env['devise.mapping'] = Devise.mappings[:admin_user]
        admin_user                     = create(:cdx_user, :admin)
        sign_in admin_user, scope: :admin_user
      end
    end
  end
end


text:
package instasarama_test

import (
	"encoding/json"
	"fmt"
)

type agentSpan struct {
	TraceID   string `json:"t"`
	ParentID  string `json:"p,omitempty"`
	SpanID    string `json:"s"`
	Timestamp uint64 `json:"ts"`
	Duration  uint64 `json:"d"`
	Name      string `json:"n"`
	From      struct {
		PID    string `json:"e"`
		HostID string `json:"h"`
	} `json:"f"`
	Batch struct {
		Size int `json:"s"`
	} `json:"b"`
	Kind int `json:"k"`
	Ec   int `json:"ec,omitempty"`
	Data struct {
		Service string             `json:"service"`
		Kafka   agentKafkaSpanData `json:"kafka"`
	} `json:"data"`
}

type agentKafkaSpanData struct {
	Service string `json:"service"`
	Access  string `json:"access"`
}

// unmarshalAgentSpan is a helper function that copies span data values
// into an agentSpan to not to depend on the implementation of instana.Recorder
func extractAgentSpan(span interface{}) (agentSpan, error) {
	d, err := json.Marshal(span)
	if err != nil {
		return agentSpan{}, fmt.Errorf("failed to marshal agent span data: %s", err)
	}

	var data agentSpan
	if err := json.Unmarshal(d, &data); err != nil {
		return agentSpan{}, fmt.Errorf("failed to unmarshal agent span data: %s", err)
	}

	return data, nil
}