text:
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.l = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };

/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};

/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};

/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 9);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

var constants = __webpack_require__(1);

var blankObject = {};
var toString = Object.prototype.toString;
var hasOwnProperty = Object.prototype.hasOwnProperty;

var concat = Array.prototype.concat;
var slice = Array.prototype.slice;
var splice = Array.prototype.splice;
var push = Array.prototype.push;
var pop = Array.prototype.pop;

/**
 * util API
 */
function noop () {}

// convert to String
function _toString (val) {
    return val == null ? '' : typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val);
}

// convert to number
function toNumber (val) {
    var n = parseFloat(val, 10);
    return (n || n === 0) ? n : val;
}

// extend
function extend (object) {
    if (!isObject(object)) {
        return object;
    }
    var size = arguments.length;
    if (size === 0) {
        return blantObject;
    }
    if (size === 1) {
        return object;
    }
    var destination = arguments[0],
        source, key, i = 0;
    for (i = 1; i < size; i++) {
        source = arguments[i];
        for (key in source) {
            if (isObject(source[key])) {
                extend(destination, source[key]);
            } else {
                destination[key] = source[key];
            }
        }
    }
    return destination;
}

function hasOwn (object, key) {
    return isObject(object) && hasOwnProperty.call(object, key);
}

function isFunction (object) {
    return !isNull(object) && !isUndefined(object) && toString.call(object) === '[object Function]';
}

function isObject (object) {
    return !isUndefined(object) && typeof object === 'object';
}

function isPlainObject (object) {
    return object && toString.call(object) === '[object Object]';
}

function isEmptyObject (object) {
    var name;
    for (name in object) {
        return false;
    }

    return true;
}

function isRegex (object) {
    return toString.call(object) === '[object Regex]';
}

function isArray (object) {
    return toString.call(object) === '[object Array]';
}

function isNumber (object) {
    return !isNull(object) && !isUndefined(object) && toString.call(object) === '[object Number]';
}

function isNaN (object) {
    return isNumber(object) && object !== +object;
}

function isNull (object) {
    return object === null;
}

function isUndefined (object) {
    return object === void(0);
}

function isBlooean (Object) {
    return !isNull(object) && isUndefined(object) && toString.call(object) === '[object Blooean]';
}

function log (msg) {
    if (typeof console !== 'undefined') {
        console.log(msg);
    }
}

function error (msg) {
    if (typeof console !== 'undefined') {
        console.error(msg);
    }
}

function warn (msg) {
    if (typeof console !== 'undefined') {
        console.warn(msg);
    }
}

/**
 * cache
 */
function cache (key) {
    var cacheMap = {};
    function cacheFn(key, value) {
        if (value) {
            cacheMap[key] = value;
        } else {
            return cacheMap[key];
        }
    }
    return cacheFn;
}

/**
 * make function
 */
function makeFunction (body) {
    var length = arguments.length;
    if (length) {
        var args;
        if (length > 1) {
            args = slice.call(arguments, 0, length - 1);
        }
        var fn;
        if (args) {
            fn = new Function(args, arguments[length - 1]);
        } else {
            fn = new Function(arguments[length - 1]);
        }
        return fn;
    }
}

/**
 * $bind
 */
function $bind (fn, ctx) {
    function bindFn() {
        if (1 < arguments.length) {
            return fn.apply(ctx, arguments);
        } else {
            return arguments.length ? fn.call(ctx, arguments[0]) : fn.call(ctx);
        }
    }
    return bindFn;
}

/**
 * defProperty
 */
function defProperty (obj, key, value, propertyDescriptor) {
    if (!propertyDescriptor) {
        propertyDescriptor = {};
    }
    Object.defineProperty(obj, key, {
        enumerable: propertyDescriptor.enumerable || true,
        configurable: propertyDescriptor.configurable || true,
        value: propertyDescriptor.value || value
    });
}

/**
 * DOM method
 */
function query (el) {
    if (typeof el === 'string') {
        var selector = el;
        el = document.querySelector(el);
        if (!el) {
            warn('Cannot find element: ' + selector);
            return document.createElement('div');
        }
    }
    return el;
}

function createElement (tagName) {
    return document.createElement(tagName);
}

/** */
var namespaceMap = {
    svg: 'http://www.w3.org/2000/svg',
    math: 'http://www.w3.org/1998/Math/MathML',
    xhtml: 'http://www.w3.org/1999/xhtml'
};

function createElementNS (namespace, tagName) {
    return document.createElementNS(namespaceMap[namespace], tagName)
}

function createTextNode (text) {
    return document.createTextNode(text)
}

function createComment (text) {
    return document.createComment(text)
}

function insertBefore (parentNode, newNode, referenceNode) {
    parentNode.insertBefore(newNode, referenceNode);
}

function removeChild (node, child) {
    node.removeChild(child);
}

function appendChild (node, child) {
    node.appendChild(child);
}

function parentNode (node) {
    return node.parentNode
}

function nextSibling (node) {
    return node.nextSibling
}

function tagName (node) {
    return node.tagName
}

function setTextContent (node, text) {
    node.textContent = text;
}

function getAttribute (node, key) {
    return node.getAttribute(key);
}

function setAttribute (node, key, val) {
    node.setAttribute (key, val);
}

function removeAttribute (node, key) {
    node.removeAttribute(key);
}

function getOuterHTML (node) {
    return node.outerHTML;
}

function isVoDirective (attrName) {
    return (-1 !== attrName.indexOf(constants.ATTR_PREFIX))
}

function isVoModelDirective (attrName) {
    return (attrName === constants.MODEL_ATTR);
}

function isVoEventDirectivePrefix (attrName) {
    return (-1 !== attrName.indexOf(constants.EVENT_ATTR_PREFIX));
}

module.exports = {
    isVoDirective: isVoDirective,
    isVoModelDirective: isVoModelDirective,
    isVoEventDirectivePrefix: isVoEventDirectivePrefix,
    blankObject: blankObject,
    toString: toString,
    hasOwnProperty: hasOwnProperty,
    concat: concat,
    slice: slice,
    splice: splice,
    push: push,
    pop: pop,
    noop: noop,
    _toString: _toString,
    toNumber: toNumber,
    extend: extend,
    hasOwn: hasOwn,
    isFunction: isFunction,
    isObject: isObject,
    isPlainObject: isPlainObject,
    isEmptyObject: isEmptyObject,
    isRegex: isRegex,
    isArray: isArray,
    isNumber: isNumber,
    isNaN: isNaN,
    isNull: isNull,
    isUndefined: isUndefined,
    isBlooean: isBlooean,
    log: log,
    warn: warn,
    error: error,
    cache: cache,
    makeFunction: makeFunction,
    $bind: $bind,
    defProperty: defProperty,
    query: query,
    createElement: createElement,
    createElementNS: createElementNS,
    createTextNode: createTextNode,
    createComment: createComment,
    insertBefore: insertBefore,
    removeChild: removeChild,
    appendChild: appendChild,
    parentNode: parentNode,
    nextSibling: nextSibling,
    tagName: tagName,
    setTextContent: setTextContent,
    setAttribute: setAttribute,
    removeAttribute: removeAttribute,
    getOuterHTML: getOuterHTML
};

/***/ }),
/* 1 */
/***/ (function(module, exports) {

var EMPTY_STRING = "";
var ONE_CHAR_STRING = " ";
var LEFT_DELIMITER = '{{';
var RIGHT_DELIMITER = '}}';
var ATTR_PREFIX = "vo-";
var MODEL_ATTR = ATTR_PREFIX + "model";
var EVENT_ATTR_PREFIX = ATTR_PREFIX + "on:";

module.exports = {
    EMPTY_STRING: EMPTY_STRING,
    ONE_CHAR_STRING: ONE_CHAR_STRING,
    LEFT_DELIMITER: LEFT_DELIMITER,
    RIGHT_DELIMITER: RIGHT_DELIMITER,
    ATTR_PREFIX: ATTR_PREFIX,
    EVENT_ATTR_PREFIX: EVENT_ATTR_PREFIX,
    MODEL_ATTR: MODEL_ATTR
};

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

var utils = __webpack_require__(0);
var constants = __webpack_require__(1);

var preWhiteSpaceCharRE = /^(\s*).*/gm;
var postWhiteSpaceCharRE = /.*\s*$/gm;

function advance (last, advanceSteps) {
    last = last.substring(advanceSteps);
    return last;
}

function parse (vo, nodeName, last) {
    var stack = [];
    // parseWhiteSpaceChar(vo, last, preWhiteSpaceCharRE, stack);
    parseChar(vo, nodeName, last, stack);
    var templateFnBody = makeTemplateFnBody(stack);
    var templateFn = utils.makeFunction("vo", templateFnBody);
    return templateFn;
}

function makeTemplateFnBody (stack) {
    var templateFnBody = "\"\"";
    if (stack && stack.length) {
        templateFnBody = stack.join(' + ').trim();
    }
    templateFnBody = "with(vo) { return " + templateFnBody + ";}";
    return templateFnBody;
}

function parseWhiteSpaceChar (vo, last, re, stack) {
    var result = re.exec(last)
    if (result && result[1]) {
        var whiteSpaceChars = result[1];
        stack.push("_ts(\"" + whiteSpaceChars.trim() + "\")");
        last = advance(last, whiteSpaceChars.length);
    }
}

function parseChar (vo, nodeName, last, stack) {
    var ldIndex = -1;
    var rdIndex = -1;
    var leftDelimiter = constants.LEFT_DELIMITER;
    var rightDelimiter = constants.RIGHT_DELIMITER;
    while (last) {
        ldIndex = last.indexOf(leftDelimiter);
        rdIndex = last.indexOf(rightDelimiter);
        if (ldIndex !== -1 && rdIndex !== -1) {
            // var token = last.substring(0, ldIndex).trim();
            var token = last.substring(0, ldIndex).replace(/\r/g, constants.ONE_CHAR_STRING).replace(/\n/g, constants.ONE_CHAR_STRING).replace(/\t/g, constants.ONE_CHAR_STRING);
            stack.push("_ts(\"" + token + "\")");
            last = advance(last, ldIndex);
            ldIndex = last.indexOf(leftDelimiter);
            rdIndex = last.indexOf(rightDelimiter);
            var responseVar = last.substring(leftDelimiter.length, rdIndex).trim();
            if (/\s+/.test(responseVar)) {
                throw new Error("\n[vo error] failed to compile template: \n" +
                    vo.$cache(vo.elem) + "\n- invalid expression: \n" +
                    last.substring(0, rdIndex + rightDelimiter.length));
            }
            if (!utils.hasOwn(vo, responseVar)) {
                throw new Error("\n[vo error] Property or method `" +
                    responseVar + "` is not defined on the instance but referenced during render. \n" +
                    "Make sure to declare reactive data properties in the data option.");
            }
            stack.push("_ts(" + responseVar + ")");
            last = advance(last, rdIndex + rightDelimiter.length);
        } else {
            // last = last.trim();
            last = last.replace(/\r/g, constants.ONE_CHAR_STRING).replace(/\n/g, constants.ONE_CHAR_STRING).replace(/\t/g, constants.ONE_CHAR_STRING);
            stack.push("_ts(\"" + last + "\")");
            last = advance(last, last.length);
        }
        ldIndex = rdIndex = -1;
    }
}

function compile$1 (vo) {
    compile$2(vo, vo.$vRootNode);
}

function compile$2 (vo, node) {
    var nodeType = node.nodeType;
    if (nodeType === 1 || nodeType === 2 || nodeType === 3) {
        refreshVdom(vo, node);
        var childNodes = node.childNodes;
        for (var i = 0, lI = childNodes.length; i < lI; i++) {
            compile$2(vo, childNodes[i]);
        }
    }
}

function refreshVdom (vo, node) {
    var attributeMap = node.attributeMap;
    if (attributeMap) {
        var attr;
        for (var i = 0, l = attributeMap.length; i < l; i++) {
            attr = attributeMap[i];
            attr.attrValue = attr.templateFn(vo);
        }
    } else {
        node.data = node.templateFn(vo);
    }
}

module.exports = {
    parse: parse,
    compile$1: compile$1,
    compile$2: compile$2
};

/***/ }),
/* 3 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/*
 * created by mawei 2017.02.05
 */

var uuid = 1;

var utils = __webpack_require__(0);
var cache = utils.cache();
var browser = __webpack_require__(5);
var observer = __webpack_require__(6);
var vdom = __webpack_require__(8);
var render = __webpack_require__(7);

function registResponse (obj, key, value, otherConfig) {
    var ownPropertyDescriptor = Object.getOwnPropertyDescriptor(obj, key);
    var getter = ownPropertyDescriptor && ownPropertyDescriptor.get;
    var setter = ownPropertyDescriptor && ownPropertyDescriptor.set;
    Object.defineProperty(obj, key, {
        enumerable: true,
        configurable: true,
        get: function () {
            var val = getter ? getter.call(obj) : value;
            return val;
        },
        set: function (newValue) {
            var nowValue = getter ? getter.call(obj) : value;
            if (newValue === nowValue || (newValue !== newValue && nowValue !== nowValue)) {
                return;
            }
            if (setter) {
                setter.call(obj, newValue);
            } else {
                value = newValue;
            }
            obj.$observer.publish(obj, otherConfig.$sub.uuid);
            vdom.patch(vo, vo.$vRootNode, vo._vRootNode);
        }
    });
}

function responseSetterProxy (key, value) {
    var vo = this;
    if (!value) {
        value = vo[key];
    }
    vo[key] = value;
    vdom.patch(vo, vo.$vRootNode, vo._vRootNode);
}

function responseGetterProxy (key) {
    var vo = this;
    return vo[key];
}

/**
 * Vo constructor
 */
function Vo (options) {
    if (!(this instanceof Vo)) {
        utils.warn('please use `new` keyword to create Vo object.');
        return new Vo(options);
    }
    this.init$1(options);
}

initMixin$2();

function initMinin$1 (vo) {
    vo.$cache = cache;
    vdom.beforeCreateVDOM(vo);
    vdom.createVDOM$1(vo);
    vdom.afterCreateVDOM(vo);
    render.renderDOM$1(vo);
}

/**
 * initialize method
 */
function init$1 (options) {
    if (utils.isNull(options) ||
        utils.isUndefined(options) ||
        !utils.isObject(options) ||
        utils.isEmptyObject(options)
    ) {
        return;
    }
    if (!utils.hasOwn(options, 'elem') || !options.elem) {
        utils.warn('Vo must has elem.');
        return;
    }
    var vo = this;
    mount$1(vo, options);
    initMinin$1(vo);
}

/**
 * mount
 */
function mount$1 (vo, options) {
    mount$2(vo, options);
}

function mount$2 (vo, options) {
    mount$moitor(vo, options);
    mount$data(vo, options);
    mount$method(vo, options);
    utils.extend(vo, options);
}

function mount$moitor (vo, options) {
    utils.defProperty(vo, '$monitors', {});
    utils.extend(vo.$monitors, options.monitors);
    options.monitors = null;
}

function mount$data (vo, options) {
    utils.extend(vo, options.data);
    vo.$observer = new observer.Observer(vo);
    if (options.data && utils.isObject(options.data)) {
        var key;
        for (key in options.data) {
            var sub = new observer.Subject(vo, utils._toString(key), vo.$monitors[key]);
            vo.$observer.addSub(sub);
            registResponse(vo, key, options.data[key], {
                $sub: sub
            });
        }
    }
    options.data = null;
}

function mount$method (vo, options) {
    utils.defProperty(vo, '$methods', {});
    var key;
    for (key in options.methods) {
        utils.defProperty(vo.$methods, key, utils.$bind(options.methods[key], vo));
    }
    options.methods = null;
}

/**
 * initMinin$2
 */
function initMixin$2 () {
    /**
     * extend inner method
     */
    utils.extend(Vo.prototype, {
        version: '1.0.0',
        init$1: init$1,
        _ts: utils._toString,
        $responseSetterProxy: responseSetterProxy,
        $responseGetterProxy: responseGetterProxy
    });
    Vo.prototype.utils = utils;
}

module.exports = Vo;

/***/ }),
/* 5 */
/***/ (function(module, exports) {

var inBrowser = typeof window !== 'undefined';

module.exports = {
    inBrowser: inBrowser
}

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

var utils = __webpack_require__(0);
var compiler = __webpack_require__(2);
var uuid = 1;

function Subject (vo, subName, monitorFn) {
    if (!(this instanceof Subject)) {
        return new Subject(subName, monitor);
    }
    this.uuid = uuid++;
    this.vo = vo;
    this.subName = subName;
    this.monitor = new Monitor(vo, monitorFn);
}

Subject.prototype.registMonitor = function (monitor) {
    if (!(monitor instanceof Monitor)) {
        return;
    }
    this.monitor = monitor;
}

Subject.prototype.removeMonitor = function () {
    this.monitor = null;
}

Subject.prototype.notify = function (vo) {
    this.monitor.update(vo, this.subName);
}

function Monitor (vo, monitorFn) {
    if (!(this instanceof Monitor)) {
        return new Monitor(vo, monitorFn);
    }
    this.uuid = uuid++;
    this.vo = vo;
    this.monitorFn = monitorFn;
}

Monitor.prototype.update = function (vo, subName) {
    if (utils.isFunction(this.monitorFn)) {
        this.monitorFn.call(vo, vo.$responseGetterProxy(subName));
    }
}

function Observer (vo, sub) {
    if (!(this instanceof Observer)) {
        return new Observer(vo, sub);
    }
    this.uuid = uuid++;
    this.vo = vo;
    var subs = [];
    if (sub) {
        subs.push(sub);
    }
    this.subs = subs;
}

Observer.prototype.addSub = function (sub) {
    if (!(sub instanceof Subject)) {
        return;
    }
    this.subs.push(sub);
}

Observer.prototype.removeSub = function (uuid) {
    if (uuid) {
        var subs = this.subs;
        for (var i = 0, l = subs.length; i < l; i++) {
            if (uuid === subs[i]['uuid']) {
                subs.splice(i, 1);
                break;
            }
        }
    } else {
        this.subs = [];
    }
}

Observer.prototype.publish = function (vo, uuid) {
    if (uuid) {
        var subs = utils.slice.call(this.subs);
        for (var i = 0, l = subs.length; i < l; i++) {
            if (uuid === subs[i]['uuid']) {
                var sub = subs[i];
                sub.notify(vo);
                break;
            }
        }
    } else {
        var subs = uitls.slice.call(this.subs);
        var sub;
        for (var i = 0, l = subs.length; i < l; i++) {
            var sub = subs[i];
            sub.notify(vo);
        }
    }
}

module.exports = {
    Monitor: Monitor,
    Subject: Subject,
    Observer: Observer
};

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

var compiler = __webpack_require__(2);
var utils = __webpack_require__(0);
var constants = __webpack_require__(1);

function beforeRenderDOM (vo) {
    // vo.$observer.publish(vo);
    compiler.compile$1(vo);
}

function renderDOM$1 (vo) {
    beforeRenderDOM(vo);
    var dom = renderDOM$2(vo);
    renderDOM$5(vo, dom);
    afterRenderDOM(vo);
}

function renderDOM$2 (vo) {
    var rootNode = vo.$vRootNode;
    var dom = renderDOM$3(vo, void(0), rootNode);
    renderDOM$4(vo, dom, rootNode);
    return dom;
}

function renderDOM$3 (vo, parentNode, node) {
    var nodeType = node.nodeType;
    var elemNode;
    switch (nodeType) {
        case 1:
            elemNode = utils.createElement(node.nodeName);
            var attributeMap = node.attributeMap;
            for (var i = 0, l = attributeMap.length; i < l; i++) {
                setAttributeWarpper(vo, elemNode, attributeMap[i]['attrName'], attributeMap[i]['attrValue']);
            }
            if (parentNode) {
                utils.appendChild(parentNode, elemNode);
            }
            node.elemRef = elemNode;
            break;
        case 3:
            var targetTextNode = utils.createTextNode(node.data);
            utils.appendChild(parentNode, targetTextNode);
            node.elemRef = targetTextNode;
            elemNode = parentNode;
            break;
        default:
            elemNode = parentNode;
            break;
    }
    return elemNode;
}

function renderDOM$4 (vo, parentNode, node) {
    var childNodes = node.childNodes;
    var elemNode;
    for (var i = 0, l = childNodes.length; i < l; i++) {
        elemNode = renderDOM$3(vo, parentNode, childNodes[i]);
        renderDOM$4(vo, elemNode, childNodes[i]);
    }
}

function renderDOM$5 (vo, dom) {
    var $elem = utils.query(vo.elem);
    var pn = $elem.parentNode;
    if (pn) {
        utils.insertBefore(pn, dom, $elem);
        utils.removeChild(pn, $elem);
    }
}

function afterRenderDOM (vo) {

}

function addEventListener (vo, elemNode, eventType, listener) {
    elemNode.addEventListener(eventType, vo.$methods[listener]);
}

function addEventListener$2 (vo, elemNode, eventType, listener) {
    elemNode.addEventListener(eventType, listener);
}

function getVoEventType (attrName) {
    return attrName.substring(constants.EVENT_ATTR_PREFIX.length);
}

function setAttributeWarpper (vo, elemNode, attrName, attrValue) {
    if (utils.isVoDirective(attrName)) {
        handleDirectives(vo, elemNode, attrName, attrValue);
    } else {
        utils.setAttribute(elemNode, attrName, attrValue);
    }
}

function trigger (elemNode, type) {
    var event = document.createEvent("HTMLEvents");
    event.initEvent(type, true, true);
    elemNode.dispatchEvent(event);
}

function handleDirectives (vo, elemNode, attrName, attrValue) {
    if (utils.isVoModelDirective(attrName)) {
        handleModelDirective(vo, elemNode, attrName, attrValue);
    }else if (utils.isVoEventDirectivePrefix(attrName)) {
        handleEventDirective(vo, elemNode, attrName, attrValue);
    }
}

function handleModelDirective (vo, elemNode, attrName, attrValue) {
    elemNode.value = vo.$responseGetterProxy(attrValue);
    if (elemNode.nodeName === "INPUT") {
        var listener = utils.$bind(function(attrValue) {
            this[attrValue] = elemNode.value;
        }, vo);
        addEventListener$2(vo, elemNode, "input", function() {
            listener(attrValue);
        });
    }
}

function handleEventDirective (vo, elemNode, attrName, attrValue) {
    var eventType = getVoEventType(attrName);
    addEventListener(vo, elemNode, eventType, attrValue)
}

module.exports = {
    renderDOM$1: renderDOM$1
}

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

var utils = __webpack_require__(0);
var compiler = __webpack_require__(2);
var constants = __webpack_require__(1);

function convertAttrToList (vo, nodeName, attributes) {
    var attrList;
    if (attributes) {
        attrList = [];
        var currentAttr;
        for (var i = 0, l = attributes.length; i < l; i++) {
            currentAttr = attributes[i];
            handleNodeAttr(vo, nodeName, currentAttr, attrList);
        }
    }
    return attrList;
}

function handleNodeAttr (vo, nodeName, currentAttr, attrList) {
    var attrName = currentAttr.nodeName;
    var attrObject = {
        attrName: attrName,
        attrValue: currentAttr.nodeValue,
        nodeName: nodeName,
        nodeType: currentAttr.nodeType,
        operation: 0
    };
    handleSpecialAttr(vo, nodeName, currentAttr, attrObject);
    attrObject.templateFn = compiler.parse(vo, nodeName, currentAttr.nodeValue);
    attrList.push(attrObject);
}

function handleSpecialAttr (vo, nodeName, currentAttr, attrObject) {

}

function beforeCreateVDOM (vo) {
    vo.$elem = utils.query(vo.elem);
    if (!vo.$cache(vo.elem)) {
        var template = utils.getOuterHTML(vo.$elem);
        vo.$cache(vo.elem, template);
    }
}

function VNode (vo, elemRef, nodeName, nodeType, attributeMap, data, parentNode, childNodes) {
    if (!(this instanceof VNode)) {
        return new VNode(vo, elemRef, nodeName, nodeType, attributeMap, data, parentNode, childNodes);
    }
    this.vo = vo;
    this.elemRef = elemRef;
    this.nodeName = nodeName;
    this.nodeType = nodeType;
    this.attributeMap = convertAttrToList(vo, nodeName, attributeMap);
    this.templateFn = compiler.parse(vo, nodeName, data);
    this.data = data;
    this.parentNode = parentNode;
    this.childNodes = childNodes;
    this.dirty = false;
    this.operation = 0;
}

function cloneVNode (vn) {
    var cloned;
    if (vn) {
        var childrenNodes = vn.childNodes.slice();
        var attributeMap = vn.attributeMap;
        if (attributeMap) {
            attributeMap = vn.attributeMap.slice();
        }
        cloned = new VNode(vn.vo, vn.elemRef, vn.nodeName, vn.nodeType, attributeMap, vn.data, vn.parentNode, childNodes);
    }
    return cloned;
}

function cloneAttribute (attr) {
    var cloned;
    if (attr) {
        cloned = {
            attrName: attr.attrName,
            attrValue: attr.nodeValue,
            nodeName: attr.nodeName,
            nodeType: attr.nodeType,
            operation: attr.operation
        };
    }
    return cloned;
}

function createVDOM$1 (vo) {
    vo.$vRootNode = new VNode(vo, vo.$elem, vo.$elem.nodeName, vo.$elem.nodeType, vo.$elem.attributes, vo.$elem.data, null, []);
    vo._vRootNode = new VNode(vo, vo.$elem, vo.$elem.nodeName, vo.$elem.nodeType, vo.$elem.attributes, vo.$elem.data, null, []);
    genVDOMTree(vo, vo.$vRootNode, vo.$elem.childNodes);
    genVDOMTree(vo, vo._vRootNode, vo.$elem.childNodes); // used to patch
}

function genVDOMTree (vo, rootNode, childNodes) {
    var parentNode = rootNode;
    for (var i = 0, l = childNodes.length; i < l; i++) {
        var cn = childNodes[i];
        if (cn.nodeType === 1 || cn.nodeType === 3) {
            var atrributeMap = cn.attributes;
            var vNode = new VNode(vo, cn, cn.nodeName, cn.nodeType, atrributeMap, cn.data, parentNode, []);
            parentNode.childNodes.push(vNode);
            genVDOMTree(vo, vNode, cn.childNodes);
        }
    }
}

function afterCreateVDOM (vo) {
    utils.log(vo.$vRootNode);
}

function patch (vo, oldVNode, newVNode) {
    // compiler.compile$2(vo, vo._vRootNode);
    patchVNode(vo, oldVNode, newVNode);
}

function patchVNode (vo, oldVNode, newVNode) {
    var nodeType = (oldVNode.nodeType === newVNode.nodeType) ? oldVNode.nodeType : 0;
    switch (nodeType) {
        case 1:
            patchAttributes(vo, oldVNode, newVNode);
            patchChildren(vo, oldVNode, newVNode);
            break;
        case 2:
            break;
        case 3:
            patchTextContent(vo, oldVNode, newVNode);
            break;
        default:
            break;
    }
}

function updateTextContent (elemRef, text) {
    utils.setTextContent(elemRef, text);
}

function patchTextContent (vo, oldVNode, newVNode) {
    if (utils.isFunction(newVNode.templateFn)) {
        var newData = newVNode.templateFn(vo);
        if (oldVNode.data !== newData) {
            oldVNode.data = newData
            oldVNode.templateFn = compiler.parse(vo, newVNode.nodeName, newVNode.data);
            updateTextContent(oldVNode.elemRef, newData);
        }
    }
}

function patchChildren (vo, oldVNode, newVNode) {
    var oldChildren = oldVNode.childNodes;
    var newChildren = newVNode.childNodes;
    updateChildren(vo, oldVNode.elemRef, oldChildren, newChildren);
}

function removeElement (vo, elemRef) {
    utils.removeChild(utls.parentNode(elemRef), elemRef);
}

function createElement (vo, parentElemRef, nodeName, attrList, children) {
    var elemRef;
    if (parentElemRef) {
        utils.appendChild(parentElemRef, elemRef);
    }
    attrList = attrList || [];
    var i, len;
    for (i = 0, len = attrList.length; i < len; i++) {
        utils.setAttribute(elemRef, attrList[i]["attrName"], attrList[i]["attrValue"]);
    }
    for (i = 0, len = children.length; i < len; i++) {
        createElement(vo, elemRef, children[i]["nodeName"], children[i]["attributeMap"], children[i]["childNodes"]);
    }
}

function createTextNode (vo, parentElemRef, text) {
    var textNode = utils.createTextNode(text);
    utils.appendChild(parentElemRef, textNode);
}

function updateChildren (vo, elemRef, oldChildren, newChildren) {
    var currentNode;
    var i = 0, lenI = newChildren.length;
    while (i < lenI) {
        currentNode = newChildren[i];
        switch (currentNode["operation"]) {
            case 1: // add
                var clonedVNode = cloneVNode(currentNode);
                clonedVNode.parentNode =
                cloneVNode.templateFn = compiler.parse(vo, newVNode.nodeName, newVNode.data);
                oldChildren.splice(i, 1, clonedVNode);
                if (clonedVNode.nodeType === 1) {
                    createElement(vo, clonedVNode.parentNode.elemRef, clonedVNode.nodeName, clonedVNode.attributeMap, clonedVNode.childNodes);
                } else if (clonedVNode.nodeType === 3) {
                    createTextNode(vo, clonedVNode.parentNode.elemRef, clonedVNode.data);
                }
                break;
            case -1: // delete
                oldChildren.splice(i, 1);
                newChildren.splice(i, 1);
                lenI--;
                removeElement(newChildren[i]["elemRef"]);
                break;
            case 0: // normalUpdate
                patchVNode(vo, oldChildren[i], newChildren[i]);
                break;
            default:
                break;
        }
        currentNode["operation"] = 0;
        i++;
    }
}

function updateAttribute (elemRef, attrName, attrValue, operation) {
    if (operation === -1) {
      utils.removeAttribute(elemRef, attrName);
    } else {
        utils.setAttribute(elemRef, attrName, attrValue);
    }
}

function abnormalUpdateAttribute (vo, elemRef, oldAttrMap, newAttrMap) {
    var len = oldAttrMap.length - newAttrMap.length;
    var indicator = len < 0 ? 1 : len === 0 ? 0 : -1;
    switch (indicator) {
        case 1: // add
            var otherUpdateAttrMap = newAttrMap.slice(newAttrMap.length + len);
            var templateFn;
            for (var i = 0, l = otherUpdateAttrMap.length; i < l; i++) {
                templateFn = otherUpdateAttrMap[i]["templateFn"];
                if (utils.isFunction(templateFn)) {
                    otherUpdateAttrMap[i]["attrValue"] = templateFn(vo);
                    updateAttribute(elemRef, otherUpdateAttrMap[i]["attrName"], otherUpdateAttrMap[i]["attrValue"]);
                }
            }
            oldAttrMap = oldAttrMap.concat(otherUpdateAttrMap);
            break;
        case -1: // delete
            for (var i = len, l = oldAttrMap.length; i < l; i++) {
                utils.removeAttribute(elemRef, oldAttrMap[i]["attrName"]);
            }
            oldAttrMap = oldAttrMap.slice(0, oldAttrMap.length + len);
            break;
        default:
            break;
    }
}

function patchAttributes (vo, oldVNode, newVNode) {
    var oldAttrMap = oldVNode.attributeMap;
    var newAttrMap = newVNode.attributeMap;
    // abnormalUpdateAttribute
    if (!oldAttrMap && !newAttrMap) {
        return;
    }
    if ((!oldAttrMap && newAttrMap) ||
        (oldAttrMap && !newAttrMap)
    ){
        abnormalUpdateAttribute (vo, oldVNode.elemRef, (oldAttrMap || []), (newAttrMap || []));
        return;
    }
    var currentAttr;
    var i = 0, lenI = newAttrMap.length;
    while (i < lenI) {
        currentAttr = newAttrMap[i];
        switch (currentAttr["operation"]) {
            case 1: // add
                var clonedAttr = cloneAttribute(currentAttr);
                clonedAttr.templateFn = compiler.parse(vo, clonedAttr.nodeName, clonedAttr.attrValue);
                oldAttrMap.splice(i, 1, clonedAttr);
                updateAttribute(oldVNode.elemRef, clonedAttr.attrName, clonedAttr.attrValue, 1);
                break;
            case -1: // delete
                oldAttrMap.splice(i, 1);
                newAttrMap.splice(i, 1);
                lenI--;
                updateAttribute(oldVNode.elemRef, clonedAttr.attrName, clonedAttr.attrValue, -1);
                break;
            case 0: // normalUpdate
                var newAttrValue = newAttrMap[i].templateFn(vo);
                if (utils.isVoDirective(newAttrMap[i]["attrName"])) {
                    if (utils.isVoModelDirective(newAttrMap[i]["attrName"])) {
                        if (newAttrMap[i]["nodeName"] === "INPUT") {
                            oldVNode.elemRef.value = vo.$responseGetterProxy(newAttrValue);
                        }
                    }
                } else {
                    if (newAttrValue !== oldAttrMap[i]["attrValue"]) {
                        oldAttrMap[i]["attrValue"] = newAttrValue;
                        oldAttrMap[i]["templateFn"] = compiler.parse(vo, oldVNode.nodeName, currentAttr.attrValue);
                        updateAttribute(oldVNode.elemRef, currentAttr.attrName, newAttrValue, 0);
                    }
                }
                break;
            default:
                break;
        }
        currentAttr["operation"] = 0;
        i++;
    }
    // abnormalUpdateAttribute
    abnormalUpdateAttribute (vo, oldVNode.elemRef, oldAttrMap, newAttrMap);
}

module.exports = {
    beforeCreateVDOM: beforeCreateVDOM,
    createVDOM$1: createVDOM$1,
    afterCreateVDOM: afterCreateVDOM,
    VNode: VNode,
    genVDOMTree: genVDOMTree,
    patch: patch
};

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {(function () {
    global.Vo = __webpack_require__(4);
})();
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ })
/******/ ]);


text:
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:paddingTop="5dp"
              android:paddingBottom="5dp">

    <TextView
        style="@style/Text.ListItem"
        android:id="@+id/lbl_speech"
        android:textColor="@android:color/white"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

</LinearLayout>

redpajama_set_name: RedPajamaGithub


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package model.exceptions;

/**
 *
 * @author Anderson Souza
 */
public class CampoNuloException extends Exception{

    public CampoNuloException() {
    }

    public CampoNuloException(String message) {
        super(message);
    }

    public CampoNuloException(Throwable cause) {
        super(cause);
    }

    public CampoNuloException(String message, Throwable cause) {
        super(message, cause);
    }

    @Override
    public String getMessage() {
        return super.getMessage(); //To change body of generated methods, choose Tools | Templates.
    }

}


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.6
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2015.10.11 at 12:10:41 PM PDT
//

package maven.pom.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

/**
 *  3.0.0+
 *
 *
Java class for Build complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="Build">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <all>
 *         <element name="sourceDirectory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="scriptSourceDirectory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="testSourceDirectory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="outputDirectory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="testOutputDirectory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="extensions" minOccurs="0">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="extension" type="{http://maven.apache.org/POM/4.0.0}Extension" maxOccurs="unbounded" minOccurs="0"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *         <element name="defaultGoal" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="resources" minOccurs="0">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="resource" type="{http://maven.apache.org/POM/4.0.0}Resource" maxOccurs="unbounded" minOccurs="0"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *         <element name="testResources" minOccurs="0">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="testResource" type="{http://maven.apache.org/POM/4.0.0}Resource" maxOccurs="unbounded" minOccurs="0"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *         <element name="directory" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="finalName" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="filters" minOccurs="0">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="filter" type="{http://www.w3.org/2001/XMLSchema}string" maxOccurs="unbounded" minOccurs="0"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *         <element name="pluginManagement" type="{http://maven.apache.org/POM/4.0.0}PluginManagement" minOccurs="0"/>
 *         <element name="plugins" minOccurs="0">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="plugin" type="{http://maven.apache.org/POM/4.0.0}Plugin" maxOccurs="unbounded" minOccurs="0"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *       </all>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Build", namespace = "http://maven.apache.org/POM/4.0.0", propOrder = {

})
public class Build
    implements Serializable
{

    private final static long serialVersionUID = 1L;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String sourceDirectory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String scriptSourceDirectory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String testSourceDirectory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String outputDirectory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String testOutputDirectory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected Build.Extensions extensions;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String defaultGoal;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected Build.Resources resources;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected Build.TestResources testResources;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String directory;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected String finalName;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected Build.Filters filters;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected PluginManagement pluginManagement;
    @XmlElement(namespace = "http://maven.apache.org/POM/4.0.0")
    protected Build.Plugins plugins;

    /**
     * Gets the value of the sourceDirectory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getSourceDirectory() {
        return sourceDirectory;
    }

    /**
     * Sets the value of the sourceDirectory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setSourceDirectory(String value) {
        this.sourceDirectory = value;
    }

    /**
     * Gets the value of the scriptSourceDirectory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getScriptSourceDirectory() {
        return scriptSourceDirectory;
    }

    /**
     * Sets the value of the scriptSourceDirectory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setScriptSourceDirectory(String value) {
        this.scriptSourceDirectory = value;
    }

    /**
     * Gets the value of the testSourceDirectory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getTestSourceDirectory() {
        return testSourceDirectory;
    }

    /**
     * Sets the value of the testSourceDirectory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setTestSourceDirectory(String value) {
        this.testSourceDirectory = value;
    }

    /**
     * Gets the value of the outputDirectory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getOutputDirectory() {
        return outputDirectory;
    }

    /**
     * Sets the value of the outputDirectory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setOutputDirectory(String value) {
        this.outputDirectory = value;
    }

    /**
     * Gets the value of the testOutputDirectory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getTestOutputDirectory() {
        return testOutputDirectory;
    }

    /**
     * Sets the value of the testOutputDirectory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setTestOutputDirectory(String value) {
        this.testOutputDirectory = value;
    }

    /**
     * Gets the value of the extensions property.
     *
     * @return
     *     possible object is
     *     {@link Build.Extensions }
     *
     */
    public Build.Extensions getExtensions() {
        return extensions;
    }

    /**
     * Sets the value of the extensions property.
     *
     * @param value
     *     allowed object is
     *     {@link Build.Extensions }
     *
     */
    public void setExtensions(Build.Extensions value) {
        this.extensions = value;
    }

    /**
     * Gets the value of the defaultGoal property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getDefaultGoal() {
        return defaultGoal;
    }

    /**
     * Sets the value of the defaultGoal property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setDefaultGoal(String value) {
        this.defaultGoal = value;
    }

    /**
     * Gets the value of the resources property.
     *
     * @return
     *     possible object is
     *     {@link Build.Resources }
     *
     */
    public Build.Resources getResources() {
        return resources;
    }

    /**
     * Sets the value of the resources property.
     *
     * @param value
     *     allowed object is
     *     {@link Build.Resources }
     *
     */
    public void setResources(Build.Resources value) {
        this.resources = value;
    }

    /**
     * Gets the value of the testResources property.
     *
     * @return
     *     possible object is
     *     {@link Build.TestResources }
     *
     */
    public Build.TestResources getTestResources() {
        return testResources;
    }

    /**
     * Sets the value of the testResources property.
     *
     * @param value
     *     allowed object is
     *     {@link Build.TestResources }
     *
     */
    public void setTestResources(Build.TestResources value) {
        this.testResources = value;
    }

    /**
     * Gets the value of the directory property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getDirectory() {
        return directory;
    }

    /**
     * Sets the value of the directory property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setDirectory(String value) {
        this.directory = value;
    }

    /**
     * Gets the value of the finalName property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getFinalName() {
        return finalName;
    }

    /**
     * Sets the value of the finalName property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setFinalName(String value) {
        this.finalName = value;
    }

    /**
     * Gets the value of the filters property.
     *
     * @return
     *     possible object is
     *     {@link Build.Filters }
     *
     */
    public Build.Filters getFilters() {
        return filters;
    }

    /**
     * Sets the value of the filters property.
     *
     * @param value
     *     allowed object is
     *     {@link Build.Filters }
     *
     */
    public void setFilters(Build.Filters value) {
        this.filters = value;
    }

    /**
     * Gets the value of the pluginManagement property.
     *
     * @return
     *     possible object is
     *     {@link PluginManagement }
     *
     */
    public PluginManagement getPluginManagement() {
        return pluginManagement;
    }

    /**
     * Sets the value of the pluginManagement property.
     *
     * @param value
     *     allowed object is
     *     {@link PluginManagement }
     *
     */
    public void setPluginManagement(PluginManagement value) {
        this.pluginManagement = value;
    }

    /**
     * Gets the value of the plugins property.
     *
     * @return
     *     possible object is
     *     {@link Build.Plugins }
     *
     */
    public Build.Plugins getPlugins() {
        return plugins;
    }

    /**
     * Sets the value of the plugins property.
     *
     * @param value
     *     allowed object is
     *     {@link Build.Plugins }
     *
     */
    public void setPlugins(Build.Plugins value) {
        this.plugins = value;
    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="extension" type="{http://maven.apache.org/POM/4.0.0}Extension" maxOccurs="unbounded" minOccurs="0"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "extensions"
    })
    public static class Extensions
        implements Serializable
    {

        private final static long serialVersionUID = 1L;
        @XmlElement(name = "extension", namespace = "http://maven.apache.org/POM/4.0.0")
        protected List<Extension> extensions;

        /**
         * Gets the value of the extensions property.
         *
         *

         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a set method for the extensions property.
         *
         *

         * For example, to add a new item, do as follows:
         *

         *    getExtensions().add(newItem);
         *

         *
         *
         *

         * Objects of the following type(s) are allowed in the list
         * {@link Extension }
         *
         *
         */
        public List<Extension> getExtensions() {
            if (extensions == null) {
                extensions = new ArrayList<Extension>();
            }
            return this.extensions;
        }

    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="filter" type="{http://www.w3.org/2001/XMLSchema}string" maxOccurs="unbounded" minOccurs="0"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "filters"
    })
    public static class Filters
        implements Serializable
    {

        private final static long serialVersionUID = 1L;
        @XmlElement(name = "filter", namespace = "http://maven.apache.org/POM/4.0.0")
        protected List<String> filters;

        /**
         * Gets the value of the filters property.
         *
         *

         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a set method for the filters property.
         *
         *

         * For example, to add a new item, do as follows:
         *

         *    getFilters().add(newItem);
         *

         *
         *
         *

         * Objects of the following type(s) are allowed in the list
         * {@link String }
         *
         *
         */
        public List<String> getFilters() {
            if (filters == null) {
                filters = new ArrayList<String>();
            }
            return this.filters;
        }

    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="plugin" type="{http://maven.apache.org/POM/4.0.0}Plugin" maxOccurs="unbounded" minOccurs="0"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "plugins"
    })
    public static class Plugins
        implements Serializable
    {

        private final static long serialVersionUID = 1L;
        @XmlElement(name = "plugin", namespace = "http://maven.apache.org/POM/4.0.0")
        protected List<Plugin> plugins;

        /**
         * Gets the value of the plugins property.
         *
         *

         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a set method for the plugins property.
         *
         *

         * For example, to add a new item, do as follows:
         *

         *    getPlugins().add(newItem);
         *

         *
         *
         *

         * Objects of the following type(s) are allowed in the list
         * {@link Plugin }
         *
         *
         */
        public List<Plugin> getPlugins() {
            if (plugins == null) {
                plugins = new ArrayList<Plugin>();
            }
            return this.plugins;
        }

    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="resource" type="{http://maven.apache.org/POM/4.0.0}Resource" maxOccurs="unbounded" minOccurs="0"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "resources"
    })
    public static class Resources
        implements Serializable
    {

        private final static long serialVersionUID = 1L;
        @XmlElement(name = "resource", namespace = "http://maven.apache.org/POM/4.0.0")
        protected List<Resource> resources;

        /**
         * Gets the value of the resources property.
         *
         *

         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a set method for the resources property.
         *
         *

         * For example, to add a new item, do as follows:
         *

         *    getResources().add(newItem);
         *

         *
         *
         *

         * Objects of the following type(s) are allowed in the list
         * {@link Resource }
         *
         *
         */
        public List<Resource> getResources() {
            if (resources == null) {
                resources = new ArrayList<Resource>();
            }
            return this.resources;
        }

    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="testResource" type="{http://maven.apache.org/POM/4.0.0}Resource" maxOccurs="unbounded" minOccurs="0"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "testResources"
    })
    public static class TestResources
        implements Serializable
    {

        private final static long serialVersionUID = 1L;
        @XmlElement(name = "testResource", namespace = "http://maven.apache.org/POM/4.0.0")
        protected List<Resource> testResources;

        /**
         * Gets the value of the testResources property.
         *
         *

         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a set method for the testResources property.
         *
         *

         * For example, to add a new item, do as follows:
         *

         *    getTestResources().add(newItem);
         *

         *
         *
         *

         * Objects of the following type(s) are allowed in the list
         * {@link Resource }
         *
         *
         */
        public List<Resource> getTestResources() {
            if (testResources == null) {
                testResources = new ArrayList<Resource>();
            }
            return this.testResources;
        }

    }

}


text:
#region License

#endregion License

using System.Collections.Generic;

namespace Irony.Parsing
{
	/// <summary>
	/// The <see cref="Scanner"/>'s function is to transform a stream of characters into aggregates/words or lexemes,
	/// like identifier, number, literal, etc.
	/// </summary>
	public class Scanner
	{
		#region Properties and Fields: Data, _source

		public readonly ScannerData Data;
		public readonly Parser Parser;
		private Grammar grammar;

		private ParsingContext Context
		{
			get { return Parser.Context; }
		}

		#endregion Properties and Fields: Data, _source

		public Scanner(Parser parser)
		{
			this.Parser = parser;
			this.Data = parser.Language.ScannerData;
			this.grammar = parser.Language.Grammar;

			// Create token streams
			var tokenStream = this.GetUnfilteredTokens();

			// Chain all token filters
			this.Context.TokenFilters.Clear();

			this.grammar.CreateTokenFilters(this.Data.Language, this.Context.TokenFilters);

			foreach (TokenFilter filter in this.Context.TokenFilters)
			{
				tokenStream = filter.BeginFiltering(this.Context, tokenStream);
			}

			this.Context.FilteredTokens = tokenStream.GetEnumerator();
		}

		public Token GetToken()
		{
			// Get new token from pipeline
			if (!this.Context.FilteredTokens.MoveNext())
				return null;

			var token = this.Context.FilteredTokens.Current;
			if (this.Context.Status == ParserStatus.Previewing)
				this.Context.PreviewTokens.Push(token);
			else
				this.Context.CurrentParseTree.Tokens.Add(token);
			return token;
		}

		internal void Reset()
		{
		}

		/// <summary>
		/// This is iterator method, so it returns immediately when called directly
		/// returns unfiltered, "raw" token stream
		/// </summary>
		/// <returns></returns>
		private IEnumerable<Token> GetUnfilteredTokens()
		{
			// We don't do "while(!_source.EOF())... because on EOF() we need to continue and produce EOF token
			while (true)
			{
				this.Context.PreviousToken = this.Context.CurrentToken;
				this.Context.CurrentToken = null;

				this.NextToken();
				this.Context.OnTokenCreated();

				yield return Context.CurrentToken;
				// Don't yield break, continue returning EOF
			}
		}

		#region Scanning tokens

		private void ComputeCurrentTerminals()
		{
			this.Context.CurrentTerminals.Clear();

			TerminalList termsForCurrentChar;

			if (!this.Data.TerminalsLookup.TryGetValue(this.Context.Source.PreviewChar, out termsForCurrentChar))
				termsForCurrentChar = this.Data.NoPrefixTerminals;

			// If we are recovering, previewing or there's no parser state, then return list as is
			if (this.Context.Status == ParserStatus.Recovering ||
				this.Context.Status == ParserStatus.Previewing ||
				this.Context.CurrentParserState == null ||
				this.grammar.LanguageFlags.IsSet(LanguageFlags.DisableScannerParserLink) ||
				this.Context.Mode == ParseMode.VsLineScan)
			{
				this.Context.CurrentTerminals.AddRange(termsForCurrentChar);
				return;
			}

			// Try filtering terms by checking with parser which terms it expects;
			var parserState = this.Context.CurrentParserState;
			foreach (var term in termsForCurrentChar)
			{
				// Note that we check the OutputTerminal with parser, not the term itself;
				// in most cases it is the same as term, but not always
				if (parserState.ExpectedTerminals.Contains(term.OutputTerminal) || this.grammar.NonGrammarTerminals.Contains(term))
					this.Context.CurrentTerminals.Add(term);
			}
		}

		/// <summary>
		/// This method is a last attempt by scanner to match ANY terminal, after regular matching (by input char) had failed.
		/// Likely this will produce some token which is invalid for current parser state (for ex, identifier where a number
		/// is expected); in this case the parser will report an error as "Error: expected number".
		/// if this matching fails, the scanner will produce an error as "unexpected character."
		/// </summary>
		/// <returns></returns>
		private bool MatchAllTerminals()
		{
			this.Context.CurrentTerminals.Clear();
			this.Context.CurrentTerminals.AddRange(this.Data.Language.GrammarData.Terminals);
			this.MatchTerminals();

			if (Context.CurrentToken is MultiToken)
				this.UnpackMultiToken();

			return this.Context.CurrentToken != null;
		}

		private bool MatchNonGrammarTerminals()
		{
			TerminalList terms;

			if (!this.Data.NonGrammarTerminalsLookup.TryGetValue(this.Context.Source.PreviewChar, out terms))
				return false;

			foreach (var term in terms)
			{
				this.Context.Source.PreviewPosition = this.Context.Source.Location.Position;
				this.Context.CurrentToken = term.TryMatch(this.Context, this.Context.Source);

				if (this.Context.CurrentToken != null)
					term.OnValidateToken(this.Context);

				if (this.Context.CurrentToken != null)
				{
					// Check if we need to fire LineStart token before this token;
					// We do it only if the token is not a comment; comments should be ignored by the outline logic
					var token = this.Context.CurrentToken;
					if (token.Category == TokenCategory.Content && this.NeedLineStartToken(token.Location))
					{
						// Buffer current token; we'll eject LineStart instead
						this.Context.BufferedTokens.Push(token);

						// Set it back to the start of the token
						this.Context.Source.Location = token.Location;

						// Generate LineStart
						this.Context.CurrentToken = this.Context.Source.CreateToken(this.grammar.LineStartTerminal);

						// Update LineStart
						this.Context.PreviousLineStart = this.Context.Source.Location;
					}
					return true;
				}
			}

			this.Context.Source.PreviewPosition = this.Context.Source.Location.Position;
			return false;
		}

		private bool MatchRegularTerminals()
		{
			// We need to eject LineStart BEFORE we try to produce a real token; this LineStart token should reach
			// the parser, make it change the state and with it to change the set of expected tokens. So when we
			// finally move to scan the real token, the expected terminal set is correct.
			if (this.NeedLineStartToken(this.Context.Source.Location))
			{
				this.Context.CurrentToken = this.Context.Source.CreateToken(this.grammar.LineStartTerminal);
				this.Context.PreviousLineStart = this.Context.Source.Location;

				return true;
			}

			// Find matching terminal
			// First, try terminals with explicit "first-char" prefixes, selected by current char in source
			this.ComputeCurrentTerminals();

			// If we have more than one candidate; let grammar method select
			if (this.Context.CurrentTerminals.Count > 1)
				this.grammar.OnScannerSelectTerminal(this.Context);

			this.MatchTerminals();

			// If we don't have a token from terminals, try Grammar's method
			if (this.Context.CurrentToken == null)
				this.Context.CurrentToken = this.grammar.TryMatch(this.Context, this.Context.Source);

			if (this.Context.CurrentToken is MultiToken)
				this.UnpackMultiToken();

			return this.Context.CurrentToken != null;
		}

		private void MatchTerminals()
		{
			Token priorToken = null;

			for (int i = 0; i < this.Context.CurrentTerminals.Count; i++)
			{
				var term = this.Context.CurrentTerminals[i];

				// If we have priorToken from prior term in the list, check if prior term has higher priority than this term;
				// if term.Priority is lower then we don't need to check anymore, higher priority (in prior token) wins
				// Note that terminals in the list are sorted in descending priority order
				if (priorToken != null && priorToken.Terminal.Priority > term.Priority)
					return;

				// Reset source position and try to match
				this.Context.Source.PreviewPosition = this.Context.Source.Location.Position;

				var token = term.TryMatch(this.Context, this.Context.Source);
				if (token == null)
					continue;

				// Skip it if it is shorter than previous token
				if (priorToken != null && !priorToken.IsError() && (token.Length < priorToken.Length))
					continue;

				// Now it becomes current token
				this.Context.CurrentToken = token;

				// Validate it
				term.OnValidateToken(this.Context);

				if (this.Context.CurrentToken != null)
					priorToken = this.Context.CurrentToken;
			}
		}

		private bool NeedLineStartToken(SourceLocation forLocation)
		{
			return this.grammar.LanguageFlags.IsSet(LanguageFlags.EmitLineStartToken) && forLocation.Line > this.Context.PreviousLineStart.Line;
		}

		private void NextToken()
		{
			// 1. Check if there are buffered tokens
			if (this.Context.BufferedTokens.Count > 0)
			{
				this.Context.CurrentToken = this.Context.BufferedTokens.Pop();
				return;
			}

			// 2. Skip whitespace.
			this.grammar.SkipWhitespace(this.Context.Source);

			// 3. That's the token start, calc location (line and column)
			this.Context.Source.Position = this.Context.Source.PreviewPosition;

			// 4. Check for EOF
			if (this.Context.Source.EOF())
			{
				this.Context.CurrentToken = new Token(this.grammar.Eof, this.Context.Source.Location, string.Empty, this.grammar.Eof.Name); ;
				return;
			}

			// 5. Actually scan the source text and construct a new token
			this.ScanToken();
		}

		/// <summary>
		/// Scans the source text and constructs a new token
		/// </summary>
		private void ScanToken()
		{
			if (!this.MatchNonGrammarTerminals() && !this.MatchRegularTerminals())
			{
				// We are in error already; try to match ANY terminal and let the parser report an error
				this.MatchAllTerminals(); //try to match any terminal out there
			}

			var token = this.Context.CurrentToken;

			// If we have normal token then return it
			if (token != null && !token.IsError())
			{
				var src = this.Context.Source;

				// Set position to point after the result token
				src.PreviewPosition = src.Position + token.Length;
				src.Position = src.PreviewPosition;

				return;
			}

			// We have an error: either error token or no token at all
			if (token == null)   //if no token then create error token
				this.Context.CurrentToken = this.Context.CreateErrorToken(Resources.ErrInvalidChar, this.Context.Source.PreviewChar);

			this.Recover();
		}

		/// <summary>
		/// If token is MultiToken then push all its child tokens into _bufferdTokens and return the first token in buffer
		/// </summary>
		private void UnpackMultiToken()
		{
			var token = Context.CurrentToken as MultiToken;

			if (token == null)
				return;

			for (int i = token.ChildTokens.Count - 1; i >= 0; i--)
			{
				this.Context.BufferedTokens.Push(token.ChildTokens[i]);
			}

			this.Context.CurrentToken = this.Context.BufferedTokens.Pop();
		}

		#endregion Scanning tokens

		#region VS Integration methods

		/// <summary>
		/// Use this method for VS integration; VS language package requires scanner that returns tokens one-by-one.
		/// Start and End positions required by this scanner may be derived from Token :
		/// start=token.Location.Position; end=start + token.Length;
		/// </summary>
		/// <param name="state"></param>
		/// <returns></returns>
		public Token VsReadToken(ref int state)
		{
			this.Context.VsLineScanState.Value = state;

			if (this.Context.Source.EOF())
				return null;

			if (state == 0)
				this.NextToken();
			else
			{
				Terminal term = this.Data.MultilineTerminals[this.Context.VsLineScanState.TerminalIndex - 1];
				this.Context.CurrentToken = term.TryMatch(this.Context, this.Context.Source);
			}

			// Set state value from context
			state = this.Context.VsLineScanState.Value;

			if (this.Context.CurrentToken != null && this.Context.CurrentToken.Terminal == this.grammar.Eof)
				return null;

			return this.Context.CurrentToken;
		}

		public void VsSetSource(string text, int offset)
		{
			var line = this.Context.Source == null ? 0 : this.Context.Source.Location.Line;
			var newLoc = new SourceLocation(offset, line + 1, 0);
			this.Context.Source = new SourceStream(text, this.Context.Language.Grammar.CaseSensitive, this.Context.TabWidth, newLoc);
		}

		#endregion VS Integration methods

		#region Error recovery

		/// <summary>
		/// Simply skip until whitespace or delimiter character
		/// </summary>
		/// <returns></returns>
		private bool Recover()
		{
			var src = this.Context.Source;
			src.PreviewPosition++;

			while (!this.Context.Source.EOF())
			{
				if (this.grammar.IsWhitespaceOrDelimiter(src.PreviewChar))
				{
					src.Position = src.PreviewPosition;
					return true;
				}

				src.PreviewPosition++;
			}

			return false;
		}

		#endregion Error recovery

		#region TokenPreview

		/// <summary>
		/// Preview mode allows custom code in grammar to help parser decide on appropriate action in case of conflict
		/// Preview process is simply searching for particular tokens in "preview set", and finding out which of the
		/// tokens will come first.
		/// In preview mode, tokens returned by FetchToken are collected in _previewTokens list; after finishing preview
		///  the scanner "rolls back" to original position - either by directly restoring the position, or moving the preview
		///  tokens into _bufferedTokens list, so that they will read again by parser in normal mode.
		/// See c# grammar sample for an example of using preview methods
		/// </summary>
		private SourceLocation previewStartLocation;

		/// <summary>
		/// Switches Scanner into preview mode
		/// </summary>
		public void BeginPreview()
		{
			this.Context.Status = ParserStatus.Previewing;
			this.previewStartLocation = this.Context.Source.Location;
			this.Context.PreviewTokens.Clear();
		}

		/// <summary>
		/// Ends preview mode
		/// </summary>
		/// <param name="keepPreviewTokens"></param>
		public void EndPreview(bool keepPreviewTokens)
		{
			if (keepPreviewTokens)
			{
				// Insert previewed tokens into buffered list, so we don't recreate them again
				while (this.Context.PreviewTokens.Count > 0)
				{
					this.Context.BufferedTokens.Push(this.Context.PreviewTokens.Pop());
				}
			}
			else
				this.Context.SetSourceLocation(this.previewStartLocation);

			this.Context.PreviewTokens.Clear();
			this.Context.Status = ParserStatus.Parsing;
		}

		#endregion TokenPreview
	}
}


text:
<?php

namespace main\BibliothequeBundle\Entity;

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

/**
 * Arme
 *
 * @ORM\Table(name="arme")
 * @ORM\Entity(repositoryClass="main\BibliothequeBundle\Repository\ArmeRepository")
 */
class Arme {

    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="nom", type="string", length=255)
     */
    private $nom;

    /**
     * @var string
     *
     * @ORM\Column(name="genre", type="string", length=255)
     */
    private $genre;

    /**
     * @var string
     *
     * @ORM\Column(name="type", type="string", length=255)
     */
    private $type;

    /**
     * @var string
     *
     * @ORM\Column(name="groupe", type="string", length=255)
     */
    private $groupe;

    /**
     * @var float
     *
     * @ORM\Column(name="portee", type="float")
     */
    private $portee;

    /**
     * @var string
     *
     * @ORM\Column(name="modes", type="string", length=255)
     */
    private $modes;

    /**
     * @var string
     *
     * @ORM\Column(name="degats", type="string", length=255)
     */
    private $degats;

    /**
     * @var string
     *
     * @ORM\Column(name="type_degats", type="string", length=2)
     */
    private $typeDegats;

    /**
     * @var int
     *
     * @ORM\Column(name="penetration", type="integer")
     */
    private $penetration;

    /**
     * @var int
     *
     * @ORM\Column(name="autonomie", type="integer")
     */
    private $autonomie;

    /**
     * @var int
     *
     * @ORM\Column(name="rechargement", type="integer")
     */
    private $rechargement;

    /**
     * @var float
     *
     * @ORM\Column(name="poids", type="float")
     */
    private $poids;

    /**
     * @var int
     *
     * @ORM\Column(name="bonus_bf", type="integer")
     */
    private $bonusBf;

    /**
     * @var float
     *
     * @ORM\Column(name="prix", type="float")
     */
    private $prix;

    /**
     * @var string
     *
     * @ORM\Column(name="disponibilite", type="string", length=255)
     */
    private $disponibilite;

    /**
     * @var string
     *
     * @ORM\Column(name="description", type="text")
     */
    private $description;

    /**
     * @ORM\ManyToMany(targetEntity="main\BibliothequeBundle\Entity\AccessoireArme", cascade={"persist"})
     */
    private $accessoires;

    /**
     * @ORM\ManyToMany(targetEntity="main\BibliothequeBundle\Entity\AttributArme", cascade={"persist"})
     */
    private $attributs;

    /**
     * @ORM\ManyToOne(targetEntity="main\BibliothequeBundle\Entity\Extension")
     * @ORM\JoinColumn(nullable=true)
     */
    private $extension;

    public function __construct() {
        $this->accessoires = new ArrayCollection();
        $this->attributs = new ArrayCollection();
    }

    /**
     * Get id
     *
     * @return int
     */
    public function getId() {
        return $this->id;
    }

    /**
     * Set nom
     *
     * @param string $nom
     *
     * @return Arme
     */
    public function setNom($nom) {
        $this->nom = $nom;

        return $this;
    }

    /**
     * Get nom
     *
     * @return string
     */
    public function getNom() {
        return $this->nom;
    }

    /**
     * Set genre
     *
     * @param string $genre
     *
     * @return Arme
     */
    public function setGenre($genre) {
        $this->genre = $genre;

        return $this;
    }

    /**
     * Get genre
     *
     * @return string
     */
    public function getGenre() {
        return $this->genre;
    }

    /**
     * Set type
     *
     * @param string $type
     *
     * @return Arme
     */
    public function setType($type) {
        $this->type = $type;

        return $this;
    }

    /**
     * Get type
     *
     * @return string
     */
    public function getType() {
        return $this->type;
    }

    /**
     * Set groupe
     *
     * @param string $groupe
     *
     * @return Arme
     */
    public function setGroupe($groupe) {
        $this->groupe = $groupe;

        return $this;
    }

    /**
     * Get groupe
     *
     * @return string
     */
    public function getGroupe() {
        return $this->groupe;
    }

    /**
     * Set portee
     *
     * @param float $portee
     *
     * @return Arme
     */
    public function setPortee($portee) {
        $this->portee = $portee;

        return $this;
    }

    /**
     * Get portee
     *
     * @return float
     */
    public function getPortee() {
        return $this->portee;
    }

    /**
     * Set modes
     *
     * @param string $modes
     *
     * @return Arme
     */
    public function setModes($modes) {
        $this->modes = $modes;

        return $this;
    }

    /**
     * Get modes
     *
     * @return string
     */
    public function getModes() {
        return $this->modes;
    }

    /**
     * Set degats
     *
     * @param string $degats
     *
     * @return Arme
     */
    public function setDegats($degats) {
        $this->degats = $degats;

        return $this;
    }

    /**
     * Get degats
     *
     * @return string
     */
    public function getDegats() {
        return $this->degats;
    }

    /**
     * Set typeDegats
     *
     * @param string $typeDegats
     *
     * @return Arme
     */
    public function setTypeDegats($typeDegats) {
        $this->typeDegats = $typeDegats;

        return $this;
    }

    /**
     * Get typeDegats
     *
     * @return string
     */
    public function getTypeDegats() {
        return $this->typeDegats;
    }

    /**
     * Set penetration
     *
     * @param integer $penetration
     *
     * @return Arme
     */
    public function setPenetration($penetration) {
        $this->penetration = $penetration;

        return $this;
    }

    /**
     * Get penetration
     *
     * @return int
     */
    public function getPenetration() {
        return $this->penetration;
    }

    /**
     * Set autonomie
     *
     * @param integer $autonomie
     *
     * @return Arme
     */
    public function setAutonomie($autonomie) {
        $this->autonomie = $autonomie;

        return $this;
    }

    /**
     * Get autonomie
     *
     * @return int
     */
    public function getAutonomie() {
        return $this->autonomie;
    }

    /**
     * Set rechargement
     *
     * @param integer $rechargement
     *
     * @return Arme
     */
    public function setRechargement($rechargement) {
        $this->rechargement = $rechargement;

        return $this;
    }

    /**
     * Get rechargement
     *
     * @return int
     */
    public function getRechargement() {
        return $this->rechargement;
    }

    /**
     * Set poids
     *
     * @param float $poids
     *
     * @return Arme
     */
    public function setPoids($poids) {
        $this->poids = $poids;

        return $this;
    }

    /**
     * Get poids
     *
     * @return float
     */
    public function getPoids() {
        return $this->poids;
    }

    /**
     * Set bonusBf
     *
     * @param integer $bonusBf
     *
     * @return Arme
     */
    public function setBonusBf($bonusBf) {
        $this->bonusBf = $bonusBf;

        return $this;
    }

    /**
     * Get bonusBf
     *
     * @return int
     */
    public function getBonusBf() {
        return $this->bonusBf;
    }

    /**
     * Set prix
     *
     * @param float $prix
     *
     * @return Arme
     */
    public function setPrix($prix) {
        $this->prix = $prix;

        return $this;
    }

    /**
     * Get prix
     *
     * @return float
     */
    public function getPrix() {
        return $this->prix;
    }

    /**
     * Set disponibilite
     *
     * @param string $disponibilite
     *
     * @return Arme
     */
    public function setDisponibilite($disponibilite) {
        $this->disponibilite = $disponibilite;

        return $this;
    }

    /**
     * Get disponibilite
     *
     * @return string
     */
    public function getDisponibilite() {
        return $this->disponibilite;
    }

    /**
     * Set description
     *
     * @param string $description
     *
     * @return Arme
     */
    public function setDescription($description) {
        $this->description = $description;

        return $this;
    }

    /**
     * Get description
     *
     * @return string
     */
    public function getDescription() {
        return $this->description;
    }

    /**
     * Add accessoire
     *
     * @param \main\BibliothequeBundle\Entity\AccessoireArme $accessoire
     *
     * @return Arme
     */
    public function addAccessoire(\main\BibliothequeBundle\Entity\AccessoireArme $accessoire)
    {
        $this->accessoires[] = $accessoire;

        return $this;
    }

    /**
     * Remove accessoire
     *
     * @param \main\BibliothequeBundle\Entity\AccessoireArme $accessoire
     */
    public function removeAccessoire(\main\BibliothequeBundle\Entity\AccessoireArme $accessoire)
    {
        $this->accessoires->removeElement($accessoire);
    }

    /**
     * Get accessoires
     *
     * @return \Doctrine\Common\Collections\Collection
     */
    public function getAccessoires()
    {
        return $this->accessoires;
    }

    /**
     * Add attribut
     *
     * @param \main\BibliothequeBundle\Entity\AttributArme $attribut
     *
     * @return Arme
     */
    public function addAttribut(\main\BibliothequeBundle\Entity\AttributArme $attribut)
    {
        $this->attributs[] = $attribut;

        return $this;
    }

    /**
     * Remove attribut
     *
     * @param \main\BibliothequeBundle\Entity\AttributArme $attribut
     */
    public function removeAttribut(\main\BibliothequeBundle\Entity\AttributArme $attribut)
    {
        $this->attributs->removeElement($attribut);
    }

    /**
     * Get attributs
     *
     * @return \Doctrine\Common\Collections\Collection
     */
    public function getAttributs()
    {
        return $this->attributs;
    }

    /**
     * Set extension
     *
     * @param \main\BibliothequeBundle\Entity\Extension $extension
     *
     * @return Arme
     */
    public function setExtension(\main\BibliothequeBundle\Entity\Extension $extension = null)
    {
        $this->extension = $extension;

        return $this;
    }

    /**
     * Get extension
     *
     * @return \main\BibliothequeBundle\Entity\Extension
     */
    public function getExtension()
    {
        return $this->extension;
    }
}


text:
import {Injectable} from '@angular/core';
import {Http} from '@angular/http';
import {Weather} from './weather';
import {Observable} from 'rxjs/Observable';
import 'rxjs/add/operator/map';

@Injectable()
export class WeatherService {
    private weatherApiURLstring = "http://api.openweathermap.org/data/2.5/weather?q=London,uk&appid=414885d939ea7344847c181fb7f59b07";

    constructor(private _http:Http){}

    getWeatherUrl(city:string) {
        return this.weatherApiURLstring + "&q=" + city;
    }

    getWeather(city: string) {
        return new Observable((observable:any) => {
            this._http.get(this.getWeatherUrl(city))
                .map(res => res.json())
                .subscribe(res => {
                    var weather: Weather = res.weather[0];
                    weather.city = city;
                    observable.next(weather);
                });
        });
    }
}


text:
package org.jetbrains.plugins.scala.util.internal

import com.intellij.psi.PsiElement
import org.jetbrains.plugins.scala.extensions._
import org.jetbrains.plugins.scala.util.internal.I18nBundleContent._

import java.io._
import java.nio.file.{Path, Paths}
import scala.io.Source

case class I18nBundleContent(entries: Seq[Entry]) {
  def hasKey(key: String): Boolean = entries.exists(_.key == key)

  def sorted: I18nBundleContent =
    copy(entries = entries.sorted)

  def withEntry(entry: Entry): I18nBundleContent = {
    val (before, after) = entries.partition(entryOrdering.lteq(_, entry))
    I18nBundleContent(before ++ Seq(entry) ++ after)
  }

  def writeTo(path: String): Unit =
    writeTo(new PrintWriter(new File(path)))

  def writeTo(outputStream: OutputStream): Unit =
    writeTo(new PrintWriter(outputStream))

  private def writeTo(printWriter: PrintWriter): Unit = try {
    import printWriter._
    var path: String = null
    //make println platform-independent
    def println(s: String = ""): Unit = {
      print(s)
      print("\n")
    }
    for (entry <- entries) {
      if (path != entry.path) {
        if (path != null) {
          println()
        }
        path = entry.path
        println(PathHeader.prefix + path)
      }
      print(entry.comments)
      println(entry.key + "=" + entry.text)
    }
  } finally printWriter.close()
}

object I18nBundleContent {
  val noPath = "<no-path>"
  val unusedPath = "<unused>"

  implicit val entryOrdering: Ordering[Entry] =
    Ordering.by((entry: Entry) => entry.isUnused -> entry.path)

  case class Entry(key: String, text: String, path: String, comments: String = "") {
    def isUnused: Boolean = path == unusedPath
  }

  def read(bundlePath: String): I18nBundleContent = {
    val lines = {
      val source = Source.fromFile(bundlePath)
      try source.getLines().toArray
      finally source.close()
    }

    var comments = ""
    var path = noPath
    val result = Seq.newBuilder[Entry]

    var i = 0
    while (lines.indices contains i) {
      val line = lines(i)
      line match {
        case PathHeader(newPath) =>
          if (comments != "")
            throw new Exception(s"Comment might get lost: '$comments'")
          path = newPath

        case _ if line.startsWith("#") =>
          comments += line + "\n"

        case _ if line.contains("=") =>
          var (key, value) = line.split("=").toSeq match { case key +: rest => key -> rest.mkString("=")}
          while (value.last == '\\') {
            i += 1
            value = value + "\n" + lines(i)
          }
          result += Entry(key, value, path, comments)
          comments = ""
        case _ =>
      }
      i += 1
    }

    new I18nBundleContent(result.result())
  }

  private object PathHeader {
    val prefix = "### "
    def unapply(line: String): Option[String] = {
      val isNewPath = line.startsWith(prefix) &&
        (line.contains('.') && line.contains('/') || line.contains(unusedPath))
      isNewPath.option(line.substring(prefix.length))
    }
  }

  case class BundleInfo(bundleFilePath: String, bundleClassPath: String, bundleClassName: String, bundleQualifiedClassName: String)
  case class BundleUsageInfo(originalPath: String, moduleSrcRoot: String, moduleResourceRoot: String, bundleInfo: Option[BundleInfo])

  /**
   * @param filePath path to the file from which "extract to bundle" action is performed
   */
  private def findBundlePathFor(filePath: String): Option[BundleUsageInfo] =
    for {
      moduleRoot <- moduleRootForFile(filePath)
    } yield {
      val srcRoot      = moduleRoot + "src/"
      val resourceRoot = moduleRoot + "resources/"
      val bundleClassPath = findBundleClass(filePath)
      val bundlePath = bundleClassPath.map(bundleInfo(srcRoot, resourceRoot, _))
      BundleUsageInfo(filePath, srcRoot, resourceRoot, bundlePath)
    }

  private def bundleInfo(srcRoot: String, resourceRoot: String, bundleClassPath: Path) = {
    val className               = withoutExtension(bundleClassPath.getFileName.toString)
    val relPathWithoutExtension = withoutExtension(bundleClassPath.toString.substring(srcRoot.length))
    val qualifiedClassName      = relPathWithoutExtension.replaceAll(raw"[/\\]", ".")
    val withPropertyEnding      = relPathWithoutExtension + ".properties"
    val expectedBundlePath      = resourceRoot + withPropertyEnding
    val bundlePath              = findBundleFileForClass(resourceRoot, expectedBundlePath, className)
    BundleInfo(bundlePath, bundleClassPath.toString, className, qualifiedClassName)
  }

  private def moduleRootForFile(path: String) = {
    assert(new File(path).isFile, s"Expected file: $path")
    val idx = path.indexOf("/src/")
    if (idx < 0) None
    else Some(path.substring(0, idx + 1 /* include the '/' */))
  }

  private def withoutExtension(path: String): String =
    path.substring(0, path.lastIndexOf('.'))

  def findBundlePathFor(element: PsiElement): Option[BundleUsageInfo] =
    element.containingVirtualFile.map(_.getPath).flatMap(findBundlePathFor)

  private val bundleClassRegex =
    raw".*Bundle\.(java|scala)".r
  private def findBundleClass(_path: String): Option[Path] = {
    Paths.get(_path)
      .parents
      .flatMap { path =>
        new File(path.toUri)
          .list()
          .map(Paths.get(path.toString, _))
          .find { path =>
            val fileName = path.getFileName.toString
            bundleClassRegex.findFirstIn(fileName).isDefined
          }
      }
      .nextOption()
  }

  private def findBundleFileForClass(resourcePath: String, expectedPath: String, bundleName: String): String = {
    if (new File(expectedPath).isFile) expectedPath
    else {
      // look for
      // resource/messages/<bundleName>.properties OR
      // resource/messages/Scala<bundleName>.properties
      // (at some point in time Scala prefix was added to all bundles)
      val path1 = resourcePath + "messages/" + bundleName + ".properties"
      val path2 = resourcePath + "messages/" + "Scala" + bundleName + ".properties"
      if (new File(path1).isFile)
        path1
      else if (new File(path2).isFile)
        path2
      else
        throw new AssertionError(s"Expected Bundle file $expectedPath or $path1")
    }
  }

  private val nonWordSeq = raw"\W+".r
  private val Trimmed = raw"\W*(.*?)\W*".r
  def convertStringToKey(string: String): String = {
    val maxKeyLength = 60
    val Trimmed(fullKey) = nonWordSeq.replaceAllIn(string, ".").toLowerCase

    lazy val lastDotIdx = fullKey.lastIndexOf(".", maxKeyLength - 3)
    if (fullKey.length < maxKeyLength) fullKey
    else if (lastDotIdx < maxKeyLength - 20) fullKey.substring(0, maxKeyLength - 3) + "..."
    else fullKey.substring(0, lastDotIdx) + "..."
  }

  def escapeText(text: String, hasArgs: Boolean): String = {
    val text1 = text.replace("\\", "\\\\")
    val text2 =
      if (!hasArgs) text1
      else text1.replace("'", "''")
    if (text2.length > 100) text2.replace("\n", "\\n\\\n")
    else text2.replace("\n", "\\n")
  }
}


text:
using System;
using JetBrains.Annotations;

namespace CodeContractNullability.Utilities
{
    /// <summary>
    /// Member precondition checks.
    /// </summary>
    public static class Guard
    {
        [AssertionMethod]
        [ContractAnnotation("value: null => halt")]
        public static void NotNull<T>([CanBeNull] [NoEnumeration] T value, [NotNull] [InvokerParameterName] string name)
            where T : class
        {
            if (value is null)
            {
                throw new ArgumentNullException(name);
            }
        }

        [AssertionMethod]
        [ContractAnnotation("value: null => halt")]
        public static void NotNullNorWhiteSpace([CanBeNull] string value, [NotNull] [InvokerParameterName] string name)
        {
            NotNull(value, name);

            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException($"'{name}' cannot be empty or contain only whitespace.", name);
            }
        }
    }
}