text:
//
//  JCCardView.m
//  JCCardView
//
//  Created by Cerko on 2017/9/22.
//  Copyright © 2017年 Cerko. All rights reserved.
//

#import "JCCardView.h"
#import <objc/runtime.h>
#import "Masonry.h"

#define RADIANS_TO_DEGREES(radians) ((radians) * (180.0 / M_PI))

#define DEGREES_TO_RADIANS(angle) ((angle) / 180.0 * M_PI)

@implementation NSMutableArray (JCQueue)

- (void)jc_enqueue:(id)obj{
    [self addObject:obj];
}
- (id)jc_dequeueFromTail{
    id obj = [self lastObject];
    if (!obj) {
        return nil;
    }

    [self removeObject:obj];
    return obj;
}

- (id)jc_dequeue{
    id obj = self.firstObject;

    if (!obj) {
        return nil;
    }

    [self removeObject:obj];
    return obj;
}

- (void)jc_push:(id)obj{
    [self addObject:obj];
}
- (nullable id)jc_pop{
    id obj = self.lastObject;
    if (!obj) {
        return nil;
    }
    [self removeObject:obj];
    return obj;
}

- (void)jc_enqueueToHead:(id)obj{
    [self insertObject:obj atIndex:0];
}

@end

@implementation NSObject (JCEx)

- (void)setJc_obj:(id)jc_obj{
    objc_setAssociatedObject(self, @selector(jc_obj), jc_obj, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (id)jc_obj{
    return objc_getAssociatedObject(self, _cmd);
}

@end

@interface UIView (JCCardViewInternal)

@property (nonatomic, strong) NSString *jc_internalIdentifier;

@end

@implementation UIView (JCCardViewInternal)

- (void)setJc_internalIdentifier:(NSString *)jc_internalIdentifier{
    objc_setAssociatedObject(self, @selector(jc_internalIdentifier), jc_internalIdentifier, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (NSString *)jc_internalIdentifier{
    return objc_getAssociatedObject(self, _cmd);
}

@end

@interface JCUndoState : NSObject

@property (nonatomic, assign) JCCardViewSwipeDirection direction;

@end

@implementation JCUndoState

@end

@interface JCCardView ()

/**
 当前显示中的所有视图
 */
@property (nonatomic, strong) NSMutableArray <__kindof UIView *> *itemViews;

#pragma mark 缓存相关
@property (nonatomic, strong) NSMutableDictionary <NSString *, NSMutableArray <__kindof UIView *> *> *reusebleItemViews;

@property (nonatomic, strong) NSMutableDictionary <NSString *, Class> *registerdItemClazz;

#pragma mark - 回退
@property (nonatomic, strong) NSMutableArray <JCUndoState *> *undoStack;//用来记录一下划走的状态

#pragma mark 手势相关
@property (nonatomic, strong, nullable) UIView *selectedView;//当前滑动中的视图

@property (nonatomic, assign) JCCardViewSwipeDirection direction;//滑动方向

@property (nonatomic, assign) CGPoint translation;//当前的移动距离

@property (nonatomic, assign) CGFloat progress;//滑动进度 0 ~ 1

@property (nonatomic, strong, nullable) UIView *tempHandlingView;//当前触发了移除条件正要移除的视图

@property (nonatomic, assign, getter=isAnimating) BOOL animating;//当前是否正在做动画

@end

@implementation JCCardView

- (instancetype)initWithCoder:(NSCoder *)aDecoder{
    if (self = [super initWithCoder:aDecoder]) {
        [self setup];
    }
    return self;
}

- (instancetype)initWithFrame:(CGRect)frame{
    if (self = [super initWithFrame:frame]) {
        [self setup];
    }
    return self;
}

- (void)setup{
    _scaleOffset = 0.05;
    _translationYOffset = 15;
    _maxDetectiveDistance = 100.f;
    _maxRadius = DEGREES_TO_RADIANS(5);
    _translationForRemovingItem = CGPointMake(400, 100);
    _animationDuration = 0.25;
    UIPanGestureRecognizer *ges = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(onPanGes:)];
    [self addGestureRecognizer:ges];

    UITapGestureRecognizer *tapGes = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(onTapGes:)];
    [self addGestureRecognizer:tapGes];
}

- (void)onTapGes:(UITapGestureRecognizer *)ges{
    if (self.isAnimating) {
        return;
    }

    if (!self.itemViews.count) {
        return;
    }

    if (self.cardItemDidClickBlock) {
        self.cardItemDidClickBlock(self, self.itemViews.firstObject, self.currentShowingItemIdx);
    }

}

- (void)onPanGes:(UIPanGestureRecognizer *)ges{
    if (self.isAnimating) {
        return;
    }

    if (UIGestureRecognizerStateBegan == ges.state) {
        self.selectedView = self.itemViews.firstObject;
        return;
    }

    if (!self.selectedView) {
        return;
    }

    if (UIGestureRecognizerStateChanged == ges.state) {
        CGPoint translation = [ges translationInView:self];
        self.direction = translation.x > 0 ? JCCardViewSwipeDirectionRight : JCCardViewSwipeDirectionLeft;
        self.translation = translation;
        //进度
        self.progress = MAX(0, MIN(1, fabs(translation.x / self.maxDetectiveDistance)));

        //回调
        if (self.itemPanningBlock) {
            self.itemPanningBlock(self, self.selectedView, self.currentShowingItemIdx, _progress);
        }

        self.selectedView.transform = CGAffineTransformMakeRotation(self.direction * self.progress * self.maxRadius);

        [self setNeedsUpdateConstraints];
        [self layoutIfNeeded];
        return;
    }

    if (UIGestureRecognizerStateEnded == ges.state) {

        BOOL (^clearBlock)() = ^(){
            self.translation = CGPointZero;
            self.progress = 0;
            self.tempHandlingView = self.selectedView;
            self.selectedView = nil;//这里设为nil,因为更新约束的函数中会根据此值来约束
            BOOL canBeginAnimation = YES;
            if (self.cardItemAnimationCanBegenBlock) {
                canBeginAnimation = self.cardItemAnimationCanBegenBlock(self, self.tempHandlingView, self.currentShowingItemIdx, self.direction);
            }

            return canBeginAnimation;
        };

        //判断是否需要恢复
        BOOL isNeedResumeCardItem = JCCardViewSwipeDirectionNone != self.direction && self.progress < 1;

        if (isNeedResumeCardItem) {
            self.direction = JCCardViewSwipeDirectionNone;
        }

        //清理一些值
        BOOL canAnimationBegin = clearBlock();
        if (!canAnimationBegin) {
            return;
        }

        if (isNeedResumeCardItem) {
            [self resumeCardItems];
        }else{
            [self swipeCardItem];
        }

        return;
    }
}

- (void)resumeCardItems{
    if (self.isAnimating) {
        return;
    }

    if (self.cardItemAnimationWillBeginBlock) {
        self.cardItemAnimationWillBeginBlock(self, self.tempHandlingView, self.currentShowingItemIdx, self.direction);
    }

    [self setNeedsUpdateConstraints];
    [self setNeedsLayout];
    self.animating = YES;
    [UIView animateWithDuration:self.animationDuration animations:^{
        self.tempHandlingView.transform = CGAffineTransformIdentity;
        [self layoutIfNeeded];
    } completion:^(BOOL finished) {
        self.tempHandlingView = nil;
        self.animating = NO;
    }];
}

- (void)swipeCardItemToDirection:(JCCardViewSwipeDirection)direction{
    if (self.isAnimating) {
        return;
    }
    self.direction = direction;
    [self swipeCardItem];
}

- (void)swipeCardItem{
    self.tempHandlingView = [self.itemViews jc_dequeue];

    if (self.cardItemAnimationWillBeginBlock) {
        self.cardItemAnimationWillBeginBlock(self, self.tempHandlingView, self.currentShowingItemIdx, self.direction);
    }

    if (self.cardItemWillDisapearBlock) {
        self.cardItemWillDisapearBlock(self, self.tempHandlingView, self.currentShowingItemIdx, self.direction);
    }

    [self.tempHandlingView mas_remakeConstraints:^(MASConstraintMaker *make) {
        make.size.equalTo(self);
        make.center.centerOffset(CGPointMake(self.direction * self.translationForRemovingItem.x, self.translationForRemovingItem.y));
        make.size.equalTo(self);
    }];

    [self fillCardItemsWithcompletion:^{

        //缓存
        NSString *identifier = self.tempHandlingView.jc_internalIdentifier;
        if (identifier.length) {
            NSMutableArray <UIView *> *itemViews = self.reusebleItemViews[identifier];
            if (!itemViews) {
                itemViews = [NSMutableArray array];
                self.reusebleItemViews[identifier] = itemViews;
            }
            [itemViews jc_enqueue:self.tempHandlingView];
        }
        self.tempHandlingView.transform = CGAffineTransformIdentity;
        [self.tempHandlingView removeFromSuperview];

        self.tempHandlingView = nil;

        //当前显示的视图索引++,并回调
        self.currentShowingItemIdx ++;

        //入撤销栈
        JCUndoState *state = [[JCUndoState alloc] init];
        state.direction = self.direction;
        [self.undoStack jc_push:state];

        self.direction = JCCardViewSwipeDirectionNone;

    }];
}

- (void)continueCardItemAnimation{
    switch (self.direction) {
        case JCCardViewSwipeDirectionNone:
            [self resumeCardItems];
            break;
        case JCCardViewSwipeDirectionLeft:
            [self swipeCardItemToDirection:JCCardViewSwipeDirectionLeft];
            break;
        case JCCardViewSwipeDirectionRight:
            [self swipeCardItemToDirection:JCCardViewSwipeDirectionRight];
            break;
    }
}

- (void)reloadCardItems{
    if (self.isAnimating) {
        return;
    }

    self.willLoadingItemIdx = 0;
    self.currentShowingItemIdx = 0;
    [self.itemViews makeObjectsPerformSelector:@selector(removeFromSuperview)];
    [self.itemViews removeAllObjects];
    [self.undoStack removeAllObjects];

    [self fillCardItems];
}

- (void)refreshCardItems{
    if (self.isAnimating) {
        return;
    }

    //如果当前正在显示某个视图,则调用willDisapear回调
    if (self.itemViews.count) {
        if (self.cardItemWillDisapearBlock) {
            self.cardItemWillDisapearBlock(self, self.itemViews.firstObject, self.currentShowingItemIdx, self.direction);
        }
    }
    self.willLoadingItemIdx -= self.itemViews.count;
    [self.itemViews makeObjectsPerformSelector:@selector(removeFromSuperview)];
    [self.itemViews removeAllObjects];
    [self.undoStack removeAllObjects];

    [self fillCardItems];

}

- (void)fillCardItems{
    [self fillCardItemsWithcompletion:NULL];
}

- (void)fillCardItemsWithcompletion:(nullable  void (^)())completion{
    while (self.itemViews.count < _maxCardItemCount + 1) {
        if (self.cardItemGetBlock) {
            UIView *obj = self.cardItemGetBlock(self, self.willLoadingItemIdx);
            if (!obj) {
                break;
            }
            obj.frame = CGRectInset(self.bounds, _translationYOffset, _translationYOffset);
            [self insertSubview:obj atIndex:0];
            [self.itemViews jc_enqueue:obj];

            //加载过的数据的索引+1
            self.willLoadingItemIdx ++;
        }else
            return;
    }

    [self setNeedsUpdateConstraints];
    self.animating = YES;
    [UIView animateWithDuration:self.animationDuration animations:^{
        [self layoutIfNeeded];
    } completion:^(BOOL finished) {
        if (completion) {
            completion();
        }

        if (self.cardItemDidApearBlock) {
            self.cardItemDidApearBlock(self, self.itemViews.firstObject, self.currentShowingItemIdx);
        }
        self.animating = NO;
    }];
}

- (void)undo{
    if (self.isAnimating) {
        return;
    }

    if (self.currentShowingItemIdx <= 0) {
        return;
    }
    //最顶层的即将消失
    UIView *viewWillDisappear = self.itemViews.firstObject;
    if (viewWillDisappear) {
        if (self.cardItemWillDisapearBlock) {
            self.cardItemWillDisapearBlock(self, viewWillDisappear, self.currentShowingItemIdx, self.direction);
        }
    }

    //从屏幕外飞回视图
    self.currentShowingItemIdx--;

    JCUndoState *undoStae = [self.undoStack jc_pop];
    JCCardViewSwipeDirection direction = undoStae.direction;

    //要回显的视图,设置center,才能从屏幕外飞回来
    NSInteger idx = self.currentShowingItemIdx;
    UIView *obj = self.cardItemGetBlock(self, idx);
    obj.frame = CGRectInset(self.bounds, _translationYOffset, _translationYOffset);
    obj.center = CGPointMake(CGRectGetMidX(obj.frame) + direction * self.translationForRemovingItem.x, CGRectGetMidY(obj.frame));

    [self addSubview:obj];

    [self.itemViews jc_enqueueToHead:obj];

    //如果当前的显示总数大于了最大显示数目,则去掉队尾的那一个
    if (self.itemViews.count > _maxCardItemCount + 1) {
        UIView *removingObj = [self.itemViews jc_dequeueFromTail];
        [removingObj removeFromSuperview];
        self.willLoadingItemIdx --;
    }

    [self setNeedsUpdateConstraints];

    self.animating = YES;
    [UIView animateWithDuration:self.animationDuration animations:^{
        [self layoutIfNeeded];
    } completion:^(BOOL finished) {
        if (self.cardItemDidApearBlock) {
            self.cardItemDidApearBlock(self, self.itemViews.firstObject, self.currentShowingItemIdx);
        }
        self.animating = NO;
    }];

}

- (void)updateConstraints{

    [self.itemViews enumerateObjectsUsingBlock:^(__kindof UIView * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        if (self.selectedView == obj) {
            [obj mas_remakeConstraints:^(MASConstraintMaker *make) {
                make.center.centerOffset(self.translation);
                make.size.equalTo(self);
            }];
        }else{
            [obj mas_remakeConstraints:^(MASConstraintMaker *make) {
                //没有选中视图,并且是最后一个,才让最后一个和倒数第二个位置相同
                NSUInteger index = idx == _maxCardItemCount && !self.selectedView ? idx - 1 : idx;//最后一个和倒数第二个的布局相同
                CGFloat mutiplied = 1 - index * _scaleOffset + self.progress * _scaleOffset;
                make.size.equalTo(self).multipliedBy(mutiplied);
                CGPoint translation = CGPointMake(0, index * _translationYOffset - self.progress * _translationYOffset);
                make.center.centerOffset(translation);
            }];
        }
    }];

    [super updateConstraints];
}

- (CGRect)frameAtIdx:(NSInteger)idx{
    return [self frameAtIdx:idx progress:0];
}

- (CGRect)frameAtIdx:(NSInteger)idx progress:(CGFloat)progress{
    if (0 == progress && idx == _maxCardItemCount) {
        idx--;
    }

    return CGRectMake(0, idx * _translationYOffset, CGRectGetWidth(self.frame), CGRectGetHeight(self.frame));

}

- (__kindof UIView *)dequeueReuseableCardItemViewWithIdentifier:(NSString *)identifier{

    NSAssert(identifier.length, @"identifier必须有值");

    NSMutableArray <__kindof UIView *> *reusebleItemViews = self.reusebleItemViews[identifier];
    if (!reusebleItemViews) {
        reusebleItemViews = [NSMutableArray array];
        self.reusebleItemViews[identifier] = reusebleItemViews;
    }

    UIView *itemView = [reusebleItemViews jc_dequeue];
    if (!itemView) {
        itemView = [[self.registerdItemClazz[identifier] alloc] init];
        itemView.jc_internalIdentifier = identifier;
    }
    return itemView;
}

- (void)registerCardItemViewClass:(Class)clazz forIdentifier:(NSString *)identifier{
    NSAssert(identifier.length, @"identifier必须有值");

    self.registerdItemClazz[identifier] = clazz;
}

- (NSMutableArray<UIView *> *)itemViews{
    if (!_itemViews) {
        _itemViews = [NSMutableArray array];
    }
    return _itemViews;
}

- (NSMutableDictionary<NSString *,Class> *)registerdItemClazz{
    if (!_registerdItemClazz) {
        _registerdItemClazz = [NSMutableDictionary dictionary];
    }
    return _registerdItemClazz;
}

- (NSMutableDictionary<NSString *,NSMutableArray<UIView *> *> *)reusebleItemViews{
    if (!_reusebleItemViews) {
        _reusebleItemViews = [NSMutableDictionary dictionary];
    }
    return _reusebleItemViews;
}

- (NSMutableArray<JCUndoState *> *)undoStack{
    if (!_undoStack) {
        _undoStack = [NSMutableArray array];
    }
    return _undoStack;
}

@end


text:
package com.jme.util.lwjgl;

import java.util.logging.Logger;

import com.jme.math.FastMath;
import com.jme.util.Timer;
import org.lwjgl.Sys;

/**
 * Timer handles the system's time related functionality. This
 * allows the calculation of the framerate. To keep the framerate calculation
 * accurate, a call to update each frame is required. Timer is a
 * singleton object and must be created via the getTimer method.
 *
 * @author Mark Powell
 * @version $Id: LWJGLTimer.java 4131 2009-03-19 20:15:28Z blaine.dev $
 */
public class LWJGLTimer extends Timer {
    private static final Logger logger = Logger.getLogger(LWJGLTimer.class
            .getName());

    private long lastFrameDiff;

    //frame rate parameters.
    private long oldTime;

    private float lastTPF, lastFPS;

    public static int TIMER_SMOOTHNESS = 32;

    private long[] tpf;

    private int smoothIndex;

    private final static long timerRez = Sys.getTimerResolution();
    private final static float invTimerRez = ( 1f / timerRez );
    private static float invTimerRezSmooth;

    private long startTime;

    private boolean allSmooth = false;

    /**
     * Constructor builds a Timer object. All values will be
     * initialized to it's default values.
     */
    public LWJGLTimer() {
        reset();

        //print timer resolution info
        logger.info("Timer resolution: " + timerRez + " ticks per second");
    }

    public void reset() {
        lastFrameDiff = 0;
        lastFPS = 0;
        lastTPF = 0;

        // init to -1 to indicate this is a new timer.
        oldTime = -1;
        //reset time
        startTime = Sys.getTime();

        tpf = new long[TIMER_SMOOTHNESS];
        smoothIndex = TIMER_SMOOTHNESS - 1;
        invTimerRezSmooth = ( 1f / (timerRez * TIMER_SMOOTHNESS));

        // set tpf... -1 values will not be used for calculating the average in update()
        for ( int i = tpf.length; --i >= 0; ) {
            tpf[i] = -1;
        }
    }

    /**
     * @see com.jme.util.Timer#getTime()
     */
    public long getTime() {
        return Sys.getTime() - startTime;
    }

    /**
     * @see com.jme.util.Timer#getResolution()
     */
    public long getResolution() {
        return timerRez;
    }

    /**
     * getFrameRate returns the current frame rate since the last
     * call to update.
     *
     * @return the current frame rate.
     */
    public float getFrameRate() {
        return lastFPS;
    }

    public float getTimePerFrame() {
        return lastTPF;
    }

    /**
     * update recalulates the frame rate based on the previous
     * call to update. It is assumed that update is called each frame.
     */
    public void update() {
        long newTime = Sys.getTime();
        long oldTime = this.oldTime;
        this.oldTime = newTime;
        if ( oldTime == -1 ) {
            // For the first frame use 60 fps. This value will not be counted in further averages.
            // This is done so initialization code between creating the timer and the first
            // frame is not counted as a single frame on it's own.
            lastTPF = 1 / 60f;
            lastFPS = 1f / lastTPF;
            return;
        }

        long frameDiff = newTime - oldTime;
        long lastFrameDiff = this.lastFrameDiff;
        if ( lastFrameDiff > 0 && frameDiff > lastFrameDiff *100 ) {
            frameDiff = lastFrameDiff *100;
        }
        this.lastFrameDiff = frameDiff;
        tpf[smoothIndex] = frameDiff;
        smoothIndex--;
        if ( smoothIndex < 0 ) {
            smoothIndex = tpf.length - 1;
        }

        lastTPF = 0.0f;
        if (!allSmooth) {
            int smoothCount = 0;
            for ( int i = tpf.length; --i >= 0; ) {
                if ( tpf[i] != -1 ) {
                    lastTPF += tpf[i];
                    smoothCount++;
                }
            }
            if (smoothCount == tpf.length)
                allSmooth  = true;
            lastTPF *= ( invTimerRez / smoothCount );
        } else {
            for ( int i = tpf.length; --i >= 0; ) {
                if ( tpf[i] != -1 ) {
                    lastTPF += tpf[i];
                }
            }
            lastTPF *= invTimerRezSmooth;
        }
        if ( lastTPF < FastMath.FLT_EPSILON ) {
            lastTPF = FastMath.FLT_EPSILON;
        }

        lastFPS = 1f / lastTPF;
    }

    /**
     * toString returns the string representation of this timer
     * in the format:

     *

     * jme.utility.Timer@1db699b

     * Time: {LONG}

     * FPS: {LONG}

     *
     * @return the string representation of this object.
     */
    public String toString() {
        String string = super.toString();
        string += "\nTime: " + oldTime;
        string += "\nFPS: " + getFrameRate();
        return string;
    }
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using ElmahLogAnalyzer.Core.Common;
using Microsoft.VisualBasic.FileIO;

namespace ElmahLogAnalyzer.Core.Domain
{
	public class CsvParser : ICsvParser
	{
		public IEnumerable<KeyValuePair<Uri, DateTime>> Parse(string content)
		{
			var bytes = Encoding.Unicode.GetBytes(content);
			using (var stream = new MemoryStream(bytes))
			using (var parser = new TextFieldParser(stream, Encoding.Unicode) { TextFieldType = FieldType.Delimited })
			{
				parser.SetDelimiters(",");
				foreach (var currentRow in parser.Read().Skip(/* headers */ 1))
				{
					var date = DateTime.Parse(currentRow[2], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AllowWhiteSpaces);
					var detailsUrl = new Uri(currentRow[9]);
					yield return new KeyValuePair<Uri, DateTime>(detailsUrl, date);
				}
			}
		}
	}
}


text:
#include <rtthread.h>
#include <board.h>

#include "drv_led.h"

static void led_thread_entry(void *parameter)
{
	while (1)
	{
		led_on();
		rt_thread_delay(RT_TICK_PER_SECOND);
		led_off();
		rt_thread_delay(RT_TICK_PER_SECOND);
	}
}

int led_hw_init(void)
{
	GPIO_InitTypeDef GPIO_InitStruct;

	/* GPIO Ports Clock Enable */
	__HAL_RCC_GPIOB_CLK_ENABLE();

	/* Configure GPIO pin: PI1 (LD2) */
	GPIO_InitStruct.Pin   = GPIO_PIN_14;
	GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull  = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	return 0;
}
INIT_BOARD_EXPORT(led_hw_init);

int led_init(void)
{
	rt_thread_t tid;

	tid = rt_thread_create("led",
						   led_thread_entry, RT_NULL,
						   512, 12, 5);

	if (tid != RT_NULL)
		rt_thread_startup(tid);

	return 0;
}
INIT_APP_EXPORT(led_init);


text:
var workerpool = require('../../index');

// an async function returning a promise
function asyncAdd (a, b) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve(a + b);
    }, 1000);
  });
}

// an async function returning a promise
function asyncMultiply (a, b) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve(a * b);
    }, 1000);
  });
}

// create a worker and register public functions
workerpool.worker({
  asyncAdd: asyncAdd,
  asyncMultiply: asyncMultiply
});


text:
import ns from 'nslookup';
import timeout from './timeout';

function nslookup(domain) {
  return new Promise(function (resolve, reject) {
    ns(domain)
        .type('ns')
        .timeout(timeout.ns)
        .end(function (err, addresses) {
          return err ? reject(err) : resolve(addresses);
        });
  });
}

export default nslookup;


text:
@interface UIViewController (MAGMore)

- (void)mag_addCloseButton;
- (IBAction)closeAction;

- (void)mag_presentVCinsideNC:(UIViewController *)vc animated:(BOOL)animated;
- (void)mag_presentVCinAppTopVCinsideNC:(UIViewController *)vc animated:(BOOL)animated;

@end


text:
//
// MessagePack for C++ deserializing routine
//
// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
//
//    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.
//
#ifndef MSGPACK_UNPACK_HPP
#define MSGPACK_UNPACK_HPP

#include "msgpack/versioning.hpp"
#include "object.hpp"
#include "zone.hpp"
#include "unpack_define.h"
#include "cpp_config.hpp"
#include "sysdep.h"

#include <memory>
#include <stdexcept>

#if defined(_MSC_VER)
// avoiding confliction std::max, std::min, and macro in windows.h
#ifndef NOMINMAX
#define NOMINMAX
#endif
#endif // defined(_MSC_VER)

#ifdef _msgpack_atomic_counter_header
#include _msgpack_atomic_counter_header
#endif

#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t))

#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE
#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024)
#endif

#ifndef MSGPACK_UNPACKER_RESERVE_SIZE
#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024)
#endif

// backward compatibility
#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE
#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE
#endif

namespace msgpack {

MSGPACK_API_VERSION_NAMESPACE(v1) {

typedef bool (*unpack_reference_func)(type::object_type, std::size_t, void*);

struct unpack_error : public std::runtime_error {
    explicit unpack_error(const std::string& msg)
        :std::runtime_error(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    explicit unpack_error(const char* msg):
        std::runtime_error(msg) {}
#endif // !defined(MSGPACK_USE_CPP03)
};

struct parse_error : public unpack_error {
    explicit parse_error(const std::string& msg)
        :unpack_error(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    explicit parse_error(const char* msg)
        :unpack_error(msg) {}
#endif // !defined(MSGPACK_USE_CPP03)
};

struct insufficient_bytes : public unpack_error {
    explicit insufficient_bytes(const std::string& msg)
        :unpack_error(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    explicit insufficient_bytes(const char* msg)
        :unpack_error(msg) {}
#endif // !defined(MSGPACK_USE_CPP03)
};

struct size_overflow : public unpack_error {
    explicit size_overflow(const std::string& msg)
        :unpack_error(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    explicit size_overflow(const char* msg)
        :unpack_error(msg) {}
#endif
};

struct array_size_overflow : public size_overflow {
    array_size_overflow(const std::string& msg)
        :size_overflow(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    array_size_overflow(const char* msg)
        :size_overflow(msg) {}
#endif
};

struct map_size_overflow : public size_overflow {
    map_size_overflow(const std::string& msg)
        :size_overflow(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    map_size_overflow(const char* msg)
        :size_overflow(msg) {}
#endif
};

struct str_size_overflow : public size_overflow {
    str_size_overflow(const std::string& msg)
        :size_overflow(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    str_size_overflow(const char* msg)
        :size_overflow(msg) {}
#endif
};

struct bin_size_overflow : public size_overflow {
    bin_size_overflow(const std::string& msg)
        :size_overflow(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    bin_size_overflow(const char* msg)
        :size_overflow(msg) {}
#endif
};

struct ext_size_overflow : public size_overflow {
    ext_size_overflow(const std::string& msg)
        :size_overflow(msg) {}
#if !defined(MSGPACK_USE_CPP03)
    ext_size_overflow(const char* msg)
        :size_overflow(msg) {}
#endif
};

class unpack_limit {
public:
    unpack_limit(
        std::size_t array = 0xffffffff,
        std::size_t map = 0xffffffff,
        std::size_t str = 0xffffffff,
        std::size_t bin = 0xffffffff,
        std::size_t ext = 0xffffffff)
        :array_(array),
         map_(map),
         str_(str),
         bin_(bin),
         ext_(ext) {}
    std::size_t array() const { return array_; }
    std::size_t map() const { return map_; }
    std::size_t str() const { return str_; }
    std::size_t bin() const { return bin_; }
    std::size_t ext() const { return ext_; }

private:
    std::size_t array_;
    std::size_t map_;
    std::size_t str_;
    std::size_t bin_;
    std::size_t ext_;
};

namespace detail {

class unpack_user {
public:
    unpack_user(unpack_reference_func f = nullptr,
                void* user_data = nullptr,
                unpack_limit const& limit = unpack_limit())
        :m_func(f), m_user_data(user_data), m_limit(limit) {}
    msgpack::zone const& zone() const { return *m_zone; }
    msgpack::zone& zone() { return *m_zone; }
    void set_zone(msgpack::zone& zone) { m_zone = &zone; }
    bool referenced() const { return m_referenced; }
    void set_referenced(bool referenced) { m_referenced = referenced; }
    unpack_reference_func reference_func() const { return m_func; }
    void* user_data() const { return m_user_data; }
    unpack_limit const& limit() const { return m_limit; }
    unpack_limit& limit() { return m_limit; }

private:
    msgpack::zone* m_zone;
    bool m_referenced;
    unpack_reference_func m_func;
    void* m_user_data;
    unpack_limit m_limit;
};

inline void unpack_uint8(uint8_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }

inline void unpack_uint16(uint16_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }

inline void unpack_uint32(uint32_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }

inline void unpack_uint64(uint64_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }

inline void unpack_int8(int8_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
        else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }

inline void unpack_int16(int16_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
        else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }

inline void unpack_int32(int32_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
        else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }

inline void unpack_int64(int64_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
        else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }

inline void unpack_float(float d, object& o)
{ o.type = type::FLOAT; o.via.f64 = d; }

inline void unpack_double(double d, object& o)
{ o.type = type::FLOAT; o.via.f64 = d; }

inline void unpack_nil(object& o)
{ o.type = type::NIL; }

inline void unpack_true(object& o)
{ o.type = type::BOOLEAN; o.via.boolean = true; }

inline void unpack_false(object& o)
{ o.type = type::BOOLEAN; o.via.boolean = false; }

struct unpack_array {
    void operator()(unpack_user& u, uint32_t n, object& o) const {
        if (n > u.limit().array()) throw array_size_overflow("array size overflow");
        o.type = type::ARRAY;
        o.via.array.size = 0;
        o.via.array.ptr = static_cast<object*>(u.zone().allocate_align(n*sizeof(object)));
    }
};

inline void unpack_array_item(object& c, object const& o)
{
#if defined(__GNUC__) && !defined(__clang__)
    std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object));
#else  /* __GNUC__ && !__clang__ */
    c.via.array.ptr[c.via.array.size++] = o;
#endif /* __GNUC__ && !__clang__ */
}

struct unpack_map {
    void operator()(unpack_user& u, uint32_t n, object& o) const {
        if (n > u.limit().map()) throw map_size_overflow("map size overflow");
        o.type = type::MAP;
        o.via.map.size = 0;
        o.via.map.ptr = static_cast<object_kv*>(u.zone().allocate_align(n*sizeof(object_kv)));
    }
};

inline void unpack_map_item(object& c, object const& k, object const& v)
{
#if defined(__GNUC__) && !defined(__clang__)
    std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object));
    std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object));
#else  /* __GNUC__ && !__clang__ */
    c.via.map.ptr[c.via.map.size].key = k;
    c.via.map.ptr[c.via.map.size].val = v;
#endif /* __GNUC__ && !__clang__ */
    ++c.via.map.size;
}

inline void unpack_str(unpack_user& u, const char* p, uint32_t l, object& o)
{
    o.type = type::STR;
    if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
        o.via.str.ptr = p;
        u.set_referenced(true);
    }
    else {
        if (l > u.limit().str()) throw str_size_overflow("str size overflow");
        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
        std::memcpy(tmp, p, l);
        o.via.str.ptr = tmp;
    }
    o.via.str.size = l;
}

inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, object& o)
{
    o.type = type::BIN;
    if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
        o.via.bin.ptr = p;
        u.set_referenced(true);
    }
    else {
        if (l > u.limit().bin()) throw bin_size_overflow("bin size overflow");
        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
        std::memcpy(tmp, p, l);
        o.via.bin.ptr = tmp;
    }
    o.via.bin.size = l;
}

inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, object& o)
{
    o.type = type::EXT;
    if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
        o.via.ext.ptr = p;
        u.set_referenced(true);
    }
    else {
        if (l > u.limit().ext()) throw ext_size_overflow("ext size overflow");
        char* tmp = static_cast<char*>(u.zone().allocate_align(l));
        std::memcpy(tmp, p, l);
        o.via.ext.ptr = tmp;
    }
    o.via.ext.size = l - 1;
}

class unpack_stack {
public:
    object const& obj() const { return m_obj; }
    object& obj() { return m_obj; }
    void set_obj(object const& obj) { m_obj = obj; }
    std::size_t count() const { return m_count; }
    void set_count(std::size_t count) { m_count = count; }
    std::size_t decl_count() { return --m_count; }
    uint32_t container_type() const { return m_container_type; }
    void set_container_type(uint32_t container_type) { m_container_type = container_type; }
    object const& map_key() const { return m_map_key; }
    void set_map_key(object const& map_key) { m_map_key = map_key; }
private:
    object m_obj;
    std::size_t m_count;
    uint32_t m_container_type;
    object m_map_key;
};

inline void init_count(void* buffer)
{
    *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer) = 1;
}

inline void decl_count(void* buffer)
{
    if(_msgpack_sync_decr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)) == 0) {
        free(buffer);
    }
}

inline void incr_count(void* buffer)
{
    _msgpack_sync_incr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer));
}

inline _msgpack_atomic_counter_t get_count(void* buffer)
{
    return *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer);
}

struct fix_tag {
    char f1[65]; // FIXME unique size is required. or use is_same meta function.
};

template <typename T>
struct value {
    typedef T type;
};
template <>
struct value<fix_tag> {
    typedef uint32_t type;
};

template <typename T>
inline void load(uint32_t& dst, const char* n, typename msgpack::enable_if<sizeof(T) == sizeof(fix_tag)>::type* = nullptr) {
    dst = static_cast<uint32_t>(*reinterpret_cast<const uint8_t*>(n)) & 0x0f;
}

template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 1>::type* = nullptr) {
    dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n));
}

template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 2>::type* = nullptr) {
    _msgpack_load16(T, n, &dst);
}

template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 4>::type* = nullptr) {
    _msgpack_load32(T, n, &dst);
}

template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 8>::type* = nullptr) {
    _msgpack_load64(T, n, &dst);
}

class context {
public:
    context(unpack_reference_func f, void* user_data, unpack_limit const& limit)
        :m_trail(0), m_user(f, user_data, limit), m_cs(CS_HEADER), m_top(0)
    {
        m_stack[0].set_obj(object());
    }

    void init()
    {
        m_cs = CS_HEADER;
        m_trail = 0;
        m_top = 0;
        m_stack[0].set_obj(object());
    }

    object const& data() const
    {
        return m_stack[0].obj();
    }

    unpack_user& user()
    {
        return m_user;
    }

    unpack_user const& user() const
    {
        return m_user;
    }

    int execute(const char* data, std::size_t len, std::size_t& off);

private:
    template <typename T>
    static uint32_t next_cs(T p)
    {
        return static_cast<uint32_t>(*p) & 0x1f;
    }

    template <typename T, typename Func>
    int push_aggregate(
        Func const& f,
        uint32_t container_type,
        object& obj,
        const char* load_pos,
        std::size_t& off) {
        if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) {
            typename value<T>::type tmp;
            load<T>(tmp, load_pos);
            f(m_user, tmp, m_stack[m_top].obj());
            if(tmp == 0) {
                obj = m_stack[m_top].obj();
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            }
            else {
                m_stack[m_top].set_container_type(container_type);
                m_stack[m_top].set_count(tmp);
                ++m_top;
                m_cs = CS_HEADER;
                ++m_current;
            }
        }
        else {
            off = m_current - m_start;
            return -1;
        }
        return 0;
    }

    int push_item(object& obj) {
        bool finish = false;
        while (!finish) {
            if(m_top == 0) {
                return 1;
            }
            m_stack_idx = m_top - 1;
            unpack_stack* sp = &m_stack[m_stack_idx];
            switch(sp->container_type()) {
            case CT_ARRAY_ITEM:
                unpack_array_item(sp->obj(), obj);
                if(sp->decl_count() == 0) {
                    obj = sp->obj();
                    --m_top;
                    /*printf("stack pop %d\n", m_top);*/
                }
                else {
                    finish = true;
                }
                break;
            case CT_MAP_KEY:
                sp->set_map_key(obj);
                sp->set_container_type(CT_MAP_VALUE);
                finish = true;
                break;
            case CT_MAP_VALUE:
                unpack_map_item(sp->obj(), sp->map_key(), obj);
                if(sp->decl_count() == 0) {
                    obj = sp->obj();
                    --m_top;
                    /*printf("stack pop %d\n", m_top);*/
                }
                else {
                    sp->set_container_type(CT_MAP_KEY);
                    finish = true;
                }
                break;
            default:
                return -1;
            }
        }
        return 0;
    }

    int push_proc(object& obj, std::size_t& off) {
        int ret = push_item(obj);
        if (ret > 0) {
            m_stack[0].set_obj(obj);
            ++m_current;
            /*printf("-- finish --\n"); */
            off = m_current - m_start;
        }
        else if (ret < 0) {
            off = m_current - m_start;
        }
        else {
            m_cs = CS_HEADER;
            ++m_current;
        }
        return ret;
    }

    template <std::size_t N>
    static void check_ext_size(std::size_t /*size*/) {
    }

private:
    char const* m_start;
    char const* m_current;

    std::size_t m_trail;
    unpack_user m_user;
    uint32_t m_cs;
    uint32_t m_top;
    uint32_t m_stack_idx;
    unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE];
};

template <>
inline void context::check_ext_size<4>(std::size_t size) {
    if (size == 0xffffffff) throw ext_size_overflow("ext size overflow");
}

inline int context::execute(const char* data, std::size_t len, std::size_t& off)
{
    assert(len >= off);

    m_start = data;
    m_current = data + off;
    m_stack_idx = 0;
    const char* const pe = data + len;
    const char* n = nullptr;

    object obj;

    if(m_current == pe) {
        off = m_current - m_start;
        return 0;
    }
    bool fixed_trail_again = false;
    do {
        if (m_cs == CS_HEADER) {
            fixed_trail_again = false;
            int selector = *reinterpret_cast<const unsigned char*>(m_current);
            if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
                unpack_uint8(*reinterpret_cast<const uint8_t*>(m_current), obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum
                unpack_int8(*reinterpret_cast<const int8_t*>(m_current), obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } else if (0xc4 <= selector && selector <= 0xdf) {
                const uint32_t trail[] = {
                    1, // bin     8  0xc4
                    2, // bin    16  0xc5
                    4, // bin    32  0xc6
                    1, // ext     8  0xc7
                    2, // ext    16  0xc8
                    4, // ext    32  0xc9
                    4, // float  32  0xca
                    8, // float  64  0xcb
                    1, // uint    8  0xcc
                    2, // uint   16  0xcd
                    4, // uint   32  0xce
                    8, // uint   64  0xcf
                    1, // int     8  0xd0
                    2, // int    16  0xd1
                    4, // int    32  0xd2
                    8, // int    64  0xd3
                    2, // fixext  1  0xd4
                    3, // fixext  2  0xd5
                    5, // fixext  4  0xd6
                    9, // fixext  8  0xd7
                    17,// fixext 16  0xd8
                    1, // str     8  0xd9
                    2, // str    16  0xda
                    4, // str    32  0xdb
                    2, // array  16  0xdc
                    4, // array  32  0xdd
                    2, // map    16  0xde
                    4, // map    32  0xdf
                };
                m_trail = trail[selector - 0xc4];
                m_cs = next_cs(m_current);
                fixed_trail_again = true;
            } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
                m_trail = static_cast<uint32_t>(*m_current) & 0x1f;
                if(m_trail == 0) {
                    unpack_str(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_STR_VALUE;
                    fixed_trail_again = true;
                }

            } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
                int ret = push_aggregate<fix_tag>(
                    unpack_array(), CT_ARRAY_ITEM, obj, m_current, off);
                if (ret != 0) return ret;
            } else if(0x80 <= selector && selector <= 0x8f) { // FixMap
                int ret = push_aggregate<fix_tag>(
                    unpack_map(), CT_MAP_KEY, obj, m_current, off);
                if (ret != 0) return ret;
            } else if(selector == 0xc2) { // false
                unpack_false(obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } else if(selector == 0xc3) { // true
                unpack_true(obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } else if(selector == 0xc0) { // nil
                unpack_nil(obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } else {
                off = m_current - m_start;
                return -1;
            }
            // end CS_HEADER
        }
        if (m_cs != CS_HEADER || fixed_trail_again) {
            if (fixed_trail_again) {
                ++m_current;
                fixed_trail_again = false;
            }
            if(static_cast<std::size_t>(pe - m_current) < m_trail) {
                off = m_current - m_start;
                return 0;
            }
            n = m_current;
            m_current += m_trail - 1;
            switch(m_cs) {
                //case CS_
                //case CS_
            case CS_FLOAT: {
                union { uint32_t i; float f; } mem;
                load<uint32_t>(mem.i, n);
                unpack_float(mem.f, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_DOUBLE: {
                union { uint64_t i; double f; } mem;
                load<uint64_t>(mem.i, n);
#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
                // https://github.com/msgpack/msgpack-perl/pull/1
                mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
#endif
                unpack_double(mem.f, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_UINT_8: {
                uint8_t tmp;
                load<uint8_t>(tmp, n);
                unpack_uint8(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_UINT_16: {
                uint16_t tmp;
                load<uint16_t>(tmp, n);
                unpack_uint16(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_UINT_32: {
                uint32_t tmp;
                load<uint32_t>(tmp, n);
                unpack_uint32(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_UINT_64: {
                uint64_t tmp;
                load<uint64_t>(tmp, n);
                unpack_uint64(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_INT_8: {
                int8_t tmp;
                load<int8_t>(tmp, n);
                unpack_int8(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_INT_16: {
                int16_t tmp;
                load<int16_t>(tmp, n);
                unpack_int16(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_INT_32: {
                int32_t tmp;
                load<int32_t>(tmp, n);
                unpack_int32(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_INT_64: {
                int64_t tmp;
                load<int64_t>(tmp, n);
                unpack_int64(tmp, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_FIXEXT_1: {
                unpack_ext(m_user, n, 1+1, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_FIXEXT_2: {
                unpack_ext(m_user, n, 2+1, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_FIXEXT_4: {
                unpack_ext(m_user, n, 4+1, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_FIXEXT_8: {
                unpack_ext(m_user, n, 8+1, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_FIXEXT_16: {
                unpack_ext(m_user, n, 16+1, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_STR_8: {
                uint8_t tmp;
                load<uint8_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_str(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_STR_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_BIN_8: {
                uint8_t tmp;
                load<uint8_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_bin(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_BIN_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_EXT_8: {
                uint8_t tmp;
                load<uint8_t>(tmp, n);
                m_trail = tmp + 1;
                if(m_trail == 0) {
                    unpack_ext(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_EXT_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_STR_16: {
                uint16_t tmp;
                load<uint16_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_str(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_STR_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_BIN_16: {
                uint16_t tmp;
                load<uint16_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_bin(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_BIN_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_EXT_16: {
                uint16_t tmp;
                load<uint16_t>(tmp, n);
                m_trail = tmp + 1;
                if(m_trail == 0) {
                    unpack_ext(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_EXT_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_STR_32: {
                uint32_t tmp;
                load<uint32_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_str(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_STR_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_BIN_32: {
                uint32_t tmp;
                load<uint32_t>(tmp, n);
                m_trail = tmp;
                if(m_trail == 0) {
                    unpack_bin(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_BIN_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case CS_EXT_32: {
                uint32_t tmp;
                load<uint32_t>(tmp, n);
                check_ext_size<sizeof(std::size_t)>(tmp);
                m_trail = tmp;
                ++m_trail;
                if(m_trail == 0) {
                    unpack_ext(m_user, n, m_trail, obj);
                    int ret = push_proc(obj, off);
                    if (ret != 0) return ret;
                }
                else {
                    m_cs = ACS_EXT_VALUE;
                    fixed_trail_again = true;
                }
            } break;
            case ACS_STR_VALUE: {
                unpack_str(m_user, n, m_trail, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case ACS_BIN_VALUE: {
                unpack_bin(m_user, n, m_trail, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case ACS_EXT_VALUE: {
                unpack_ext(m_user, n, m_trail, obj);
                int ret = push_proc(obj, off);
                if (ret != 0) return ret;
            } break;
            case CS_ARRAY_16: {
                int ret = push_aggregate<uint16_t>(
                    unpack_array(), CT_ARRAY_ITEM, obj, n, off);
                if (ret != 0) return ret;
            } break;
            case CS_ARRAY_32: {
                /* FIXME security guard */
                int ret = push_aggregate<uint32_t>(
                    unpack_array(), CT_ARRAY_ITEM, obj, n, off);
                if (ret != 0) return ret;
            } break;
            case CS_MAP_16: {
                int ret = push_aggregate<uint16_t>(
                    unpack_map(), CT_MAP_KEY, obj, n, off);
                if (ret != 0) return ret;
            } break;
            case CS_MAP_32: {
                /* FIXME security guard */
                int ret = push_aggregate<uint32_t>(
                    unpack_map(), CT_MAP_KEY, obj, n, off);
                if (ret != 0) return ret;
            } break;
            default:
                off = m_current - m_start;
                return -1;
            }
        }
    } while(m_current != pe);

    off = m_current - m_start;
    return 0;
}

} // detail

class unpacked {
public:
    unpacked() {}

    unpacked(object const& obj, msgpack::unique_ptr<msgpack::zone> z) :
        m_obj(obj), m_zone(msgpack::move(z)) { }

    void set(object const& obj)
        { m_obj = obj; }

    const object& get() const
        { return m_obj; }

    msgpack::unique_ptr<msgpack::zone>& zone()
        { return m_zone; }

    const msgpack::unique_ptr<msgpack::zone>& zone() const
        { return m_zone; }

private:
    object m_obj;
    msgpack::unique_ptr<msgpack::zone> m_zone;
};

class unpacker {
public:
    unpacker(unpack_reference_func f = &unpacker::default_reference_func,
             void* user_data = nullptr,
             std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
             unpack_limit const& limit = unpack_limit());

#if !defined(MSGPACK_USE_CPP03)
    unpacker(unpacker&& other);
    unpacker& operator=(unpacker&& other);
#endif // !defined(MSGPACK_USE_CPP03)

    ~unpacker();

public:
    /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */
    void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE);

    /*! 2. read data to the buffer() up to buffer_capacity() bytes */
    char* buffer();
    std::size_t buffer_capacity() const;

    /*! 3. specify the number of bytes actually copied */
    void buffer_consumed(std::size_t size);

    /*! 4. repeat next() until it retunrs false */
    bool next(unpacked* result);
    bool next(unpacked& result, bool& referenced);
    bool next(unpacked& result);

    /*! 5. check if the size of message doesn't exceed assumption. */
    std::size_t message_size() const;

    // Basic usage of the unpacker is as following:
    //
    // unpacker pac;
    // while( /* input is readable */ ) {
    //
    //     // 1.
    //     pac.reserve_buffer(32*1024);
    //
    //     // 2.
    //     std::size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity());
    //
    //     // error handling ...
    //
    //     // 3.
    //     pac.buffer_consumed(bytes);
    //
    //     // 4.
    //     unpacked result;
    //     while(pac.next(&result)) {
    //         // do some with the object with the zone.
    //         object obj = result.get();
    //         std::auto_ptr<msgpack:zone> z = result.zone();
    //         on_message(obj, z);
    //
    //         //// boost::shared_ptr is also usable:
    //         // boost::shared_ptr<zone> life(z.release());
    //         // on_message(result.get(), life);
    //     }
    //
    //     // 5.
    //     if(pac.message_size() > 10*1024*1024) {
    //         throw std::runtime_error("message is too large");
    //     }
    // }
    //

    /*! for backward compatibility */
    bool execute();

    /*! for backward compatibility */
    object const& data();

    /*! for backward compatibility */
    zone* release_zone();

    /*! for backward compatibility */
    void reset_zone();

    /*! for backward compatibility */
    void reset();

public:
    // These functions are usable when non-MessagePack message follows after
    // MessagePack message.
    std::size_t parsed_size() const;

    /*! get address of the buffer that is not parsed */
    char* nonparsed_buffer();
    std::size_t nonparsed_size() const;

    /*! skip specified size of non-parsed buffer, leaving the buffer */
    // Note that the `size' argument must be smaller than nonparsed_size()
    void skip_nonparsed_buffer(std::size_t size);

    /*! remove unparsed buffer from unpacker */
    // Note that reset() leaves non-parsed buffer.
    void remove_nonparsed_buffer();

private:
    void expand_buffer(std::size_t size);
    int execute_imp();
    bool flush_zone();
    static bool default_reference_func(type::object_type type, std::size_t len, void*);

private:
    char* m_buffer;
    std::size_t m_used;
    std::size_t m_free;
    std::size_t m_off;
    std::size_t m_parsed;
    msgpack::unique_ptr<zone> m_z;
    std::size_t m_initial_buffer_size;
    detail::context m_ctx;

#if defined(MSGPACK_USE_CPP03)
private:
    unpacker(const unpacker&);
    unpacker& operator=(const unpacker&);
#else  // defined(MSGPACK_USE_CPP03)
    unpacker(const unpacker&) = delete;
    unpacker& operator=(const unpacker&) = delete;
#endif // defined(MSGPACK_USE_CPP03)
};

#if !defined(MSGPACK_USE_CPP03)

unpacked unpack(
    const char* data, std::size_t len, std::size_t& off, bool& referenced,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
unpacked unpack(
    const char* data, std::size_t len, std::size_t& off,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
unpacked unpack(
    const char* data, std::size_t len, bool& referenced,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
unpacked unpack(
    const char* data, std::size_t len,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());

#endif // !defined(MSGPACK_USE_CPP03)

void unpack(unpacked& result,
            const char* data, std::size_t len, std::size_t& off, bool& referenced,
            unpack_reference_func f = nullptr, void* user_data = nullptr,
            unpack_limit const& limit = unpack_limit());
void unpack(unpacked& result,
            const char* data, std::size_t len, std::size_t& off,
            unpack_reference_func f = nullptr, void* user_data = nullptr,
            unpack_limit const& limit = unpack_limit());
void unpack(unpacked& result,
            const char* data, std::size_t len, bool& referenced,
            unpack_reference_func f = nullptr, void* user_data = nullptr,
            unpack_limit const& limit = unpack_limit());

void unpack(unpacked& result,
            const char* data, std::size_t len,
            unpack_reference_func f = nullptr, void* user_data = nullptr,
            unpack_limit const& limit = unpack_limit());

object unpack(
    zone& z,
    const char* data, std::size_t len, std::size_t& off, bool& referenced,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
object unpack(
    zone& z,
    const char* data, std::size_t len, std::size_t& off,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
object unpack(
    zone& z,
    const char* data, std::size_t len, bool& referenced,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());
object unpack(
    zone& z,
    const char* data, std::size_t len,
    unpack_reference_func f = nullptr, void* user_data = nullptr,
    unpack_limit const& limit = unpack_limit());

// obsolete
void unpack(unpacked* result,
            const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr,
            unpack_reference_func f = nullptr, void* user_data = nullptr,
            unpack_limit const& limit = unpack_limit());

// for internal use
typedef enum {
    UNPACK_SUCCESS              =  2,
    UNPACK_EXTRA_BYTES          =  1,
    UNPACK_CONTINUE             =  0,
    UNPACK_PARSE_ERROR          = -1
} unpack_return;

inline unpacker::unpacker(unpack_reference_func f,
                          void* user_data,
                          std::size_t initial_buffer_size,
                          unpack_limit const& limit)
    :m_z(new zone), m_ctx(f, user_data, limit)
{
    if(initial_buffer_size < COUNTER_SIZE) {
        initial_buffer_size = COUNTER_SIZE;
    }

    char* buffer = static_cast<char*>(::malloc(initial_buffer_size));
    if(!buffer) {
        throw std::bad_alloc();
    }

    m_buffer = buffer;
    m_used = COUNTER_SIZE;
    m_free = initial_buffer_size - m_used;
    m_off = COUNTER_SIZE;
    m_parsed = 0;
    m_initial_buffer_size = initial_buffer_size;

    detail::init_count(m_buffer);

    m_ctx.init();
    m_ctx.user().set_zone(*m_z);
    m_ctx.user().set_referenced(false);
}

#if !defined(MSGPACK_USE_CPP03)
// Move constructor and move assignment operator

inline unpacker::unpacker(unpacker&& other)
    :m_buffer(other.m_buffer),
     m_used(other.m_used),
     m_free(other.m_free),
     m_off(other.m_off),
     m_parsed(other.m_parsed),
     m_z(std::move(other.m_z)),
     m_initial_buffer_size(other.m_initial_buffer_size),
     m_ctx(other.m_ctx) {
    other.m_buffer = nullptr;
}

inline unpacker& unpacker::operator=(unpacker&& other) {
    this->~unpacker();
    new (this) unpacker(std::move(other));
    return *this;
}

#endif // !defined(MSGPACK_USE_CPP03)

inline unpacker::~unpacker()
{
    // These checks are required for move operations.
    if (m_buffer) detail::decl_count(m_buffer);
}

inline void unpacker::reserve_buffer(std::size_t size)
{
    if(m_free >= size) return;
    expand_buffer(size);
}

inline void unpacker::expand_buffer(std::size_t size)
{
    if(m_used == m_off && detail::get_count(m_buffer) == 1
        && !m_ctx.user().referenced()) {
        // rewind buffer
        m_free += m_used - COUNTER_SIZE;
        m_used = COUNTER_SIZE;
        m_off  = COUNTER_SIZE;

        if(m_free >= size) return;
    }

    if(m_off == COUNTER_SIZE) {
        std::size_t next_size = (m_used + m_free) * 2;    // include COUNTER_SIZE
        while(next_size < size + m_used) {
            std::size_t tmp_next_size = next_size * 2;
            if (tmp_next_size <= next_size) {
                next_size = size + m_used;
                break;
            }
            next_size = tmp_next_size;
        }

        char* tmp = static_cast<char*>(::realloc(m_buffer, next_size));
        if(!tmp) {
            throw std::bad_alloc();
        }

        m_buffer = tmp;
        m_free = next_size - m_used;

    } else {
        std::size_t next_size = m_initial_buffer_size;  // include COUNTER_SIZE
        std::size_t not_parsed = m_used - m_off;
        while(next_size < size + not_parsed + COUNTER_SIZE) {
            std::size_t tmp_next_size = next_size * 2;
            if (tmp_next_size <= next_size) {
                next_size = size + not_parsed + COUNTER_SIZE;
                break;
            }
            next_size = tmp_next_size;
        }

        char* tmp = static_cast<char*>(::malloc(next_size));
        if(!tmp) {
            throw std::bad_alloc();
        }

        detail::init_count(tmp);

        std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed);

        if(m_ctx.user().referenced()) {
            try {
                m_z->push_finalizer(&detail::decl_count, m_buffer);
            }
            catch (...) {
                ::free(tmp);
                throw;
            }
            m_ctx.user().set_referenced(false);
        } else {
            detail::decl_count(m_buffer);
        }

        m_buffer = tmp;
        m_used  = not_parsed + COUNTER_SIZE;
        m_free  = next_size - m_used;
        m_off   = COUNTER_SIZE;
    }
}

inline char* unpacker::buffer()
{
    return m_buffer + m_used;
}

inline std::size_t unpacker::buffer_capacity() const
{
    return m_free;
}

inline void unpacker::buffer_consumed(std::size_t size)
{
    m_used += size;
    m_free -= size;
}

inline bool unpacker::next(unpacked& result, bool& referenced)
{
    referenced = false;
    int ret = execute_imp();
    if(ret < 0) {
        throw parse_error("parse error");
    }

    if(ret == 0) {
        result.zone().reset();
        result.set(object());
        return false;

    } else {
        referenced = m_ctx.user().referenced();
        result.zone().reset( release_zone() );
        result.set(data());
        reset();
        return true;
    }
}

inline bool unpacker::next(unpacked& result)
{
    bool referenced;
    return next(result, referenced);
}

inline bool unpacker::next(unpacked* result)
{
    return next(*result);
}

inline bool unpacker::execute()
{
    int ret = execute_imp();
    if(ret < 0) {
        throw parse_error("parse error");
    } else if(ret == 0) {
        return false;
    } else {
        return true;
    }
}

inline int unpacker::execute_imp()
{
    std::size_t off = m_off;
    int ret = m_ctx.execute(m_buffer, m_used, m_off);
    if(m_off > off) {
        m_parsed += m_off - off;
    }
    return ret;
}

inline object const& unpacker::data()
{
    return m_ctx.data();
}

inline zone* unpacker::release_zone()
{
    if(!flush_zone()) {
        return nullptr;
    }

    zone* r =  new zone;
    zone* old = m_z.release();
    m_z.reset(r);
    m_ctx.user().set_zone(*m_z);

    return old;
}

inline void unpacker::reset_zone()
{
    m_z->clear();
}

inline bool unpacker::flush_zone()
{
    if(m_ctx.user().referenced()) {
        try {
            m_z->push_finalizer(&detail::decl_count, m_buffer);
        } catch (...) {
            return false;
        }
        m_ctx.user().set_referenced(false);

        detail::incr_count(m_buffer);
    }

    return true;
}

inline void unpacker::reset()
{
    m_ctx.init();
    // don't reset referenced flag
    m_parsed = 0;
}

inline std::size_t unpacker::message_size() const
{
    return m_parsed - m_off + m_used;
}

inline std::size_t unpacker::parsed_size() const
{
    return m_parsed;
}

inline char* unpacker::nonparsed_buffer()
{
    return m_buffer + m_off;
}

inline std::size_t unpacker::nonparsed_size() const
{
    return m_used - m_off;
}

inline void unpacker::skip_nonparsed_buffer(std::size_t size)
{
    m_off += size;
}

inline void unpacker::remove_nonparsed_buffer()
{
    m_used = m_off;
}

namespace detail {

inline unpack_return
unpack_imp(const char* data, std::size_t len, std::size_t& off,
           zone& result_zone, object& result, bool& referenced,
           unpack_reference_func f = nullptr, void* user_data = nullptr,
           unpack_limit const& limit = unpack_limit())
{
    std::size_t noff = off;

    if(len <= noff) {
        // FIXME
        return UNPACK_CONTINUE;
    }

    detail::context ctx(f, user_data, limit);
    ctx.init();

    ctx.user().set_zone(result_zone);
    ctx.user().set_referenced(false);
    referenced = false;

    int e = ctx.execute(data, len, noff);
    if(e < 0) {
        return UNPACK_PARSE_ERROR;
    }

    referenced = ctx.user().referenced();
    off = noff;

    if(e == 0) {
        return UNPACK_CONTINUE;
    }

    result = ctx.data();

    if(noff < len) {
        return UNPACK_EXTRA_BYTES;
    }

    return UNPACK_SUCCESS;
}

} // detail

// reference version

#if !defined(MSGPACK_USE_CPP03)

inline unpacked unpack(
    const char* data, std::size_t len, std::size_t& off, bool& referenced,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    object obj;
    msgpack::unique_ptr<zone> z(new zone);
    referenced = false;
    unpack_return ret = detail::unpack_imp(
        data, len, off, *z, obj, referenced, f, user_data, limit);

    switch(ret) {
    case UNPACK_SUCCESS:
        return unpacked(obj, msgpack::move(z));
    case UNPACK_EXTRA_BYTES:
        return unpacked(obj, msgpack::move(z));
    case UNPACK_CONTINUE:
        throw insufficient_bytes("insufficient bytes");
    case UNPACK_PARSE_ERROR:
    default:
        throw parse_error("parse error");
    }
    return unpacked();
}

inline unpacked unpack(
    const char* data, std::size_t len, std::size_t& off,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    return unpack(data, len, off, referenced, f, user_data, limit);
}

inline unpacked unpack(
    const char* data, std::size_t len, bool& referenced,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    std::size_t off = 0;
    return unpack(data, len, off, referenced, f, user_data, limit);
}

inline unpacked unpack(
    const char* data, std::size_t len,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    std::size_t off = 0;
    return unpack(data, len, off, referenced, f, user_data, limit);
}

#endif // !defined(MSGPACK_USE_CPP03)

inline void unpack(unpacked& result,
                   const char* data, std::size_t len, std::size_t& off, bool& referenced,
                   unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    object obj;
    msgpack::unique_ptr<zone> z(new zone);
    referenced = false;
    unpack_return ret = detail::unpack_imp(
        data, len, off, *z, obj, referenced, f, user_data, limit);

    switch(ret) {
    case UNPACK_SUCCESS:
        result.set(obj);
        result.zone() = msgpack::move(z);
        return;
    case UNPACK_EXTRA_BYTES:
        result.set(obj);
        result.zone() = msgpack::move(z);
        return;
    case UNPACK_CONTINUE:
        throw insufficient_bytes("insufficient bytes");
    case UNPACK_PARSE_ERROR:
    default:
        throw parse_error("parse error");
    }
}

inline void unpack(unpacked& result,
                   const char* data, std::size_t len, std::size_t& off,
                   unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    unpack(result, data, len, off, referenced, f, user_data, limit);
}

inline void unpack(unpacked& result,
                   const char* data, std::size_t len, bool& referenced,
                   unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    std::size_t off = 0;
    unpack(result, data, len, off, referenced, f, user_data, limit);
}

inline void unpack(unpacked& result,
                   const char* data, std::size_t len,
                   unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    std::size_t off = 0;
    unpack(result, data, len, off, referenced, f, user_data, limit);
}

inline object unpack(
    zone& z,
    const char* data, std::size_t len, std::size_t& off, bool& referenced,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    object obj;
    referenced = false;
    unpack_return ret = detail::unpack_imp(
        data, len, off, z, obj, referenced, f, user_data, limit);

    switch(ret) {
    case UNPACK_SUCCESS:
        return obj;
    case UNPACK_EXTRA_BYTES:
        return obj;
    case UNPACK_CONTINUE:
        throw insufficient_bytes("insufficient bytes");
    case UNPACK_PARSE_ERROR:
    default:
        throw parse_error("parse error");
    }
    return obj;
}

inline object unpack(
    zone& z,
    const char* data, std::size_t len, std::size_t& off,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    return unpack(z, data, len, off, referenced, f, user_data, limit);
}

inline object unpack(
    zone& z,
    const char* data, std::size_t len, bool& referenced,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    std::size_t off = 0;
    return unpack(z, data, len, off, referenced, f, user_data, limit);
}

inline object unpack(
    zone& z,
    const char* data, std::size_t len,
    unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    bool referenced;
    std::size_t off = 0;
    return unpack(z, data, len, off, referenced, f, user_data, limit);
}

// obsolete
// pointer version
inline void unpack(unpacked* result,
                   const char* data, std::size_t len, std::size_t* off, bool* referenced,
                   unpack_reference_func f, void* user_data, unpack_limit const& limit)
{
    if (off)
        if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data, limit);
        else unpack(*result, data, len, *off, f, user_data, limit);
    else
        if (referenced) unpack(*result, data, len, *referenced, f, user_data, limit);
        else unpack(*result, data, len, f, user_data, limit);
}

inline bool unpacker::default_reference_func(type::object_type /*type*/, std::size_t /*len*/, void*)
{
    return true;
}

}  // MSGPACK_API_VERSION_NAMESPACE(v1)

}  // namespace msgpack

#endif /* msgpack/unpack.hpp */


text:
Here is a [Demo](http://jsfiddle.net/filasienof/m53ob1q6/embedded/result/) of how the qwe Hierarchical state Machines work.

Documentation under development. Code should be final.


text:
                    Please enable JavaScript to view the comments powered by Disqus.
                    comments powered by Disqus


text:
<!DOCTYPE html>

	<title>

            Rutter Inc. -

    Complete profile - Canadian Company Capabilities - Industries and Business - Industry Canada
  </title>

<meta charset="utf-8" />
<meta name="dcterms.language" title="ISO639-2" content="eng" />
<meta name="dcterms.title" content="" />
<meta name="description" content="" />
<meta name="dcterms.description" content="" />
<meta name="dcterms.type" content="report, data set" />
<meta name="dcterms.subject" content="businesses, industry" />
<meta name="dcterms.subject" content="businesses, industry" />
<meta name="dcterms.issued" title="W3CDTF" content="" />
<meta name="dcterms.modified" title="W3CDTF" content="" />
<meta name="keywords" content="" />

<meta name="dcterms.creator" content="" />
<meta name="author" content="" />
<meta name="dcterms.created" title="W3CDTF" content="" />
<meta name="dcterms.publisher" content="" />
<meta name="dcterms.audience" title="icaudience" content="" />
<meta name="dcterms.spatial" title="ISO3166-1" content="" />
<meta name="dcterms.spatial" title="gcgeonames" content="" />
<meta name="dcterms.format" content="HTML" />
<meta name="dcterms.identifier" title="ICsiteProduct" content="536" />

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta content="width=device-width,initial-scale=1" name="viewport">

<meta name = "format-detection" content = "telephone=no">

<meta name="robots" content="noarchive">

<link href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/favicon.ico" rel="icon" type="image/x-icon">
<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/wet-boew.min.css">

<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/theme.min.css">

<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/noscript.min.css" />

<link rel="stylesheet" href="/eic/home.nsf/css/add_WET_4-0_Canada_Apps.css">

  	<link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
  	<link href="/app/ccc/srch/css/print.css" media="print" rel="stylesheet" type="text/css" />

<meta property="legalName" content="Department_of_Industry">

Skip to main content

Skip to "About this site"

Language selection

Français

<object type="image/svg+xml" tabindex="-1" data="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/sig-blk-en.svg"></object> Government of Canada

Search and menus

Search and menus

Topics menu

Jobs

Immigration

Travel

Business

Benefits

Health

Taxes

More services

You are here:

Home

Industries and Business

Canadian Company Capabilities

<input id="showMore" type="hidden" value='more'/>
<input id="showLess" type="hidden" value='less'/>

 Company profile - Canadian Company Capabilities

New Search |

<form name="searchForm" method="post" action="/app/ccc/srch/bscSrch.do">

          <input type="hidden" name="lang" value="eng" />
          <input type="hidden" name="profileId" value="" />
          <input type="hidden" name="prtl" value="1" />
          <input type="hidden" name="searchPage" value="%2Fapp%2Fccc%2Fsrch%2FcccBscSrch.do%3Flang%3Deng%26amp%3Bprtl%3D1%26amp%3Btagid%3D"  />

          <input type="hidden" name="V_SEARCH.scopeCategory" value="CCC.Root" />

          <input type="hidden" name="V_SEARCH.depth" value="1" />
          <input type="hidden" name="V_SEARCH.showStricts" value="false" />
          <input id="repeatSearchBtn" class="btn btn-link" type="submit" value="Return to search results" />

  </form>

| Previous Company

| Next Company

      Third-Party Information Liability Disclaimer

Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.

      Rutter Inc.

Legal/Operating Name:

Rutter Inc.

http://www.rutter.ca

sales@rutter.ca

Mailing Address:

              	<address class="mrgn-bttm-md">

                   70 Brookfield Rd

                    ST. JOHN'S,

                    Newfoundland and Labrador

                  A1E 3T9

                </address>

Location Address:

              	         <address class="mrgn-bttm-md">

                   70 Brookfield Rd

                    ST. JOHN'S,

                    Newfoundland and Labrador

                  A1E 3T9

                         </address>

Tel.:
		      (709) 576-6666

Fax:
		      (709) 576-7635

Logo

Company Profile

            Rutter Inc. radar image processing systems fulfill marine safety, security and environmental monitoring applications. Products include the sigma S6 Ice Navigator™, Small Target Surveillance, and Oil Spill Detection product lines as well as the sigma S6 WaMoS® II wave and current monitoring system. Detection and tracking capabilities of sigma S6 systems are known and trusted throughout the marine industry. It boasts superior high resolution image quality and detailed decision support information for applications such as:

- Iceberg detection, monitoring, and sea ice management

- Security, surveillance and seismic array anti-fouling

- Oil spill detection and response management

- Surveillance and search & rescue

The sigma S6 WaMoS® II wave and current monitoring system uses X-band radar to provide real-time data about significant wave height, peak wave period, peak wave direction, and surface current speed & direction. It is a sophisticated tool used to manage operational risk and support safe operations at sea.  All sigma and WaMoS products are available in combination to provide consolidated information reporting and unparalleled decision support.

				Full profile

				Full profile

				Contact information

                Brian
                Johnston

	                  Title:

  						Strategic Business Development & Regional Sales

                    Area of Responsibility:

                    Export Sales & Marketing.

                  Telephone:

                (709) 748-7137

                  Facsimile:

                (709) 576-7635

                    Email:

                  bjohnston@rutter.ca

                Steve
                Hale

	                  Title:

  						Director of Sales, Marketing, & R&D Business Development

                    Area of Responsibility:

                    Management Executive.

                  Telephone:

                (709) 576-6666

                  Ext:

                7127

                  Facsimile:

                (709) 576-7635

                    Email:

                  shale@rutter.ca

  top of page

				Company description

            Country of Ownership:

              Canada

              Year Established:

            1986

            Exporting:

              Yes

                Quality Certification:

                ISO 9001.

                Primary Industry (NAICS):

				334511 - Navigational and Guidance Instruments Manufacturing

            Primary Business Activity:

            Manufacturer / Processor / Producer

              Total Sales ($CDN):

            $25,000,000 to $49,999,999

              Export Sales ($CDN):

            $25,000,000 to $49,999,999

              Number of Employees:

            50

				Product / Service / Licensing

                              Product Name:

                            Radar Systems

                            High Resolution Radar Processing and Recording Technology

Rutter offers a wide range of enhanced Radar imaging technologies including its Oil Spill Detection System, Ice Navigator Radar, and Small Target Detection System.  These products are offered with Rutter''s complete Radar 100 S6 antenna and transceiver:

Oil Spill Detection

Rutter's sigma S6 Oil Spill Detection system can detect even small quantities of surface oil, outline and estimate the size of the oil slick, and accurately predict the trajectory of the spill.  The complete Oil Spill Response and Management system, integrating radar processing technology with electro-optics capabilities, measures relative thickness of an oil slick and provides oil spill detection, confirmation and management during clean-up operations across a range of visibility conditions in real-time.

Ice Navigator

The Ice Navigator provides the enhanced ability to detect small navigational hazards such as growlers and bergy bits that are difficult to detect with other sensors.  In addition, it provides a photographic like image of pack ice in the vicinity of a vessel across a range of visibility conditions in real-time.  The system provides for improved navigational safety and reduced fuel consumption through ice waters.

Small Target Detection

The Small Target Detection system provides enhanced radar imagery and target detection capabilities.  The standalone radar system is a practical solution for specialty radar applications such as search and rescue and vessel traffic monitoring; its radar and electro-optics integrated system is ideal for surveillance applications, including platform security and antipiracy.

sigma S6 WaMoS II Wave & Current Monitoring System

Developed by our authorized representative, OceanWaveS GmbH, WaMoS II is a proven radar-based wave and surface current monitoring system. It is capable of offering the same information as conventional wave rider buoys and current profiling devices, but for a broader area and in a richer context. Measurements are constantly refreshed while a vessel is underway, which provides real-time data reported from the closest available point of reference. High definition images of wave fields combined with numerical data and intuitive graphical reporting  keep the operator well informed in assessing environmental risk and identifying safe operational windows.

              FSC Code:

              2090-Miscellaneous Ship and Marine Equipment

              5999-Miscellaneous Electrical and Electronic Components

  top of page

					Technology profile

            Rutter Inc. radar image processing systems fulfill marine safety, security and environmental monitoring applications. Products include the sigma S6 Ice Navigator™, Small Target Surveillance, and Oil Spill Detection product lines as well as the sigma S6 WaMoS® II wave and current monitoring system. Detection and tracking capabilities of sigma S6 systems are known and trusted throughout the marine industry. It boasts superior high resolution image quality and detailed decision support information for applications such as:

•	Iceberg detection, monitoring, and sea ice management

•	Security, surveillance and seismic array anti-fouling

•	Oil spill detection and response management

•	Surveillance and search & rescue

The sigma S6 WaMoS® II wave and current monitoring system uses X-band radar to provide real-time data about significant wave height, peak wave period, peak wave direction, and surface current speed & direction. It is a sophisticated tool used to manage operational risk and support safe operations at sea.  All sigma and WaMoS products are available in combination to provide consolidated information reporting and unparalleled decision support.

					Market profile

                        Alliances:

Sales/Marketing

                          Industry sector market interests:

Environment

Fishery

Information Technology and Telecommunications

Manufacturing

Service Industry

Transportation

Aerospace

Defence

Automotive

Electrical Equipment

              Geographic markets:

                  Export experience:

Australia

Germany

Indonesia

Ireland

Italy

Japan

Korea, Republic of

Monaco

Netherlands

Norway

Russian Federation

Singapore

Sweden

Turkey

United Kingdom

United States

  top of page

					Third-Party Information Liability Disclaimer

					Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.

				Contacts

				Contact information

                Brian
                Johnston

	                  Title:

  						Strategic Business Development & Regional Sales

                    Area of Responsibility:

                    Export Sales & Marketing.

                  Telephone:

                (709) 748-7137

                  Facsimile:

                (709) 576-7635

                    Email:

                  bjohnston@rutter.ca

                Steve
                Hale

	                  Title:

  						Director of Sales, Marketing, & R&D Business Development

                    Area of Responsibility:

                    Management Executive.

                  Telephone:

                (709) 576-6666

                  Ext:

                7127

                  Facsimile:

                (709) 576-7635

                    Email:

                  shale@rutter.ca

				Description

				Company description

            Country of Ownership:

              Canada

              Year Established:

            1986

            Exporting:

              Yes

                Quality Certification:

                ISO 9001.

                Primary Industry (NAICS):

				334511 - Navigational and Guidance Instruments Manufacturing

            Primary Business Activity:

            Manufacturer / Processor / Producer

              Total Sales ($CDN):

            $25,000,000 to $49,999,999

              Export Sales ($CDN):

            $25,000,000 to $49,999,999

              Number of Employees:

            50

				Products, services and licensing

				Product / Service / Licensing

                              Product Name:

                            Radar Systems

                            High Resolution Radar Processing and Recording Technology

Rutter offers a wide range of enhanced Radar imaging technologies including its Oil Spill Detection System, Ice Navigator Radar, and Small Target Detection System.  These products are offered with Rutter''s complete Radar 100 S6 antenna and transceiver:

Oil Spill Detection

Rutter's sigma S6 Oil Spill Detection system can detect even small quantities of surface oil, outline and estimate the size of the oil slick, and accurately predict the trajectory of the spill.  The complete Oil Spill Response and Management system, integrating radar processing technology with electro-optics capabilities, measures relative thickness of an oil slick and provides oil spill detection, confirmation and management during clean-up operations across a range of visibility conditions in real-time.

Ice Navigator

The Ice Navigator provides the enhanced ability to detect small navigational hazards such as growlers and bergy bits that are difficult to detect with other sensors.  In addition, it provides a photographic like image of pack ice in the vicinity of a vessel across a range of visibility conditions in real-time.  The system provides for improved navigational safety and reduced fuel consumption through ice waters.

Small Target Detection

The Small Target Detection system provides enhanced radar imagery and target detection capabilities.  The standalone radar system is a practical solution for specialty radar applications such as search and rescue and vessel traffic monitoring; its radar and electro-optics integrated system is ideal for surveillance applications, including platform security and antipiracy.

sigma S6 WaMoS II Wave & Current Monitoring System

Developed by our authorized representative, OceanWaveS GmbH, WaMoS II is a proven radar-based wave and surface current monitoring system. It is capable of offering the same information as conventional wave rider buoys and current profiling devices, but for a broader area and in a richer context. Measurements are constantly refreshed while a vessel is underway, which provides real-time data reported from the closest available point of reference. High definition images of wave fields combined with numerical data and intuitive graphical reporting  keep the operator well informed in assessing environmental risk and identifying safe operational windows.

              FSC Code:

              2090-Miscellaneous Ship and Marine Equipment

              5999-Miscellaneous Electrical and Electronic Components

							Technology

							Technology profile

            Rutter Inc. radar image processing systems fulfill marine safety, security and environmental monitoring applications. Products include the sigma S6 Ice Navigator™, Small Target Surveillance, and Oil Spill Detection product lines as well as the sigma S6 WaMoS® II wave and current monitoring system. Detection and tracking capabilities of sigma S6 systems are known and trusted throughout the marine industry. It boasts superior high resolution image quality and detailed decision support information for applications such as:

•	Iceberg detection, monitoring, and sea ice management

•	Security, surveillance and seismic array anti-fouling

•	Oil spill detection and response management

•	Surveillance and search & rescue

The sigma S6 WaMoS® II wave and current monitoring system uses X-band radar to provide real-time data about significant wave height, peak wave period, peak wave direction, and surface current speed & direction. It is a sophisticated tool used to manage operational risk and support safe operations at sea.  All sigma and WaMoS products are available in combination to provide consolidated information reporting and unparalleled decision support.

					Market

					Market profile

                        Alliances:

Sales/Marketing

                          Industry sector market interests:

Environment

Fishery

Information Technology and Telecommunications

Manufacturing

Service Industry

Transportation

Aerospace

Defence

Automotive

Electrical Equipment

              Geographic markets:

                  Export experience:

Australia

Germany

Indonesia

Ireland

Italy

Japan

Korea, Republic of

Monaco

Netherlands

Norway

Russian Federation

Singapore

Sweden

Turkey

United Kingdom

United States

    Last Update Date 2016-10-05

Date Modified:

      <time>2017-03-02</time>

About government

Contact us

Departments and agencies

Public service and military

News

Treaties, laws and regulations

Government-wide reporting

Prime Minister

How government works

Open government

About this site

Social media

Mobile applications

About Canada.ca

Terms and conditions

Privacy

Top of Page

<object type="image/svg+xml" tabindex="-1" role="img" data="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/wmms-blk.svg" aria-label="Symbol of the Government of Canada"></object>


text:
require 'helper'
require 'shellwords'

module ParadeiserTest
  #
  # We put all integration tests into separate files so we only run one at a
  # time after a change. These tests are expensive to run.
  #
  class IntegrationTest < MiniTest::Test
    PAR = 'bin/par'
    include Executor

    def initialize(*args)
      super(*args)
      @do_not_clear = nil
    end

    def setup
      if Scheduler.list.any?
        @do_not_clear = true
        raise "The at queue '#{queue}' is not empty. Clean it up before running this test again."
      end

      @orig_PAR_DIR = ENV['PAR_DIR']
      ENV['PAR_DIR'] = Dir.mktmpdir(name)
      ENV['PAR_AT_QUEUE'] = 'i'
      assert_command('init')
    end

    def teardown
      FileUtils.rm_rf(Paradeiser.par_dir)
      ENV['PAR_DIR'] = @orig_PAR_DIR
      Scheduler.clear unless @do_not_clear
      raise "The at queue #{queue} is not empty. Clean it up before running this test again." if Scheduler.list.any?
      ENV.delete('PAR_AT_QUEUE')
    end

    def assert_command(cmd, expected_status = 0, *args)
      out, err, status = Open3.capture3("#{PAR} #{cmd} #{Shellwords.join(args)}")
      assert_equal(expected_status, status.exitstatus, "Expected exit status to be #{expected_status}, but it was #{status.exitstatus}. STDERR is: '#{err}'")
      assert_empty(err)
      out
    end

    def refute_command(cmd, expected_status = 1, *args)
      out, err, status = Open3.capture3("#{PAR} #{cmd}")
      assert_equal(expected_status, status.exitstatus, "Expected exit status to be #{expected_status}, but it was #{status.exitstatus}.")
      [out, err]
    end
  end
end