text:
#pragma once
#include "TensorWrapper/TensorImpl/TensorTypes.hpp"
#include <cstddef>
#include <type_traits>

/** \file This file contains a bunch of meta-templating structs and typedefs to
 *  help make the rest of the code easier to read.
 */

namespace TWrapper {

//Forward declarations we'll need start here
namespace detail_ {enum class TensorTypes;}

template<size_t R, typename T, detail_::TensorTypes TT> class TensorWrapper;

template<size_t R,typename T> class TensorWrapperBase;

namespace detail_ {

template<typename T> class OperationBase;

//Meta-templating stuff starts here

/** \brief Type for enabling a function if the two backends are \b not the same
 *
 *  If \p TT1 and \p TT2 are \b not the same this type will contain a typedef
 *  called \p type.  If it exists, \p type will be a typedef of int.  Hence
 *  starting a template function defintion with:
 *
 *  \code
 *  template<TensorTypes TT1, TensorTypes TT2,
 *           typename EnableIfNotSameBackend<TT1,TT2>::type=0>
 *  \endcode
 *
 *  will leverage SFINAE to enable an overload of the subsequent function only
 *  if the two backends are \p not the same.
 *
 *  \tparam TT1 The enum of the first backend
 *  \tparam TT2 The enum of the other backend
 */
template<TensorTypes TT1, TensorTypes TT2>
using EnableIfNotSameBackend=std::enable_if<TT1!=TT2,int>;

///A type for discerning the rank and scalar type of a tensor
template<typename tensor_t>
struct TensorTraits{
    ///\p value is true if tensor_t is a TensorWrapper tensor
    constexpr static bool value=false;
};

///Partial specialization for the common base class
template<size_t R, typename T>
struct TensorTraits<TWrapper::TensorWrapperBase<R,T>>
{
    constexpr static bool value=true;
    static const size_t rank=R;
    using scalar_type=T;
    using type=TWrapper::TensorWrapperBase<R,T>;
};

template<size_t R, typename T, TensorTypes TT>
struct TensorTraits<TWrapper::TensorWrapper<R,T,TT>>
{
    constexpr static bool value=true;
    static const size_t rank=R;
    using scalar_type=T;
    using type=TWrapper::TensorWrapper<R,T,TT>;
};

///Type for removing const/reference
template<typename T>
using CleanType=
    typename std::remove_const<typename std::remove_reference<T>::type>::type;

/** \brief A type for discerning if a type is convertable to a
 *         TensorWrapperBase instance
 *
 *   If \p Other_t is convertable to a TensorWrapperBase this type will
 *   contain a static boolean member \p value that will be set to true,
 *   otherwise, said member will be false.
 *
 *  \tparam R The rank the resulting TensorWrapper should have
 *  \tparam T The scalar type the resulting TensorWrapperBase should have
 *  \tparam Other_t The type to check
 */
template<typename Other_t>
using IsATWrapper=TensorTraits<CleanType<Other_t>>;

/** \brief A type that enables a function if \p Other_t is not convertible to
 *         a TensorWrapperBase.
 *
 * This type is intended to be used with SFINAE.  Specifically, put this type
 * in your list of template type parameters and it will enable a function if
 * \p Other_t is not convertible to a TensorWrapperBase.  We use this to comb
 *  our classes out of arbitrary template types.
 *
 * \tparam Other_t The type to be checked
 */
template<typename Other_t>
using EnableIfNotATWrapper=std::enable_if<!IsATWrapper<Other_t>::value,int>;

///Type for discerning if another type is an Operation
template<typename RHS_t>
struct OperationTraits
{
    static constexpr bool value=
            std::is_convertible<RHS_t,OperationBase<RHS_t>>::value;
};

template<typename RHS_t>
struct OperationTraits<OperationBase<RHS_t>>{
    using type=OperationBase<RHS_t>;
    static constexpr bool value=true;
};

template<typename RHS_t>
using IsAnOperation=OperationTraits<CleanType<RHS_t>>;

template<typename RHS_t>
struct IsOpOrTW
{
    static constexpr bool is_op=IsAnOperation<RHS_t>::value;
    static constexpr bool is_tw=IsATWrapper<RHS_t>::value;
    static constexpr bool value=is_op || is_tw;
};

template<typename RHS_t>
using EnableIfAnOperation=std::enable_if<IsAnOperation<RHS_t>::value,int>;

template<typename RHS_t>
using EnableIfNotAnOperation=std::enable_if<!IsAnOperation<RHS_t>::value,int>;

template<typename RHS_t>
using EnableIfOpOrTW=std::enable_if<IsOpOrTW<RHS_t>::value,int>;

template<typename RHS_t>
using EnableIfNotOpOrTW=std::enable_if<!IsOpOrTW<RHS_t>::value,int>;

}}//end namespaces


text:
/**
 * IndexBar is a component used to display a list of data (primarily an alphabet) which can then be used to quickly
 * navigate through a list (see {@link Ext.List}) of data. When a user taps on an item in the {@link Ext.IndexBar},
 * it will fire the {@link #index} event.
 *
 * Here is an example of the usage in a {@link Ext.List}:
 *
 *     @example phone portrait preview
 *     Ext.define('Contact', {
 *         extend: 'Ext.data.Model',
 *         config: {
 *             fields: ['firstName', 'lastName']
 *         }
 *     });
 *
 *     var store = new Ext.data.JsonStore({
 *        model: 'Contact',
 *        sorters: 'lastName',
 *
 *        grouper: {
 *            groupFn: function(record) {
 *                return record.get('lastName')[0];
 *            }
 *        },
 *
 *        data: [
 *            {firstName: 'Screech', lastName: 'Powers'},
 *            {firstName: 'Kelly',   lastName: 'Kapowski'},
 *            {firstName: 'Zach',    lastName: 'Morris'},
 *            {firstName: 'Jessie',  lastName: 'Spano'},
 *            {firstName: 'Lisa',    lastName: 'Turtle'},
 *            {firstName: 'A.C.',    lastName: 'Slater'},
 *            {firstName: 'Richard', lastName: 'Belding'}
 *        ]
 *     });
 *
 *     var list = new Ext.List({
 *        fullscreen: true,
 *        itemTpl: '
{firstName} {lastName}
',
 *
 *        grouped     : true,
 *        indexBar    : true,
 *        store: store,
 *        hideOnMaskTap: false
 *     });
 *
*/
Ext.define('Ext.dataview.IndexBar', {
    extend: 'Ext.Component',
    alternateClassName: 'Ext.IndexBar',

    /**
     * @event index
     * Fires when an item in the index bar display has been tapped.
     * @param {Ext.dataview.IndexBar} this The IndexBar instance
     * @param {String} html The HTML inside the tapped node.
     * @param {Ext.dom.Element} target The node on the indexbar that has been tapped.
     */

    config: {
        baseCls: Ext.baseCSSPrefix + 'indexbar',

        /**
         * @cfg {String} direction
         * Layout direction, can be either 'vertical' or 'horizontal'
         * @accessor
         */
        direction: 'vertical',

        /**
         * @cfg {Array} letters
         * The letters to show on the index bar.
         * @accessor
         */
        letters: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],

        ui: 'alphabet',

        /**
         * @cfg {String} listPrefix
         * The prefix string to be used at the beginning of the list.
         * E.g: useful to add a "#" prefix before numbers.
         * @accessor
         */
        listPrefix: null
    },

    /**
     * @private
     */
    itemCls: Ext.baseCSSPrefix + '',

    updateDirection: function(newDirection, oldDirection) {
        var baseCls = this.getBaseCls();

        this.element.replaceCls(baseCls + '-' + oldDirection, baseCls + '-' + newDirection);
    },

    getElementConfig: function() {
        // Blackberry Specific code for Index Bar Indicator
        if(Ext.theme.is.Blackberry) {
            return {
                reference: 'wrapper',
                classList: ['x-centered', 'x-indexbar-wrapper'],
                children: [
                    {
                        reference: 'indicator',
                        classList: ['x-indexbar-indicator'],
                        hidden: true,
                        children: [{
                            reference: 'indicatorInner',
                            classList: ['x-indexbar-indicator-inner']
                        }]
                    },
                    this.callParent()
                ]
            };
        } else {
            return {
                reference: 'wrapper',
                classList: ['x-centered', 'x-indexbar-wrapper'],
                children: [this.callParent()]
            };
        }
    },

    updateLetters: function(letters) {
        this.innerElement.setHtml('');

        if (letters) {
            var ln = letters.length,
                i;

            for (i = 0; i < ln; i++) {
                this.innerElement.createChild({
                    html: letters[i]
                });
            }
        }
    },

    updateListPrefix: function(listPrefix) {
        if (listPrefix && listPrefix.length) {
            this.innerElement.createChild({
                html: listPrefix
            }, 0);
        }
    },

    /**
     * @private
     */
    initialize: function() {
        this.callParent();

        this.innerElement.on({
            touchstart: this.onTouchStart,
            touchend: this.onTouchEnd,
            dragend: this.onDragEnd,
            drag: this.onDrag,
            scope: this
        });
    },

    onTouchStart: function(e) {
        e.stopPropagation();
        this.innerElement.addCls(this.getBaseCls() + '-pressed');
        this.pageBox = this.innerElement.getBox();
        this.onDrag(e);
    },

    onTouchEnd: function(e) {
        this.onDragEnd();
    },

    /**
     * @private
     */
    onDragEnd: function() {
        this.innerElement.removeCls(this.getBaseCls() + '-pressed');

        // Blackberry Specific code for Index Bar Indicator
        if(this.indicator) {
            this.indicator.hide();
        }
    },

    /**
     * @private
     */
    onDrag: function(e) {
        var point = Ext.util.Point.fromEvent(e),
            target, isValidTarget,
            pageBox = this.pageBox;

        if (!pageBox) {
            pageBox = this.pageBox = this.el.getBox();
        }

        if (this.getDirection() === 'vertical') {
            if (point.y > pageBox.bottom || point.y < pageBox.top) {
                return;
            }
            target = Ext.Element.fromPoint(pageBox.left + (pageBox.width / 2), point.y);
            isValidTarget = target.getParent() == this.element;

            // Blackberry Specific code for Index Bar Indicator
            if(this.indicator) {
                this.indicator.show();

                var halfIndicatorHeight = this.indicator.getHeight() / 2,
                    y = point.y - this.element.getY();

                y = Math.min(Math.max(y, halfIndicatorHeight), this.element.getHeight() - halfIndicatorHeight);

                if (this.indicatorInner && isValidTarget) {
                    this.indicatorInner.setHtml(target.getHtml().toUpperCase());
                }
                this.indicator.setTop(y - (halfIndicatorHeight));
            }
        }
        else {
            if (point.x > pageBox.right || point.x < pageBox.left) {
                return;
            }
            target = Ext.Element.fromPoint(point.x, pageBox.top + (pageBox.height / 2));
            isValidTarget = target.getParent() == this.element;
        }

        if (target && isValidTarget) {
            this.fireEvent('index', this, target.dom.innerHTML, target);
        }
    },

    destroy: function() {
        var me = this,
            elements = Array.prototype.slice.call(me.innerElement.dom.childNodes),
            ln = elements.length,
            i = 0;

        for (; i < ln; i++) {
            Ext.removeNode(elements[i]);
        }
        this.callParent();
    }
});

redpajama_set_name: RedPajamaGithub


text:
return LoadFont("title")..{
	BeginCommand=function(self)
		self:settext(
			string.format(
				THEME:GetString( Var "LoadingScreen", "%d songs in %d groups, %d courses"),
				SONGMAN:GetNumSongs(),
				SONGMAN:GetNumSongGroups(),
				SONGMAN:GetNumCourses()
			)
		);
	end
}


text:
package prefux.action;

import java.util.Iterator;

import prefux.Visualization;
import prefux.data.expression.Predicate;
import prefux.visual.VisualItem;
import prefux.visual.expression.VisiblePredicate;

/**
 * An Action that processes VisualItems one item at a time. By default,
 * it only processes items that are visible. Use the
 * {@link #setFilterPredicate(Predicate)} method
 * to change the filtering criteria.
 *
 * @author jeffrey heer
 */
public abstract class ItemAction extends GroupAction {

    /** A reference to filtering predicate for this Action */
    protected Predicate m_predicate;

    /**
     * Create a new ItemAction that processes all groups.
     * @see Visualization#ALL_ITEMS
     */
    public ItemAction() {
        this((Visualization)null);
    }

    /**
     * Create a new ItemAction that processes all groups.
     * @param vis the {@link prefux.Visualization} to process
     * @see Visualization#ALL_ITEMS
     */
    public ItemAction(Visualization vis) {
        this(vis, Visualization.ALL_ITEMS);
    }

    /**
     * Create a new ItemAction that processes the specified group.
     * @param group the name of the group to process
     */
    public ItemAction(String group) {
        this(null, group);
    }

    /**
     * Create a new ItemAction that processes the specified group.
     * @param group the name of the group to process
     * @param filter the filtering {@link prefux.data.expression.Predicate}
     */
    public ItemAction(String group, Predicate filter) {
        this(null, group, filter);
    }

    /**
     * Create a new ItemAction that processes the specified group.
     * @param vis the {@link prefux.Visualization} to process
     * @param group the name of the group to process
     */
    public ItemAction(Visualization vis, String group) {
        this(vis, group, VisiblePredicate.TRUE);
    }

    /**
     * Create a new ItemAction that processes the specified group.
     * @param vis the {@link prefux.Visualization} to process
     * @param group the name of the group to process
     * @param filter the filtering {@link prefux.data.expression.Predicate}
     */
    public ItemAction(Visualization vis, String group, Predicate filter) {
        super(vis, group);
        m_predicate = filter;
    }

    // ------------------------------------------------------------------------

    /**
     * Returns the filtering predicate used by this Action.
     * @return the filtering {@link prefux.data.expression.Predicate}
     */
    public Predicate getFilterPredicate() {
        return m_predicate;
    }

    /**
     * Sets the filtering predicate used by this Action.
     * @param filter the filtering {@link prefux.data.expression.Predicate}
     * to use
     */
    public void setFilterPredicate(Predicate filter) {
        m_predicate = filter;
    }

    /**
     * @see prefux.action.Action#run(double)
     */
    public void run(double frac) {
        Iterator<VisualItem> items = getVisualization().items(m_group, m_predicate);
        while ( items.hasNext() ) {
            process(items.next(), frac);
        }
    }

    /**
     * Processes an individual item.
     * @param item the VisualItem to process
     * @param frac the fraction of elapsed duration time
     */
    public abstract void process(VisualItem item, double frac);

} // end of class ItemAction


text:
Reports .equals() or
.hashCode() being called
on java.net.URL objects. This can cause performance
problems because those methods uses a DNS lookup
to determine the equality of two java.net.URL objects.
Depending on the availability of the network and the speed of the DNS server, this can cause
significant delays.

Powered by InspectionGadgets


text:
package com.telefonica.euro_iaas.sdc.dao;

import java.util.List;

import com.telefonica.euro_iaas.commons.dao.BaseDAO;
import com.telefonica.euro_iaas.sdc.model.NodeCommand;
import com.telefonica.euro_iaas.sdc.model.searchcriteria.NodeCommandSearchCriteria;

/**
 * Defines the methods needed to persist NodeCommand Object
 *
 * @author Jesus M. Movilla
 * @version $Id: $
 */
public interface NodeCommandDao extends BaseDAO<NodeCommand, Long> {

    /**
     * Find by criteria
     *
     * @param criteria
     *            the search criteria (containing pagination info, and some fields criteria).
     * @return the elements that match with the search criteria
     */
    List<NodeCommand> findByCriteria(NodeCommandSearchCriteria criteria);

}


text:
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Class profile_field_checkbox
 *
 * @copyright  2008 onwards Shane Elliot {@link http://pukunui.com}
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class profile_field_checkbox extends profile_field_base {

    /**
     * Constructor method.
     * Pulls out the options for the checkbox from the database and sets the
     * the corresponding key for the data if it exists
     *
     * @param int $fieldid
     * @param int $userid
     */
    public function __construct($fieldid=0, $userid=0) {
        global $DB;
        // First call parent constructor.
        parent::__construct($fieldid, $userid);

        if (!empty($this->field)) {
            $datafield = $DB->get_field('user_info_data', 'data', array('userid' => $this->userid, 'fieldid' => $this->fieldid));
            if ($datafield !== false) {
                $this->data = $datafield;
            } else {
                $this->data = $this->field->defaultdata;
            }
        }
    }

    /**
     * Old syntax of class constructor. Deprecated in PHP7.
     *
     * @deprecated since Moodle 3.1
     */
    public function profile_field_checkbox($fieldid=0, $userid=0) {
        debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
        self::__construct($fieldid, $userid);
    }

    /**
     * Add elements for editing the profile field value.
     * @param moodleform $mform
     */
    public function edit_field_add($mform) {
        // Create the form field.
        $checkbox = $mform->addElement('advcheckbox', $this->inputname, format_string($this->field->name));
        if ($this->data == '1') {
            $checkbox->setChecked(true);
        }
        $mform->setType($this->inputname, PARAM_BOOL);
        if ($this->is_required() and !has_capability('moodle/user:update', context_system::instance())) {
            $mform->addRule($this->inputname, get_string('required'), 'nonzero', null, 'client');
        }
    }

    /**
     * Display the data for this field
     *
     * @return string HTML.
     */
    public function display_data() {
        $options = new stdClass();
        $options->para = false;
        $checked = intval($this->data) === 1 ? 'checked="checked"' : '';
        return '<input disabled="disabled" type="checkbox" name="'.$this->inputname.'" '.$checked.' />';
    }

    /**
     * Return the field type and null properties.
     * This will be used for validating the data submitted by a user.
     *
     * @return array the param type and null property
     * @since Moodle 3.2
     */
    public function get_field_properties() {
        return array(PARAM_BOOL, NULL_NOT_ALLOWED);
    }
}


text:
"""
websocket - WebSocket client library for Python

Copyright (C) 2010 Hiroki Ohtani(liris)

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1335  USA

"""
from __future__ import print_function

import six
import socket

if six.PY3:
    from base64 import encodebytes as base64encode
else:
    from base64 import encodestring as base64encode

import struct
import threading

# websocket modules
from ._exceptions import *
from ._abnf import *
from ._socket import *
from ._utils import *
from ._url import *
from ._logging import *
from ._http import *
from ._handshake import *
from ._ssl_compat import *

"""
websocket python client.
=========================

This version support only hybi-13.
Please see http://tools.ietf.org/html/rfc6455 for protocol.
"""

class WebSocket(object):
    """
    Low level WebSocket interface.
    This class is based on
      The WebSocket protocol draft-hixie-thewebsocketprotocol-76
      http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76

    We can connect to the websocket server and send/receive data.
    The following example is an echo client.

    >>> import websocket
    >>> ws = websocket.WebSocket()
    >>> ws.connect("ws://echo.websocket.org")
    >>> ws.send("Hello, Server")
    >>> ws.recv()
    'Hello, Server'
    >>> ws.close()

    get_mask_key: a callable to produce new mask keys, see the set_mask_key
      function's docstring for more details
    sockopt: values for socket.setsockopt.
        sockopt must be tuple and each element is argument of sock.setsockopt.
    sslopt: dict object for ssl socket option.
    fire_cont_frame: fire recv event for each cont frame. default is False
    enable_multithread: if set to True, lock send method.
    skip_utf8_validation: skip utf8 validation.
    """

    def __init__(self, get_mask_key=None, sockopt=None, sslopt=None,
                 fire_cont_frame=False, enable_multithread=False,
                 skip_utf8_validation=False):
        """
        Initialize WebSocket object.
        """
        self.sock_opt = sock_opt(sockopt, sslopt)
        self.handshake_response = None
        self.sock = None

        self.connected = False
        self.get_mask_key = get_mask_key
        # These buffer over the build-up of a single frame.
        self.frame_buffer = frame_buffer(self._recv, skip_utf8_validation)
        self.cont_frame = continuous_frame(fire_cont_frame, skip_utf8_validation)

        if enable_multithread:
            self.lock = threading.Lock()
        else:
            self.lock = NoLock()

    def __iter__(self):
        """
        Allow iteration over websocket, implying sequential `recv` executions.
        """
        while True:
            yield self.recv()

    def __next__(self):
        return self.recv()

    def next(self):
        return self.__next__()

    def fileno(self):
        return self.sock.fileno()

    def set_mask_key(self, func):
        """
        set function to create musk key. You can customize mask key generator.
        Mainly, this is for testing purpose.

        func: callable object. the func takes 1 argument as integer.
              The argument means length of mask key.
              This func must return string(byte array),
              which length is argument specified.
        """
        self.get_mask_key = func

    def gettimeout(self):
        """
        Get the websocket timeout(second).
        """
        return self.sock_opt.timeout

    def settimeout(self, timeout):
        """
        Set the timeout to the websocket.

        timeout: timeout time(second).
        """
        self.sock_opt.timeout = timeout
        if self.sock:
            self.sock.settimeout(timeout)

    timeout = property(gettimeout, settimeout)

    def getsubprotocol(self):
        """
        get subprotocol
        """
        if self.handshake_response:
            return self.handshake_response.subprotocol
        else:
            return None

    subprotocol = property(getsubprotocol)

    def getstatus(self):
        """
        get handshake status
        """
        if self.handshake_response:
            return self.handshake_response.status
        else:
            return None

    status = property(getstatus)

    def getheaders(self):
        """
        get handshake response header
        """
        if self.handshake_response:
            return self.handshake_response.headers
        else:
            return None

    headers = property(getheaders)

    def connect(self, url, **options):
        """
        Connect to url. url is websocket url scheme.
        ie. ws://host:port/resource
        You can customize using 'options'.
        If you set "header" list object, you can set your own custom header.

        >>> ws = WebSocket()
        >>> ws.connect("ws://echo.websocket.org/",
                ...     header=["User-Agent: MyProgram",
                ...             "x-custom: header"])

        timeout: socket timeout time. This value is integer.
                 if you set None for this value,
                 it means "use default_timeout value"

        options: "header" -> custom http header list or dict.
                 "cookie" -> cookie value.
                 "origin" -> custom origin url.
                 "host"   -> custom host header string.
                 "http_proxy_host" - http proxy host name.
                 "http_proxy_port" - http proxy port. If not set, set to 80.
                 "http_no_proxy"   - host names, which doesn't use proxy.
                 "http_proxy_auth" - http proxy auth information.
                                     tuple of username and password.
                                     default is None
                 "subprotocols" - array of available sub protocols.
                                  default is None.
                 "socket" - pre-initialized stream socket.

        """
        self.sock, addrs = connect(url, self.sock_opt, proxy_info(**options),
                                   options.pop('socket', None))

        try:
            self.handshake_response = handshake(self.sock, *addrs, **options)
            self.connected = True
        except:
            if self.sock:
                self.sock.close()
                self.sock = None
            raise

    def send(self, payload, opcode=ABNF.OPCODE_TEXT):
        """
        Send the data as string.

        payload: Payload must be utf-8 string or unicode,
                  if the opcode is OPCODE_TEXT.
                  Otherwise, it must be string(byte array)

        opcode: operation code to send. Please see OPCODE_XXX.
        """

        frame = ABNF.create_frame(payload, opcode)
        return self.send_frame(frame)

    def send_frame(self, frame):
        """
        Send the data frame.

        frame: frame data created  by ABNF.create_frame

        >>> ws = create_connection("ws://echo.websocket.org/")
        >>> frame = ABNF.create_frame("Hello", ABNF.OPCODE_TEXT)
        >>> ws.send_frame(frame)
        >>> cont_frame = ABNF.create_frame("My name is ", ABNF.OPCODE_CONT, 0)
        >>> ws.send_frame(frame)
        >>> cont_frame = ABNF.create_frame("Foo Bar", ABNF.OPCODE_CONT, 1)
        >>> ws.send_frame(frame)

        """
        if self.get_mask_key:
            frame.get_mask_key = self.get_mask_key
        data = frame.format()
        length = len(data)
        trace("send: " + repr(data))

        with self.lock:
            while data:
                l = self._send(data)
                data = data[l:]

        return length

    def send_binary(self, payload):
        return self.send(payload, ABNF.OPCODE_BINARY)

    def ping(self, payload=""):
        """
        send ping data.

        payload: data payload to send server.
        """
        if isinstance(payload, six.text_type):
            payload = payload.encode("utf-8")
        self.send(payload, ABNF.OPCODE_PING)

    def pong(self, payload):
        """
        send pong data.

        payload: data payload to send server.
        """
        if isinstance(payload, six.text_type):
            payload = payload.encode("utf-8")
        self.send(payload, ABNF.OPCODE_PONG)

    def recv(self):
        """
        Receive string data(byte array) from the server.

        return value: string(byte array) value.
        """
        opcode, data = self.recv_data()
        if six.PY3 and opcode == ABNF.OPCODE_TEXT:
            return data.decode("utf-8")
        elif opcode == ABNF.OPCODE_TEXT or opcode == ABNF.OPCODE_BINARY:
            return data
        else:
            return ''

    def recv_data(self, control_frame=False):
        """
        Receive data with operation code.

        control_frame: a boolean flag indicating whether to return control frame
        data, defaults to False

        return  value: tuple of operation code and string(byte array) value.
        """
        opcode, frame = self.recv_data_frame(control_frame)
        return opcode, frame.data

    def recv_data_frame(self, control_frame=False):
        """
        Receive data with operation code.

        control_frame: a boolean flag indicating whether to return control frame
        data, defaults to False

        return  value: tuple of operation code and string(byte array) value.
        """
        while True:
            frame = self.recv_frame()
            if not frame:
                # handle error:
                # 'NoneType' object has no attribute 'opcode'
                raise WebSocketProtocolException("Not a valid frame %s" % frame)
            elif frame.opcode in (ABNF.OPCODE_TEXT, ABNF.OPCODE_BINARY, ABNF.OPCODE_CONT):
                self.cont_frame.validate(frame)
                self.cont_frame.add(frame)

                if self.cont_frame.is_fire(frame):
                    return self.cont_frame.extract(frame)

            elif frame.opcode == ABNF.OPCODE_CLOSE:
                self.send_close()
                return (frame.opcode, frame)
            elif frame.opcode == ABNF.OPCODE_PING:
                if len(frame.data) < 126:
                    self.pong(frame.data)
                else:
                    raise WebSocketProtocolException("Ping message is too long")
                if control_frame:
                    return (frame.opcode, frame)
            elif frame.opcode == ABNF.OPCODE_PONG:
                if control_frame:
                    return (frame.opcode, frame)

    def recv_frame(self):
        """
        receive data as frame from server.

        return value: ABNF frame object.
        """
        return self.frame_buffer.recv_frame()

    def send_close(self, status=STATUS_NORMAL, reason=six.b("")):
        """
        send close data to the server.

        status: status code to send. see STATUS_XXX.

        reason: the reason to close. This must be string or bytes.
        """
        if status < 0 or status >= ABNF.LENGTH_16:
            raise ValueError("code is invalid range")
        self.connected = False
        self.send(struct.pack('!H', status) + reason, ABNF.OPCODE_CLOSE)

    def close(self, status=STATUS_NORMAL, reason=six.b(""), timeout=3):
        """
        Close Websocket object

        status: status code to send. see STATUS_XXX.

        reason: the reason to close. This must be string.

        timeout: timeout until receive a close frame.
            If None, it will wait forever until receive a close frame.
        """
        if self.connected:
            if status < 0 or status >= ABNF.LENGTH_16:
                raise ValueError("code is invalid range")

            try:
                self.connected = False
                self.send(struct.pack('!H', status) + reason, ABNF.OPCODE_CLOSE)
                sock_timeout = self.sock.gettimeout()
                self.sock.settimeout(timeout)
                try:
                    frame = self.recv_frame()
                    if isEnabledForError():
                        recv_status = struct.unpack("!H", frame.data)[0]
                        if recv_status != STATUS_NORMAL:
                            error("close status: " + repr(recv_status))
                except:
                    pass
                self.sock.settimeout(sock_timeout)
                self.sock.shutdown(socket.SHUT_RDWR)
            except:
                pass

        self.shutdown()

    def abort(self):
        """
        Low-level asynchronous abort, wakes up other threads that are waiting in recv_*
        """
        if self.connected:
            self.sock.shutdown(socket.SHUT_RDWR)

    def shutdown(self):
        "close socket, immediately."
        if self.sock:
            self.sock.close()
            self.sock = None
            self.connected = False

    def _send(self, data):
        return send(self.sock, data)

    def _recv(self, bufsize):
        try:
            return recv(self.sock, bufsize)
        except WebSocketConnectionClosedException:
            if self.sock:
                self.sock.close()
            self.sock = None
            self.connected = False
            raise

def create_connection(url, timeout=None, class_=WebSocket, **options):
    """
    connect to url and return websocket object.

    Connect to url and return the WebSocket object.
    Passing optional timeout parameter will set the timeout on the socket.
    If no timeout is supplied,
    the global default timeout setting returned by getdefauttimeout() is used.
    You can customize using 'options'.
    If you set "header" list object, you can set your own custom header.

    >>> conn = create_connection("ws://echo.websocket.org/",
         ...     header=["User-Agent: MyProgram",
         ...             "x-custom: header"])

    timeout: socket timeout time. This value is integer.
             if you set None for this value,
             it means "use default_timeout value"

    class_: class to instantiate when creating the connection. It has to implement
            settimeout and connect. It's __init__ should be compatible with
            WebSocket.__init__, i.e. accept all of it's kwargs.
    options: "header" -> custom http header list or dict.
             "cookie" -> cookie value.
             "origin" -> custom origin url.
             "host"   -> custom host header string.
             "http_proxy_host" - http proxy host name.
             "http_proxy_port" - http proxy port. If not set, set to 80.
             "http_no_proxy"   - host names, which doesn't use proxy.
             "http_proxy_auth" - http proxy auth information.
                                    tuple of username and password.
                                    default is None
             "enable_multithread" -> enable lock for multithread.
             "sockopt" -> socket options
             "sslopt" -> ssl option
             "subprotocols" - array of available sub protocols.
                              default is None.
             "skip_utf8_validation" - skip utf8 validation.
             "socket" - pre-initialized stream socket.
    """
    sockopt = options.pop("sockopt", [])
    sslopt = options.pop("sslopt", {})
    fire_cont_frame = options.pop("fire_cont_frame", False)
    enable_multithread = options.pop("enable_multithread", False)
    skip_utf8_validation = options.pop("skip_utf8_validation", False)
    websock = class_(sockopt=sockopt, sslopt=sslopt,
                     fire_cont_frame=fire_cont_frame,
                     enable_multithread=enable_multithread,
                     skip_utf8_validation=skip_utf8_validation, **options)
    websock.settimeout(timeout if timeout is not None else getdefaulttimeout())
    websock.connect(url, **options)
    return websock


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace Nimp
{
    public unsafe static class Memory
    {
        public static byte*[] Pages = new byte*[1 << 20];
        static byte* _cp; // cached page
        static uint _cpid = uint.MaxValue;

        public static uint StackStart = 0x7fffffff;
        public static uint StackSize = 1 << 16; // 64kb stack page
        public static byte* StackPage;

        public static void Init()
        {
            Memory.StackPage = (byte*)calloc(1 << 16);
            State.Registers = (int*)calloc(32 * 4);
        }

        public static IntPtr calloc(int len)
        {
            var ret = Marshal.AllocHGlobal(len);
            byte* p = (byte*)ret;

            for (int i = 0; i < len; i++)
                p[i] = 0;

            return ret;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static byte* GetPage(uint location)
        {
            unchecked
            {
                if ((location & 0xffff0000) == 0x7fff0000)
                {
                    // stack
                    return StackPage;
                }

                uint pid = location >> 12; // calculate page id

                if (pid == _cpid)
                {
                    return _cp; // return cached page
                }

                //if(_cpid != 0xffffffff)
                //{
                //    // commit cached page
                //    Pages[_cpid] = _cp;
                //}

                byte* page = Pages[pid];
                _cpid = pid; // write to cache

                if (page == null)
                    return _cp = Pages[pid] = (byte*)Marshal.AllocHGlobal(1 << 12);
                return _cp = page;
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static byte ReadByte(uint location)
        {
            byte* page = GetPage(location);
            return page[location & 0xFFF];
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void WriteByte(uint location, byte v)
        {
            byte* page = GetPage(location);
            page[location & 0xFFF] = v;
        }

        // TODO: Handle unaligned reads across pages

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static uint ReadWord(uint location)
        {
            byte* page = GetPage(location);

            location &= 0xFFF;

            return page[location] |
                ((uint)page[location + 1] << 8) |
                ((uint)page[location + 2] << 16) |
                ((uint)page[location + 3] << 24);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void WriteWord(uint word, uint location)
        {
            byte* page = GetPage(location);

            location &= 0xFFF;

            page[location] = (byte)(word & 0xFF);
            page[location + 1] = (byte)((word & 0xFF00) >> 8);
            page[location + 2] = (byte)((word & 0xFF0000) >> 16);
            page[location + 3] = (byte)((word & 0xFF000000) >> 24);
        }
    }
}


text:
namespace Microsoft.Graph
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net.Http;
    using System.Threading;
    using System.Linq.Expressions;

    /// <summary>
    /// The type ContractRequest.
    /// </summary>
    public partial class ContractRequest : BaseRequest, IContractRequest
    {
        /// <summary>
        /// Constructs a new ContractRequest.
        /// </summary>
        /// <param name="requestUrl">The URL for the built request.</param>
        /// <param name="client">The <see cref="IBaseClient"/> for handling requests.</param>
        /// <param name="options">Query and header option name value pairs for the request.</param>
        public ContractRequest(
            string requestUrl,
            IBaseClient client,
            IEnumerable<Option> options)
            : base(requestUrl, client, options)
        {
        }

        /// <summary>
        /// Creates the specified Contract using POST.
        /// </summary>
        /// <param name="contractToCreate">The Contract to create.</param>
        /// <returns>The created Contract.</returns>
        public System.Threading.Tasks.Task<Contract> CreateAsync(Contract contractToCreate)
        {
            return this.CreateAsync(contractToCreate, CancellationToken.None);
        }

        /// <summary>
        /// Creates the specified Contract using POST.
        /// </summary>
        /// <param name="contractToCreate">The Contract to create.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
        /// <returns>The created Contract.</returns>
        public async System.Threading.Tasks.Task<Contract> CreateAsync(Contract contractToCreate, CancellationToken cancellationToken)
        {
            this.ContentType = "application/json";
            this.Method = "POST";
            var newEntity = await this.SendAsync<Contract>(contractToCreate, cancellationToken).ConfigureAwait(false);
            this.InitializeCollectionProperties(newEntity);
            return newEntity;
        }

        /// <summary>
        /// Deletes the specified Contract.
        /// </summary>
        /// <returns>The task to await.</returns>
        public System.Threading.Tasks.Task DeleteAsync()
        {
            return this.DeleteAsync(CancellationToken.None);
        }

        /// <summary>
        /// Deletes the specified Contract.
        /// </summary>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
        /// <returns>The task to await.</returns>
        public async System.Threading.Tasks.Task DeleteAsync(CancellationToken cancellationToken)
        {
            this.Method = "DELETE";
            await this.SendAsync<Contract>(null, cancellationToken).ConfigureAwait(false);
        }

        /// <summary>
        /// Gets the specified Contract.
        /// </summary>
        /// <returns>The Contract.</returns>
        public System.Threading.Tasks.Task<Contract> GetAsync()
        {
            return this.GetAsync(CancellationToken.None);
        }

        /// <summary>
        /// Gets the specified Contract.
        /// </summary>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
        /// <returns>The Contract.</returns>
        public async System.Threading.Tasks.Task<Contract> GetAsync(CancellationToken cancellationToken)
        {
            this.Method = "GET";
            var retrievedEntity = await this.SendAsync<Contract>(null, cancellationToken).ConfigureAwait(false);
            this.InitializeCollectionProperties(retrievedEntity);
            return retrievedEntity;
        }

        /// <summary>
        /// Updates the specified Contract using PATCH.
        /// </summary>
        /// <param name="contractToUpdate">The Contract to update.</param>
        /// <returns>The updated Contract.</returns>
        public System.Threading.Tasks.Task<Contract> UpdateAsync(Contract contractToUpdate)
        {
            return this.UpdateAsync(contractToUpdate, CancellationToken.None);
        }

        /// <summary>
        /// Updates the specified Contract using PATCH.
        /// </summary>
        /// <param name="contractToUpdate">The Contract to update.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
        /// <returns>The updated Contract.</returns>
        public async System.Threading.Tasks.Task<Contract> UpdateAsync(Contract contractToUpdate, CancellationToken cancellationToken)
        {
            this.ContentType = "application/json";
            this.Method = "PATCH";
            var updatedEntity = await this.SendAsync<Contract>(contractToUpdate, cancellationToken).ConfigureAwait(false);
            this.InitializeCollectionProperties(updatedEntity);
            return updatedEntity;
        }

        /// <summary>
        /// Adds the specified expand value to the request.
        /// </summary>
        /// <param name="value">The expand value.</param>
        /// <returns>The request object to send.</returns>
        public IContractRequest Expand(string value)
        {
            this.QueryOptions.Add(new QueryOption("$expand", value));
            return this;
        }

        /// <summary>
        /// Adds the specified expand value to the request.
        /// </summary>
        /// <param name="expandExpression">The expression from which to calculate the expand value.</param>
        /// <returns>The request object to send.</returns>
        public IContractRequest Expand(Expression<Func<Contract, object>> expandExpression)
        {
		    if (expandExpression == null)
            {
                throw new ArgumentNullException(nameof(expandExpression));
            }
            string error;
            string value = ExpressionExtractHelper.ExtractMembers(expandExpression, out error);
            if (value == null)
            {
                throw new ArgumentException(error, nameof(expandExpression));
            }
            else
            {
                this.QueryOptions.Add(new QueryOption("$expand", value));
            }
            return this;
        }

        /// <summary>
        /// Adds the specified select value to the request.
        /// </summary>
        /// <param name="value">The select value.</param>
        /// <returns>The request object to send.</returns>
        public IContractRequest Select(string value)
        {
            this.QueryOptions.Add(new QueryOption("$select", value));
            return this;
        }

        /// <summary>
        /// Adds the specified select value to the request.
        /// </summary>
        /// <param name="selectExpression">The expression from which to calculate the select value.</param>
        /// <returns>The request object to send.</returns>
        public IContractRequest Select(Expression<Func<Contract, object>> selectExpression)
        {
            if (selectExpression == null)
            {
                throw new ArgumentNullException(nameof(selectExpression));
            }
            string error;
            string value = ExpressionExtractHelper.ExtractMembers(selectExpression, out error);
            if (value == null)
            {
                throw new ArgumentException(error, nameof(selectExpression));
            }
            else
            {
                this.QueryOptions.Add(new QueryOption("$select", value));
            }
            return this;
        }

        /// <summary>
        /// Initializes any collection properties after deserialization, like next requests for paging.
        /// </summary>
        /// <param name="contractToInitialize">The <see cref="Contract"/> with the collection properties to initialize.</param>
        private void InitializeCollectionProperties(Contract contractToInitialize)
        {

        }
    }
}


text:
package codeine.jsons.labels;

import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import javax.inject.Inject;

import codeine.configuration.PathHelper;
import codeine.model.Constants;
import codeine.utils.JsonFileUtils;

import com.google.common.collect.Maps;

public class LabelJsonFromFileProvider implements LabelJsonProvider {

	private @Inject JsonFileUtils jsonFileUtils;
	private @Inject PathHelper pathHelper;
	private Map<String, Set<ProjectLabelVersionJson>> labels = Maps.newConcurrentMap();

	private Set<ProjectLabelVersionJson> forProject(String project){
		if (!labels.containsKey(project)){
			Set<ProjectLabelVersionJson> versions = Collections.newSetFromMap(new ConcurrentHashMap<ProjectLabelVersionJson, Boolean>());
			versions.addAll(jsonFileUtils.getConfFromFile(pathHelper.getVersionLabelFile(project), new VersionLabelSetJson()).versions());
			labels.put(project, versions);
		}
		return labels.get(project);
	}

	@Override
	public Set<ProjectLabelVersionJson> versions(String project) {
		return forProject(project);
	}

	private void store(String projectName, VersionLabelSetJson versionLabelSetJson) {
		jsonFileUtils.setContent(pathHelper.getVersionLabelFile(projectName), versionLabelSetJson);
	}

	@Override
	public void updateLabel(ProjectLabelVersionJson versionLabelJson) {
		deleteLabel(versionLabelJson.label(), versionLabelJson.project());
		addLabel(versionLabelJson, versionLabelJson.project());
	}

	private void addLabel(ProjectLabelVersionJson versionLabelJson, String projectName) {
		Set<ProjectLabelVersionJson> versions = versions(projectName);
		versions.add(versionLabelJson);
		VersionLabelSetJson versionLabelSetJson = new VersionLabelSetJson(versions);
		store(projectName, versionLabelSetJson);
	}

	@Override
	public void deleteLabel(String alias, String projectName) {
		Set<ProjectLabelVersionJson> versions2 = versions(projectName);
		synchronized (versions2) {
			for (Iterator<ProjectLabelVersionJson> iterator = versions2.iterator(); iterator.hasNext();) {
				ProjectLabelVersionJson versionLabelJson2 = (ProjectLabelVersionJson) iterator.next();
				if (versionLabelJson2.label().equals(alias)){
					iterator.remove();
				}
			}
		}
		VersionLabelSetJson versionLabelSetJson = new VersionLabelSetJson(versions2);
		store(projectName, versionLabelSetJson);
	}

	@Override
	public String labelForVersion(String version, String projectName) {
		Set<ProjectLabelVersionJson> versions = versions(projectName);
		for (ProjectLabelVersionJson versionLabelJson : versions) {
			if (versionLabelJson.name().equals(version)){
				return versionLabelJson.label();
			}
		}
		return version;
	}
	@Override
	public String versionForLabel(String label, String projectName) {
		if (Constants.ALL_VERSION.equals(label)){
			return label;
		}
		Set<ProjectLabelVersionJson> versions = versions(projectName);
		for (ProjectLabelVersionJson versionLabelJson : versions) {
			if (versionLabelJson.label().equals(label)){
				return versionLabelJson.name();
			}
		}
		return label;
	}
}


text:
	Транспортная задача (задача Монжа — Канторовича) — математическая задача линейного программирования специального вида о поиске оптимального распределения однородных объектов из аккумулятора к приемникам с минимизацией затрат на перемещение. Для простоты понимания рассматривается как задача об оптимальном плане перевозок грузов из пунктов отправления в пункты потребления, с минимальными затратами на перевозки. Транспортная задача по теории сложности вычислений входит в класс сложности P. Когда суммарный объём предложений (грузов, имеющихся в пунктах отправления) не равен общему объёму спроса на товары (грузы), запрашиваемые пунктами потребления, транспортная задача называется несбалансированной (открытой).

	Транспортная задача (классическая) — задача об оптимальном плане перевозок однородного продукта из однородных пунктов наличия в однородные пункты потребления на однородных транспортных средствах (предопределённом количестве) со статичными данными и линеарном подходе (это основные условия задачи).

	Для классической транспортной задачи выделяют два типа задач: критерий стоимости (достижение минимума затрат на перевозку) или расстояний и критерий времени (затрачивается минимум времени на перевозку). Под названием транспортная задача, определяется широкий круг задач с единой математической моделью, эти задачи относятся к задачам линейного программирования и могут быть решены оптимальным методом. Однако, спец.метод решения транспортной задачи позволяет существенно упростить её решение, поскольку транспортная задача разрабатывалась для минимизации стоимости перевозок.


text:
package com.gauravbytes.openclose.bad;

public class Square extends Shape {

	public Square() {
		super(ShapeType.SQUARE);
	}

}


text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: diplomacy_tensorflow/core/debug/debugger_event_metadata.proto

#ifndef PROTOBUF_INCLUDED_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
#define PROTOBUF_INCLUDED_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto

namespace protobuf_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[1];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto
namespace third_party {
namespace tensorflow {
namespace core {
namespace debug {
class DebuggerEventMetadata;
class DebuggerEventMetadataDefaultTypeInternal;
extern DebuggerEventMetadataDefaultTypeInternal _DebuggerEventMetadata_default_instance_;
}  // namespace debug
}  // namespace core
}  // namespace tensorflow
}  // namespace third_party
namespace google {
namespace protobuf {
template<> ::third_party::tensorflow::core::debug::DebuggerEventMetadata* Arena::CreateMaybeMessage<::third_party::tensorflow::core::debug::DebuggerEventMetadata>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace third_party {
namespace tensorflow {
namespace core {
namespace debug {

// ===================================================================

class DebuggerEventMetadata : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:third_party.tensorflow.core.debug.DebuggerEventMetadata) */ {
 public:
  DebuggerEventMetadata();
  virtual ~DebuggerEventMetadata();

  DebuggerEventMetadata(const DebuggerEventMetadata& from);

  inline DebuggerEventMetadata& operator=(const DebuggerEventMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DebuggerEventMetadata(DebuggerEventMetadata&& from) noexcept
    : DebuggerEventMetadata() {
    *this = ::std::move(from);
  }

  inline DebuggerEventMetadata& operator=(DebuggerEventMetadata&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const DebuggerEventMetadata& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DebuggerEventMetadata* internal_default_instance() {
    return reinterpret_cast<const DebuggerEventMetadata*>(
               &_DebuggerEventMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(DebuggerEventMetadata* other);
  friend void swap(DebuggerEventMetadata& a, DebuggerEventMetadata& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline DebuggerEventMetadata* New() const final {
    return CreateMaybeMessage<DebuggerEventMetadata>(NULL);
  }

  DebuggerEventMetadata* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<DebuggerEventMetadata>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const DebuggerEventMetadata& from);
  void MergeFrom(const DebuggerEventMetadata& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DebuggerEventMetadata* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string device = 1;
  void clear_device();
  static const int kDeviceFieldNumber = 1;
  const ::std::string& device() const;
  void set_device(const ::std::string& value);
  #if LANG_CXX11
  void set_device(::std::string&& value);
  #endif
  void set_device(const char* value);
  void set_device(const char* value, size_t size);
  ::std::string* mutable_device();
  ::std::string* release_device();
  void set_allocated_device(::std::string* device);

  // int32 output_slot = 2;
  void clear_output_slot();
  static const int kOutputSlotFieldNumber = 2;
  ::google::protobuf::int32 output_slot() const;
  void set_output_slot(::google::protobuf::int32 value);

  // int32 num_chunks = 3;
  void clear_num_chunks();
  static const int kNumChunksFieldNumber = 3;
  ::google::protobuf::int32 num_chunks() const;
  void set_num_chunks(::google::protobuf::int32 value);

  // int32 chunk_index = 4;
  void clear_chunk_index();
  static const int kChunkIndexFieldNumber = 4;
  ::google::protobuf::int32 chunk_index() const;
  void set_chunk_index(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:third_party.tensorflow.core.debug.DebuggerEventMetadata)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr device_;
  ::google::protobuf::int32 output_slot_;
  ::google::protobuf::int32 num_chunks_;
  ::google::protobuf::int32 chunk_index_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto::TableStruct;
};
// ===================================================================

// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// DebuggerEventMetadata

// string device = 1;
inline void DebuggerEventMetadata::clear_device() {
  device_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& DebuggerEventMetadata::device() const {
  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
  return device_.GetNoArena();
}
inline void DebuggerEventMetadata::set_device(const ::std::string& value) {

  device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
}
#if LANG_CXX11
inline void DebuggerEventMetadata::set_device(::std::string&& value) {

  device_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
}
#endif
inline void DebuggerEventMetadata::set_device(const char* value) {
  GOOGLE_DCHECK(value != NULL);

  device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
}
inline void DebuggerEventMetadata::set_device(const char* value, size_t size) {

  device_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
}
inline ::std::string* DebuggerEventMetadata::mutable_device() {

  // @@protoc_insertion_point(field_mutable:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
  return device_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DebuggerEventMetadata::release_device() {
  // @@protoc_insertion_point(field_release:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)

  return device_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DebuggerEventMetadata::set_allocated_device(::std::string* device) {
  if (device != NULL) {

  } else {

  }
  device_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device);
  // @@protoc_insertion_point(field_set_allocated:third_party.tensorflow.core.debug.DebuggerEventMetadata.device)
}

// int32 output_slot = 2;
inline void DebuggerEventMetadata::clear_output_slot() {
  output_slot_ = 0;
}
inline ::google::protobuf::int32 DebuggerEventMetadata::output_slot() const {
  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.output_slot)
  return output_slot_;
}
inline void DebuggerEventMetadata::set_output_slot(::google::protobuf::int32 value) {

  output_slot_ = value;
  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.output_slot)
}

// int32 num_chunks = 3;
inline void DebuggerEventMetadata::clear_num_chunks() {
  num_chunks_ = 0;
}
inline ::google::protobuf::int32 DebuggerEventMetadata::num_chunks() const {
  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.num_chunks)
  return num_chunks_;
}
inline void DebuggerEventMetadata::set_num_chunks(::google::protobuf::int32 value) {

  num_chunks_ = value;
  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.num_chunks)
}

// int32 chunk_index = 4;
inline void DebuggerEventMetadata::clear_chunk_index() {
  chunk_index_ = 0;
}
inline ::google::protobuf::int32 DebuggerEventMetadata::chunk_index() const {
  // @@protoc_insertion_point(field_get:third_party.tensorflow.core.debug.DebuggerEventMetadata.chunk_index)
  return chunk_index_;
}
inline void DebuggerEventMetadata::set_chunk_index(::google::protobuf::int32 value) {

  chunk_index_ = value;
  // @@protoc_insertion_point(field_set:third_party.tensorflow.core.debug.DebuggerEventMetadata.chunk_index)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)

}  // namespace debug
}  // namespace core
}  // namespace tensorflow
}  // namespace third_party

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_diplomacy_5ftensorflow_2fcore_2fdebug_2fdebugger_5fevent_5fmetadata_2eproto


text:
@interface NSData (PhoenixFC)

- (NSInteger)getIntegerWithRange:(NSRange)range;

@end


text:
<?php
declare(strict_types=1);

namespace Muffin\Footprint\Test\TestCase\Model\Behavior;

use Cake\ORM\Entity;
use Cake\TestSuite\TestCase;

class FootprintBehaviorTest extends TestCase
{
    protected $fixtures = [
        'plugin.Muffin/Footprint.Articles',
    ];

    public function setUp(): void
    {
        parent::setUp();

        $table = $this->getTableLocator()->get('Muffin/Footprint.Articles');
        $table->addBehavior('Muffin/Footprint.Footprint', [
            'events' => [
                'Model.beforeSave' => [
                    'created_by' => 'new',
                    'modified_by' => 'always',
                    'company_id' => 'always',
                ],
                'Model.beforeFind' => 'created_by',
            ],
            'propertiesMap' => [
                'company_id' => '_footprint.company.id',
            ],
        ]);

        $this->Table = $table;
        $this->footprint = new Entity([
            'id' => 2,
            'company' => new Entity(['id' => 5]),
        ]);
    }

    public function tearDown(): void
    {
        parent::tearDown();
        $this->getTableLocator()->clear();
    }

    public function testSave()
    {
        $entity = new Entity(['title' => 'new article']);
        $entity = $this->Table->save($entity, ['_footprint' => $this->footprint]);
        $expected = [
            'id' => $entity->id,
            'title' => 'new article',
            'created_by' => 2,
            'modified_by' => 2,
            'company_id' => 5,
        ];
        $this->assertSame(
            $expected,
            $entity->extract(['id', 'title', 'created_by', 'modified_by', 'company_id'])
        );

        $footprint = new Entity([
            'id' => 3,
        ]);
        $entity->title = 'new title';
        $entity = $this->Table->save($entity, ['_footprint' => $footprint]);
        $expected = ['id' => $entity->id, 'title' => 'new title', 'created_by' => 2, 'modified_by' => 3];
        $this->assertSame($expected, $entity->extract(['id', 'title', 'created_by', 'modified_by']));

        $entity = new Entity(['title' => 'without footprint']);
        $entity = $this->Table->save($entity);
        $expected = ['id' => $entity->id, 'title' => 'without footprint', 'created_by' => null, 'modified_by' => null];
        $this->assertSame($expected, $entity->extract(['id', 'title', 'created_by', 'modified_by']));
    }

    public function testFind()
    {
        $result = $this->Table->find('all', ['_footprint' => $this->footprint])
            ->enableHydration(false)
            ->first();

        $expected = ['id' => 3, 'title' => 'article 3', 'created_by' => 2, 'modified_by' => 1];
        $this->assertSame($expected, $result);

        // Test to show value of "id" is not used from footprint if
        // "Articles.created_by" is already set in condition.
        $result = $this->Table->find('all', ['_footprint' => $this->footprint])
            ->where(['Articles.created_by' => 1])
            ->enableHydration(false)
            ->first();

        $expected = ['id' => 1, 'title' => 'article 1', 'created_by' => 1, 'modified_by' => 1];
        $this->assertSame($expected, $result);
    }

    public function testInjectEntityException()
    {
        $this->expectException('UnexpectedValueException');
        $this->expectExceptionMessage('When should be one of "always", "new" or "existing". The passed value "invalid" is invalid');

        $this->Table->behaviors()->Footprint->setConfig(
            'events',
            [
                'Model.beforeSave' => [
                    'created_by' => 'invalid',
                ],
            ]
        );
        $entity = new Entity(['title' => 'new article']);
        $entity = $this->Table->save($entity, ['_footprint' => $this->footprint]);
    }

    public function testDispatchException()
    {
        $this->expectException('InvalidArgumentException');
        $this->expectExceptionMessage('Event "Model.beforeMarshal" is not supported.');

        $behavior = $this->Table->behaviors()->Footprint;
        $behavior->setConfig('events', ['Model.beforeMarshal' => ['modified_by']]);
        $this->Table->getEventManager()->on('Model.beforeMarshal', [$behavior, 'dispatch']);
        $this->Table->newEntity([]);
    }
}


text:
import AbstractBehavior from "./AbstractBehavior";
import {DisplayObject} from "../display/DisplayObject";
import Stage from "../display/Stage";
import Container from "../display/Container";
import DisplayType from "../enum/DisplayType";

/**
 * @method ButtonBehavior
 * @author Mient-jan Stelling <mientjan.stelling@gmail.com>
 */
class ButtonBehavior extends AbstractBehavior
{
	private _stage:Stage;

	private _onClickInstance:Function = null;
	private _onPointerOverInstance:Function = null;
	private _onPointerOutInstance:Function = null;

	/**
	 * @method initialize
	 * @param displayObject
	 */
	public initialize(displayObject:DisplayObject):void
	{
		super.initialize(displayObject);

		this.owner.setMouseInteraction(true);
		this.owner.cursor = 'pointer';

		if(typeof(this.owner['onClick']) == 'function')
		{

			this._onClickInstance = this.owner['onClick'].bind(this.owner);
			this.owner.addEventListener(DisplayObject.EVENT_MOUSE_CLICK, this._onClickInstance );
		}

		if(typeof(this.owner['onPointerOver']) == 'function')
		{
			this._onPointerOverInstance = this.owner['onPointerOver'].bind(this.owner);
			this.owner.addEventListener(DisplayObject.EVENT_MOUSE_OVER, this._onPointerOverInstance );
		}

		if(typeof(this.owner['onPointerOut']) == 'function')
		{
			this._onPointerOutInstance = this.owner['onPointerOut'].bind(this.owner);
			this.owner.addEventListener(DisplayObject.EVENT_MOUSE_OUT, this._onPointerOutInstance  );
		}

	}

	public destruct():void
	{
		if(this._onClickInstance)
		{
			this.owner.removeEventListener(DisplayObject.EVENT_MOUSE_CLICK, this._onClickInstance);
		}

		if(this._onPointerOverInstance)
		{
			this.owner.removeEventListener(DisplayObject.EVENT_MOUSE_OVER, this._onPointerOverInstance);
		}

		if(this._onPointerOutInstance)
		{
			this.owner.removeEventListener(DisplayObject.EVENT_MOUSE_OUT, this._onPointerOutInstance);
		}

		this._stage = null;
		this._onClickInstance = null;
		this._onPointerOverInstance = null;
		this._onPointerOutInstance = null;

		super.destruct();
	}
}

export default ButtonBehavior;


text:
NTSTATUS arbusno_Constructor(__in PPCI_COMMON_EXTENSION Ext,__in PPCI_INTERFACE PciIntf,__in PVOID Data,__in USHORT Version,__in USHORT Size,__in PINTERFACE Interface);

//
// initializer
//
NTSTATUS arbusno_Initializer(__in PPCI_ARBITER_INSTANCE Instance);

//
// unpack requirement
//
NTSTATUS arbusno_UnpackRequirement(__in PIO_RESOURCE_DESCRIPTOR Desc,__out PULONGLONG Minimum,__out PULONGLONG Maximum,__out PULONG Length,__out PULONG Alignment);

//
// pack resource
//
NTSTATUS arbusno_PackResource(__in PIO_RESOURCE_DESCRIPTOR Requirement,__in ULONGLONG Start,__out PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor);

//
// unpack resource
//
NTSTATUS arbusno_UnpackResource(__in PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,__out PULONGLONG Start,__out PULONG Length);

//
// score requirement
//
LONG arbusno_ScoreRequirement(__in PIO_RESOURCE_DESCRIPTOR Descriptor);


text:
💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/platinumazure/eslint-plugin-qunit/blob/master/README.md#configurations).

<!-- end auto-generated rule header -->

Early versions of QUnit exposed the `QUnit.reset()` function, which allowed
consumers to invoke the internal QUnit fixture reset logic. This has been
discouraged for a long time since QUnit now automatically invokes this method
between tests. In QUnit 2.0, the function will be removed from the public API.
Tests that rely on this functionality will need to be split into multiple tests.

This rule will detect and report calls to `QUnit.reset()`.

## Rule Details

The following patterns are considered warnings:

```js

QUnit.reset();

```

The following patterns are not warnings:

```js

QUnit.reset;  // Only attempting to invoke the function is reported

```

## When Not To Use It

This rule can be disabled if there are tests that rely on this functionality and
there are no plans to migrate to QUnit 2.0. For the other 99.9% of use cases,
use of this rule is *highly* recommended.

## Further Reading

* [QUnit Upgrade Guide: Stop using `QUnit.reset`](https://qunitjs.com/upgrade-guide-2.x/#stop-using-qunit-reset-split-one-test-into-multiple-tests)


text:
require_relative '../../views_and_triggers/list/list'
require_relative '../../views_and_triggers/list/sql'

module Multitenant
  module Views
    module SQL

      class Drop

        def self.run
          list = Multitenant::List.new
          list.sql = Multitenant::SQL::VIEWS

          list.to_a.each do |view|
            ActiveRecord::Base.connection.execute("DROP VIEW #{view};")
            p "==================== Dropped View: #{view} =================="
          end
        end

      end

    end
  end
end


text:
function createElement (type, attrs, styles, html) {
    var i,
        el = document.createElement(type);

    if (attrs) {
        for (i in attrs) {
            if (attrs.hasOwnProperty(i)) {
                el[i] = attrs[i];
            }
        }
    }

    if (styles) {
        for (s in styles) {
            if (styles.hasOwnProperty(s)) {
                el.style[s] = styles[s];
            }
        }
    }

    return el;
}

function setValue(el, val) {
    var action = el.tagName === 'INPUT' ? 'value' : 'innerHTML';
    return el[action] = val;
}

function getValue(el) {
    var action = el.tagName === 'INPUT' ? 'value' : 'innerHTML';
    return el[action];
}

createElement('DIV', {id: 'wrapper', class: 'wrapper'}, {color: 'red', display: 'inline-block'}, el)


text:
import { fromJS, List, Set } from 'immutable';

// GENERAL
export function isValidList(list) {
  return list && !list.isEmpty();
}

export function filterCatalogue(idsByAids, idsByFilters, idsByAvailability) {
  let toIntersect = fromJS([idsByAvailability]);
  if (idsByAids) {
    toIntersect = toIntersect.push(idsByAids);
  }
  if (idsByFilters) {
    toIntersect = toIntersect.push(idsByFilters);
  }
  return Set.intersect(toIntersect.toJS());
}

// AIDS
export function filterProductsByAid(sellingAids, activeAid) {
  if (isValidList(sellingAids) && activeAid) {
    const selectedAid = sellingAids.find(a => a.get('code') === activeAid);
    if (selectedAid) {
      return selectedAid.get('products').toSet();
    }
  }
  return null;
}

// FILTERS
export function getProductsByFilter(filterGroups, activeFilters) {
  return filterGroups
    .map(g =>
      g
        .get('filters')
        .reduce((acc, f) => {
          if (activeFilters.includes(f.get('code'))) {
            return acc.push(f.get('products'));
          }
          return acc;
        }, List())
        .flatten()
        .toSet()
    )
    .filterNot(f => f.isEmpty())
    .toArray();
}

export function filterProducts(filterGroups, activeFilters) {
  if (isValidList(filterGroups) && isValidList(activeFilters)) {
    return Set.intersect(getProductsByFilter(filterGroups, activeFilters));
  }
  return null;
}

// AVAILABILITY
export function filterProductsByAvailability(productList, activeAvailability) {
  if (isValidList(productList)) {
    let products = productList;
    if (activeAvailability) {
      products = productList.filter(p => p.get('storeStock') > 0);
    }
    return products.map(p => p.get('code')).toSet();
  }
  return Set();
}


text:
<div *ngIf="initialized">
  <ceb-page-toolbar>
    <button pButton label="Nová" icon="fa-plus"></button>
    <button pButton label="Smazat" icon="fa-trash"></button>
    <p-splitButton label="Export" icon="fa-file-o" [model]="exportMenuItems"></p-splitButton>
  </ceb-page-toolbar>
  <div class="grid-header">
    <ceb-page-view-menu [menuItems]="filterMenuItems" [selectedMenuItem]="selectedPageViewMenuItem"></ceb-page-view-menu>
  </div>
</div>


text:
package org.apache.sling.scripting.freemarker.it;

import java.io.IOException;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.ops4j.pax.exam.junit.PaxExam;
import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
import org.ops4j.pax.exam.spi.reactors.PerClass;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

@RunWith(PaxExam.class)
@ExamReactorStrategy(PerClass.class)
public class SimpleIT extends FreemarkerTestSupport {

    private Document document;

    @Before
    public void setup() throws IOException {
        final String url = String.format("http://localhost:%s/freemarker/simple.html", httpPort());
        document = Jsoup.connect(url).get();
    }

    @Test
    public void testTitle() {
        assertThat(document.title(), is("freemarker simple"));
    }

    @Test
    public void testPageName() {
        final Element name = document.getElementById("name");
        assertThat("simple", is(name.text()));
    }

}


text:
package CC190_Network_ChatRoom;
/*
 * ¿Í»§¶Ë£º·¢ËÍÊý¾Ý+½ÓÊÕÊý¾Ý
 * д³öÊý¾Ý£ºÊä³öÁ÷
 * ¶ÁÈ¡Êý¾Ý£ºÊäÈëÁ÷
 */
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket client=new Socket("localhost",9999);
		//¿ØÖÆ̨ÊäÈëÁ÷£º
		BufferedReader console =new BufferedReader(new InputStreamReader(System.in));
		DataOutputStream dos=new DataOutputStream(client.getOutputStream());
		DataInputStream dis=new DataInputStream(client.getInputStream());
		while (true) {
			String info=console.readLine();
			//Êä³öÁ÷:Êä³öµ½·þÎñÆ÷
			dos.writeUTF(info);
			dos.flush();
			//ÊäÈëÁ÷£º´Ó·þÎñÆ÷½ÓÊÕ
			String msg=dis.readUTF();
			System.out.println(msg);
		}

	}

}


text:
Sub Project Status

<input type="checkbox" checked>

<input type="checkbox" checked>

                        33%
                        Fund used(This Quarter)

23%

                        134Million

35%

                        Over all progress

Sub Projects

                                <form autocomplete="off" class="form-inline">

                                        <button type="button" class="btn btn-inverse pull-right"></button>

                                            <input class="form-control" type="text" value="" placeholder="Find Sub Projects ..">

                                    <select style="width: 100%; margin-bottom: 3px;">
                                        <optgroup label="Components">
                                            <option value="window1">Component 1</option>
                                            <option value="window2">Component 2</option>
                                            <option value="window3">Component 3</option>
                                        </optgroup>
                                    </select>
                                    <select style="width: 100%;">
                                        <optgroup label="Windows">
                                            <option value="window1">Window 1</option>
                                            <option value="window2">Window 2</option>
                                            <option value="window3">Window 3</option>
                                        </optgroup>
                                    </select>
                                </form>

                            350 Sub Projects Found

<img src="<?php echo base_url(); ?>resources/images/project.png" alt="Image" />

                                            BSMMU
                                            info@bsmmu.edu.bd

<img src="<?php echo base_url(); ?>resources/images/project.png" alt="Image" />

                                            NSTU
                                            info@nstu.com

<img src="<?php echo base_url(); ?>resources/images/project.png" alt="Image" />

                                            BUET
                                            buet.edu.bd

BSMMU

                                            Window 1

1 project(s)

80%

<img src="<?php echo base_url(); ?>resources/images/project.png" alt="Profile" class="img-responsive" />

 Send Email

 +88 01658623659

 bsmmu

About

Modernization of research facilities and post graduate course curicullum based on innovative research on medical education in the department of Anatomy.

                                                                Total Budget
Tk 2,000,000.00 (In Taka)

                                                                Total Expense
Tk 1,200,000.00 (In Taka)

 Management Team

1Atiqul IslamProject Manager

2A.R. Azimul HoqueConsultant

Alerts

                                Sales

                                20

                                Alerts

                                125

                                2
                                Orders

                                30
                                Bookings

Recent Activity

Users

Orders

                                                    21/03

                                                    Darius Jackson registered at John Doe's suggestion.

                                                    21/03

                                                    Martin Glades registered at Jane Doe's suggestion.

                                                    21/03

                                                    Martin Glades registered at Jane Doe's suggestion.

                                                    21/03

                                                    Darius Jackson registered at Jane Doe's suggestion.

                                                    21/03

                                                    Martin Glades registered at Martin Glades's suggestion.

                                                    21/03

                                                    Darius Jackson bought 10 items worth of €50 (order #2301)

                                                    21/03

                                                    Jane Doe bought 10 items worth of €50 (order #2302)

                                                    21/03

                                                    Jane Doe bought 10 items worth of €50 (order #2303)

                                                    21/03

                                                    Jane Doe bought 10 items worth of €50 (order #2304)

                                                    21/03

                                                    Melisa Ragae bought 10 items worth of €50 (order #2305)

                                                        You have received an email from Melisa Ragae (melisa.ragae@grr-email.net)
                                                        on 29 March, 2013 1 hour ago

                                                        You have received an email from Jane Doe (jane.doe@lovely-email.net)
                                                        on 29 March, 2013 1 hour ago

                                                        You have received an email from Melisa Ragae (melisa.ragae@grr-email.net)
                                                        on 29 March, 2013 1 hour ago

                                                        You have received an email from Martin Glades (martin.glades@wee-email.com)
                                                        on 29 March, 2013 1 hour ago

                                                        You have received an email from Jane Doe (jane.doe@lovely-email.net)
                                                        on 29 March, 2013 1 hour ago

                                                    21/03

                                                    Jane Doe bought 10 items worth of €50 (order #2301)

                                                    21/03

                                                    Darius Jackson bought 10 items worth of €50 (order #2302)

                                                    21/03

                                                    Jane Doe bought 10 items worth of €50 (order #2303)

                                                    21/03

                                                    Darius Jackson bought 10 items worth of €50 (order #2304)

                                                    21/03

                                                    Darius Jackson bought 10 items worth of €50 (order #2305)

                                                    21/03

                                                    John Doe bought 10 items worth of €50 (order #2301)

                                                    21/03

                                                    Melisa Ragae bought 10 items worth of €50 (order #2302)

                                                    21/03

                                                    Martin Glades bought 10 items worth of €50 (order #2303)

                                                    21/03

                                                    Darius Jackson bought 10 items worth of €50 (order #2304)

Chat

                                    Martin

<img src="<?php echo base_url(); ?>resources/assets/images/avatar-51x51.jpg" alt="Image" />

                                            just now

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin vitae accumsan mauris. Donec vitae nibh felis, facilisis bibendum sapien.

                                    John Doe

<img src="<?php echo base_url(); ?>resources/assets/images/avatar-51x51.jpg" alt="Image" />

                                            15 seconds ago

In ultricies ante eget tortor euismod vitae molestie eros hendrerit. Cras tristique, orci ac lacinia aliquet, velit risus laoreet lectus, eget sollicitudin metus orci non nulla.

                                    Ricky

<img src="<?php echo base_url(); ?>resources/assets/images/avatar-51x51.jpg" alt="Image" />

                                            5 minutes ago

Pellentesque ac turpis turpis. Aliquam erat volutpat. Proin semper auctor mauris vel tempor. Ut eget turpis neque. Nam ultricies tortor eu odio ultricies euismod.

                                <form class="margin-none">

                                            <input type="text" name="message" class="form-control" placeholder="Type your message .." />

                                            <button type="submit" class="btn btn-block btn-primary">Send</button>

                                </form>

Activity

                            view all

                                    Sales today
                                    €5,900

                                    Some other stats
                                    36,900

                                    Some stunning stats
                                    26,999

                                    Awesome stats
                                    4,900

Get this item now!

Cras justo odio, dapibus ac facilisis in, egestas eget quam. Donec id elit non mi porta gravida at eget metus. Nullam id dolor id nibh ultricies vehicula ut.
 Buy Quick Admin!

                                        <img src="<?php echo base_url(); ?>resources/assets/images/gallery-2/6.jpg" alt="" class="img-responsive" />

Get this item now!

Cras justo odio, dapibus ac facilisis in, egestas eget quam. Donec id elit non mi porta gravida at eget metus. Nullam id dolor id nibh ultricies vehicula ut.
 Buy Quick Admin!

                                        <img src="<?php echo base_url(); ?>resources/assets/images/gallery-2/7.jpg" alt="" class="img-responsive" />

Get this item now!

Cras justo odio, dapibus ac facilisis in, egestas eget quam. Donec id elit non mi porta gravida at eget metus. Nullam id dolor id nibh ultricies vehicula ut.
 Buy Quick Admin!

                                        <img src="<?php echo base_url(); ?>resources/assets/images/gallery-2/8.jpg" alt="" class="img-responsive" />

Special Offers

Product or Service Name

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin vitae accumsan mauris. Donec vitae nibh

                                            Price: $29.90

                                            <button type="button" class="btn btn-inverse btn-icon glyphicons shopping_cart btn-sm">Purchase</button>

Special Offers

Product or Service Name

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin vitae accumsan mauris. Donec vitae nibh

                                            Price: $29.90

                                            <button type="button" class="btn btn-inverse btn-icon glyphicons shopping_cart btn-sm">Purchase</button>

Special Offers

Product or Service Name

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin vitae accumsan mauris. Donec vitae nibh

                                            Price: $29.90

                                            <button type="button" class="btn btn-inverse btn-icon glyphicons shopping_cart btn-sm">Purchase</button>

Windows Wise Sub Project total

                            Window 1
                            35

                            Window 2
                            30

                            Window 3
                            19

Notes

Every University should be Posted their entry before ending this month

                ×

Date line of sending report are 31-jan-2015.

Previous Quarter Cost

                    view all

                            photo
                            57 Sub Project
€5,900.00

                            photo
                            Window 1
€2,900

                            photo
                            Window 2
€2,700

                            photo
                            Window 3
€6,753

Twitter feed

Loading ..


text:
Step 1

<?php
	if($countErrors > 0) {
		echo "

				Unable to continue installation because of the following error:

				".$dispError."

		";
	}

?>

	NOTE: A major update to themes has been made in R15.  If you haven't done so already, please download a new copy of the theme you were using here: http://bluethrust.com/themes.

<form action='index.php?step=2' method='post'>

			Database Information

			Database Name:
			<input type='text' class='textBox' name='dbname'>

			Database Username:
			<input type='text' class='textBox' name='dbuser'>

			Database Password:
			<input type='password' class='textBox' name='dbpass'>

			Database Host:
			<input type='text' class='textBox' name='dbhost'>

			Install Type:
			<select name='installType' id='installType' class='textBox'><option value='1'>Fresh Install</option><option value='2'>Update</option></select>

				<input type='submit' name='step1submit' style='width: 125px' class='submitButton' value='Go to Step 2'>

</form>


text:
<!DOCTYPE compass-core-mapping PUBLIC
    "-//Compass/Compass Core Mapping DTD 2.3//EN"
    "http://www.compass-project.org/dtd/compass-core-mapping-2.3.dtd">

<compass-core-mapping package="org.compass.core.test.managedid">

    <class name="A" alias="a">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue2</meta-data>
        </property>

    </class>

    <class name="B" alias="b">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
        </property>

    </class>

    <class name="C" alias="c">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

    </class>

    <class name="D" alias="d">

        <id name="id" />

        <property name="value" managed-id="false">
            <meta-data store="no">mvalue</meta-data>
        </property>

    </class>

    <class name="Constant" alias="constant">

        <id name="id" />

        <constant>
            <meta-data>mvalue1</meta-data>
            <meta-data-value>mvalueVALUE</meta-data-value>
        </constant>

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

    </class>

    <class name="ParentComponent" alias="parentComp">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

        <component name="childComponent" ref-alias="childComp" />

    </class>

    <class name="ChildComponent" alias="childComp" root="false">

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

    </class>

    <class name="ParentReference" alias="parentRef">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

        <reference name="childReference" ref-alias="childRef1" />

    </class>

    <class name="ChildReference" alias="childRef1">

        <id name="id" />

        <property name="value1">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue1</meta-data>
        </property>

        <property name="value2">
            <meta-data>mvalue</meta-data>
            <meta-data>mvalue2</meta-data>
        </property>

    </class>

</compass-core-mapping>


text:
<!DOCTYPE html>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title>CSS Test:  font-variant: normal; low level equivalence</title>
<link rel="author" title="Chris Lilley" href="chris@w3.org">
<link rel="help" href="https://www.w3.org/TR/css-fonts-4/#font-variant-prop">
<link rel="help" href="https://www.w3.org/TR/css-fonts-4/#font-feature-settings-prop">
<link rel="help" href="https://www.w3.org/TR/css-fonts-4/#font-rend-desc">
<link rel="match" href="font-variant-descriptor-01-ref.html">
<meta name="assert" content="These descriptors define initial settings that apply when the font defined by an @font-face rule is rendered">

Test passes if the three lines below are identical, with (in purple) eight check marks (✓)

CDGFEJQa

CDGFEJQa

AAAAAAAA


text:
/**
* Module dependencies.
*/

var fs = require('fs');
var home = require('home');

exports.get = function(app_name, field) {
    var path = home() + '/.credentials';

    fs.open(path, 'r', function (err, fd) {
        if (err) {
            console.error('Credential files have not been created yet, please see [doc]')
        }
    });

    var keys = app_name.split('.');

    var obj = JSON.parse(fs.readFileSync(home() + '/.credentials/credentials_apps.json', 'utf8'));

    var new_keys = obj[keys[0]][keys[1]].split('.');

    var new_obj = JSON.parse(fs.readFileSync(home() + '/.credentials/credentials.json', 'utf8'));

    return new_obj[new_keys[0]][new_keys[1]][field];
}