统一变为多个点组成的多边形，用于处理碰撞
517562
def update_points(self):
        
        x, y, w, h = self.x, self.y, self.w, self.h
        self.points = (x, y, x + w, y, x + w, y + h, x, y + h)
337136
public static Object newInstance(Class type) {
        Constructor _constructor = null;
        Object[] _constructorArgs = new Object[0];
        try {
            _constructor = type.getConstructor(new Class[] {});// 先尝试默认的空构造函数
        } catch (NoSuchMethodException e) {
            // ignore
        }

        if (_constructor == null) {// 没有默认的构造函数，尝试别的带参数的函数
            Constructor[] constructors = type.getConstructors();
            if (constructors.length == 0) {
                throw new UnsupportedOperationException("Class[" + type.getName() + "] has no public constructors");
            }
            _constructor = constructors[0];// 默认取第一个参数
            Class[] params = _constructor.getParameterTypes();
            _constructorArgs = new Object[params.length];
            for (int i = 0; i < params.length; i++) {
                _constructorArgs[i] = getDefaultValue(params[i]);
            }
        }

        return ReflectUtils.newInstance(_constructor, _constructorArgs);
    }
1052779
private void writePerData(T data) throws WriteExcelException {
        if (this.needInitSheet()) {
            this.initSheet();
        }
        //将data转换成Map数据结构
        Map<String, Object> mapBean = null;
        if (data instanceof Map) {
            mapBean = (Map<String, Object>) data;
        } else {
            mapBean = CommonUtils.toMap(data);
        }
        Row rowTemp = null;
        if (!this.isBlankLastRow || (this.isBlankLastRow && !this.isSkipBlankRow)) {
            //下移一行
            this.currentRowInSheet++;
            rowTemp = this.currentSheet.createRow(this.currentRowInSheet);
            if (this.defaultHeight > 0) {
                rowTemp.setHeightInPoints(this.defaultHeight);
            }
        } else {
            //上一行是空行,并且配置了需要跳过空行,即不需要写入空行
            rowTemp = this.lastRow;
        }
        boolean isBlankRow = !this.writePerRow(rowTemp, mapBean, data);
        if (!isBlankRow) {
            //非空行
            this.realRowInExcel++;
            this.isBlankLastRow = false;
        } else if (this.isSkipBlankRow) {
            //是空行并且不需要写入空行
            this.isBlankLastRow = true;
            this.lastRow = rowTemp;
        }
    }
747609
@SuppressWarnings("unchecked")
	private void createConnection() throws ThriftConnectionPoolException {
		try {
			transport = new TSocket(host, port, connectionTimeOut);
			transport.open();
			TProtocol protocol = createTProtocol(transport);
			// 反射实例化客户端对象
			Constructor<? extends TServiceClient> clientConstructor = clientClass.getConstructor(TProtocol.class);
			client = (T) clientConstructor.newInstance(protocol);
			if (logger.isDebugEnabled()) {
				logger.debug("创建新连接成功:" + host + " 端口：" + port);
			}
		} catch (Exception e) {
			throw new ThriftConnectionPoolException("无法连接服务器：" + host + " 端口：" + port);
		}
	}
899816
private static int getMachinePiece() {
		// 机器码
		int machinePiece;
		try {
			StringBuilder netSb = new StringBuilder();
			// 返回机器所有的网络接口
			Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
			// 遍历网络接口
			while (e.hasMoreElements()) {
				NetworkInterface ni = e.nextElement();
				// 网络接口信息
				netSb.append(ni.toString());
			}
			// 保留后两位
			machinePiece = netSb.toString().hashCode() << 16;
		} catch (Throwable e) {
			// 出问题随机生成,保留后两位
			machinePiece = (RandomUtil.randomInt()) << 16;
		}
		return machinePiece;
	}
1306440
static byte[] encode(int count) {
        // 计算需要填充的位数
        int amountToPad = BLOCK_SIZE - (count % BLOCK_SIZE);
        if (amountToPad == 0) {
            amountToPad = BLOCK_SIZE;
        }
        // 获得补位所用的字符
        char padChr = chr(amountToPad);
        String tmp = new String();
        for (int index = 0; index < amountToPad; index++) {
            tmp += padChr;
        }
        return tmp.getBytes(CHARSET);
    }
479189
protected void genCell(int columnMaxLen, String preChar, String value, String fillChar, String postChar, StringBuilder ret) {
		ret.append(preChar);
		ret.append(value);
		for (int i=0, n=columnMaxLen-value.length() + 1; i<n; i++) {
			ret.append(fillChar);	// 值后的填充字符，值为 " "、"-"
		}
		ret.append(postChar);
	}
328607
@SuppressWarnings("unchecked")
	
	/**
	 * 返回列表 key 中，下标为 index 的元素。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，
	 * 以 1 表示列表的第二个元素，以此类推。
	 * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * 如果 key 不是列表类型，返回一个错误。
	 */
	public <T> T lindex(Object key, long index) {
		Jedis jedis = getJedis();
		try {
			return (T)valueFromBytes(jedis.lindex(keyToBytes(key), index));
		}
		finally {close(jedis);}
	}
1246848
public int build(List<String> _key, int _length[], int _value[],
                     int _keySize)
    {
        if (_key == null || _keySize > _key.size())
            return 0;

        // progress_func_ = progress_func;
        key = _key;
        length = _length;
        keySize = _keySize;
        value = _value;
        progress = 0;
        allocSize = 0;

        resize(65536 * 32); // 32个双字节

        base[0] = 1;
        nextCheckPos = 0;

        Node root_node = new Node();
        root_node.left = 0;
        root_node.right = keySize;
        root_node.depth = 0;

        List<Node> siblings = new ArrayList<Node>();
        fetch(root_node, siblings);
        insert(siblings, new BitSet());
        shrink();

        // size += (1 << 8 * 2) + 1; // ???
        // if (size >= allocSize) resize (size);

        key = null;
        length = null;

        return error_;
    }
852892
function compile(options) {
    options = options || {};
    var fs = require('fs');
    var content = fs.readFileSync(options.indexFile || INDEX_FILE, 'utf8');
    // 插入同步数据的注入点
    content = content.replace('</head>', '<script>window.__rebas__ = ${rebas}</script>\n</head>');

    var etpl = require('etpl');
    etpl = new etpl.Engine({defaultFilter: 'raw'});
    return etpl.compile(content);
}
360702
private boolean needInitSheet() {
        if (null == this.currentSheet) {
            //证明是第一页,肯定需要初始化
            return true;
        }
        //标识即将写入的下一行的行标
        int nextRowIndex = this.currentRowInSheet;
        if (!this.isBlankLastRow || (this.isBlankLastRow && !this.isSkipBlankRow)) {
            nextRowIndex++;
        }
        return nextRowIndex >= this.allowMaxRows;
    }
819614
function() {
                // 获取现有颜色映射
                //     resource => color_index
                var colorMapping = this._getResourceColorIndexMapping();

                var resource, used, i;

                used = [];

                // 抽取已经使用的值到 used 数组
                for (resource in colorMapping) {
                    if (Object.prototype.hasOwnProperty.call(colorMapping, resource)) {
                        used.push(colorMapping[resource]);
                    }
                }

                // 枚举所有的可用值，如果还没被使用，返回
                for (i = 0; i < RESOURCE_COLOR_SERIES.length; i++) {
                    if (!~used.indexOf(i)) return i;
                }

                // 没有可用的颜色了
                return -1;
            }
382743
function(rules) {
      if (typeOf(rules) === "string") { //当不是hash传入时
        var tmp = {};
        tmp[rules] = arguments[1];
        rules = tmp;
      }
      // 可以同时接受object型或者key, value对的参数
      for (var i in rules) {
        var rule = rules[i];
        if (typeOf(rule) !== "object") {
          rule = {
            regexp: rule
          };
        }
        var reg = rule.regexp;
        if (typeOf(reg) === "regexp") {
          rule.regexp = reg.toString().slice(1, -1);
        }
        // 初始化order
        if (rule.order === undefined) rule.order = 1;
        this._rules[i] = rule;
      }
      // 每进行一次新规则监听，都重新组装一次
      this.setup();
      return this;
    }
146581
public function save()
    {
        /**
         * 使用PHP Sesion，Readonl，未启动 这3种情况下不需要保存
         */
        if ($this->use_php_session or !$this->isStart or $this->readonly)
        {
            return true;
        }
        //设置为Session关闭状态
        $this->isStart = false;
        $key = self::$cache_prefix . $this->sessID;
        return $this->cache->set($key, serialize($_SESSION), $this->session_lifetime);
    }
303479
function Overload() {
		if (arguments.length == 0) {
			throw new ERR.Arguments('1+', 0);
		}
		var args = Array.from(arguments);

		var method = args.pop();
		if (typeof method == 'function') {
			this.method = method;
		}
		else {
			throw new ERR.Generic('overloading implementation function missed');
		}

		// 支持可变长度参数后，用于代表值组长度的数字，也可以用 Param 实例来表征。
		// 在此我们仍保留 argLength，是出于提高性能的考虑。
		if (typeof args[0] == 'number' && args.length == 1) {
			// if (args.length > 1) {
			// 	throw new ERR.Arguments(2, args.length + 1);
			// }
			this.argLength = args[0];
		}
		else if (args[0] instanceof ParamList) {
			if (args.length > 1) {
				throw new ERR.Arguments(2, args.length + 1);
			}
			this.params = args[0];
		}
		else {
			this.params = ParamList.parse.apply(null, args);
		}
	}
412984
function (dataType) {
      // 优先考虑 defaultValue, 其次考虑 genExpression
      if (!dataType.defaultValue && dataType.genExpression) {
        return this._evalExp(dataType.genExpression, dataType, this.ds);
      }
      // todo: 后端返回的格式有点乱, 有时字符有时数字, 这里先统一转成字符
      switch (dataType.id.toString()) {
        case '10001':
          // 字符串类型
          return dataType.defaultValue || this._getStr(null, null, dataType.name);
        case '10002':
          // 数值类型
          var num = parseFloat(dataType.defaultValue);
          return isNaN(num) ? this._getNum(null, 0, dataType.name) : num;
        case '10003':
          // 布尔类型
          var dv = dataType.defaultValue;
          return dv ? !/(^false|0)$/i.test(dv.toLowerCase()) : this._getBool();
        case '10000':
          // 可变类型
          return this._getVar();
        case '9999':
          // 文件类型
          return null;
        default:
          return null;
      }
    }
757452
function handle(e) {
  co(function*() {
    log.debug('error code = %s', e.code);
    log.debug(e.stack || e);
    const handList = utils.getHandleList().concat(innerList);
    // 发送错误日志
    report.error(e.code || 'fie-error', e.stack || e, true);

    for (let i = 0; i < handList.length; i += 1) {
      const res = yield handList[i](e);
      if (res === true) {
        // 说明错误已被处理, 可以直接返回了
        return;
      }
    }
  }).catch(err => {
    console.log(err);
  });
}