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

package cpu

import (
	"sync"
	"time"
)

// rollingAvg holds the rolling average of the cpu load on the minio
// server over its lifetime
var rollingAvg *Load

// cpuMeasureInterval is the interval of time between two
// measurements of CPU load
const cpuLoadMeasureInterval = 5 * time.Second

// triggers the average load computation at server spawn
func init() {
	rollingAvg = &Load{
		Min: float64(0),
		Max: float64(0),
		Avg: float64(0),
	}
	var rollingSum float64
	var cycles float64
	go func() {
		for {
			time.Sleep(cpuLoadMeasureInterval)
			cycles = cycles + 1
			currLoad := GetLoad()
			if rollingAvg.Max < currLoad.Max || rollingAvg.Max == 0 {
				rollingAvg.Max = currLoad.Max
			}
			if rollingAvg.Min > currLoad.Min || rollingAvg.Min == 0 {
				rollingAvg.Min = currLoad.Min
			}
			rollingSum = rollingSum + currLoad.Avg
			rollingAvg.Avg = rollingSum / cycles
		}
	}()
}

const (
	// cpuLoadWindow is the interval of time for which the
	// cpu utilization is measured
	cpuLoadWindow = 200 * time.Millisecond

	// cpuLoadSampleSize is the number of samples measured
	// for calculating cpu utilization
	cpuLoadSampleSize = 3

	// endOfTime represents the end of time
	endOfTime = time.Duration(1<<63 - 1)
)

// Load holds CPU utilization % measured in three intervals of 200ms each
type Load struct {
	Avg   float64 `json:"avg"`
	Max   float64 `json:"max"`
	Min   float64 `json:"min"`
	Error string  `json:"error,omitempty"`
}

type counter struct{}

// GetHistoricLoad returns the historic CPU utilization of the current process
func GetHistoricLoad() Load {
	return *rollingAvg
}

// GetLoad returns the CPU utilization of the current process
// This function works by calcualating the amount of cpu clock
// cycles the current process used in a given time window
//
// This corresponds to the CPU utilization calculation done by
// tools like top. Here, we use the getclocktime with the
// CLOCK_PROCESS_CPUTIME_ID parameter to obtain the total number of
// clock ticks used by the process so far. Then we sleep for
// 200ms and obtain the the total number of clock ticks again. The
// difference between the two counts provides us the number of
// clock ticks used by the process in the 200ms interval.
//
// The ratio of clock ticks used (measured in nanoseconds) to number
// of nanoseconds in 200 milliseconds provides us the CPU usage
// for the process currently
func GetLoad() Load {
	vals := make(chan time.Duration, 3)
	wg := sync.WaitGroup{}
	for i := 0; i < cpuLoadSampleSize; i++ {
		cpuCounter, err := newCounter()
		if err != nil {
			return Load{
				Error: err.Error(),
			}
		}
		wg.Add(1)
		go func() {
			start := cpuCounter.now()
			time.Sleep(cpuLoadWindow)
			end := cpuCounter.now()
			vals <- end.Sub(start)
			wg.Done()
		}()
	}
	wg.Wait()

	sum := time.Duration(0)
	max := time.Duration(0)
	min := (endOfTime)
	for i := 0; i < cpuLoadSampleSize; i++ {
		val := <-vals
		sum = sum + val
		if val > max {
			max = val
		}
		if val < min {
			min = val
		}
	}
	close(vals)
	avg := sum / 3
	return Load{
		Avg:   toFixed4(float64(avg)/float64(200*time.Millisecond)) * 100,
		Max:   toFixed4(float64(max)/float64(200*time.Millisecond)) * 100,
		Min:   toFixed4(float64(min)/float64(200*time.Millisecond)) * 100,
		Error: "",
	}
}


text:
import Ember from 'ember';

/**
 * Template-only component
 */
export default Ember.Component.extend({
});

redpajama_set_name: RedPajamaGithub


text:
import {Tag} from 'cerebral/tags'
import isValidFormHelper from './helpers/isValidForm'
import isValidFormFactory from './factories/isValidForm'

export {default as form} from './form'
export {default as rules} from './rules'

export {default as changeField} from './chains/changeField'

export {default as validateField} from './factories/validateField'
export {default as validateForm} from './factories/validateForm'
export {default as resetForm} from './factories/resetForm'

export {default as formToJSON} from './helpers/formToJSON'
export {default as getFormFields} from './helpers/getFormFields'
export {default as getInvalidFormFields} from './helpers/getInvalidFormFields'

export function isValidForm (form) {
  if (typeof form === 'string' || form instanceof Tag) {
    return isValidFormFactory(form)
  }

  return isValidFormHelper(form)
}


text:
/*
 * compute_code.h
 *
 *  Created on: May 26, 2013
 *      Author: CongDanh
 */

#ifndef COMPUTE_CODE_H_
#define COMPUTE_CODE_H_

#include <stdint.h>

int getHotpCode(const uint8_t *secret, int secretLen, unsigned long step, int digits = 6);
int getTotpCode(const uint8_t *secret, int secretLen, int digits = 6);

#endif /* COMPUTE_CODE_H_ */


text:
ACCEPTED

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

#### Published in
Bot. Ztg. 25: 133 (1867)

#### Original name
Dermatiscum Nyl.

### Remarks
null


text:
/** \file os/win32/code/os_heap.c
 *  \brief Heap memory management service
 *
 * Implements functions for allocation and freeing
 * memory from and to heap respectively.
 */

#include <memory.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

#include "os_defs.h"
#include "os_heap.h"

static void *os__realloc(void *memblk, os_size_t size);

static void *(* ptr_malloc)(size_t) = malloc;
static void (* ptr_free)(void *) = free;
static void *(* ptr_realloc)(void *,size_t) = (void *(*)(void *,size_t))os__realloc;

static void *
os__realloc(
    void *memblk,
    os_size_t size)
{
    os_size_t oldsize;
    void *new_block;

    if (!memblk) {
        return os_malloc(size);
    }
    if (size == 0) {
        ptr_free(memblk);
        return NULL;
    }
    new_block = os_malloc(size);
    if (new_block) {
        oldsize = _msize(memblk);
        if (oldsize > size) {
            memcpy(new_block, memblk, size);
        } else {
            memcpy(new_block, memblk, oldsize);
        }
        ptr_free(memblk);
    }

    return new_block;
}

/** \brief Allocate memory from heap
 *
 * \b os_malloc calls \b ptr_malloc which is a function pointer
 * which defaults to \b malloc, but can be redefined via
 * \b os_heapSetService.
 */
void *
os_malloc (
    os_size_t size)
{
    return (ptr_malloc((size_t)size));
}

void *
os_realloc(
    void *memblk,
    os_size_t size)
{
    return (ptr_realloc(memblk, (size_t)size));
}

/** \brief Free memory to heap
 *
 * \b os_free calls \b ptr_free which is a function pointer
 * which defaults to \b free, but can be redefined via
 * \b os_heapSetService.
 */
void
os_free (
    void *ptr)
{
    if (ptr != NULL) {
        ptr_free (ptr);
    }
    return;
}

/** \brief Set heap memory management services
 *
 * \b os_heapSetService enables the feature to redefine the SPLICE-DDS
 * heap memory management functions. Either to specific functions
 * identified by \b pmalloc (pmalloc != NULL) and \b pfree
 * (pfree != NULL). Or back to the default values when \b pmalloc
 * = NULL and \b pfree = NULL.
 */
void
os_heapSetService (
    void *(* pmalloc)(os_size_t),
    void *(* prealloc)(void *,os_size_t),
    void (* pfree)(void *))
{
    assert (((pmalloc != NULL) && (prealloc != NULL) && (pfree != NULL)) ||
            ((pmalloc == NULL) && (prealloc == NULL) && (pfree == NULL)));
    if (pmalloc == NULL) {
	ptr_malloc = malloc;
        ptr_realloc = realloc;
	ptr_free = free;
    } else {
	ptr_malloc = (void *(*)(size_t))pmalloc;
        ptr_realloc = (void *(*)(void *,size_t))prealloc;
	ptr_free = pfree;
    }
    return;
}


text:
var Router = module.exports = exports = function() {
  this.routes = {
    'GET': {},
    'POST': {},
    'PUT': {},
    'PATCH': {},
    'DELETE': {}
  };
};

Router.prototype.get = function(route, cb) {
  this.routes['GET'][route] = cb;
};

Router.prototype.post = function(route, cb) {
  this.routes['POST'][route] = cb;
};

Router.prototype.put = function(route, cb) {
  this.routes['PUT'][route] = cb;
};

Router.prototype.patch = function(route, cb) {
  this.routes['PATCH'][route] = cb;
};

Router.prototype.delete = function(route, cb) {
  this.routes['DELETE'][route] = cb;
};

Router.prototype.fourOhFour = function(req, res) {
  res.writeHead(404, {
    'Content-Type': 'text/plain'
  });
  res.write('not found');
  res.end();
};

Router.prototype.route = function(req, res) {
  (this.routes[req.method][req.url] || this.fourOhFour)(req, res);
};


text:
package com.esri.arcgis.android.samples.routing;

import android.app.Activity;
import android.app.Fragment;
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.ListView;
import android.widget.Switch;
import android.widget.TextView;

/*
 * This fragment populates the Navigation Drawer with
 * a customized listview and also provides the interface
 * for communicating with the activity.
 */
public class RoutingListFragment extends Fragment implements
		ListView.OnItemClickListener, TextToSpeech.OnInitListener {
	public static ListView mDrawerList;
	onDrawerListSelectedListener mCallback;
	private TextToSpeech tts;
	private boolean isSoundOn = true;

	// Container Activity must implement this interface
	public interface onDrawerListSelectedListener {
		void onSegmentSelected(String segment);
	}

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
	}

	@Override
	public void onAttach(Activity activity) {

		super.onAttach(activity);

		try {
			mCallback = (onDrawerListSelectedListener) activity;
		} catch (ClassCastException e) {
			throw new ClassCastException(activity.toString()
					+ " must implement onDrawerListSelectedListener");
		}

		setHasOptionsMenu(true);

	}

	@Override
	public void onActivityCreated(Bundle savedInstanceState) {
		super.onActivityCreated(savedInstanceState);
		tts = new TextToSpeech(getActivity(), this);

		MyAdapter adapter = new MyAdapter(getActivity(),
				RoutingSample.curDirections);
		mDrawerList = (ListView) getActivity().findViewById(R.id.right_drawer);

		mDrawerList.setAdapter(adapter);
		mDrawerList.setOnItemClickListener(this);

		Switch sound_toggle = (Switch) getActivity().findViewById(R.id.switch1);
		sound_toggle.setOnCheckedChangeListener(new OnCheckedChangeListener() {

			@Override
			public void onCheckedChanged(CompoundButton buttonView,
					boolean isChecked) {
				isSoundOn = isChecked;
			}
		});

	}

	@Override
	public void onItemClick(AdapterView<?> parent, View view, int position,
			long id) {
		TextView segment = (TextView) view.findViewById(R.id.segment);
		RoutingSample.mDrawerLayout.closeDrawers();
		if (isSoundOn)
			speakOut(segment.getText().toString());
		mCallback.onSegmentSelected(segment.getText().toString());
	}

	private void speakOut(String text) {
		tts.speak(text, TextToSpeech.QUEUE_FLUSH, null);
	}

	@Override
	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
		inflater.inflate(R.menu.action_layout, menu);
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		switch (item.getItemId()) {
		case R.id.direction:
			if (RoutingSample.mDrawerLayout.isDrawerOpen(Gravity.END)) {
				RoutingSample.mDrawerLayout.closeDrawers();
			} else {
				RoutingSample.mDrawerLayout.openDrawer(Gravity.END);
			}
			return true;

		default:
			return super.onOptionsItemSelected(item);
		}
	}

	@Override
	public void onInit(int status) {

	}

	@Override
	public void onStop() {
		super.onStop();
		tts.shutdown();

	}

	@Override
	public void onDestroy() {
		super.onDestroy();
	}
}


text:
import {generator} from '../generator';

generator('export-variables', 'let-number');


text:
package jds;

public class BinaryTreeTest {

	public static void main(String[] args) {
		BinaryTree tree = new BinaryTree(5);
		tree.r.left = new Node(6);
		tree.r.right = new Node(7);

		tree.r.left.left = new Node(8);
		tree.r.left.left.left = tree.nil;
		tree.r.left.left.right = tree.nil;

		tree.r.left.right = new Node(9);

		tree.r.left.right.left = new Node(12);
		tree.r.left.right.right = new Node(13);
		tree.r.left.right.left.left = tree.nil;
		tree.r.left.right.left.right = tree.nil;
		tree.r.left.right.right.left = tree.nil;
		tree.r.left.right.right.right = tree.nil;

		tree.r.right.left = new Node(10);
		tree.r.right.left.right = tree.nil;
		tree.r.right.right = new Node(11);

		tree.r.right.left.left = new Node(14);
		tree.r.right.right.left = new Node(15);
		tree.r.right.right.left.left = tree.nil;
		tree.r.right.right.left.right = tree.nil;
		tree.r.right.right.right = new Node(16);
		tree.r.right.right.right.left = tree.nil;
		tree.r.right.right.right.right = tree.nil;

		tree.r.right.left.left.left = tree.nil;
		tree.r.right.left.left.right = tree.nil;

		tree.inOrderNumbersNonRecursive();
		System.out.println(tree.r.inorderN);
	}

}


text:
package fixtures.bodydatetime.implementation;

import retrofit2.Retrofit;
import fixtures.bodydatetime.Datetimes;
import com.google.common.reflect.TypeToken;
import com.microsoft.rest.ServiceCallback;
import com.microsoft.rest.ServiceFuture;
import com.microsoft.rest.ServiceResponse;
import fixtures.bodydatetime.models.ErrorException;
import java.io.IOException;
import okhttp3.ResponseBody;
import org.joda.time.DateTime;
import retrofit2.http.Body;
import retrofit2.http.GET;
import retrofit2.http.Headers;
import retrofit2.http.PUT;
import retrofit2.Response;
import rx.functions.Func1;
import rx.Observable;

/**
 * An instance of this class provides access to all the operations defined
 * in Datetimes.
 */
public class DatetimesImpl implements Datetimes {
    /** The Retrofit service to perform REST calls. */
    private DatetimesService service;
    /** The service client containing this operation class. */
    private AutoRestDateTimeTestServiceImpl client;

    /**
     * Initializes an instance of Datetimes.
     *
     * @param retrofit the Retrofit instance built from a Retrofit Builder.
     * @param client the instance of the service client containing this operation class.
     */
    public DatetimesImpl(Retrofit retrofit, AutoRestDateTimeTestServiceImpl client) {
        this.service = retrofit.create(DatetimesService.class);
        this.client = client;
    }

    /**
     * The interface defining all the services for Datetimes to be
     * used by Retrofit to perform actually REST calls.
     */
    interface DatetimesService {
        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getNull" })
        @GET("datetime/null")
        Observable<Response<ResponseBody>> getNull();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getInvalid" })
        @GET("datetime/invalid")
        Observable<Response<ResponseBody>> getInvalid();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getOverflow" })
        @GET("datetime/overflow")
        Observable<Response<ResponseBody>> getOverflow();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getUnderflow" })
        @GET("datetime/underflow")
        Observable<Response<ResponseBody>> getUnderflow();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putUtcMaxDateTime" })
        @PUT("datetime/max/utc")
        Observable<Response<ResponseBody>> putUtcMaxDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getUtcLowercaseMaxDateTime" })
        @GET("datetime/max/utc/lowercase")
        Observable<Response<ResponseBody>> getUtcLowercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getUtcUppercaseMaxDateTime" })
        @GET("datetime/max/utc/uppercase")
        Observable<Response<ResponseBody>> getUtcUppercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putLocalPositiveOffsetMaxDateTime" })
        @PUT("datetime/max/localpositiveoffset")
        Observable<Response<ResponseBody>> putLocalPositiveOffsetMaxDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalPositiveOffsetLowercaseMaxDateTime" })
        @GET("datetime/max/localpositiveoffset/lowercase")
        Observable<Response<ResponseBody>> getLocalPositiveOffsetLowercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalPositiveOffsetUppercaseMaxDateTime" })
        @GET("datetime/max/localpositiveoffset/uppercase")
        Observable<Response<ResponseBody>> getLocalPositiveOffsetUppercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putLocalNegativeOffsetMaxDateTime" })
        @PUT("datetime/max/localnegativeoffset")
        Observable<Response<ResponseBody>> putLocalNegativeOffsetMaxDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalNegativeOffsetUppercaseMaxDateTime" })
        @GET("datetime/max/localnegativeoffset/uppercase")
        Observable<Response<ResponseBody>> getLocalNegativeOffsetUppercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalNegativeOffsetLowercaseMaxDateTime" })
        @GET("datetime/max/localnegativeoffset/lowercase")
        Observable<Response<ResponseBody>> getLocalNegativeOffsetLowercaseMaxDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putUtcMinDateTime" })
        @PUT("datetime/min/utc")
        Observable<Response<ResponseBody>> putUtcMinDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getUtcMinDateTime" })
        @GET("datetime/min/utc")
        Observable<Response<ResponseBody>> getUtcMinDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putLocalPositiveOffsetMinDateTime" })
        @PUT("datetime/min/localpositiveoffset")
        Observable<Response<ResponseBody>> putLocalPositiveOffsetMinDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalPositiveOffsetMinDateTime" })
        @GET("datetime/min/localpositiveoffset")
        Observable<Response<ResponseBody>> getLocalPositiveOffsetMinDateTime();

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes putLocalNegativeOffsetMinDateTime" })
        @PUT("datetime/min/localnegativeoffset")
        Observable<Response<ResponseBody>> putLocalNegativeOffsetMinDateTime(@Body DateTime datetimeBody);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: fixtures.bodydatetime.Datetimes getLocalNegativeOffsetMinDateTime" })
        @GET("datetime/min/localnegativeoffset")
        Observable<Response<ResponseBody>> getLocalNegativeOffsetMinDateTime();

    }

    /**
     * Get null datetime value.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getNull() {
        return getNullWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get null datetime value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getNullAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getNullWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get null datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getNullAsync() {
        return getNullWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get null datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getNullWithServiceResponseAsync() {
        return service.getNull()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getNullDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getNullDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get invalid datetime value.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getInvalid() {
        return getInvalidWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get invalid datetime value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getInvalidAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getInvalidWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get invalid datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getInvalidAsync() {
        return getInvalidWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get invalid datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getInvalidWithServiceResponseAsync() {
        return service.getInvalid()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getInvalidDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getInvalidDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get overflow datetime value.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getOverflow() {
        return getOverflowWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get overflow datetime value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getOverflowAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getOverflowWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get overflow datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getOverflowAsync() {
        return getOverflowWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get overflow datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getOverflowWithServiceResponseAsync() {
        return service.getOverflow()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getOverflowDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getOverflowDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get underflow datetime value.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getUnderflow() {
        return getUnderflowWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get underflow datetime value.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getUnderflowAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getUnderflowWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get underflow datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getUnderflowAsync() {
        return getUnderflowWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get underflow datetime value.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getUnderflowWithServiceResponseAsync() {
        return service.getUnderflow()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getUnderflowDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getUnderflowDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @param datetimeBody the DateTime value
     */
    public void putUtcMaxDateTime(DateTime datetimeBody) {
        putUtcMaxDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putUtcMaxDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putUtcMaxDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putUtcMaxDateTimeAsync(DateTime datetimeBody) {
        return putUtcMaxDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putUtcMaxDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putUtcMaxDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putUtcMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putUtcMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value 9999-12-31t23:59:59.9999999z.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getUtcLowercaseMaxDateTime() {
        return getUtcLowercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value 9999-12-31t23:59:59.9999999z.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getUtcLowercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getUtcLowercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value 9999-12-31t23:59:59.9999999z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getUtcLowercaseMaxDateTimeAsync() {
        return getUtcLowercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value 9999-12-31t23:59:59.9999999z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getUtcLowercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getUtcLowercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getUtcLowercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getUtcLowercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getUtcUppercaseMaxDateTime() {
        return getUtcUppercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getUtcUppercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getUtcUppercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getUtcUppercaseMaxDateTimeAsync() {
        return getUtcUppercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value 9999-12-31T23:59:59.9999999Z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getUtcUppercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getUtcUppercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getUtcUppercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getUtcUppercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @param datetimeBody the DateTime value
     */
    public void putLocalPositiveOffsetMaxDateTime(DateTime datetimeBody) {
        putLocalPositiveOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putLocalPositiveOffsetMaxDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putLocalPositiveOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putLocalPositiveOffsetMaxDateTimeAsync(DateTime datetimeBody) {
        return putLocalPositiveOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putLocalPositiveOffsetMaxDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putLocalPositiveOffsetMaxDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putLocalPositiveOffsetMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putLocalPositiveOffsetMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalPositiveOffsetLowercaseMaxDateTime() {
        return getLocalPositiveOffsetLowercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalPositiveOffsetLowercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalPositiveOffsetLowercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalPositiveOffsetLowercaseMaxDateTimeAsync() {
        return getLocalPositiveOffsetLowercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalPositiveOffsetLowercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getLocalPositiveOffsetLowercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalPositiveOffsetLowercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalPositiveOffsetLowercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999+14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalPositiveOffsetUppercaseMaxDateTime() {
        return getLocalPositiveOffsetUppercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999+14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalPositiveOffsetUppercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalPositiveOffsetUppercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalPositiveOffsetUppercaseMaxDateTimeAsync() {
        return getLocalPositiveOffsetUppercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalPositiveOffsetUppercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getLocalPositiveOffsetUppercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalPositiveOffsetUppercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalPositiveOffsetUppercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @param datetimeBody the DateTime value
     */
    public void putLocalNegativeOffsetMaxDateTime(DateTime datetimeBody) {
        putLocalNegativeOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putLocalNegativeOffsetMaxDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putLocalNegativeOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putLocalNegativeOffsetMaxDateTimeAsync(DateTime datetimeBody) {
        return putLocalNegativeOffsetMaxDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put max datetime value with positive numoffset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putLocalNegativeOffsetMaxDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putLocalNegativeOffsetMaxDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putLocalNegativeOffsetMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putLocalNegativeOffsetMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999-14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalNegativeOffsetUppercaseMaxDateTime() {
        return getLocalNegativeOffsetUppercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999-14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalNegativeOffsetUppercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalNegativeOffsetUppercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalNegativeOffsetUppercaseMaxDateTimeAsync() {
        return getLocalNegativeOffsetUppercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31T23:59:59.9999999-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalNegativeOffsetUppercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getLocalNegativeOffsetUppercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalNegativeOffsetUppercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalNegativeOffsetUppercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalNegativeOffsetLowercaseMaxDateTime() {
        return getLocalNegativeOffsetLowercaseMaxDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalNegativeOffsetLowercaseMaxDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalNegativeOffsetLowercaseMaxDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalNegativeOffsetLowercaseMaxDateTimeAsync() {
        return getLocalNegativeOffsetLowercaseMaxDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get max datetime value with positive num offset 9999-12-31t23:59:59.9999999-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalNegativeOffsetLowercaseMaxDateTimeWithServiceResponseAsync() {
        return service.getLocalNegativeOffsetLowercaseMaxDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalNegativeOffsetLowercaseMaxDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalNegativeOffsetLowercaseMaxDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00Z.
     *
     * @param datetimeBody the DateTime value
     */
    public void putUtcMinDateTime(DateTime datetimeBody) {
        putUtcMinDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00Z.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putUtcMinDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putUtcMinDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00Z.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putUtcMinDateTimeAsync(DateTime datetimeBody) {
        return putUtcMinDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00Z.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putUtcMinDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putUtcMinDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putUtcMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putUtcMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00Z.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getUtcMinDateTime() {
        return getUtcMinDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00Z.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getUtcMinDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getUtcMinDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00Z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getUtcMinDateTimeAsync() {
        return getUtcMinDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00Z.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getUtcMinDateTimeWithServiceResponseAsync() {
        return service.getUtcMinDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getUtcMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getUtcMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @param datetimeBody the DateTime value
     */
    public void putLocalPositiveOffsetMinDateTime(DateTime datetimeBody) {
        putLocalPositiveOffsetMinDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putLocalPositiveOffsetMinDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putLocalPositiveOffsetMinDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putLocalPositiveOffsetMinDateTimeAsync(DateTime datetimeBody) {
        return putLocalPositiveOffsetMinDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putLocalPositiveOffsetMinDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putLocalPositiveOffsetMinDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putLocalPositiveOffsetMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putLocalPositiveOffsetMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalPositiveOffsetMinDateTime() {
        return getLocalPositiveOffsetMinDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalPositiveOffsetMinDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalPositiveOffsetMinDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalPositiveOffsetMinDateTimeAsync() {
        return getLocalPositiveOffsetMinDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00+14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalPositiveOffsetMinDateTimeWithServiceResponseAsync() {
        return service.getLocalPositiveOffsetMinDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalPositiveOffsetMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalPositiveOffsetMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @param datetimeBody the DateTime value
     */
    public void putLocalNegativeOffsetMinDateTime(DateTime datetimeBody) {
        putLocalNegativeOffsetMinDateTimeWithServiceResponseAsync(datetimeBody).toBlocking().single().body();
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @param datetimeBody the DateTime value
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> putLocalNegativeOffsetMinDateTimeAsync(DateTime datetimeBody, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(putLocalNegativeOffsetMinDateTimeWithServiceResponseAsync(datetimeBody), serviceCallback);
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> putLocalNegativeOffsetMinDateTimeAsync(DateTime datetimeBody) {
        return putLocalNegativeOffsetMinDateTimeWithServiceResponseAsync(datetimeBody).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Put min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @param datetimeBody the DateTime value
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> putLocalNegativeOffsetMinDateTimeWithServiceResponseAsync(DateTime datetimeBody) {
        if (datetimeBody == null) {
            throw new IllegalArgumentException("Parameter datetimeBody is required and cannot be null.");
        }
        return service.putLocalNegativeOffsetMinDateTime(datetimeBody)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = putLocalNegativeOffsetMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> putLocalNegativeOffsetMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @return the DateTime object if successful.
     */
    public DateTime getLocalNegativeOffsetMinDateTime() {
        return getLocalNegativeOffsetMinDateTimeWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<DateTime> getLocalNegativeOffsetMinDateTimeAsync(final ServiceCallback<DateTime> serviceCallback) {
        return ServiceFuture.fromResponse(getLocalNegativeOffsetMinDateTimeWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<DateTime> getLocalNegativeOffsetMinDateTimeAsync() {
        return getLocalNegativeOffsetMinDateTimeWithServiceResponseAsync().map(new Func1<ServiceResponse<DateTime>, DateTime>() {
            @Override
            public DateTime call(ServiceResponse<DateTime> response) {
                return response.body();
            }
        });
    }

    /**
     * Get min datetime value 0001-01-01T00:00:00-14:00.
     *
     * @return the observable to the DateTime object
     */
    public Observable<ServiceResponse<DateTime>> getLocalNegativeOffsetMinDateTimeWithServiceResponseAsync() {
        return service.getLocalNegativeOffsetMinDateTime()
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DateTime>>>() {
                @Override
                public Observable<ServiceResponse<DateTime>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DateTime> clientResponse = getLocalNegativeOffsetMinDateTimeDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<DateTime> getLocalNegativeOffsetMinDateTimeDelegate(Response<ResponseBody> response) throws ErrorException, IOException {
        return this.client.restClient().responseBuilderFactory().<DateTime, ErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<DateTime>() { }.getType())
                .registerError(ErrorException.class)
                .build(response);
    }

}


text:
package com.japlj.healthydiet.network;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;

public class MessagePlayerJoinInAnnouncementHandler implements IMessageHandler<MessagePlayerJoinInAnnouncement, MessagePlayerNutritionalConditions> {
	@Override
	public MessagePlayerNutritionalConditions onMessage(MessagePlayerJoinInAnnouncement message, MessageContext ctx) {
		String uuid = message.getUuid();
		EntityPlayer player = ctx.getServerHandler().playerEntity;

		if (player.getGameProfile().getId().toString().equals(uuid)) {
			return new MessagePlayerNutritionalConditions(player);
		}
		return null;
	}
}


text:
layout: page
title: Acevedo Black Motors Party
date: 2016-05-24
author: Walter Bates
tags: weekly links, java
status: published
summary: Vestibulum ultricies eros turpis, eget posuere.
banner: images/banner/meeting-01.jpg
booking:
  startDate: 12/04/2018
  endDate: 12/07/2018
  ctyhocn: MFDONHX
  groupCode: ABMP
published: true
---
Etiam iaculis mauris tortor, vitae gravida sapien fermentum mollis. Proin at libero libero. Praesent consectetur imperdiet odio. Quisque felis arcu, mattis eget convallis eget, porta eget elit. Aenean convallis ac odio varius tempor. Mauris lobortis ex sit amet mi commodo vehicula. Aenean a diam id sem iaculis accumsan. Ut fermentum aliquam turpis, vel porta lacus. Pellentesque ac lectus bibendum, elementum mi ut, lacinia sapien.

* Duis ac lacus at magna lacinia laoreet a in felis
* Donec ac est vel libero rutrum elementum
* Nullam eu leo tempor, pulvinar enim vitae, facilisis nunc
* Aenean sed quam id ex tempus ultrices at id eros.

In rhoncus magna nisi, id luctus ex sodales quis. Suspendisse eleifend commodo condimentum. Nullam ut fermentum orci. Aenean feugiat, metus a efficitur consequat, ante enim ultrices augue, quis rutrum lorem nunc et arcu. Phasellus molestie, leo ornare tincidunt vehicula, risus sem vestibulum tellus, eget aliquam risus diam malesuada mi. Mauris quis tempor arcu, porta consectetur sem. Proin viverra semper viverra. Cras urna leo, blandit suscipit massa eu, vestibulum consectetur augue. Nulla sed est aliquam, vestibulum enim sed, imperdiet ante. Phasellus aliquam ullamcorper luctus.


text: My personal Xcode theme.


text:
#pragma once
#include <aws/personalize/Personalize_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/personalize/model/MetricAttribute.h>
#include <utility>

namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;

namespace Utils
{
namespace Json
{
  class JsonValue;
} // namespace Json
} // namespace Utils
namespace Personalize
{
namespace Model
{
  class AWS_PERSONALIZE_API ListMetricAttributionMetricsResult
  {
  public:
    ListMetricAttributionMetricsResult();
    ListMetricAttributionMetricsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
    ListMetricAttributionMetricsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);

    /**
     *
The metrics for the specified metric attribution.

     */
    inline const Aws::Vector<MetricAttribute>& GetMetrics() const{ return m_metrics; }

    /**
     *
The metrics for the specified metric attribution.

     */
    inline void SetMetrics(const Aws::Vector<MetricAttribute>& value) { m_metrics = value; }

    /**
     *
The metrics for the specified metric attribution.

     */
    inline void SetMetrics(Aws::Vector<MetricAttribute>&& value) { m_metrics = std::move(value); }

    /**
     *
The metrics for the specified metric attribution.

     */
    inline ListMetricAttributionMetricsResult& WithMetrics(const Aws::Vector<MetricAttribute>& value) { SetMetrics(value); return *this;}

    /**
     *
The metrics for the specified metric attribution.

     */
    inline ListMetricAttributionMetricsResult& WithMetrics(Aws::Vector<MetricAttribute>&& value) { SetMetrics(std::move(value)); return *this;}

    /**
     *
The metrics for the specified metric attribution.

     */
    inline ListMetricAttributionMetricsResult& AddMetrics(const MetricAttribute& value) { m_metrics.push_back(value); return *this; }

    /**
     *
The metrics for the specified metric attribution.

     */
    inline ListMetricAttributionMetricsResult& AddMetrics(MetricAttribute&& value) { m_metrics.push_back(std::move(value)); return *this; }

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline const Aws::String& GetNextToken() const{ return m_nextToken; }

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline void SetNextToken(const Aws::String& value) { m_nextToken = value; }

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline void SetNextToken(Aws::String&& value) { m_nextToken = std::move(value); }

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline void SetNextToken(const char* value) { m_nextToken.assign(value); }

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline ListMetricAttributionMetricsResult& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline ListMetricAttributionMetricsResult& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}

    /**
     *
Specify the pagination token from a previous
     * ListMetricAttributionMetricsResponse request to retrieve the next
     * page of results.

     */
    inline ListMetricAttributionMetricsResult& WithNextToken(const char* value) { SetNextToken(value); return *this;}

  private:

    Aws::Vector<MetricAttribute> m_metrics;

    Aws::String m_nextToken;
  };

} // namespace Model
} // namespace Personalize
} // namespace Aws


text:
<?xml version='1.0' encoding='UTF-8'?>
<Document>
  <Header>
    <SchemaName>Location</SchemaName>
    <Identifier>location_geonames_2746954</Identifier>
    <DocumentState>public</DocumentState>
    <TimeStamp>1390753462080</TimeStamp>
    <SummaryFields>
      <Title>NL > North Brabant > Spekt</Title>
    </SummaryFields>
  </Header>
  <Body>
    <Location>
      <GeopoliticalHierarchy>NL,North Brabant,Spekt</GeopoliticalHierarchy>
      <LocationName>
        <Appelation>Spekt</Appelation>
        <LocationNameType>populated place</LocationNameType>
        <Comments></Comments>
      </LocationName>
      <Coordinates>
        <Longitude>5.53889</Longitude>
        <Latitude>51.495</Latitude>
      </Coordinates>
      <GeonamesURI>http://www.geonames.org/2746954</GeonamesURI>
      <WikipediaLink/>
      <DbpediaLink/>
    </Location>
  </Body>
</Document>


text:
package io.s4.zeno.util;

import java.util.List;

import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.ACL;

// TODO: Auto-generated Javadoc
/**
 * The Class ZenoDefs.
 */
public class ZenoDefs {

    /** The Constant emptyBytes. */
    public static final byte[] emptyBytes = {};

    /** The Constant zkACL. */
    public static final List<ACL> zkACL = ZooDefs.Ids.OPEN_ACL_UNSAFE;

    /** The Constant emptyString. */
    public static final String emptyString = "";
}


text: assert_errors "$1" check . --all --no-flowlib --show-all-errors --include-warnings --color=always


text:
package com.jdroid.android.uri;

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

public class NoSegmentsUriHandler implements UriHandler {

	@Override
	public Boolean matches(Uri uri) {
		return uri.getPathSegments().isEmpty();
	}

	@Override
	public Intent getStartIntent(Context context, Uri uri) {
		return null;
	}
}


text:
@interface HDBaseViewModel ()
@property (nonatomic, strong, readwrite) RACSubject *errors;
@property (nonatomic, strong, readwrite) RACSubject *showHUDSignal;
@property (nonatomic, strong, readwrite) RACSubject *willDisappearSignal;
@end

@implementation HDBaseViewModel

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    HDBaseViewModel *viewModel = [super allocWithZone:zone];

    @weakify(viewModel)

    [[viewModel
      rac_signalForSelector:@selector(initWithParams:)]
    	subscribeNext:^(id x) {
            @strongify(viewModel)
            [viewModel HDInitialize];
        }];

    return viewModel;
}

- (instancetype)initWithParams:(NSDictionary *)params {
    self = [super init];
    if (self) {
        self.shouldRequestRemoteDataOnViewDidLoad = YES;
        if (params) {
            [self setValuesForKeysWithDictionary:params];
        }
    }
    return self;
}

- (instancetype)initWithBlock:(VoidBlock_id)block{
    self = [super init];
    if (self) {
        self.shouldRequestRemoteDataOnViewDidLoad = YES;
        if (block) {
            block(self);
        }
    }
    return self;
}

- (__kindof UIViewController *)routerVC{

    NSString * className = [[[NSStringFromClass([self class]) componentsSeparatedByString:@"iewModel"] firstObject] stringByAppendingString:@"C"];

    NSParameterAssert([NSClassFromString(className) instancesRespondToSelector:@selector(initWithViewModel:)]);

    return [[NSClassFromString(className) alloc] initWithViewModel:self];

}

- (RACSubject *)errors {
    if (!_errors) _errors = [RACSubject subject];
    return _errors;
}

- (RACSubject *)showHUDSignal{
    if (!_showHUDSignal) {
        _showHUDSignal = [RACSubject subject];
    }
    return _showHUDSignal;
}

- (RACSubject *)willDisappearSignal {
    if (!_willDisappearSignal) _willDisappearSignal = [RACSubject subject];
    return _willDisappearSignal;
}

- (void)HDInitialize{

}

@end


text:
using namespace std;

float eval_aPar ( CParticle &p, C3<float> r, const float *r_GC, const float *bDotGradB, int nGC );
float eval_vPer ( CParticle &p, C3<float> r, const float *r_b0, const C3<float> *b0_CYL, int n );
C3<float> eval_vGC ( CParticle &p, C3<float> r, const float vPer, const float vPar, const float *r_b0, const C3<float> *b0_CYL, int n, const float *r_GC, const C3<float> *curv_CYL, const C3<float> *grad_CYL, int nGC );
float GetAlpComp ( const float vPer, const float phs );
float GetBetComp ( const float vPer, const float phs );

#endif


text:
package com.microsoft.azure.management.containerregistry.v2019_06_01_preview.implementation;

import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.Task;
import com.microsoft.azure.arm.model.implementation.CreatableUpdatableImpl;
import rx.Observable;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TaskUpdateParameters;
import java.util.Map;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.IdentityProperties;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.ProvisioningState;
import org.joda.time.DateTime;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TaskStatus;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.PlatformProperties;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.AgentProperties;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TaskStepProperties;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TriggerProperties;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.Credentials;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.PlatformUpdateParameters;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TaskStepUpdateParameters;
import com.microsoft.azure.management.containerregistry.v2019_06_01_preview.TriggerUpdateParameters;
import rx.functions.Func1;

class TaskImpl extends CreatableUpdatableImpl<Task, TaskInner, TaskImpl> implements Task, Task.Definition, Task.Update {
    private final ContainerRegistryManager manager;
    private String resourceGroupName;
    private String registryName;
    private String taskName;
    private TaskUpdateParameters updateParameter;

    TaskImpl(String name, ContainerRegistryManager manager) {
        super(name, new TaskInner());
        this.manager = manager;
        // Set resource name
        this.taskName = name;
        //
        this.updateParameter = new TaskUpdateParameters();
    }

    TaskImpl(TaskInner inner, ContainerRegistryManager manager) {
        super(inner.name(), inner);
        this.manager = manager;
        // Set resource name
        this.taskName = inner.name();
        // set resource ancestor and positional variables
        this.resourceGroupName = IdParsingUtils.getValueFromIdByName(inner.id(), "resourceGroups");
        this.registryName = IdParsingUtils.getValueFromIdByName(inner.id(), "registries");
        this.taskName = IdParsingUtils.getValueFromIdByName(inner.id(), "tasks");
        //
        this.updateParameter = new TaskUpdateParameters();
    }

    @Override
    public ContainerRegistryManager manager() {
        return this.manager;
    }

    @Override
    public Observable<Task> createResourceAsync() {
        TasksInner client = this.manager().inner().tasks();
        return client.createAsync(this.resourceGroupName, this.registryName, this.taskName, this.inner())
            .map(new Func1<TaskInner, TaskInner>() {
               @Override
               public TaskInner call(TaskInner resource) {
                   resetCreateUpdateParameters();
                   return resource;
               }
            })
            .map(innerToFluentMap(this));
    }

    @Override
    public Observable<Task> updateResourceAsync() {
        TasksInner client = this.manager().inner().tasks();
        return client.updateAsync(this.resourceGroupName, this.registryName, this.taskName, this.updateParameter)
            .map(new Func1<TaskInner, TaskInner>() {
               @Override
               public TaskInner call(TaskInner resource) {
                   resetCreateUpdateParameters();
                   return resource;
               }
            })
            .map(innerToFluentMap(this));
    }

    @Override
    protected Observable<TaskInner> getInnerAsync() {
        TasksInner client = this.manager().inner().tasks();
        return client.getAsync(this.resourceGroupName, this.registryName, this.taskName);
    }

    @Override
    public boolean isInCreateMode() {
        return this.inner().id() == null;
    }

    private void resetCreateUpdateParameters() {
        this.updateParameter = new TaskUpdateParameters();
    }

    @Override
    public AgentProperties agentConfiguration() {
        return this.inner().agentConfiguration();
    }

    @Override
    public DateTime creationDate() {
        return this.inner().creationDate();
    }

    @Override
    public Credentials credentials() {
        return this.inner().credentials();
    }

    @Override
    public String id() {
        return this.inner().id();
    }

    @Override
    public IdentityProperties identity() {
        return this.inner().identity();
    }

    @Override
    public String location() {
        return this.inner().location();
    }

    @Override
    public String name() {
        return this.inner().name();
    }

    @Override
    public PlatformProperties platform() {
        return this.inner().platform();
    }

    @Override
    public ProvisioningState provisioningState() {
        return this.inner().provisioningState();
    }

    @Override
    public TaskStatus status() {
        return this.inner().status();
    }

    @Override
    public TaskStepProperties step() {
        return this.inner().step();
    }

    @Override
    public Map<String, String> tags() {
        return this.inner().getTags();
    }

    @Override
    public Integer timeout() {
        return this.inner().timeout();
    }

    @Override
    public TriggerProperties trigger() {
        return this.inner().trigger();
    }

    @Override
    public String type() {
        return this.inner().type();
    }

    @Override
    public TaskImpl withExistingRegistry(String resourceGroupName, String registryName) {
        this.resourceGroupName = resourceGroupName;
        this.registryName = registryName;
        return this;
    }

    @Override
    public TaskImpl withLocation(String location) {
        this.inner().withLocation(location);
        return this;
    }

    @Override
    public TaskImpl withPlatform(PlatformProperties platform) {
        this.inner().withPlatform(platform);
        return this;
    }

    @Override
    public TaskImpl withStep(TaskStepProperties step) {
        this.inner().withStep(step);
        return this;
    }

    @Override
    public TaskImpl withTrigger(TriggerProperties trigger) {
        this.inner().withTrigger(trigger);
        return this;
    }

    @Override
    public TaskImpl withPlatform(PlatformUpdateParameters platform) {
        this.updateParameter.withPlatform(platform);
        return this;
    }

    @Override
    public TaskImpl withStep(TaskStepUpdateParameters step) {
        this.updateParameter.withStep(step);
        return this;
    }

    @Override
    public TaskImpl withTrigger(TriggerUpdateParameters trigger) {
        this.updateParameter.withTrigger(trigger);
        return this;
    }

    @Override
    public TaskImpl withAgentConfiguration(AgentProperties agentConfiguration) {
        if (isInCreateMode()) {
            this.inner().withAgentConfiguration(agentConfiguration);
        } else {
            this.updateParameter.withAgentConfiguration(agentConfiguration);
        }
        return this;
    }

    @Override
    public TaskImpl withCredentials(Credentials credentials) {
        if (isInCreateMode()) {
            this.inner().withCredentials(credentials);
        } else {
            this.updateParameter.withCredentials(credentials);
        }
        return this;
    }

    @Override
    public TaskImpl withIdentity(IdentityProperties identity) {
        if (isInCreateMode()) {
            this.inner().withIdentity(identity);
        } else {
            this.updateParameter.withIdentity(identity);
        }
        return this;
    }

    @Override
    public TaskImpl withStatus(TaskStatus status) {
        if (isInCreateMode()) {
            this.inner().withStatus(status);
        } else {
            this.updateParameter.withStatus(status);
        }
        return this;
    }

    @Override
    public TaskImpl withTags(Map<String, String> tags) {
        if (isInCreateMode()) {
            this.inner().withTags(tags);
        } else {
            this.updateParameter.withTags(tags);
        }
        return this;
    }

    @Override
    public TaskImpl withTimeout(Integer timeout) {
        if (isInCreateMode()) {
            this.inner().withTimeout(timeout);
        } else {
            this.updateParameter.withTimeout(timeout);
        }
        return this;
    }

}


text:
#ifndef INCLUDE_merge_h__
#define INCLUDE_merge_h__

#include "vector.h"
#include "commit_list.h"
#include "pool.h"

#include "git2/merge.h"
#include "git2/types.h"

#define GIT_MERGE_MSG_FILE		"MERGE_MSG"
#define GIT_MERGE_MODE_FILE		"MERGE_MODE"
#define GIT_MERGE_FILE_MODE		0666

#define GIT_MERGE_TREE_RENAME_THRESHOLD	50
#define GIT_MERGE_TREE_TARGET_LIMIT		1000

/** Types of changes when files are merged from branch to branch. */
typedef enum {
	/* No conflict - a change only occurs in one branch. */
	GIT_MERGE_DIFF_NONE = 0,

	/* Occurs when a file is modified in both branches. */
	GIT_MERGE_DIFF_BOTH_MODIFIED = (1 << 0),

	/* Occurs when a file is added in both branches. */
	GIT_MERGE_DIFF_BOTH_ADDED = (1 << 1),

	/* Occurs when a file is deleted in both branches. */
	GIT_MERGE_DIFF_BOTH_DELETED = (1 << 2),

	/* Occurs when a file is modified in one branch and deleted in the other. */
	GIT_MERGE_DIFF_MODIFIED_DELETED = (1 << 3),

	/* Occurs when a file is renamed in one branch and modified in the other. */
	GIT_MERGE_DIFF_RENAMED_MODIFIED = (1 << 4),

	/* Occurs when a file is renamed in one branch and deleted in the other. */
	GIT_MERGE_DIFF_RENAMED_DELETED = (1 << 5),

	/* Occurs when a file is renamed in one branch and a file with the same
	 * name is added in the other.  Eg, A->B and new file B.  Core git calls
	 * this a "rename/delete". */
	GIT_MERGE_DIFF_RENAMED_ADDED = (1 << 6),

	/* Occurs when both a file is renamed to the same name in the ours and
	 * theirs branches.  Eg, A->B and A->B in both.  Automergeable. */
	GIT_MERGE_DIFF_BOTH_RENAMED = (1 << 7),

	/* Occurs when a file is renamed to different names in the ours and theirs
	 * branches.  Eg, A->B and A->C. */
	GIT_MERGE_DIFF_BOTH_RENAMED_1_TO_2 = (1 << 8),

	/* Occurs when two files are renamed to the same name in the ours and
	 * theirs branches.  Eg, A->C and B->C. */
	GIT_MERGE_DIFF_BOTH_RENAMED_2_TO_1 = (1 << 9),

	/* Occurs when an item at a path in one branch is a directory, and an
	 * item at the same path in a different branch is a file. */
	GIT_MERGE_DIFF_DIRECTORY_FILE = (1 << 10),

	/* The child of a folder that is in a directory/file conflict. */
	GIT_MERGE_DIFF_DF_CHILD = (1 << 11),
} git_merge_diff_type_t;

typedef struct {
	git_repository *repo;
	git_pool pool;

	/* Vector of git_index_entry that represent the merged items that
	 * have been staged, either because only one side changed, or because
	 * the two changes were non-conflicting and mergeable.  These items
	 * will be written as staged entries in the main index.
	 */
	git_vector staged;

	/* Vector of git_merge_diff entries that represent the conflicts that
	 * have not been automerged.  These items will be written to high-stage
	 * entries in the main index.
	 */
	git_vector conflicts;

	/* Vector of git_merge_diff that have been automerged.  These items
	 * will be written to the REUC when the index is produced.
	 */
	git_vector resolved;
} git_merge_diff_list;

/**
 * Description of changes to one file across three trees.
 */
typedef struct {
	git_merge_diff_type_t type;

	git_index_entry ancestor_entry;

	git_index_entry our_entry;
	git_delta_t our_status;

	git_index_entry their_entry;
	git_delta_t their_status;

	int binary:1;
} git_merge_diff;

int git_merge__bases_many(
	git_commit_list **out,
	git_revwalk *walk,
	git_commit_list_node *one,
	git_vector *twos);

/*
 * Three-way tree differencing
 */

git_merge_diff_list *git_merge_diff_list__alloc(git_repository *repo);

int git_merge_diff_list__find_differences(git_merge_diff_list *merge_diff_list,
	const git_tree *ancestor_tree,
	const git_tree *ours_tree,
	const git_tree *theirs_tree);

int git_merge_diff_list__find_renames(git_repository *repo, git_merge_diff_list *merge_diff_list, const git_merge_options *opts);

void git_merge_diff_list__free(git_merge_diff_list *diff_list);

/* Merge metadata setup */

int git_merge__setup(
	git_repository *repo,
	const git_annotated_commit *our_head,
	const git_annotated_commit *heads[],
	size_t heads_len);

int git_merge__check_result(git_repository *repo, git_index *index_new);

int git_merge__append_conflicts_to_merge_msg(git_repository *repo, git_index *index);

#endif


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.yanglin.dao.LossaccessmentVehicleMapper" >
  <resultMap id="BaseResultMap" type="com.yanglin.model.LossaccessmentVehicle" >
    <!--
      WARNING - @mbggenerated
      This element is automatically generated by MyBatis Generator, do not modify.
    -->
    <result column="baoanhao" property="baoanhao" jdbcType="VARCHAR" />
    <result column="shifou_biaodiche" property="shifouBiaodiche" jdbcType="VARCHAR" />
    <result column="chepaihao" property="chepaihao" jdbcType="VARCHAR" />
    <result column="VIN" property="vin" jdbcType="VARCHAR" />
    <result column="dingsun_chexing" property="dingsunChexing" jdbcType="VARCHAR" />
    <result column="zuoweishu" property="zuoweishu" jdbcType="VARCHAR" />
    <result column="cheliang_zhonglei" property="cheliangZhonglei" jdbcType="VARCHAR" />
    <result column="shiyongxingzhi" property="shiyongxingzhi" jdbcType="VARCHAR" />
    <result column="ranliao_leixing" property="ranliaoLeixing" jdbcType="VARCHAR" />
    <result column="peiliang" property="peiliang" jdbcType="DECIMAL" />
    <result column="biansuxiang_leixing" property="biansuxiangLeixing" jdbcType="VARCHAR" />
    <result column="xingshi_lichengshu" property="xingshiLichengshu" jdbcType="BIGINT" />
    <result column="shengchan_nianfen" property="shengchanNianfen" jdbcType="TIMESTAMP" />
    <result column="shiyong_nianxian" property="shiyongNianxian" jdbcType="INTEGER" />
  </resultMap>

  <select id="getVehicleInfoByClaimAndBrandNumber" resultMap="BaseResultMap">
  	select * from lossaccessment_vehicle where baoanhao = #{baoanhao} and chepaihao = #{chepaihao}
  </select>
</mapper>