text:
package com.programandoando.hamp.tipsdesalud.Modelo;

import android.support.annotation.NonNull;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * Modelo de datos para los artículos que se inflarán en la lista
 */
public class ModeloArticulos {

    /**
     * Arreglo de objetos {@link Articulo} que simula una fuente de datos
     */
    public static final List<Articulo> ITEMS = new ArrayList<Articulo>();

    /**
     * Mapa simulador de búsquedas de articulos por id
     */
    public static final Map<String, Articulo> MAPA_ITEMS = new HashMap<String, Articulo>();

    static {
        // Añadir elementos de ejemplo
        agregarItem(new Articulo(generarId(),
                "10 Plantillas Para Determinar Tus Necesidades Calóricas",
                "Descarga nuestras plantillas para Microsoft Excel que te permitirán, calcular exactamente...",
                "10 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo1.jpg"));
        agregarItem(new Articulo(generarId(),
                "¿Qué Tan Malo Es Consumir Chocolate?",
                "Si aún no has podido resolver tus dudas sobre comer chocolate, entonces este artículo es para ti...",
                "11 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo2.jpg"));
        agregarItem(new Articulo(generarId(),
                "Guía Para Identificar Alimentos Con Trigo Perjudiciales",
                "Aprende a distinguir aquellos alimentos que están hechos de trigo mal procesado...",
                "12 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo3.jpg"));
        agregarItem(new Articulo(generarId(),
                "Descubre Qué Harían 10 Minutos De Ejercicio Diario En Tu Cuerpo",
                "Entra y descubre los beneficios de realizar una rutina de 10 minutos los 7 días...",
                "13 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo4.jpg"));
        agregarItem(new Articulo(generarId(),
                "Aumentando Las Defensas Del Cuerpo Con Frutos Rojos",
                "Los frutos rojos frecuentemente son ignorados por la mayoría de las personas, pero hoy te mostraremos...",
                "14 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo5.jpg"));
        agregarItem(new Articulo(generarId(),
                "5 Recetas Bajas En Grasa Para El Almuerzo",
                "Variar las recetas a la hora de alimentarse permite obtener distintos beneficios dependiendo del alimento, ...",
                "15 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo6.jpg"));
        agregarItem(new Articulo(generarId(),
                "Combina Cardio + Fuerza Para Obtener Verdaderos Resultados",
                "Muchos creen que solo realizar ejercicios de cardio los hará perder de peso y...",
                "16 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo7.jpg"));
        agregarItem(new Articulo(generarId(),
                "Planificador Semanal Para Optimizar Tu Dieta",
                "Descarga nuestro nueva plantilla para prácticar buenos hábitos alimenticios. Se trata de...",
                "17 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo8.jpg"));
        agregarItem(new Articulo(generarId(),
                "Las 30 Razones De Por Qué Superman Come Cacahuates",
                "Los frutos secos han sido desde la antiguedad la principal fuente de proteínas para muchas civilizaciones...",
                "18 de Mayo", "http://www.programandoando.com/wp-content/uploads/articulo9.jpg"));

    }

    @NonNull
    private static String generarId() {
        return UUID.randomUUID().toString();
    }

    private static void agregarItem(Articulo item) {
        ITEMS.add(item);
        MAPA_ITEMS.put(item.id, item);
    }

    /**
     * Un 'articulo' representa la estructura general de cada tip de salud
     */
    public static class Articulo {

        public final String id;

        public final String titulo;

        public final String descripcion;

        public final String fecha;

        public final String urlMiniatura;

        public Articulo(String id, String titulo, String descripcion,
                        String fecha, String urlMiniatura) {
            this.id = id;
            this.titulo = titulo;
            this.descripcion = descripcion;
            this.fecha = fecha;
            this.urlMiniatura = urlMiniatura;
        }
    }
}


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.4-2
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2014.09.07 at 08:01:35 PM IST
//

package com.mozu.qbintegration.model.qbmodel.allgen;

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.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 *
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>
 *         <group ref="{}TxnCoreMod"/>
 *         <element ref="{}TxnDate" minOccurs="0"/>
 *         <element name="RefNumber" minOccurs="0">
 *           <simpleType>
 *             <restriction base="{}STRTYPE">
 *               <maxLength value="11"/>
 *             </restriction>
 *           </simpleType>
 *         </element>
 *         <element ref="{}IsAdjustment" minOccurs="0"/>
 *         <element ref="{}IsAmountsEnteredInHomeCurrency" minOccurs="0"/>
 *         <element ref="{}CurrencyRef" minOccurs="0"/>
 *         <element ref="{}ExchangeRate" minOccurs="0"/>
 *         <element ref="{}JournalLineMod" maxOccurs="unbounded" minOccurs="0"/>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "txnID",
    "editSequence",
    "txnDate",
    "refNumber",
    "isAdjustment",
    "isAmountsEnteredInHomeCurrency",
    "currencyRef",
    "exchangeRate",
    "journalLineMod"
})
@XmlRootElement(name = "JournalEntryMod")
public class JournalEntryMod {

    @XmlElement(name = "TxnID", required = true)
    protected String txnID;
    @XmlElement(name = "EditSequence", required = true)
    protected String editSequence;
    @XmlElement(name = "TxnDate")
    protected String txnDate;
    @XmlElement(name = "RefNumber")
    protected String refNumber;
    @XmlElement(name = "IsAdjustment")
    protected String isAdjustment;
    @XmlElement(name = "IsAmountsEnteredInHomeCurrency")
    protected String isAmountsEnteredInHomeCurrency;
    @XmlElement(name = "CurrencyRef")
    protected CurrencyRef currencyRef;
    @XmlElement(name = "ExchangeRate")
    protected String exchangeRate;
    @XmlElement(name = "JournalLineMod")
    protected List<JournalLineMod> journalLineMod;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * Gets the value of the currencyRef property.
     *
     * @return
     *     possible object is
     *     {@link CurrencyRef }
     *
     */
    public CurrencyRef getCurrencyRef() {
        return currencyRef;
    }

    /**
     * Sets the value of the currencyRef property.
     *
     * @param value
     *     allowed object is
     *     {@link CurrencyRef }
     *
     */
    public void setCurrencyRef(CurrencyRef value) {
        this.currencyRef = value;
    }

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

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

    /**
     * Gets the value of the journalLineMod 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 journalLineMod property.
     *
     *

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

     *    getJournalLineMod().add(newItem);
     *

     *
     *
     *

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

}

redpajama_set_name: RedPajamaGithub


text:
"""Contains the Lambda layer."""

import sys
import textwrap
import types as python_types
import warnings

import numpy as np
import tensorflow.compat.v2 as tf

from keras.engine.base_layer import Layer
from keras.saving.legacy import serialization
from keras.utils import generic_utils
from keras.utils import tf_inspect
from keras.utils import tf_utils

# isort: off
from tensorflow.python.platform import tf_logging
from tensorflow.python.util.tf_export import keras_export

@keras_export("keras.layers.Lambda")
class Lambda(Layer):
    """Wraps arbitrary expressions as a `Layer` object.

    The `Lambda` layer exists so that arbitrary expressions can be used
    as a `Layer` when constructing `Sequential`
    and Functional API models. `Lambda` layers are best suited for simple
    operations or quick experimentation. For more advanced use cases, follow
    [this guide](
    https://www.tensorflow.org/guide/keras/custom_layers_and_models)
    for subclassing `tf.keras.layers.Layer`.

    WARNING: `tf.keras.layers.Lambda` layers have (de)serialization limitations!

    The main reason to subclass `tf.keras.layers.Layer` instead of using a
    `Lambda` layer is saving and inspecting a Model. `Lambda` layers
    are saved by serializing the Python bytecode, which is fundamentally
    non-portable. They should only be loaded in the same environment where
    they were saved. Subclassed layers can be saved in a more portable way
    by overriding their `get_config` method. Models that rely on
    subclassed Layers are also often easier to visualize and reason about.

    Examples:

    ```python
    # add a x -> x^2 layer
    model.add(Lambda(lambda x: x ** 2))
    ```
    ```python
    # add a layer that returns the concatenation
    # of the positive part of the input and
    # the opposite of the negative part

    def antirectifier(x):
        x -= K.mean(x, axis=1, keepdims=True)
        x = K.l2_normalize(x, axis=1)
        pos = K.relu(x)
        neg = K.relu(-x)
        return K.concatenate([pos, neg], axis=1)

    model.add(Lambda(antirectifier))
    ```

    Variables:
      While it is possible to use Variables with Lambda layers, this practice is
      discouraged as it can easily lead to bugs. For instance, consider the
      following layer:

    ```python
      scale = tf.Variable(1.)
      scale_layer = tf.keras.layers.Lambda(lambda x: x * scale)
    ```

      Because scale_layer does not directly track the `scale` variable, it will
      not appear in `scale_layer.trainable_weights` and will therefore not be
      trained if `scale_layer` is used in a Model.

      A better pattern is to write a subclassed Layer:

    ```python
      class ScaleLayer(tf.keras.layers.Layer):
        def __init__(self):
          super(ScaleLayer, self).__init__()
          self.scale = tf.Variable(1.)

        def call(self, inputs):
          return inputs * self.scale
    ```

      In general, Lambda layers can be convenient for simple stateless
      computation, but anything more complex should use a subclass Layer
      instead.

    Args:
      function: The function to be evaluated. Takes input tensor as first
        argument.
      output_shape: Expected output shape from function. This argument can be
        inferred if not explicitly provided. Can be a tuple or function. If a
        tuple, it only specifies the first dimension onward;
        sample dimension is assumed either the same as the input:
        `output_shape = (input_shape[0], ) + output_shape` or, the input is
        `None` and the sample dimension is also `None`:
        `output_shape = (None, ) + output_shape` If a function, it specifies the
        entire shape as a function of the input shape:
        `output_shape = f(input_shape)`
      mask: Either None (indicating no masking) or a callable with the same
        signature as the `compute_mask` layer method, or a tensor that will be
        returned as output mask regardless of what the input is.
      arguments: Optional dictionary of keyword arguments to be passed to the
        function.
    Input shape: Arbitrary. Use the keyword argument input_shape (tuple of
      integers, does not include the samples axis) when using this layer as the
      first layer in a model.
    Output shape: Specified by `output_shape` argument
    """

    @tf.__internal__.tracking.no_automatic_dependency_tracking
    def __init__(
        self, function, output_shape=None, mask=None, arguments=None, **kwargs
    ):
        super().__init__(**kwargs)

        self.arguments = arguments or {}
        self.function = function

        if mask is not None:
            self.supports_masking = True
        self.mask = mask
        self._output_shape = output_shape

        # Warning on every invocation will be quite irksome in Eager mode.
        self._already_warned = False

        function_args = tf_inspect.getfullargspec(function).args
        self._fn_expects_training_arg = "training" in function_args
        self._fn_expects_mask_arg = "mask" in function_args

    @tf_utils.shape_type_conversion
    def compute_output_shape(self, input_shape):
        if self._output_shape is None:
            # Make use of existing autocomputation but provide Lambda-specific
            # error message. This is always safe to run even when the outer
            # context is Graph mode because Lambda layers don't have side
            # effects such as `add_loss`.
            with tf.__internal__.eager_context.eager_mode():
                try:
                    return super().compute_output_shape(input_shape)
                except NotImplementedError:
                    raise NotImplementedError(
                        "We could not automatically infer the shape of "
                        "the Lambda's output. Please specify `output_shape` "
                        "for this Lambda."
                    )

        if callable(self._output_shape):
            output_shapes = self._output_shape(input_shape)
            return tf_utils.convert_shapes(output_shapes, to_tuples=False)

        # Output shapes are passed directly and don't include batch dimension.
        input_tensor_shape = tf_utils.convert_shapes(
            input_shape, to_tuples=False
        )
        batch_size = (
            tf.nest.flatten(input_tensor_shape)[0][0] if input_shape else None
        )

        def _add_batch(shape):
            return tf.TensorShape([batch_size] + shape.as_list())

        output_shapes = tf_utils.convert_shapes(
            self._output_shape, to_tuples=False
        )
        return tf.nest.map_structure(_add_batch, output_shapes)

    def call(self, inputs, mask=None, training=None):
        # We must copy for thread safety, but it only needs to be a shallow
        # copy.
        kwargs = {k: v for k, v in self.arguments.items()}
        if self._fn_expects_mask_arg:
            kwargs["mask"] = mask
        if self._fn_expects_training_arg:
            kwargs["training"] = training

        created_variables = []

        def _variable_creator(next_creator, **kwargs):
            var = next_creator(**kwargs)
            created_variables.append(var)
            return var

        with tf.GradientTape(
            watch_accessed_variables=True
        ) as tape, tf.variable_creator_scope(_variable_creator):
            result = self.function(inputs, **kwargs)
        self._check_variables(created_variables, tape.watched_variables())
        return result

    def _check_variables(self, created_variables, accessed_variables):
        if not created_variables and not accessed_variables:
            # In the common case that a Lambda layer does not touch a Variable,
            # we don't want to incur the runtime cost of assembling any state
            # used for checking only to immediately discard it.
            return

        # Filter out the state variable in the tf.random.Generator, which is
        # commonly used for initializer or droput. The variable is intentionally
        # not tracked and it is not a trainable variable.
        created_variables = [
            v for v in created_variables if "StateVar" not in v.name
        ]

        tracked_weights = set(v.ref() for v in self.weights)
        untracked_new_vars = [
            v for v in created_variables if v.ref() not in tracked_weights
        ]
        if untracked_new_vars:
            variable_str = "\n".join(f"  {i}" for i in untracked_new_vars)
            error_str = textwrap.dedent(
                """
          The following Variables were created within a Lambda layer ({name})
          but are not tracked by said layer:
          {variable_str}
          The layer cannot safely ensure proper Variable reuse across multiple
          calls, and consequently this behavior is disallowed for safety. Lambda
          layers are not well suited to stateful computation; instead, writing a
          subclassed Layer is the recommend way to define layers with
          Variables."""
            ).format(name=self.name, variable_str=variable_str)
            raise ValueError(error_str)

        untracked_used_vars = [
            v for v in accessed_variables if v.ref() not in tracked_weights
        ]
        if untracked_used_vars and not self._already_warned:
            variable_str = "\n".join(f"  {i}" for i in untracked_used_vars)
            self._warn(
                textwrap.dedent(
                    """
          The following Variables were used a Lambda layer's call ({name}), but
          are not present in its tracked objects:
          {variable_str}
          It is possible that this is intended behavior, but it is more likely
          an omission. This is a strong indication that this layer should be
          formulated as a subclassed Layer rather than a Lambda layer."""
                ).format(name=self.name, variable_str=variable_str)
            )
            self._already_warned = True

    def _warn(self, msg):
        # This method will be overridden in a unit test to raise an error,
        # because self.assertWarns is not universally implemented.
        return tf_logging.warning(msg)

    def compute_mask(self, inputs, mask=None):
        if callable(self.mask):
            return self.mask(inputs, mask)
        return self.mask

    def get_config(self):
        function_config = self._serialize_function_to_config(self.function)
        output_shape_config = self._serialize_function_to_config(
            self._output_shape, allow_raw=True
        )
        config = {
            "function": function_config[0],
            "function_type": function_config[1],
            "module": function_config[2],
            "output_shape": output_shape_config[0],
            "output_shape_type": output_shape_config[1],
            "output_shape_module": output_shape_config[2],
        }
        if self.mask is not None:
            mask_config = self._serialize_function_to_config(self.mask)
            config.update(
                {
                    "mask": mask_config[0],
                    "mask_type": mask_config[1],
                    "mask_module": mask_config[2],
                }
            )
        config["arguments"] = self.arguments

        base_config = super().get_config()
        return dict(list(base_config.items()) + list(config.items()))

    def _serialize_function_to_config(self, inputs, allow_raw=False):
        if isinstance(inputs, python_types.LambdaType):
            output = generic_utils.func_dump(inputs)
            output_type = "lambda"
            module = inputs.__module__
        elif callable(inputs):
            output = inputs.__name__
            output_type = "function"
            module = inputs.__module__
        elif allow_raw:
            output = inputs
            output_type = "raw"
            module = None
        else:
            raise ValueError(
                f"Invalid input for serialization, type: {type(inputs)} "
            )

        return output, output_type, module

    @classmethod
    def from_config(cls, config, custom_objects=None):
        config = config.copy()
        function = cls._parse_function_from_config(
            config, custom_objects, "function", "module", "function_type"
        )

        output_shape = cls._parse_function_from_config(
            config,
            custom_objects,
            "output_shape",
            "output_shape_module",
            "output_shape_type",
        )
        if "mask" in config:
            mask = cls._parse_function_from_config(
                config, custom_objects, "mask", "mask_module", "mask_type"
            )
        else:
            mask = None

        config["function"] = function
        config["output_shape"] = output_shape
        config["mask"] = mask

        # If arguments were numpy array, they have been saved as
        # list. We need to recover the ndarray
        if "arguments" in config:
            for key in config["arguments"]:
                if isinstance(config["arguments"][key], dict):
                    arg_dict = config["arguments"][key]
                    if "type" in arg_dict and arg_dict["type"] == "ndarray":
                        # Overwrite the argument with its numpy translation
                        config["arguments"][key] = np.array(arg_dict["value"])

        return cls(**config)

    @classmethod
    def _parse_function_from_config(
        cls,
        config,
        custom_objects,
        func_attr_name,
        module_attr_name,
        func_type_attr_name,
    ):
        globs = globals().copy()
        module = config.pop(module_attr_name, None)
        if module in sys.modules:
            globs.update(sys.modules[module].__dict__)
        elif module is not None:
            # Note: we don't know the name of the function if it's a lambda.
            warnings.warn(
                "{} is not loaded, but a Lambda layer uses it. "
                "It may cause errors.".format(module),
                UserWarning,
                stacklevel=2,
            )
        if custom_objects:
            globs.update(custom_objects)
        function_type = config.pop(func_type_attr_name)
        if function_type == "function":
            # Simple lookup in custom objects
            function = serialization.deserialize_keras_object(
                config[func_attr_name],
                custom_objects=custom_objects,
                printable_module_name="function in Lambda layer",
            )
        elif function_type == "lambda":
            # Unsafe deserialization from bytecode
            function = generic_utils.func_load(
                config[func_attr_name], globs=globs
            )
        elif function_type == "raw":
            function = config[func_attr_name]
        else:
            supported_types = ["function", "lambda", "raw"]
            raise TypeError(
                "Unsupported value for `function_type` argument. Received: "
                f"function_type={function_type}. "
                f"Expected one of {supported_types}"
            )
        return function


text:
{% extends "base.html" %}

{% block content %}

                            {{project.name}}

                            By
                            {% for role in project.roles %}
                                {% if role.role == 'owner' %}
                                    {{role.user.name}}
                                {% endif %}
                            {% endfor %}

{{project.video_url|safe}}

Project status

{{status_choices[project.status]}}

{{ project.roles|length }} People signed

                                {% for role in project.roles %}
                                    {% if 'confirmed' or 'owner' in role.role %}
                                        {{role.user.name}}

                                    {% endif %}
                                {% endfor %}

Created

{{project.date_created.strftime('%d %b %Y')}}

                        {% if project.status == '1' %}
                            {% if current_user.is_authenticated() %}
                                {% if not applied %}

                                        <button id='project_apply' class='btn btn-primary btn-lg' data-url="{{ url_for('main.project_signup', project_url=project.url, user_url=current_user.url, role='worker') }}">Sign Up</button>
                                        Lead This Project

                                {% elif applied %}

You have applied to this project!

                                {% endif %}
                            {% else %}

                                    Sign Up</button>
                                    Lead This Project

                            {% endif %}
                        {% endif %}

What is project

{% if project.description %}
                                            {{project.description}}
                                            {% endif %}

What we need

{% if project.need %}
                                            {{project.need}}
                                            {% endif %}

Project rewards

{% if project.rewards %}
                                            {{project.rewards}}
                                            {% endif %}

{% endblock %}


text:
package com.intellij.util.containers;

import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**
 * Created by IntelliJ IDEA.
 * User: ksafonov
 * Date: 22.03.2010
 * Time: 16:43:12
 * To change this template use File | Settings | File Templates.
 */
public abstract class DistinctRootsCollection<T> implements Collection<T> {
  private final Collection<T> myCollection = new ArrayList<T>();

  protected abstract boolean isAncestor(@NotNull T ancestor, @NotNull T t);

  public DistinctRootsCollection() {
  }

  public DistinctRootsCollection(Collection<T> collection) {
    addAll(collection);
  }

  public DistinctRootsCollection(T[] collection) {
    this(Arrays.asList(collection));
  }

  public int size() {
    return myCollection.size();
  }

  public boolean isEmpty() {
    return myCollection.isEmpty();
  }

  public boolean contains(Object o) {
    return myCollection.contains(o);
  }

  public Iterator<T> iterator() {
    return myCollection.iterator();
  }

  public Object[] toArray() {
    return myCollection.toArray();
  }

  public <T> T[] toArray(T[] a) {
    return myCollection.toArray(a);
  }

  public boolean add(T o) {
    Collection<T> toRemove = new ArrayList<T>();
    for (T existing : myCollection) {
      if (isAncestor(existing, o)) {
        return false;
      }
      if (isAncestor(o, existing)) {
        toRemove.add(existing);
      }
    }
    myCollection.removeAll(toRemove);
    myCollection.add(o);
    return true;
  }

  public boolean remove(Object o) {
    return myCollection.remove(o);
  }

  public boolean containsAll(Collection<?> c) {
    return myCollection.containsAll(c);
  }

  public boolean addAll(Collection<? extends T> c) {
    boolean changed = false;
    for (T t : c) {
      changed |= add(t);
    }
    return changed;
  }

  public boolean removeAll(Collection<?> c) {
    return myCollection.removeAll(c);
  }

  public boolean retainAll(Collection<?> c) {
    return myCollection.retainAll(c);
  }

  public void clear() {
    myCollection.clear();
  }

}


text:
package net.vdrinkup.alpaca.protocol.config;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;

@XmlAccessorType( XmlAccessType.FIELD )
abstract class AbstractDefinition {
}


text:
app.factory('auth', ['$http', '$window', function($http, $window) {
	var auth = {};

	auth.saveToken = function(token) {
		$window.localStorage['stocks-token'] = token;
	};

	auth.getToken = function() {
		return $window.localStorage['stocks-token'];
	};

	auth.isLoggedIn = function() {
		var token = auth.getToken();

		if (token) {
			var payload = JSON.parse($window.atob(token.split('.')[1]));

			return payload.exp > Date.now() / 1000;
		} else {
			return false;
		}
	};

	auth.currentUser = function() {
		if (auth.isLoggedIn()) {
			var token = auth.getToken();
			var payload = JSON.parse($window.atob(token.split('.')[1]));

			return { _id: payload._id, username: payload.username };
		}
	};

	auth.register = function(user) {
		return $http.post('http://localhost:3000/register', user).success(function(data) {
			auth.saveToken(data.token);
		});
	};

	auth.login = function(user) {
		return $http.post('http://localhost:3000/login', user).success(function(data) {
			auth.saveToken(data.token);
		}).error(function(data) {
			console.log(data);
		});
	};

	auth.logout = function() {
		$window.localStorage.removeItem('stocks-token');
	};

	return auth;
}]);


text:
.class public final Landroid/media/projection/MediaProjection;
.super Ljava/lang/Object;
.source "MediaProjection.java"

# annotations
.annotation system Ldalvik/annotation/MemberClasses;
    value = {
        Landroid/media/projection/MediaProjection$1;,
        Landroid/media/projection/MediaProjection$CallbackRecord;,
        Landroid/media/projection/MediaProjection$MediaProjectionCallback;,
        Landroid/media/projection/MediaProjection$Callback;
    }
.end annotation

# static fields
.field private static final TAG:Ljava/lang/String; = "MediaProjection"

# instance fields
.field private final mCallbacks:Ljava/util/Map;
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "Ljava/util/Map",
            "<",
            "Landroid/media/projection/MediaProjection$Callback;",
            "Landroid/media/projection/MediaProjection$CallbackRecord;",
            ">;"
        }
    .end annotation
.end field

.field private final mContext:Landroid/content/Context;

.field private final mImpl:Landroid/media/projection/IMediaProjection;

# direct methods
.method public constructor <init>(Landroid/content/Context;Landroid/media/projection/IMediaProjection;)V
    .locals 4
    .param p1, "context"    # Landroid/content/Context;
    .param p2, "impl"    # Landroid/media/projection/IMediaProjection;

    .prologue
    .line 55
    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    .line 56
    new-instance v1, Landroid/util/ArrayMap;

    invoke-direct {v1}, Landroid/util/ArrayMap;-><init>()V

    iput-object v1, p0, Landroid/media/projection/MediaProjection;->mCallbacks:Ljava/util/Map;

    .line 57
    iput-object p1, p0, Landroid/media/projection/MediaProjection;->mContext:Landroid/content/Context;

    .line 58
    iput-object p2, p0, Landroid/media/projection/MediaProjection;->mImpl:Landroid/media/projection/IMediaProjection;

    .line 60
    :try_start_0
    iget-object v1, p0, Landroid/media/projection/MediaProjection;->mImpl:Landroid/media/projection/IMediaProjection;

    new-instance v2, Landroid/media/projection/MediaProjection$MediaProjectionCallback;

    const/4 v3, 0x0

    invoke-direct {v2, p0, v3}, Landroid/media/projection/MediaProjection$MediaProjectionCallback;-><init>(Landroid/media/projection/MediaProjection;Landroid/media/projection/MediaProjection$1;)V

    invoke-interface {v1, v2}, Landroid/media/projection/IMediaProjection;->start(Landroid/media/projection/IMediaProjectionCallback;)V
    :try_end_0
    .catch Landroid/os/RemoteException; {:try_start_0 .. :try_end_0} :catch_0

    .line 64
    return-void

    .line 61
    :catch_0
    move-exception v0

    .line 62
    .local v0, "e":Landroid/os/RemoteException;
    new-instance v1, Ljava/lang/RuntimeException;

    const-string v2, "Failed to start media projection"

    invoke-direct {v1, v2, v0}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;Ljava/lang/Throwable;)V

    throw v1
.end method

.method static synthetic access$100(Landroid/media/projection/MediaProjection;)Ljava/util/Map;
    .locals 1
    .param p0, "x0"    # Landroid/media/projection/MediaProjection;

    .prologue
    .line 47
    iget-object v0, p0, Landroid/media/projection/MediaProjection;->mCallbacks:Ljava/util/Map;

    return-object v0
.end method

# virtual methods
.method public createAudioRecord(IIII)Landroid/media/AudioRecord;
    .locals 1
    .param p1, "sampleRateInHz"    # I
    .param p2, "channelConfig"    # I
    .param p3, "audioFormat"    # I
    .param p4, "bufferSizeInBytes"    # I

    .prologue
    .line 149
    const/4 v0, 0x0

    return-object v0
.end method

.method public createVirtualDisplay(Ljava/lang/String;IIIILandroid/view/Surface;Landroid/hardware/display/VirtualDisplay$Callback;Landroid/os/Handler;)Landroid/hardware/display/VirtualDisplay;
    .locals 10
    .param p1, "name"    # Ljava/lang/String;
    .param p2, "width"    # I
    .param p3, "height"    # I
    .param p4, "dpi"    # I
    .param p5, "flags"    # I
    .param p6, "surface"    # Landroid/view/Surface;
    .param p7, "callback"    # Landroid/hardware/display/VirtualDisplay$Callback;
    .param p8, "handler"    # Landroid/os/Handler;

    .prologue
    .line 137
    iget-object v1, p0, Landroid/media/projection/MediaProjection;->mContext:Landroid/content/Context;

    const-string v2, "display"

    invoke-virtual {v1, v2}, Landroid/content/Context;->getSystemService(Ljava/lang/String;)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Landroid/hardware/display/DisplayManager;

    .local v0, "dm":Landroid/hardware/display/DisplayManager;
    move-object v1, p0

    move-object v2, p1

    move v3, p2

    move v4, p3

    move v5, p4

    move-object/from16 v6, p6

    move v7, p5

    move-object/from16 v8, p7

    move-object/from16 v9, p8

    .line 138
    invoke-virtual/range {v0 .. v9}, Landroid/hardware/display/DisplayManager;->createVirtualDisplay(Landroid/media/projection/MediaProjection;Ljava/lang/String;IIILandroid/view/Surface;ILandroid/hardware/display/VirtualDisplay$Callback;Landroid/os/Handler;)Landroid/hardware/display/VirtualDisplay;

    move-result-object v1

    return-object v1
.end method

.method public createVirtualDisplay(Ljava/lang/String;IIIZLandroid/view/Surface;Landroid/hardware/display/VirtualDisplay$Callback;Landroid/os/Handler;)Landroid/hardware/display/VirtualDisplay;
    .locals 11
    .param p1, "name"    # Ljava/lang/String;
    .param p2, "width"    # I
    .param p3, "height"    # I
    .param p4, "dpi"    # I
    .param p5, "isSecure"    # Z
    .param p6, "surface"    # Landroid/view/Surface;
    .param p7, "callback"    # Landroid/hardware/display/VirtualDisplay$Callback;
    .param p8, "handler"    # Landroid/os/Handler;

    .prologue
    .line 104
    iget-object v1, p0, Landroid/media/projection/MediaProjection;->mContext:Landroid/content/Context;

    const-string v2, "display"

    invoke-virtual {v1, v2}, Landroid/content/Context;->getSystemService(Ljava/lang/String;)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Landroid/hardware/display/DisplayManager;

    .line 105
    .local v0, "dm":Landroid/hardware/display/DisplayManager;
    if-eqz p5, :cond_0

    const/4 v10, 0x4

    .line 106
    .local v10, "flags":I
    :goto_0
    or-int/lit8 v1, v10, 0x10

    or-int/lit8 v7, v1, 0x2

    move-object v1, p0

    move-object v2, p1

    move v3, p2

    move v4, p3

    move v5, p4

    move-object/from16 v6, p6

    move-object/from16 v8, p7

    move-object/from16 v9, p8

    invoke-virtual/range {v0 .. v9}, Landroid/hardware/display/DisplayManager;->createVirtualDisplay(Landroid/media/projection/MediaProjection;Ljava/lang/String;IIILandroid/view/Surface;ILandroid/hardware/display/VirtualDisplay$Callback;Landroid/os/Handler;)Landroid/hardware/display/VirtualDisplay;

    move-result-object v1

    return-object v1

    .line 105
    .end local v10    # "flags":I
    :cond_0
    const/4 v10, 0x0

    goto :goto_0
.end method

.method public getProjection()Landroid/media/projection/IMediaProjection;
    .locals 1

    .prologue
    .line 168
    iget-object v0, p0, Landroid/media/projection/MediaProjection;->mImpl:Landroid/media/projection/IMediaProjection;

    return-object v0
.end method

.method public registerCallback(Landroid/media/projection/MediaProjection$Callback;Landroid/os/Handler;)V
    .locals 2
    .param p1, "callback"    # Landroid/media/projection/MediaProjection$Callback;
    .param p2, "handler"    # Landroid/os/Handler;

    .prologue
    .line 76
    if-nez p1, :cond_0

    .line 77
    new-instance v0, Ljava/lang/IllegalArgumentException;

    const-string v1, "callback should not be null"

    invoke-direct {v0, v1}, Ljava/lang/IllegalArgumentException;-><init>(Ljava/lang/String;)V

    throw v0

    .line 79
    :cond_0
    if-nez p2, :cond_1

    .line 80
    new-instance p2, Landroid/os/Handler;

    .end local p2    # "handler":Landroid/os/Handler;
    invoke-direct {p2}, Landroid/os/Handler;-><init>()V

    .line 82
    .restart local p2    # "handler":Landroid/os/Handler;
    :cond_1
    iget-object v0, p0, Landroid/media/projection/MediaProjection;->mCallbacks:Ljava/util/Map;

    new-instance v1, Landroid/media/projection/MediaProjection$CallbackRecord;

    invoke-direct {v1, p1, p2}, Landroid/media/projection/MediaProjection$CallbackRecord;-><init>(Landroid/media/projection/MediaProjection$Callback;Landroid/os/Handler;)V

    invoke-interface {v0, p1, v1}, Ljava/util/Map;->put(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;

    .line 83
    return-void
.end method

.method public stop()V
    .locals 3

    .prologue
    .line 157
    :try_start_0
    iget-object v1, p0, Landroid/media/projection/MediaProjection;->mImpl:Landroid/media/projection/IMediaProjection;

    invoke-interface {v1}, Landroid/media/projection/IMediaProjection;->stop()V
    :try_end_0
    .catch Landroid/os/RemoteException; {:try_start_0 .. :try_end_0} :catch_0

    .line 161
    :goto_0
    return-void

    .line 158
    :catch_0
    move-exception v0

    .line 159
    .local v0, "e":Landroid/os/RemoteException;
    const-string v1, "MediaProjection"

    const-string v2, "Unable to stop projection"

    invoke-static {v1, v2, v0}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)I

    goto :goto_0
.end method

.method public unregisterCallback(Landroid/media/projection/MediaProjection$Callback;)V
    .locals 2
    .param p1, "callback"    # Landroid/media/projection/MediaProjection$Callback;

    .prologue
    .line 92
    if-nez p1, :cond_0

    .line 93
    new-instance v0, Ljava/lang/IllegalArgumentException;

    const-string v1, "callback should not be null"

    invoke-direct {v0, v1}, Ljava/lang/IllegalArgumentException;-><init>(Ljava/lang/String;)V

    throw v0

    .line 95
    :cond_0
    iget-object v0, p0, Landroid/media/projection/MediaProjection;->mCallbacks:Ljava/util/Map;

    invoke-interface {v0, p1}, Ljava/util/Map;->remove(Ljava/lang/Object;)Ljava/lang/Object;

    .line 96
    return-void
.end method


text:
package com.test.banner.demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Spinner;

import com.test.banner.App;
import com.test.banner.R;
import com.test.banner.loader.GlideImageLoader;
import com.youth.banner.Banner;
import com.youth.banner.BannerConfig;

public class BannerStyleActivity extends AppCompatActivity implements  AdapterView.OnItemSelectedListener {
    Banner banner;
    Spinner spinnerStyle;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_banner_style);
        banner = (Banner) findViewById(R.id.banner);
        spinnerStyle = (Spinner) findViewById(R.id.spinnerStyle);
        spinnerStyle.setOnItemSelectedListener(this);

        //默认是CIRCLE_INDICATOR
        banner.setImages(App.images)
                .setBannerTitles(App.titles)
                .setBannerStyle(BannerConfig.NOT_INDICATOR)
                .setImageLoader(new GlideImageLoader())
                .start();
    }

    @Override
    public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
        switch (position){
            case 0:
                banner.updateBannerStyle(BannerConfig.NOT_INDICATOR);
                break;
            case 1:
                banner.updateBannerStyle(BannerConfig.CIRCLE_INDICATOR);
                break;
            case 2:
                banner.updateBannerStyle(BannerConfig.NUM_INDICATOR);
                break;
            case 3:
                banner.updateBannerStyle(BannerConfig.NUM_INDICATOR_TITLE);
                break;
            case 4:
                banner.updateBannerStyle(BannerConfig.CIRCLE_INDICATOR_TITLE);
                break;
            case 5:
                banner.updateBannerStyle(BannerConfig.CIRCLE_INDICATOR_TITLE_INSIDE);
                break;
        }
    }

    @Override
    public void onNothingSelected(AdapterView<?> parent) {

    }
}


text:
package com.mfizz.ruby.types;

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

/**
 *
 * @author mfizz
 */
public class RubySymbol extends RubyType implements Comparable<RubySymbol> {

    // name of symbol w/o the leading ":" char
    private final String name;

    /**
     * Creates a new symbol.  If in Ruby you'd type ":name", you just use the
     * "name" part here and don't include the leading ':' char.
     * @param name
     */
    public RubySymbol(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public int hashCode() {
        // hash code of a symobl should NOT match a string
        return ":".hashCode() + this.name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final RubySymbol other = (RubySymbol) obj;
        if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
            return false;
        }
        return true;
    }

    @Override
    public int compareTo(RubySymbol o) {
        return this.name.compareTo(o.name);
    }

    @Override
    public void inspect(StringBuilder sb, int indent) {
        sb.append(':');
        sb.append(this.name);
    }
}


text:
#import "LoggerTextStyleManager.h"
#import "SynthesizeSingleton.h"
#import "NullStringCheck.h"

@interface LoggerTextStyleManager()
+(CGSize)_sizeForString:(NSString *)aString
			 constraint:(CGSize)aConstraint
				   font:(CTFontRef)aFont
				  style:(CTParagraphStyleRef)aStyle;
@end

@implementation LoggerTextStyleManager
SYNTHESIZE_SINGLETON_FOR_CLASS_WITH_ACCESSOR(LoggerTextStyleManager,sharedStyleManager);

@synthesize defaultFont = _defaultFont;
@synthesize defaultParagraphStyle = _defaultParagraphStyle;

@synthesize defaultTagAndLevelFont = _defaultTagAndLevelFont;
@synthesize defaultTagAndLevelParagraphStyle = _defaultTagAndLevelParagraphStyle;

@synthesize defaultMonospacedFont = _defaultMonospacedFont;
@synthesize defaultMonospacedStyle = _defaultMonospacedStyle;

+(CGSize)_sizeForString:(NSString *)aString constraint:(CGSize)aConstraint font:(CTFontRef)aFont style:(CTParagraphStyleRef)aStyle
{

	// calcuate string drawable size
	CFRange textRange = CFRangeMake(0, aString.length);

	//  Create an empty mutable string big enough to hold our test
	CFMutableAttributedStringRef string = CFAttributedStringCreateMutable(kCFAllocatorDefault, aString.length);

	//  Inject our text into it
	CFAttributedStringReplaceString(string, CFRangeMake(0, 0), (CFStringRef)aString);

	//  Apply our font and line spacing attributes over the span
	CFAttributedStringSetAttribute(string, textRange, kCTFontAttributeName, aFont);
	CFAttributedStringSetAttribute(string, textRange, kCTParagraphStyleAttributeName, aStyle);

	CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString(string);
	CFRange fitRange;

	CGSize frameSize = CTFramesetterSuggestFrameSizeWithConstraints(framesetter, textRange, NULL, aConstraint, &fitRange);

	CFRelease(framesetter);
	CFRelease(string);

	return frameSize;
}

+(CGSize)sizeForStringWithDefaultFont:(NSString *)aString constraint:(CGSize)aConstraint
{
	if(IS_NULL_STRING(aString))
		return CGSizeZero;

	CTFontRef font = [[LoggerTextStyleManager sharedStyleManager] defaultFont];
	CTParagraphStyleRef style = [[LoggerTextStyleManager sharedStyleManager] defaultParagraphStyle];

	return [LoggerTextStyleManager
			_sizeForString:aString
			constraint:aConstraint
			font:font
			style:style];
}

+(CGSize)sizeForStringWithDefaultTagAndLevelFont:(NSString *)aString constraint:(CGSize)aConstraint
{
	if(IS_NULL_STRING(aString))
		return CGSizeZero;

	CTFontRef font = [[LoggerTextStyleManager sharedStyleManager] defaultTagAndLevelFont];
	CTParagraphStyleRef style = [[LoggerTextStyleManager sharedStyleManager] defaultTagAndLevelParagraphStyle];

	return [LoggerTextStyleManager
			_sizeForString:aString
			constraint:aConstraint
			font:font
			style:style];
}

+(CGSize)sizeForStringWithDefaultMonospacedFont:(NSString *)aString constraint:(CGSize)aConstraint
{
	if(IS_NULL_STRING(aString))
		return CGSizeZero;

	CTFontRef font = [[LoggerTextStyleManager sharedStyleManager] defaultMonospacedFont];
	CTParagraphStyleRef style = [[LoggerTextStyleManager sharedStyleManager] defaultMonospacedStyle];

	return [LoggerTextStyleManager
			_sizeForString:aString
			constraint:aConstraint
			font:font
			style:style];
}

-(id)init
{
	self = [super init];
	if(self)
	{
		CTTextAlignment alignment = kCTTextAlignmentLeft;

		//-------------------------- default font ------------------------------
		// we're to use system default helvetica to get a cover for UTF-8 chars, emoji, and many more.
		_defaultFont =  CTFontCreateWithName(CFSTR("Helvetica"),DEFAULT_FONT_SIZE, NULL);

		//http://stackoverflow.com/questions/3374591/ctframesettersuggestframesizewithconstraints-sometimes-returns-incorrect-size
		//  When you create an attributed string the default paragraph style has a leading
		//  of 0.0. Create a paragraph style that will set the line adjustment equal to
		//  the leading value of the font.
		CGFloat defaultLeading = CTFontGetLeading(_defaultFont) + CTFontGetDescent(_defaultFont);

		CTParagraphStyleSetting defaultStyle[2] = {
			{kCTParagraphStyleSpecifierLineSpacingAdjustment, sizeof (CGFloat), &defaultLeading }
			,{kCTParagraphStyleSpecifierAlignment,sizeof(CTTextAlignment),&alignment}
		};

		_defaultParagraphStyle = CTParagraphStyleCreate(defaultStyle, 2);

		//-------------------------- tag and level font ------------------------
		// in ios, no Lucida Sans. we're going with 'Telugu Sangman MN'
		_defaultTagAndLevelFont =  CTFontCreateWithName(CFSTR("TeluguSangamMN"), DEFAULT_TAG_LEVEL_SIZE, NULL);

		CGFloat tagLevelLeading = CTFontGetLeading(_defaultTagAndLevelFont) + CTFontGetDescent(_defaultTagAndLevelFont);

		CTParagraphStyleSetting tagLevelStyle[2] = {
			{kCTParagraphStyleSpecifierLineSpacingAdjustment, sizeof (CGFloat), &tagLevelLeading }
			,{kCTParagraphStyleSpecifierAlignment,sizeof(CTTextAlignment),&alignment}
		};

		_defaultTagAndLevelParagraphStyle = CTParagraphStyleCreate(tagLevelStyle, 2);

		//-------------------------- monospaced font ---------------------------
		// this is for binary, so we're to go with cusom font
		NSString *fontPath =
			[NSString stringWithFormat:@"%@/%@"
			 ,[[NSBundle mainBundle] bundlePath]
			 ,@"NSLoggerResource.bundle/fonts/Inconsolata.ttf"];

		CGDataProviderRef fontProvider = CGDataProviderCreateWithFilename([fontPath UTF8String]);
		CGFontRef cgFont = CGFontCreateWithDataProvider(fontProvider);
		_defaultMonospacedFont = CTFontCreateWithGraphicsFont(cgFont,DEFAULT_MONOSPACED_SIZE,NULL,NULL);

		CGFloat monospacedLeading = CTFontGetLeading(_defaultMonospacedFont) + CTFontGetDescent(_defaultMonospacedFont);

		CTParagraphStyleSetting monospacedStyle[2] = {
			{kCTParagraphStyleSpecifierLineSpacingAdjustment, sizeof (CGFloat), &monospacedLeading }
			,{kCTParagraphStyleSpecifierAlignment,sizeof(CTTextAlignment),&alignment}
		};

		_defaultMonospacedStyle = CTParagraphStyleCreate(monospacedStyle, 2);

		CGDataProviderRelease(fontProvider);
		CFRelease(cgFont);

	}
	return self;
}
@end


text:
package org.springframework.boot.context.event;

import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

/**
 * {@link SpringApplicationRunListener} to publish {@link SpringApplicationEvent}s.
 *
 * @author Phillip Webb
 */
public class EventPublishingRunListener implements SpringApplicationRunListener {

	private final ApplicationEventMulticaster multicaster;

	private SpringApplication application;

	private String[] args;

	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.multicaster = new SimpleApplicationEventMulticaster();
		for (ApplicationListener<?> listener : application.getListeners()) {
			this.multicaster.addApplicationListener(listener);
		}
	}

	@Override
	public void started() {
		publishEvent(new ApplicationStartedEvent(this.application, this.args));
	}

	@Override
	public void environmentPrepared(ConfigurableEnvironment environment) {
		publishEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args,
				environment));
	}

	@Override
	public void contextPrepared(ConfigurableApplicationContext context) {
		registerApplicationEventMulticaster(context);
	}

	private void registerApplicationEventMulticaster(
			ConfigurableApplicationContext context) {
		context.getBeanFactory().registerSingleton(
				AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME,
				this.multicaster);
		if (this.multicaster instanceof BeanFactoryAware) {
			((BeanFactoryAware) this.multicaster)
					.setBeanFactory(context.getBeanFactory());
		}
	}

	@Override
	public void contextLoaded(ConfigurableApplicationContext context) {
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware) {
				((ApplicationContextAware) listener).setApplicationContext(context);
			}
			context.addApplicationListener(listener);
		}
		publishEvent(new ApplicationPreparedEvent(this.application, this.args, context));
	}

	@Override
	public void finished(ConfigurableApplicationContext context, Throwable exception) {
		publishEvent(getFinishedEvent(context, exception));
	}

	private SpringApplicationEvent getFinishedEvent(
			ConfigurableApplicationContext context, Throwable exception) {
		if (exception != null) {
			return new ApplicationFailedEvent(this.application, this.args, context,
					exception);
		}
		return new ApplicationReadyEvent(this.application, this.args, context);
	}

	private void publishEvent(SpringApplicationEvent event) {
		this.multicaster.multicastEvent(event);
	}

}


text:
package com.google.dart;

import com.google.common.collect.ImmutableSet;
import com.google.dart.util.OsUtil;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.output.StringBuilderWriter;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import org.codehaus.plexus.compiler.util.scan.SourceInclusionScanner;
import org.codehaus.plexus.compiler.util.scan.StaleSourceScanner;
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
import org.codehaus.plexus.util.cli.Arg;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import org.codehaus.plexus.util.cli.StreamConsumer;
import org.codehaus.plexus.util.cli.WriterStreamConsumer;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Goal to compile dart files to javascript.
 *
 * @author Daniel Zwicker
 */
@Mojo(name = "dart2js", defaultPhase = LifecyclePhase.COMPILE, threadSafe = true)
public class Dart2JsMojo
    extends PubMojo {

    /**
     * Where to find packages, that is, "package:..." imports.
     *
     * @since 2.0
     */
    private final static String ARGUMENT_CHECKED_MODE = "-c";

    /**
     * Generate the output into <file>
     *
     * @since 1.0
     */
    private final static String ARGUMENT_OUTPUT_FILE = "-o";

    /**
     * Where to find packages, that is, "package:..." imports.
     *
     * @since 2.0
     */
    private final static String ARGUMENT_PACKAGE_PATH = "-p";

    /**
     * Display verbose information.
     *
     * @since 1.0.3
     */
    private final static String ARGUMENT_VERBOSE = "-v";

    /**
     * Analyze all code. Without this option, the compiler only analyzes code that is reachable from [main].
     * This option is useful for finding errors in libraries,
     * but using it can result in bigger and slower output.
     *
     * @since 1.0.3
     */
    private final static String ARGUMENT_ANALYSE_ALL = "--analyze-all";

    /**
     * Generate minified output.
     *
     * @since 1.0.3
     */
    private final static String ARGUMENT_MINIFY = "--minify";

    /**
     * Do not display any warnings.
     *
     * @since 1.0.3
     */
    private final static String ARGUMENT_SUPPRESS_WARNINGS = "--suppress-warnings";

    /**
     * Do not display any hints.
     *
     * @since 3.0.6
     */
    private final static String ARGUMENT_SUPPRESS_HINTS = "--suppress-hints";

    /**
     * Add colors to diagnostic messages.
     *
     * @since 1.0.3
     */
    private final static String ARGUMENT_DIAGNOSTIC_COLORS = "--enable-diagnostic-colors";

    /**
     * Name of the global variable used by dart2js compiler in the generated code.
     * The name must match the regular expression "\$[a-z]*".
     *
     * @since 2.1.2
     */
    private final static String ARGUMENT_GLOBAL_JS_NAME = "--global-js-name=";

    /**
     * The default category is Client, which tells dart2js to expect a web app.
     *
     * @since 3.0.8
     */
    private final static String ARGUMENT_CATEGORIES = "--categories=";

    /**
     * Skip the execution of dart2js.
     *
     * @since 1.1
     */
    @Parameter(defaultValue = "false", property = "dart.skip")
    private boolean skipDart2Js;

    /**
     * Insert runtime type checks and enable assertions (checked mode).
     *
     * @since 1.0
     */
    @Parameter(defaultValue = "false", property = "dart.checkedMode")
    private boolean checkedMode;

    /**
     * Display verbose information.
     *
     * @since 1.0.3
     */
    @Parameter(defaultValue = "false", property = "dart.verbose")
    private boolean verbose;

    /**
     * Analyze all code. Without this option, the compiler only analyzes code that is reachable from [main].
     * This option is useful for finding errors in libraries,
     * but using it can result in bigger and slower output.
     *
     * @since 1.0.3
     */
    @Parameter(defaultValue = "false", property = "dart.analyseAll")
    private boolean analyseAll;

    /**
     * Generate minified output.
     *
     * @since 1.0.3
     */
    @Parameter(defaultValue = "false", property = "dart.minify")
    private boolean minify;

    /**
     * Do not display any warnings.
     *
     * @since 1.0.3
     */
    @Parameter(defaultValue = "false", property = "dart.suppressWarnings")
    private boolean suppressWarnings;

    /**
     * Do not display any hints.
     *
     * @since 3.0.6
     */
    @Parameter(defaultValue = "false", property = "dart.suppressHints")
    private boolean suppressHints;

    /**
     * Add colors to diagnostic messages.
     *
     * @since 1.0.3
     */
    @Parameter(defaultValue = "false", property = "dart.diagnosticColors")
    private boolean diagnosticColors;

    /**
     * Where to find packages, that is, "package:..." imports.
     *
     * @since 2.0
     */
    @Parameter(property = "dart.packagepath")
    private File packagePath;

    /**
     * Force compilation of all files.
     *
     * @since 2.0.2
     */
    @Parameter(defaultValue = "false", property = "dart.force")
    private boolean force;

    /**
     * The directory to place the js files after compiling.
     *

     * If not specified the default is 'target/dart'.
     *
     * @since 1.0
     */
    @Parameter(defaultValue = "${project.build.directory}/dart", required = true, property = "dart.outputDirectory")
    private File outputDirectory;

    /**
     * A list of inclusion filters for the dart2js compiler.
     *

     * If not specified the default is 'web/**/*.dart'
     *
     * @since 1.0
     */
    @Parameter
    private Set<String> includes = new HashSet<>();

    /**
     * A list of exclusion filters for the dart2js compiler.
     *

     * If not specified the default is 'web/**/packages/**'
     *
     * @since 1.0
     */
    @Parameter
    private final Set<String> excludes = new HashSet<>();

    /**
     * Sets the granularity in milliseconds of the last modification
     * date for testing whether a dart source needs recompilation.
     *
     * @since 1.0
     */
    @Parameter(property = "lastModGranularityMs", defaultValue = "0")
    private int staleMillis;

    /**
     * Set this to 'true' to skip running dart's packagemanager pub.
     *
     * @since 2.0.1
     */
    @Parameter(defaultValue = "false", property = "dart.pup.skip")
    private boolean skipPub;

    /**
     * Name of the global variable used by dart2js compiler in the generated code.
     * The name must match the regular expression "\$[a-z]*".
     * Only available in dart2js < 1.1.
     *
     * @since 2.1.2
     */
    @Parameter(property = "dart.global.js.name")
    private String globalJsName;

    /**
     * Use with --analyze-only to analyze a command-line app.
     * The default category is Client, which tells dart2js to expect a web app.
     *
     * @since 3.0.8
     */
    @Parameter(property = "dart.categories")
    private String categories;

    /**
     * The number of threads used to span dart2js instances.
     *
     * @since 3.0.0
     */
    @Parameter(defaultValue = "1", property = "dart.thread.count")
    private int threadCount;

    /**
     * The maximum time in ms all dart files should be compiled.
     *
     * @since 3.0.0
     */
    @Parameter(defaultValue = "0", property = "dart.thread.timeout")
    private int timeout;

    public void execute()
        throws MojoExecutionException {
        if (isSkipDart2Js()) {
            getLog().info("skipping dart2js execution");
            return;
        }

        final Set<File> dartPackageRoots = findDartPackageRoots();
        processPubDependencies(dartPackageRoots);
        processDart2Js(dartPackageRoots);
    }

    private void processDart2Js(final Set<File> dartPackageRoots) throws MojoExecutionException {

        if (isForce()) {
            clearOutputDirectory();
        }

        final Set<File> staleDartSources =
            computeStaleSources(dartPackageRoots, getSourceInclusionScanner());

        if (getLog().isDebugEnabled()) {
            getLog().debug("staleMillis: " + staleMillis);
            getLog().debug("basedir: " + getBasedir());
            getLog().debug("outputDirectory: " + outputDirectory);

            getLog().debug("Source includes:");

            for (final String include : getIncludes()) {
                getLog().debug(" " + include);
            }

            getLog().debug("Source excludes:");
            for (final String exclude : getExcludes()) {
                getLog().debug(" " + exclude);
            }
        }

        checkAndCreateOutputDirectory();

        System.out.println();
        System.out.println();

        //threads
        if (staleDartSources.isEmpty()) {
            getLog().info("Nothing to compile - all dart javascripts are up to date");
        } else {

            checkDart2Js();
            final ExecutorService executor = Executors.newFixedThreadPool(threadCount);

            getLog().info("Run " + threadCount + " dart2js's in parallel.");
            getLog().info("Compile " + staleDartSources.size() + " dart files");

            final List<Future<List<String>>> logging = new ArrayList<>(staleDartSources.size());
            for (final File dartSourceFile : staleDartSources) {
                getLog().info("Queue " + dartSourceFile.getAbsolutePath() + " to compile.");
                logging.add(
                    executor.submit(new Callable<List<String>>() {
                        @Override
                        public List<String> call() throws Exception {

                            getLog().info("compile " + dartSourceFile.getAbsolutePath());
                            final List<String> messages = new ArrayList<>();
                            try {
                                final Commandline cl = createBaseCommandline(messages);
                                final Arg outPutFileArg = cl.createArg();
                                final Arg dartFileArg = cl.createArg();
                                final File dartOutputFile = createOutputFileArgument(messages, outPutFileArg, dartSourceFile);
                                createDartFileArgument(messages, dartFileArg, dartSourceFile);

                                if (getLog().isDebugEnabled()) {
                                    messages.add("debug#" + cl.toString());
                                }
                                if (!dartOutputFile.getParentFile().exists()) {
                                    if (getLog().isDebugEnabled()) {
                                        messages.add("debug#Create directory " + dartOutputFile.getParentFile().getAbsolutePath());
                                    }
                                    dartOutputFile.getParentFile().mkdirs();
                                }

                                if (getLog().isDebugEnabled()) {
                                    messages.add("debug#" + cl.toString());
                                }

                                final StringBuilderWriter writer = new StringBuilderWriter();
                                final StreamConsumer output = new WriterStreamConsumer(writer);

                                final int returnValue = CommandLineUtils.executeCommandLine(cl, output, output);

                                writer.flush();
                                writer.close();
                                final StringBuilder stringBuilder = writer.getBuilder();
                                messages.add("info#" + stringBuilder.toString());

                                if (getLog().isDebugEnabled()) {
                                    messages.add("debug#dart2js return code: " + returnValue);
                                }
                                if (returnValue != 0) {
                                    throw new MojoExecutionException(null, "Dart2Js returned error code " + returnValue,
                                        stringBuilder.toString());
                                }

                                System.out.println();
                                System.out.println();

                            } catch (final CommandLineException e) {
                                messages.add("error#dart2js error: " + e.getMessage());
                                getLog().error("dart2js error", e);
                            }
                            getLog().info("done " + dartSourceFile.getAbsolutePath());
                            return messages;
                        }
                    })
                );
            }

            executor.shutdown();
            try {
                logResults(logging);
                getLog().info(
                    "Compiling " + staleDartSources.size() + " dart file" + (staleDartSources.size() == 1 ? ""
                        : "s")
                        + " to " + outputDirectory.getAbsolutePath());
            } catch (InterruptedException | TimeoutException e) {
                throw new MojoExecutionException("Unable to compile all dart files within " + timeout + "ms. Perhaps increase it.", e);
            } catch (ExecutionException e) {
                throw new MojoExecutionException("Unable to compile all dart files.", e);
            }
        }

        System.out.println();
        System.out.println();
    }

    private void logResults(List<Future<List<String>>> logging) throws InterruptedException, ExecutionException, TimeoutException {
        for (final Future<List<String>> future : logging) {
            List<String> messages;
            if (timeout > 0) {
                messages = future.get(timeout, TimeUnit.MILLISECONDS);
            } else {
                messages = future.get();
            }
            for (final String logMessage : messages) {
                final String[] m = logMessage.split("#");
                if (m.length > 1) {
                    final String level = m[0];
                    final String message = m[1];
                    switch (level) {
                        case "debug":
                            getLog().debug(message);
                            break;
                        case "info":
                            getLog().info(message);
                            break;
                        case "warn":
                            getLog().warn(message);
                            break;
                        case "error":
                            getLog().error(message);
                            break;
                    }
                } else {
                    // defaults to info
                    getLog().info(logMessage);
                }
            }
        }
    }

    private Commandline createBaseCommandline(List<String> messages) throws MojoExecutionException {
        final String dart2jsPath = getDart2JsExecutable().getAbsolutePath();

        if (getLog().isDebugEnabled()) {
            messages.add("debug#Using dart2js '" + dart2jsPath + "'.");
            messages.add("debug#Source directories: " + getCompileSourceRoots().toString().replace(',', '\n'));
            messages.add("debug#Output directory: " + getOutputDirectory());
        }

        final Commandline cl = new Commandline();
        cl.setExecutable(dart2jsPath);

        if (isCheckedMode()) {
            cl.createArg().setValue(ARGUMENT_CHECKED_MODE);
        }

        if (isVerbose()) {
            cl.createArg().setValue(ARGUMENT_VERBOSE);
        }

        if (isAnalyseAll()) {
            cl.createArg().setValue(ARGUMENT_ANALYSE_ALL);
        }

        if (isMinify()) {
            cl.createArg().setValue(ARGUMENT_MINIFY);
        }

        if (isSuppressWarnings()) {
            cl.createArg().setValue(ARGUMENT_SUPPRESS_WARNINGS);
        }

        if (isSuppressHints()) {
            cl.createArg().setValue(ARGUMENT_SUPPRESS_HINTS);
        }

        if (isDiagnosticColors()) {
            cl.createArg().setValue(ARGUMENT_DIAGNOSTIC_COLORS);
        }

        if (isPackagePath()) {
            cl.createArg().setValue(ARGUMENT_PACKAGE_PATH + packagePath.getAbsolutePath());
        }

        if (isGlobalJs()) {
            cl.createArg().setValue(ARGUMENT_GLOBAL_JS_NAME + globalJsName);
        }

        if (isCategories()) {
            cl.createArg().setValue(ARGUMENT_CATEGORIES + categories);
        }

        if (getLog().isDebugEnabled()) {
            messages.add("debug#Base dart2js command: " + cl.toString());
        }

        return cl;
    }

    protected void checkDart2Js() {
        checkDartSdk();
        if (!getDart2JsExecutable().canExecute()) {
            throw new IllegalArgumentException("Dart2js not executable! Configuration error for dartSdk? dartSdk="
                + getDartSdk().getAbsolutePath());
        }
    }

    protected File getDart2JsExecutable() {
        return new File(getDartSdk(), "bin/dart2js" + (OsUtil.isWindows() ? ".bat" : ""));
    }

    private void clearOutputDirectory() throws MojoExecutionException {
        try {
            if (outputDirectory.exists()) {
                FileUtils.cleanDirectory(outputDirectory);
                getLog().info("Cleared all compiled dart-files.");
            }
        } catch (IOException e) {
            getLog().debug("Unable to clear directory '" + outputDirectory.getAbsolutePath() + "'.", e);
            throw new MojoExecutionException("Unable to clear directory '"
                + outputDirectory.getAbsolutePath() + "'.", e);
        }
    }

    private void checkAndCreateOutputDirectory() throws MojoExecutionException {
        if (!outputDirectory.exists()) {
            outputDirectory.mkdirs();
        } else if (!outputDirectory.isDirectory()) {
            throw new MojoExecutionException(
                "Fatal error compiling dart to js. Output directory is not a directory");
        }
    }

    private void createDartFileArgument(List<String> messages, final Arg compilerArguments, final File dartSourceFile) {
        final String dartSourceFileAbsolutePath = dartSourceFile.getAbsolutePath();
        compilerArguments.setValue(dartSourceFileAbsolutePath);
        messages.add("info#dart2js for '" + relativePath(dartSourceFile) + "'");
    }

    private File createOutputFileArgument(List<String> messages, final Arg outPutFileArg, final File dartSourceFile)
        throws MojoExecutionException {
        final String dartSourceFileAbsolutePath = dartSourceFile.getAbsolutePath();

        String dartOutputFileRelativeToBasedir = null;
        for (final File compileSourceRoot : getCompileSourceRoots()) {
            final String compileSourceRootAsString = compileSourceRoot.getAbsolutePath();
            if (dartSourceFileAbsolutePath.startsWith(compileSourceRootAsString)) {
                dartOutputFileRelativeToBasedir = dartSourceFileAbsolutePath.replace(compileSourceRootAsString, "");
                dartOutputFileRelativeToBasedir += ".js";
                break;
            }

        }

        if (dartOutputFileRelativeToBasedir == null) {
            messages.add("error#Unable to find compilerSourceRoot for dart file '" + dartSourceFileAbsolutePath + "'");
            messages.add("error#compilerSourceRoots are:");
            for (final File compileSourceRoot : getCompileSourceRoots()) {
                getLog().error(compileSourceRoot.getAbsolutePath());
            }

            System.out.println("");
            System.out.println("");

            throw new MojoExecutionException("There is something wrong. ");
        }

        final String dartOutputFile = outputDirectory.getAbsolutePath() + dartOutputFileRelativeToBasedir;

        if (getLog().isDebugEnabled()) {
            messages.add("debug#dart2js compiles dart-file '" + dartSourceFileAbsolutePath + "' to outputdirectory '"
                + dartOutputFile + "'");
        }
        outPutFileArg.setValue(ARGUMENT_OUTPUT_FILE + dartOutputFile);
        return new File(dartOutputFile);
    }

    private Set<File> computeStaleSources(final Set<File> packageRoots, final SourceInclusionScanner scanner)
        throws MojoExecutionException {
        final SourceMapping mapping = new SuffixMapping("dart", "dart.js");
        scanner.addSourceMapping(mapping);

        final Set<File> staleSources = new HashSet<>();
        for (final File packageRoot : packageRoots) {
            try {
                final File packageOutputDirectory = getPackageOutputDirectory(packageRoot);
                staleSources.addAll(scanner.getIncludedSources(packageRoot, packageOutputDirectory));
            } catch (final InclusionScanException e) {
                throw new MojoExecutionException(
                    "Error scanning source root: \'" + relativePath(packageRoot)
                        + "\' for stale files to recompile.", e);
            }
        }

        return staleSources;
    }

    private File getPackageOutputDirectory(final File packageRoot) {
        String packageRootOffset = packageRoot.getAbsolutePath();
        for (final File compileSourceRoot : getCompileSourceRoots()) {
            final String compileSourceRootAsString = compileSourceRoot.getAbsolutePath();
            if (packageRootOffset.startsWith(compileSourceRootAsString)) {
                packageRootOffset = packageRootOffset.replace(compileSourceRootAsString + "/", "");
                break;
            }
        }
        return new File(getOutputDirectory(), packageRootOffset);
    }

    private SourceInclusionScanner getSourceInclusionScanner() {
        return new StaleSourceScanner(getStaleMillis(), getIncludes(), getExcludes());
    }

    public Set<String> getIncludes() {
        if (includes.isEmpty()) {
            return ImmutableSet.copyOf(Arrays.asList(new String[]{"web/**/*.dart"}));
        }
        return includes;
    }

    protected Set<String> getExcludes() {
        if (excludes.isEmpty()) {
            return ImmutableSet.copyOf(Arrays.asList(new String[]{"web/**/packages/**"}));
        }
        return excludes;
    }

    @Override
    public boolean isPubSkipped() {
        return skipPub;
    }

    protected boolean isSkipDart2Js() {
        return skipDart2Js;
    }

    protected File getOutputDirectory() {
        return outputDirectory;
    }

    protected boolean isCheckedMode() {
        return checkedMode;
    }

    protected int getStaleMillis() {
        return staleMillis;
    }

    protected boolean isVerbose() {
        return verbose;
    }

    protected boolean isAnalyseAll() {
        return analyseAll;
    }

    protected boolean isMinify() {
        return minify;
    }

    protected boolean isSuppressWarnings() {
        return suppressWarnings;
    }

    protected boolean isSuppressHints() {
        return suppressHints;
    }

    protected boolean isDiagnosticColors() {
        return diagnosticColors;
    }

    protected boolean isForce() {
        return force;
    }

    protected boolean isPackagePath() {
        return packagePath != null;
    }

    protected boolean isGlobalJs() {
        return globalJsName != null;
    }

    protected boolean isCategories() {
        return categories != null;
    }

}