text:
FutureSystems
=============

This section gives an overview of the FutureSystems that are available
as part of the DSC infrastructure. We cover the creation of
FutureSystems Account, Uploading SSH Key and how to instantiate and log
into Virtual Machine and accessing Ipython are covered. In the end we
discuss about running Python and Java on Virtual Machine.

FutureSystems evolved from FutureGrid
-------------------------------------

In this video we introduce FutureGrid a precurser to FutureSystems.

[:clapper: Systems 12:12 FutureGid](http://youtu.be/RibpNSyd4qg)

At thsi time we are replacing several of the older systems. To use these
new systems you need to ask for access through them via our portal.

Creating Portal Account
-----------------------

This lesson explains how to create a portal account, which is the first
step in gaining access to FutureSystems.

See Lesson 4 and 7 for SSH key generation on Linux, OSX or Windows.

[:clapper: Python 11:50 FutureGrid Introduction](http://youtu.be/X6zeVEALzTk)

SSH Key Generation using ssh-keygen command
-------------------------------------------

SSH keys are used to identify user accounts in most systems including
FutureSystems. This lesson walks you through generating an SSH key via
ssh-keygen command line tool.

[:clapper: Python 4:06 ssh-key gen](http://youtu.be/pQb2VV1zNIc)

Shell Access via SSH
--------------------

This lesson explains how to get access FutureSystems resources vis SSH
terminal with your registered SSH key.

[:clapper: Python 2:34 Shell Access via SSH](http://youtu.be/aJDXfvOrzRE)

Advanced SSH
------------

This lesson shows you how to write SSH 'config' file in advanced
settings.

[:clapper: Python 2:47 Advanced SSH](http://youtu.be/eYanElmtqMo)

SSH Key Generation via putty
----------------------------

This lesson is for Windows users. You will learn how to create an SSH
key using PuTTYgen, add the public key to you FutureSystems portal, and
then login using the PuTTY SSH client.

[:clapper: Python 3:51 Windows users](http://youtu.be/irmVJKwWQCU)

FutureSystems Facilities
------------------------

FutureSystems system resources are located at Indiana University
(Bloomington). Resources at Indiana University (Bloomington) include a

1.  128-core HP cluster (Bravo),

2.  92-core cloud cluster (Echo),

3.  192-core Tesla GPU cluster (Delta),

4.  3456-core Haswell cluster (Juliet),

5.  126-core NVIDIA K80/Volta GPU cluster (Romeo),

6.  3264-core Knight's Landing cluster (Tango),

7.  480-core Platinum cluster (Tempest),

8.  768-core Platinum cluster (Victor).

Details of the resources are listed in subsequent sections.

### Bravo

The large-memory HP cluster (Bravo) is a 1.7 Tflop HP Proliant
distributed shared memory cluster with 128 processor cores and 3 TB
total memory capacity. The compute nodes consist of 16 HP DL180 servers,
each with two quad-core Intel Xeon E5620 2.4 GHz processors, 192 GB of
memory, 12 TB of local attached storage, and a PCIe 4x QDR InfiniBand
adapter for high bandwidth, low-latency MPI applications. Br avo is
currently used as a shared storage cluster and is not being utilized for
compute jobs. Operating System: RedHat Linux 6.9.

### Delta

The GPU cluster (Delta) is a SuperMicro distributed shared memory
cluster with 192 CPU cores and 14,336 GPU cores and 3TB total memory
capacity. The compute nodes consist of 16 SuperMicro X8DTG-QF servers,
each with 2 6-core Intel Xeon 5660 2.80 GHz processors, 2 nVIDIA Tesla
C2075 GPUs with 448 cores per GPU, 192GB of memory, 9TB of local
attached storage, and a Mellanox ConnectX-2 VPI dual-port InfiniBand
QDR/10GigE PCIe adapter card. Operating System: RedHat Linux 7.4

### Echo

The cloud cluster (Echo) is a SuperMicro distributed shared memory
cluster with 192 CPU cores and 6TB total memory capacity. The compute
nodes consist of 16 SuperMicro X9DRW servers, each node with 2 6-core
Intel(R) Xeon(R) CPU E5-2640 2.50GHz processors; 384GB of memory, 10TB
of local disk storage, a 10GbE Ethernet and a Mellanox ConnectX-3
InfiniBand FDR 56GT/s onboard adapter for high bandwidth, low-latency
MPI applications. Operating System: Ubuntu Linux 16.04

### Juliet

The Haswell cluster (Juliet) is a SuperMicro distributed shared memory
cluster with 3456 CPU cores and 16TB total memory capacity. The compute
nodes consist of SuperMicro X10DRT-HIBF servers, 32 nodes with 2 18-core
Intel(R) Xeon(R) CPU E5-2699 v3 2.30GHz processors; 96 nodes with 2
12-core Intel(R) Xeon(R) CPU E5-2670 v3 2.30GHz processors, all compute
nodes with 128GB of memory, 8TB of local disk storage, 400GB of NVMe
storage, and a Mellanox ConnectX-3 InfiniBand FDR 56GT/s onboard adapter
for high bandwidth, low-latency MPI applications. Operating System:
RedHat Linux 7.4

### Romeo

The K80/Volta GPU cluster (Romeo) is a SuperMicro distributed shared
memory cluster with 126 CPU cores, 161792 CUDA cores, and 768GB total
memory capacity. The compute nodes consist of 4 SuperMicro X10DGQ
servers with 2 12-core Intel(R) Xeon(R) CPU E5-2670 v3 2.30GHz
processors, 4 NVIDIA GK210GL [Tesla K80] GPU Accelerator cards with
4992 CUDA cores, and 2 SuperMicro X10DGO servers with 2 10-core Intel
Xeon E5-2600 v4 2.2GHz processors and 8 NVIDIA V100 (Tesla Volta)
accelerators with 5120 CUDA cores. All nodes with 128GB of memory, 8TB
of local disk storage, 400GB of NVMe storage, and a Mellanox ConnectX-3
InfiniBand FDR 56GT/s onboard adapter for high bandwidth, low-latency
MPI applications. Operating System: RedHat Linux 7.4

### Tango

The Knight's Landing cluster (Tango) is a Penguin Computing distributed
shared memory cluster with 3264 Xeon Phi cores and 12.8TB total memory
capacity. The compute nodes consist of 16 nodes with 1 72-core Intel(R)
Xeon Phi(TM) CPU 7290F 1.50GHz processor and 48 nodes with 1 68-core
Intel(R) Xeon Phi(TM) CPU 7250F 1.50GHz processor. All nodes with 200GB
of memory, 3.2TB of local disk storage, 800GB of NVMe storage, and an
Intel OmniPath adapter for high bandwidth, low-latency MPI applications.
Operating System: CentOS release 7.2.1511

### Tempest

The Platinum cluster (Tempest) is a SuperMicro distributed shared memory
cluster with 480 CPU cores and 2.5TB total memory capacity. The 10
compute nodes consist of SuperMicro X11DPT-PS servers with 2 24-core
Intel(R) Xeon(R) Platinum 8160 2.10GHz processors, 256GB of memory, 8TB
of local disk storage, 400GB of NVMe storage, and an Intel OmniPath
adapter for high bandwidth, low-latency MPI applications. Operating
System: RedHat Linux 7.4

### Victor

The Platinum cluster (Victor) is a SuperMicro distributed shared memory
cluster with 768 CPU cores and 2.5TB total memory capacity. The 16
compute nodes consist of SuperMicro X11DPT-PS servers with 2 24-core
Intel(R) Xeon(R) Platinum 8160 2.10GHz processors, 256GB of memory, 8TB
of local disk storage, 400GB of NVMe storage, and a Mellanox ConnectX-3
InfiniBand FDR 56GT/s adapter for high bandwidth, low-latency MPI
applications. Operating System: RedHat Linux 7.4 (see
Figure [\[F:victor\]](#F:victor){reference-type="ref"
reference="F:victor"}).

![Cabeling of Victor[]{label="F:victor"}](images/victor.jpg){width="90%"}

### PI Cluster

The details will be added once we have completed the purchase.


text:
module Sisimai::Lhost
  # Sisimai::Lhost::KDDI parses a bounce email which created by au by KDDI.
  # Methods in the module are called from only Sisimai::Message.
  module KDDI
    class << self
      # Imported from p5-Sisimail/lib/Sisimai/Lhost/KDDI.pm
      require 'sisimai/lhost'

      Indicators = Sisimai::Lhost.INDICATORS
      ReBackbone = %r|^Content-Type:[ ]message/rfc822|.freeze
      MarkingsOf = {
        message: %r/\AYour[ ]mail[ ](?:
             sent[ ]on:?[ ][A-Z][a-z]{2}[,]
            |attempted[ ]to[ ]be[ ]delivered[ ]on:?[ ][A-Z][a-z]{2}[,]
            )
        /x,
      }.freeze
      MessagesOf = {
        'mailboxfull' => ['As their mailbox is full'],
        'norelaying'  => ['Due to the following SMTP relay error'],
        'hostunknown' => ['As the remote domain doesnt exist'],
      }.freeze

      # Parse bounce messages from au by KDDI
      # @param  [Hash] mhead    Message headers of a bounce email
      # @param  [String] mbody  Message body of a bounce email
      # @return [Hash]          Bounce data list and message/rfc822 part
      # @return [Nil]           it failed to parse or the arguments are missing
      def make(mhead, mbody)
        # :'message-id' => %r/[@].+[.]ezweb[.]ne[.]jp[>]\z/,
        match  = 0
        match += 1 if mhead['from'] =~ /no-reply[@].+[.]dion[.]ne[.]jp/
        match += 1 if mhead['reply-to'].to_s == 'no-reply@app.auone-net.jp'
        match += 1 if mhead['received'].any? { |a| a.include?('ezweb.ne.jp (') }
        match += 1 if mhead['received'].any? { |a| a.include?('.au.com (') }
        return nil unless match > 0

        dscontents = [Sisimai::Lhost.DELIVERYSTATUS]
        emailsteak = Sisimai::RFC5322.fillet(mbody, ReBackbone)
        bodyslices = emailsteak[0].split("\n")
        readcursor = 0      # (Integer) Points the current cursor position
        recipients = 0      # (Integer) The number of 'Final-Recipient' header
        v = nil

        while e = bodyslices.shift do
          # Read error messages and delivery status lines from the head of the email
          # to the previous line of the beginning of the original message.
          if readcursor == 0
            # Beginning of the bounce message or delivery status part
            readcursor |= Indicators[:deliverystatus] if e =~ MarkingsOf[:message]
            next
          end
          next if (readcursor & Indicators[:deliverystatus]) == 0
          next if e.empty?

          v = dscontents[-1]
          if cv = e.match(/\A[ \t]+Could not be delivered to: [<]([^ ]+[@][^ ]+)[>]/)
            # Your mail sent on: Thu, 29 Apr 2010 11:04:47 +0900
            #     Could not be delivered to: <******@**.***.**>
            #     As their mailbox is full.
            if v['recipient']
              # There are multiple recipient addresses in the message body.
              dscontents << Sisimai::Lhost.DELIVERYSTATUS
              v = dscontents[-1]
            end
            r = Sisimai::Address.s3s4(cv[1])
            next unless Sisimai::RFC5322.is_emailaddress(r)
            v['recipient'] = r
            recipients += 1

          elsif cv = e.match(/Your mail sent on: (.+)\z/)
            # Your mail sent on: Thu, 29 Apr 2010 11:04:47 +0900
            v['date'] = cv[1]
          else
            #     As their mailbox is full.
            v['diagnosis'] ||= ''
            v['diagnosis'] << e + ' ' if e.start_with?(' ', "\t")
          end
        end
        return nil unless recipients > 0

        dscontents.each do |e|
          e['diagnosis'] = Sisimai::String.sweep(e['diagnosis'])

          if mhead['x-spasign'].to_s == 'NG'
            # Content-Type: text/plain; ..., X-SPASIGN: NG (spamghetti, au by KDDI)
            # Filtered recipient returns message that include 'X-SPASIGN' header
            e['reason'] = 'filtered'
          else
            if e['command'] == 'RCPT'
              # set "userunknown" when the remote server rejected after RCPT
              # command.
              e['reason'] = 'userunknown'
            else
              # SMTP command is not RCPT
              MessagesOf.each_key do |r|
                # Verify each regular expression of session errors
                next unless MessagesOf[r].any? { |a| e['diagnosis'].include?(a) }
                e['reason'] = r
                break
              end
            end
          end

        end

        return { 'ds' => dscontents, 'rfc822' => emailsteak[1] }
      end
      def description; return 'au by KDDI: https://www.au.kddi.com'; end
    end
  end
end

redpajama_set_name: RedPajamaGithub


text:
enum NodeAttrDef;

class LinearGradientNode : public GradientNodeComm {
	WTF_MAKE_FAST_ALLOCATED;
public:
	virtual LPCTSTR GetClass() const {return _SC("linearGradient");}
	virtual UINodeEnum GetClassEnum() const {return eNE_LinearGradient;}

	virtual GradientData* CollectGradientArgByNode(UINode* owner);

	virtual NodeAttrDef* GetCanRefreshAttrs(NodeAttrDef style) const {
		static NodeAttrDef validAttrs[] = {
			eNRStyleX1,
			eNRStyleY1,
			eNRStyleX2,
			eNRStyleY2,
		};
		return validAttrs;
	}
};

#endif // LinearGradientNode_h


text:
require 'active_support/core_ext/string/inflections'
require 'active_support/core_ext/class/attribute'
require 'action_controller/base'

module Police
  module Controller
    def police (options = {}, &block)
      options    = {
        user:       :current_user,
        user_class: 'User'
      }.merge!(options)
      user       = options.delete(:user)
      user_class = options.delete(:user_class)

      police_user = []
      police_user << "#{user}"           if user
      police_user << "#{user_class}.new" if user_class
      police_user << 'nil'               if police_user.empty?
      police_user = police_user.compact.join(' || ')

      include Police
      include InstanceMethods

      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
        def police_user                   # def police_user
          @police_user ||= #{police_user} #   @police_user ||= current_user || User.new
        end                               # end
      RUBY_EVAL

      hide_action   :model_base_classes, :policies, :policy_class, :model_class
      helper_method :police!, :police?, :authorize!, :authorized?, :can?,
                    :cannot?, :owner?, :policy
      before_action :police!, options, &block
    end

    module InstanceMethods
      def authorize! (user, action, *models)
        if user.nil?
          user = police_user
        elsif user.is_a?(Symbol) || user.is_a?(String)
          models.unshift(action)
          user, action = police_user, user
        end
        super
      end
    end
  end
end

ActionController::Base.send(:extend, Police::Controller)


text:
from __future__ import (absolute_import, division, print_function)

import os
import sys
import numpy as np

from .util import banded_jacobian, sparse_jacobian_csc, sparse_jacobian_csr

def _DenseMatrix(be, *args, **kwargs):
        if len(args) == 1:
            return be.Matrix(len(args[0]), 1, args[0], **kwargs)
        else:
            nr, nc, elems = args
            return be.Matrix(nr, nc, elems, **kwargs)

class _Base(object):

    def __getattr__(self, key):
        return getattr(self.__sym_backend__, key)

    def banded_jacobian(self, exprs, dep, ml, mu):
        """ Wraps Matrix around result of .util.banded_jacobian """
        exprs = banded_jacobian(exprs, dep, ml, mu)
        return self.Matrix(ml+mu+1, len(dep), list(exprs.flat))

    def sparse_jacobian_csc(self, exprs, dep):
        """ Wraps Matrix/ndarray around results of .util.sparse_jacobian_csc """
        jac_exprs, colptrs, rowvals = sparse_jacobian_csc(exprs, dep)
        nnz = len(jac_exprs)
        return (
            self.Matrix(1, nnz, jac_exprs),
            np.asarray(colptrs, dtype=int),
            np.asarray(rowvals, dtype=int)
        )

    def sparse_jacobian_csr(self, exprs, dep):
        """ Wraps Matrix/ndarray around results of .util.sparse_jacobian_csr """
        jac_exprs, rowptrs, colvals = sparse_jacobian_csr(exprs, dep)
        nnz = len(jac_exprs)
        return (
            self.Matrix(1, nnz, jac_exprs),
            np.asarray(rowptrs, dtype=int),
            np.asarray(colvals, dtype=int)
        )

class _SymPy(_Base):

    def __init__(self):
        self.__sym_backend__ = __import__('sympy')
        from ._sympy_Lambdify import _Lambdify
        self.Lambdify = _Lambdify

    def real_symarray(self, prefix, shape):
        return self.symarray(prefix, shape, real=True)

    DenseMatrix = _DenseMatrix

class _SymPySymEngine(_SymPy):

    def __init__(self):
        self.__sym_backend__ = __import__('sympy')
        from symengine import Lambdify
        self.Lambdify = Lambdify

class _Diofant(_SymPy):

    def __init__(self):
        self.__sym_backend__ = __import__('diofant')
        from ._sympy_Lambdify import _Lambdify

        class DiofantLambdify(_Lambdify):
            def __init__(self, args, *exprs, **kwargs):
                kwargs['backend'] = 'diofant'
                super().__init__(args, *exprs, **kwargs)

        self.Lambdify = DiofantLambdify

    DenseMatrix = _DenseMatrix

    __sym_backend_name__ = 'diofant'

class _SymEngine(_Base):

    _dummy_counter = [0]

    def __init__(self):
        self.__sym_backend__ = __import__('symengine')
        # cse isn't in any symengine release yet; only in dev version
        # this will allow backend use with older symengine versions,
        # failing gracefully only if cse is invoked
        self._cse = getattr(self.__sym_backend__, 'cse', None)

    def Matrix(self, *args, **kwargs):
        return self.DenseMatrix(*args, **kwargs)

    def real_symarray(self, prefix, shape):
        return self.symarray(prefix, shape)

    def Dummy(self):
        self._dummy_counter[0] += 1
        return self.Symbol('Dummy_'+str(self._dummy_counter[0] - 1))

    def numbered_symbols(self, prefix='x', cls=None, start=0, exclude=None, *args):
        exclude = set(exclude or [])
        if cls is None:
            cls = self.Symbol

        while True:
            name = '%s%s' % (prefix, start)
            s = cls(name, *args)
            if s not in exclude:
                yield s
            start += 1

    def cse(self, exprs, symbols=None):
        # symengine's cse, but augmented with custom cse symbols ala sympy
        if self._cse is None:
            raise NotImplementedError("CSE not yet supported in symengine version %s" %
                                      self.__sym_backend__.__version__)
        if symbols is None:
            symbols = self.numbered_symbols()
        else:
            symbols = iter(symbols)

        old_repl, old_reduced = self._cse(exprs)
        if not old_repl:
            return old_repl, old_reduced
        old_cse_symbols, old_cses = zip(*old_repl)
        cse_symbols = [next(symbols) for _ in range(len(old_cse_symbols))]
        subsd = dict(zip(old_cse_symbols, cse_symbols))

        cses = [c.xreplace(subsd) for c in old_cses]
        reduced = [e.xreplace(subsd) for e in old_reduced]
        return list(zip(cse_symbols, cses)), reduced

class _PySym(_Base):

    def __init__(self):
        self.__sym_backend__ = __import__('pysym')

    def real_symarray(self, prefix, shape):
        return self.symarray(prefix, shape)

    DenseMatrix = _DenseMatrix

class _SymCXX(_Base):

    def __init__(self):
        self.__sym_backend__ = __import__('symcxx').NameSpace()

    def real_symarray(self, prefix, shape):
        return self.symarray(prefix, shape)

    DenseMatrix = _DenseMatrix

def Backend(name=None, envvar='SYM_BACKEND', default='sympy'):
    """ Backend for the underlying symbolic manipulation packages

    Parameters
    ----------
    name: str (default: None)
        Name of package e.g. 'sympy'
    envvar: str (default: 'SYM_BACKEND')
        name of environment variable to read name from (when name is ``None``)
    default: str
        name to use when the environment variable described by ``envvar`` is
        unset or empty (default: 'sympy')

    Examples
    --------
    >>> be = Backend('sympy')  # or e.g. 'symengine'
    >>> x, y = map(be.Symbol, 'xy')
    >>> exprs = [x + y + 1, x*y**2]
    >>> lmb = be.Lambdify([x, y], exprs)
    >>> import numpy as np
    >>> lmb(np.arange(6.0).reshape((3, 2)))  # doctest: +NORMALIZE_WHITESPACE
    array([[   2.,    0.],
           [   6.,   18.],
           [  10.,  100.]])

    """
    if name is None:
        name = os.environ.get(envvar, '') or default
    if isinstance(name, _Base):
        return name
    else:
        return Backend.backends[name]()

Backend.backends = {
    'sympy': _SymPy,
    'symengine': _SymEngine,
    'sympysymengine': _SymPySymEngine,  # uses selected parts from SymEngine to augment SymPy
    'pysym': _PySym,
    'symcxx': _SymCXX,
}

if sys.version_info[0] > 2:
    Backend.backends['diofant'] = _Diofant


text:
package org.rs2server.rs2.model.skills;

import java.util.HashMap;
import java.util.Map;

import org.rs2server.rs2.action.impl.ProductionAction;
import org.rs2server.rs2.model.Animation;
import org.rs2server.rs2.model.Graphic;
import org.rs2server.rs2.model.Item;
import org.rs2server.rs2.model.ItemDefinition;
import org.rs2server.rs2.model.Mob;
import org.rs2server.rs2.model.Skills;

public class Fletching extends ProductionAction {

	/**
	 * The amount of items to produce.
	 */
	private int productionCount;

	/**
	 * The log index.
	 */
	private int logIndex;

	/**
	 * The log we are fletching.
	 */
	private Log log;

	public Fletching(Mob mob, int productionCount, int logIndex, Log log) {
		super(mob);
		this.productionCount = productionCount;
		this.logIndex = logIndex;
		this.log = log;
	}

	/**
	 * Represents a type of log that is able to be fletched.
	 * @author Michael
	 *
	 */
	public static enum Log {

		NORMAL(1511, new int[] { /*52, */53, 841, 839, 9174 }, new int[] { 1, 5, 10, 9 }, new double[] { 5, 10, 20, 24 }),

		OAK(1521, new int[] { 843, 9177, 845 }, new int[] { 20, 24, 25 }, new double[] { 16.5, 88, 25 }),

		WILLOW(1519, new int[] { 849, 9181, 847 }, new int[] { 35, 39, 40 }, new double[] { 66.6, 128, 83}),

		MAPLE(1517, new int[] { 853, 9183, 851 }, new int[] { 50, 54, 55 }, new double[] { 100, 164, 116.6 }),

		YEW(1515, new int[] { 857, 9185, 855 }, new int[] { 65, 69, 70 }, new double[] { 135, 200, 150 }),

		MAGIC(1513, new int[] { 861, 859 }, new int[] { 80, 85 }, new double[] { 166.6, 183 });

		/**
		 * The id of the logs
		 */
		private int logId;

		/**
		 * @return the logId
		 */
		public int getLogId() {
			return logId;
		}

		/**
		 * The first item displayed on the fletching interface.
		 */
		private int[] item;

		/**
		 * The level required to fletch the first item on the fletching interface.
		 */
		private int[] level;

		/**
		 * The experience granted for the first item on the flteching interface.
		 */
		private double[] experience;

		/**
		 * A map of item ids to logs.
		 */
		private static Map<Integer, Log> logs = new HashMap<Integer, Log>();

		/**
		 * Gets a log by an item id.
		 * @param item The item id.
		 * @return The Log, or null if the object is not a log.
		 */
		public static Log forId(int item) {
			return logs.get(item);
		}

		/**
		 * Populates the log map.
		 */
		static {
			for (Log log : Log.values()) {
				logs.put(log.logId, log);
			}
		}

		private Log(int logId, int[] item, int[] level, double[] experience) {
			this.logId = logId;
			this.item = item;
			this.level = level;
			this.experience = experience;
		}

		/**
		 * @return the item
		 */
		public int[] getItem() {
			return item;
		}

		/**
		 * @return the level
		 */
		public int[] getLevel() {
			return level;
		}

		/**
		 * @return the experience
		 */
		public double[] getExperience() {
			return experience;
		}
	}

	public static enum ArrowTip {
		BRONZE(39, 882, 1, 2.6),

		IRON(40, 884, 15, 3.8),

		STEEL(41, 886, 30, 6.3),

		MITHRIL(42, 888, 45, 8.8),

		ADAMANT(43, 890, 60, 11.3),

		RUNE(44, 892, 75, 13.8)
		;

		/**
		 * The id
		 */
		private int id;

		/**
		 * The reward;
		 */
		private int reward;

		/**
		 * The level required.
		 */
		private int levelRequired;

		/**
		 * The experience granted.
		 */
		private double experience;

		/**
		 * A map of item ids to arrow tips.
		 */
		private static Map<Integer, ArrowTip> arrowtips = new HashMap<Integer, ArrowTip>();

		/**
		 * Gets an arrow tip by an item id.
		 * @param item The item id.
		 * @return The ArrowTip, or null if the object is not a arrow tip.
		 */
		public static ArrowTip forId(int item) {
			return arrowtips.get(item);
		}

		/**
		 * Populates the log map.
		 */
		static {
			for (ArrowTip arrowtip : ArrowTip.values()) {
				arrowtips.put(arrowtip.id, arrowtip);
			}
		}

		private ArrowTip(int id, int reward, int levelRequired, double experience) {
			this.id = id;
			this.reward = reward;
			this.levelRequired = levelRequired;
			this.experience = experience;
		}

		/**
		 * @return the id
		 */
		public int getId() {
			return id;
		}

		/**
		 * @return the reward
		 */
		public int getReward() {
			return reward;
		}

		/**
		 * @return the levelRequired
		 */
		public int getLevelRequired() {
			return levelRequired;
		}

		/**
		 * @return the experience
		 */
		public double getExperience() {
			return experience;
		}

	}

	@Override
	public boolean canProduce() {
		return true;
	}

	@Override
	public Animation getAnimation() {
		return Animation.create(1248);
	}

	@Override
	public Item[] getConsumedItems() {
		return new Item[] { new Item(log.getLogId()) };
	}

	@Override
	public int getCycleCount() {
		return 3;
	}

	@Override
	public double getExperience() {
		return log.getExperience()[logIndex];
	}

	@Override
	public Graphic getGraphic() {
		return null;
	}

	@Override
	public String getLevelTooLowMessage() {
		return "You need a Fletching level of " + getRequiredLevel() + " to fletch this.";
	}

	@Override
	public int getProductionCount() {
		return productionCount;
	}

	@Override
	public int getRequiredLevel() {
		return log.getLevel()[logIndex];
	}

	@Override
	public Item[] getRewards() {
		return new Item[] { new Item(log.getItem()[logIndex], log.getItem()[logIndex] == 53 ? 15 : 1) };
	}

	@Override
	public int getSkill() {
		return Skills.FLETCHING;
	}

	@Override
	public String getSuccessfulProductionMessage() {
		String prefix = "a";
		String suffix = "";
		char first = ItemDefinition.forId(log.getItem()[logIndex]).getName().toLowerCase().charAt(0);
		if(first == 'a' || first == 'e' || first == 'i' || first == 'o' || first == 'u') {
			prefix = "an";
		}
		if(log.getItem()[logIndex] == 52) {
			prefix = "some";
			suffix = "s";
		}
		return "You successfully fletch " + prefix + " " + ItemDefinition.forId(log.getItem()[logIndex]).getName().toLowerCase() + "" + suffix + ".";
	}

}


text:
<?php

namespace KevinGH\Bcrypt\Exception;

use InvalidArgumentException;

/**
 * This exception is thrown if the encoded string used was not a string that
 * would have been generated by the Blowfish encoding function. It could also
 * mean that the string used was not encoded at all.
 *
 * @author Kevin Herrera <kevin@herrera.io>
 */
class InvalidEncodedStringException extends InvalidArgumentException
{
    /**
     * The invalid encodedString.
     *
     * @var string
     */
    private $encodedString;

    /**
     * Sets the invalid encodedString.
     *
     * @param string $encodedString The invalid encoded string.
     */
    public function __construct($encodedString)
    {
        $this->encodedString = $encodedString;
    }

    /**
     * Returns the invalid encodedString.
     *
     * @return string The invalid encoded string.
     */
    public function getEncodedString()
    {
        return $this->encodedString;
    }
}


text:
const mockTranslate = jest.fn()
jest.mock('@/base/i18n', () => ({ t: mockTranslate }))

import { createDatastore } from '>/helpers'

describe('breadcrumbs', () => {
  let datastoreMocks
  let datastore

  beforeEach(() => jest.resetModules())
  beforeEach(() => {
    datastoreMocks = {
      currentGroup: {
        getters: {
          value: () => ({ id: 1, name: 'my current group' }),
        },
      },
      groups: {
        getters: {
          activePreview: () => ({ id: 4, name: 'my current group info' }),
        },
      },
      places: {
        getters: {
          activePlace: () => ({ id: 2, name: 'my active place' }),
        },
      },
      users: {
        getters: {
          activeUser: () => ({ id: 3, displayName: 'my active user' }),
        },
      },
    }
    datastore = createDatastore({
      breadcrumbs: require('./breadcrumbs').default,
      ...datastoreMocks,
    })
  })

  it('can create an currentGroup item', async () => {
    await datastore.commit('breadcrumbs/set', [{ type: 'currentGroup' }])
    expect(datastore.getters['breadcrumbs/all']).toEqual([{ name: 'my current group', route: { name: 'group', groupId: 1 } }])
  })

  it('can create an activeGroupPreview item', async () => {
    await datastore.commit('breadcrumbs/set', [{ type: 'activeGroupPreview' }])
    expect(datastore.getters['breadcrumbs/all']).toEqual([{ name: 'my current group info', route: { name: 'groupPreview', groupPreviewId: 4 } }])
  })

  it('can create an activePlace item', async () => {
    await datastore.commit('breadcrumbs/set', [{ type: 'activePlace' }])
    expect(datastore.getters['breadcrumbs/all']).toEqual([{ name: 'my active place', route: { name: 'place', placeId: 2 } }])
  })

  it('can create an activeUser item', async () => {
    await datastore.commit('breadcrumbs/set', [{ type: 'activeUser' }])
    expect(datastore.getters['breadcrumbs/all']).toEqual([{ name: 'my active user', route: { name: 'user', userId: 3 } }])
  })

  it('can do translation stuff', async () => {
    mockTranslate.mockReturnValueOnce('translated value')
    await datastore.commit('breadcrumbs/set', [{ translation: 'translation.key' }])
    expect(datastore.getters['breadcrumbs/all']).toEqual([{ name: 'translated value', translation: 'translation.key' }])
  })
})


text:
package Exp

import (
	"fmt"
	dbg "github.com/Englebabz/CasGO/Debugprint"
	"github.com/Englebabz/CasGO/Stringmanipulations"
	"strings"
)

func textToCasReal(instring string, recs string) (exp Express, err error) {
	//TextToCas will turn a string (eg "2*x+3") to an Express class
	//var origin = instring
	//fmt.Println(instring, "oi")
	newstringindent := recs + "    "
	origin := instring
	//fix stupid signs

	instring = strings.Replace(instring, "-", "+-", -1)
	instring = strings.Replace(instring, "++", "+", -1)
	instring = strings.Replace(instring, "--", "+", -1)
	instring = strings.Replace(instring, "(+-", "(-", -1)
	newinstring := ""
	for index, charbyte := range instring {
		char := string(charbyte)
		if char == "_" && index != 0 &&
			strmans.StringInSlice(string(instring[index-1]), []string{"*", "/", "+", "-", "("}) == false &&
			(((index >= 2 && string(instring[index-2]) == "-") || (index+1 < len(instring) && string(instring[index+1]) == "{")) == false) {

			newinstring += "*"

		}
		newinstring += char
	}
	instring = newinstring
	if len(strmans.StrToBracketpairs(instring)) > 0 &&
		strmans.StrToBracketpairs(instring)[0][0] == 0 &&
		strmans.StrToBracketpairs(instring)[0][1] == len(instring)-1 {
		instring = instring[1 : len(instring)-1]
	}
	if string(instring[0]) == "+" || string(instring[0]) == "*" {
		instring = instring[1:]
	}
	//fix negative numbers
	if instring == "-1" { //Avoid "-1" becomes product(-1,1)
		return Number("-1"), nil
	}
	if string(instring[0]) == "-" && len(strmans.FindCharOutsideBracket("+", instring)) == 0 {
		dbg.Debug(10, recs+origin+" Becomes minusnumber")
		retval, err := textToCasReal(instring[1:], newstringindent)
		if err == nil {
			return Product(Number("-1"), retval), nil
		} else {
			panic("bad input to TextToCas " + origin)
		}

	}
	/*if string(instring[0]) == "-" &&
		len(strmans.StrToBracketpairs(instring)) == 0 {
		dbg.Debug(10, recs+origin+" Becomes minusnumber")
		retval, err := textToCasReal(instring[1:], newstringindent)
		if err == nil {
			return Product(Number("-1"), retval), nil
		} else {
			panic("bad input to TextToCas " + origin)
		}
	}*/
	//remove unnecessary bracket it's sorrounding the whole instring
	bracketPairs := strmans.StrToBracketpairs(instring)
	if len(bracketPairs) > 0 && bracketPairs[0][0] == 0 && bracketPairs[0][1] == len(instring)-1 {
		instring = instring[1 : len(instring)-1]
	}
	bracketPairs = strmans.StrToBracketpairs(instring)
	if instring == "-1" { //Avoid "-1" becomes product(-1,1)
		return Number("-1"), nil
	}
	//parse addition
	plusses := strmans.FindCharOutsideBracket("+", instring)
	if len(plusses) > 0 {
		dbg.Debug(10, recs+origin+" becomes ADDITION"+
			fmt.Sprintf("%v", strmans.SplitStringByIndexes(instring, plusses)))
		var retaddends []Express
		for _, addendstring := range strmans.SplitStringByIndexes(instring, plusses) {
			returnaddend, err := textToCasReal(addendstring, newstringindent)
			if err != nil {
				panic("bad input to TextToCas " + origin)
			}
			retaddends = append(retaddends, returnaddend)
		}
		return Addition(retaddends...), nil
	}
	//if it's not addition, check for product
	productsigns := strmans.FindCharOutsideBracket("*", instring)
	if len(productsigns) > 0 {
		dbg.Debug(10, recs+origin+" becomes PRODUCT"+
			fmt.Sprintf("%v", strmans.SplitStringByIndexes(instring, productsigns)))
		var retfactors []Express
		for _, factorstring := range strmans.SplitStringByIndexes(instring, productsigns) {
			returnfactor, err := textToCasReal(factorstring, newstringindent)
			if err != nil {
				panic("bad input to TextToCas " + origin)
			}
			retfactors = append(retfactors, returnfactor)
		}
		return Product(retfactors...), nil
	}
	//if it's not a product, check for fraction
	fractionsigns := strmans.FindCharOutsideBracket("/", instring)
	if len(fractionsigns) > 0 {
		if len(fractionsigns) > 1 {
			dbg.Debug(0, "BAD FRACTION, DON'T DO STUFF LIKE 2/3/2 (BRACKETS PLEASE)")
		}

		dbg.Debug(10, recs+origin+" becomes FRACTION"+
			fmt.Sprintf("%v", strmans.SplitStringByIndexes(instring, fractionsigns)))
		retnum, err1 := textToCasReal(strmans.SplitStringByIndexes(instring, fractionsigns)[0], newstringindent)
		retdenom, err2 := textToCasReal(strmans.SplitStringByIndexes(instring, fractionsigns)[1], newstringindent)
		if err1 != nil || err2 != nil {
			panic("bad input to TextToCas " + origin)
		}
		return Fraction(retnum, retdenom), nil

	}
	//if it's not a fraction, then it might be a power
	powersigns := strmans.FindCharOutsideBracket("^", instring)
	if len(powersigns) > 0 {
		if len(powersigns) > 1 {
			dbg.Debug(0, "BAD POWER, PLEASE USE BRACKETS")
		}
		dbg.Debug(10, recs+origin+" becomes POWER"+
			fmt.Sprintf("%v", (strmans.SplitStringByIndexes(instring, powersigns))))
		rootandexpstrings := strmans.SplitStringByIndexes(instring, powersigns)
		retroot, err1 := textToCasReal(rootandexpstrings[0], newstringindent)
		retexp, err2 := textToCasReal(rootandexpstrings[1], newstringindent)
		if err1 != nil || err2 != nil {
			panic("Bad input to TextToCas " + origin)
		}
		retval := Power(retroot, retexp)
		retval.Forcepowerprint = true
		return retval, nil
	}
	//no usual things to look after; check for functions
	for index, charbytes := range instring {
		char := string(charbytes)
		if char == "(" && string(instring[index-1]) != "(" && string(instring[index-1]) != ")" {
			startbracket := index
			//find function string
			bracketoffset := 1
			var funcend int
			for indexk := len(instring) - 1; indexk > -1; indexk-- {
				if string(instring[indexk]) == "(" {
					bracketoffset++
				} else if string(instring[indexk]) == ")" {
					bracketoffset--
					if bracketoffset == 0 {
						funcend = indexk
						break
					}
				}
			}
			funcstring := instring[0:startbracket]
			insidebrackets := instring[startbracket+1 : funcend]
			//findcommas
			escapeoffset := 0
			var commaindexes []int
			for index, charbytes := range insidebrackets {
				char := string(charbytes)
				if escapeoffset > 0 {
					if char == "}" {
						escapeoffset--
					}
				}
				if char == "{" {
					escapeoffset++
				}
				if char == "," {
					commaindexes = append(commaindexes, index)
				}
			}
			if len(commaindexes) == 0 {
				switch funcstring {
				case "sin":
					{
						dbg.Debug(10, recs+origin+" becomes sine: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Sine(argexp), nil
					}
				case "cos":
					{
						dbg.Debug(10, recs+origin+" becomes cosine: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Cosine(argexp), nil
					}
				case "tan":
					{
						dbg.Debug(10, recs+origin+" becomes tangent: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Tangent(argexp), nil
					}
				case "arcsin":
					{
						dbg.Debug(10, recs+origin+" becomes arcsine: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Arcsine(argexp), nil
					}
				case "arccos":
					{
						dbg.Debug(10, recs+origin+" becomes arccosine: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Arccosine(argexp), nil
					}
				case "arctan":
					{
						dbg.Debug(10, recs+origin+" becomes arctangent: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Arctangent(argexp), nil
					}
				case "ln":
					{
						dbg.Debug(10, recs+origin+" becomes natlogarithm: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Natlog(argexp), nil
					}
				case "log":
					{
						dbg.Debug(10, recs+origin+" becomes comlogarithm: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Comlog(argexp), nil
					}
				case "sqrt":
					{
						dbg.Debug(10, recs+origin+" becomes squareroot: "+insidebrackets)
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Squareroot(argexp), nil
					}
				default:
					{
						dbg.Debug(10, recs+origin+" becomes unknownfunction: "+
							funcstring+"("+insidebrackets+")")
						argexp, err := textToCasReal(insidebrackets, newstringindent)
						if err != nil {
							panic("bad input to TextToCas " + origin)
						}
						return Unknownfunction(funcstring, []Express{argexp}), nil
					}
				}
			} else {
				argstrings := strmans.SplitStringByIndexes(insidebrackets, commaindexes)
				dbg.Debug(10, recs+origin+"becomes unknownfunction: "+
					funcstring+"("+insidebrackets+")")
				var retargs []Express
				for _, argstr := range argstrings {
					retarg, err := textToCasReal(argstr, newstringindent)
					if err != nil {
						panic("Bad input to TextToCas " + origin)
					}
					retargs = append(retargs, retarg)
				}
				return Unknownfunction(funcstring, retargs), nil

			}
		}
	}
	stillsignsininstring := false
	bracketoffset := 0
	for _, charbyte := range instring {
		char := string(charbyte)
		if char == "{" {
			bracketoffset++
		} else if char == "}" {
			bracketoffset--
		}
		if bracketoffset == 0 &&
			(char == "+" || char == "*" || char == "/" || char == "^") {

			stillsignsininstring = true
			break
		}

	}
	if stillsignsininstring {
		brackets := strmans.StrToBracketpairs(instring)
		if string(instring[0]) == "-" &&
			len(brackets) > 0 && brackets[0][0] == 1 && brackets[0][1] == len(instring)-1 {
			dbg.Debug(10, recs+origin+"becomes negative "+instring[1:len(instring)-1])
			partret, err := textToCasReal(instring[1:len(instring)-1], newstringindent)
			if err != nil {
				panic("Bad input to TextToCas: " + origin)
			}
			return Product(Number("-1"), partret), nil
		}
		panic("BAD EXPRESSION")
	}
	if string(instring[0]) == "-" {
		dbg.Debug(10, recs+origin+" becomes negative "+instring[1:])
		dbg.Debug(10, recs+"    "+"-1")
		partret, err := textToCasReal(instring[1:], newstringindent)
		if err != nil {
			panic("Bad input to TextToCas: " + origin)
		}
		return Product(Number("-1"), partret), nil
	} else {
		//NUMBER INSTANCE
		dbg.Debug(10, recs+origin)
		return Number(instring), nil

	}

}
func TextToCas(instring string) (exp Express) {
	retval, err := textToCasReal(instring, "")
	if err != nil {
		panic("Bad input to TextToCas: " + instring)
	}
	return retval
}


text:
package com.oasisfeng.android.app;

import android.app.Fragment;
import android.os.Bundle;

import javax.annotation.ParametersAreNonnullByDefault;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;

/**
 * Extends the native {@link Fragment} with compatibility for lifecycle in Android Jet Pack.
 *
 * Created by Oasis on 2018/5/17.
 */
@ParametersAreNonnullByDefault
public class LifecycleFragment extends Fragment implements LifecycleOwner {

	@Override public void onSaveInstanceState(final Bundle outState) {
		super.onSaveInstanceState(outState);
	}

	/* Lifecycle */

	@Override public @NonNull Lifecycle getLifecycle() { return mLifecycleRegistry; }

	@Override public void onCreate(@Nullable final Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
	}
	@Override public void onStart() {
		super.onStart();
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
	}
	@Override public void onResume() {
		super.onResume();
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
	}
	@Override public void onPause() {
		super.onPause();
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
	}
	@Override public void onStop() {
		super.onStop();
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
	}
	@Override public void onDestroy() {
		super.onDestroy();
		mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
	}

	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
}


text:
var _ = require('underscore');
var util = require('util');

var Validator = require('oae-util/lib/validator').Validator;

var TenantNetworksDAO = require('./internal/dao.networks');
var TenantsAPI = require('./api');

/**
 * Create a tenant network
 *
 * @param  {Context}        ctx                     Standard context object containing the current user and the current tenant
 * @param  {String}         displayName             The display name of the tenant network
 * @param  {Function}       callback                Standard callback function
 * @param  {Object}         callback.err            An error that occurred, if any
 * @param  {TenantNetwork}  callback.tenantNetwork  The tenant network that was created
 */
var createTenantNetwork = module.exports.createTenantNetwork = function(ctx, displayName, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to create a tenant network'}).isGlobalAdministratorUser(ctx);
    validator.check(displayName, {'code': 400, 'msg': 'A tenant network must contain a display name'}).notEmpty();
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    return TenantNetworksDAO.createTenantNetwork(displayName, callback);
};

/**
 * Get all tenant networks and their associated tenants
 *
 * @param  {Context}    ctx                         Standard context object containing the current user and the current tenant
 * @param  {Function}   callback                    Standard callback function
 * @param  {Object}     callback.err                An error that occurred, if any
 * @param  {Object}     callback.tenantNetworks     All tenant networks in the system, keyed by their tenant network id
 */
var getTenantNetworks = module.exports.getTenantNetworks = function(ctx, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to view tenant networks'}).isGlobalAdministratorUser(ctx);
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    TenantNetworksDAO.getAllTenantNetworks(function(err, tenantNetworks) {
        if (err) {
            return callback(err);
        }

        TenantNetworksDAO.getAllTenantNetworkTenantAliases(function(err, tenantNetworkTenantAliases) {
            if (err) {
                return callback(err);
            }

            _.each(tenantNetworks, function(tenantNetwork, tenantNetworkId) {
                // Expand the tenant network aliases for each tenant network into full tenant objects
                // and apply them to the tenantNetwork object
                tenantNetwork.tenants = _.chain(tenantNetworkTenantAliases[tenantNetworkId])
                    .map(TenantsAPI.getTenant)
                    .compact()
                    .value();
            });

            return callback(null, tenantNetworks);
        });
    });
};

/**
 * Update a tenant network
 *
 * @param  {Context}        ctx                     Standard context object containing the current user and the current tenant
 * @param  {String}         id                      The id of the tenant network to update
 * @param  {String}         displayName             The new display name of the tenant network
 * @param  {Function}       callback                Standard callback function
 * @param  {Object}         callback.err            An error that occurred, if any
 * @param  {TenantNetwork}  callback.tenantNetwork  The updated tenant network
 */
var updateTenantNetwork = module.exports.updateTenantNetwork = function(ctx, id, displayName, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to update a tenant network'}).isGlobalAdministratorUser(ctx);
    validator.check(id, {'code': 400, 'msg': 'Must specify a tenant network id'}).notEmpty();
    validator.check(displayName, {'code': 400, 'msg': 'A tenant network must contain a display name'}).notEmpty();
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    return TenantNetworksDAO.updateTenantNetwork(id, displayName, callback);
};

/**
 * Delete a tenant network
 *
 * @param  {Context}    ctx             Standard context object containing the current user and the current tenant
 * @param  {String}     id              The id of the tenant network to delete
 * @param  {Function}   callback        Standard callback function
 * @param  {Object}     callback.err    An error that occurred, if any
 */
var deleteTenantNetwork = module.exports.deleteTenantNetwork = function(ctx, id, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to delete a tenant network'}).isGlobalAdministratorUser(ctx);
    validator.check(id, {'code': 400, 'msg': 'Must specify a tenant network id'}).notEmpty();
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    return TenantNetworksDAO.deleteTenantNetwork(id, callback);
};

/**
 * Add the provided tenant(s) to a tenant network
 *
 * @param  {Context}    ctx                 Standard context object containing the current user and the current tenant
 * @param  {String}     tenantNetworkId     The id of the tenant network to which to add the provided tenant aliases
 * @param  {String[]}   tenantAlises        The tenant aliases to add to the tenant network
 * @param  {Function}   callback            Standard callback function
 * @param  {Object}     callback.err        An error that occurred, if any
 */
var addTenantAliases = module.exports.addTenantAliases = function(ctx, tenantNetworkId, tenantAliases, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to update a tenant network'}).isGlobalAdministratorUser(ctx);
    validator.check(tenantNetworkId, {'code': 400, 'msg': 'Must specify a tenant network id'}).notEmpty();
    validator.check(tenantAliases, {'code': 400, 'msg': 'Must specify a list of tenant aliases to add'}).notNull();
    validator.check(tenantAliases.length, {'code': 400, 'msg': 'Must specify at least one tenant alias to add'}).notNull();
    _.each(tenantAliases, function(tenantAlias) {
        validator.check(TenantsAPI.getTenant(tenantAlias), {'code': 400, 'msg': util.format('Tenant with alias "%s" does not exist', tenantAlias)}).notEmpty();
    });
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    return TenantNetworksDAO.addTenantAliases(tenantNetworkId, tenantAliases, callback);
};

/**
 * Remove the provided tenant(s) from a tenant network
 *
 * @param  {Context}    ctx                 Standard context object containing the current user and the current tenant
 * @param  {String}     tenantNetworkId     The id of the tenant network from which to remove the provided tenant aliases
 * @param  {String[]}   tenantAlises        The tenant alias(es) to remove from the tenant network
 * @param  {Function}   callback            Standard callback function
 * @param  {Object}     callback.err        An error that occurred, if any
 */
var removeTenantAliases = module.exports.removeTenantAliases = function(ctx, tenantNetworkId, tenantAliases, callback) {
    var validator = new Validator();
    validator.check(null, {'code': 401, 'msg': 'Must be a global administrator user to update a tenant network'}).isGlobalAdministratorUser(ctx);
    validator.check(tenantNetworkId, {'code': 400, 'msg': 'Must specify a tenant network id'}).notEmpty();
    validator.check(tenantAliases, {'code': 400, 'msg': 'Must specify a list of tenant aliases to remove'}).notNull();
    validator.check(tenantAliases.length, {'code': 400, 'msg': 'Must specify at least one tenant alias to remove'}).notNull();
    if (validator.hasErrors()) {
        return callback(validator.getFirstError());
    }

    return TenantNetworksDAO.removeTenantAliases(tenantNetworkId, tenantAliases, callback);
};


text:
using System;
using System.Collections.Generic;
using Microsoft.AspNet.Mvc.Infrastructure;
using Microsoft.AspNet.Routing;

namespace Orchard.Hosting.Web.Mvc.Routing {
    public class DefaultShellRouteBuilder : IRouteBuilder {
        public DefaultShellRouteBuilder(IServiceProvider serviceProvider) {
            Routes = new List<IRouter>();
            DefaultHandler = new MvcRouteHandler();
            ServiceProvider = serviceProvider;
        }

        public IRouter DefaultHandler { get; set; }

        public IServiceProvider ServiceProvider { get; set; }

        public IList<IRouter> Routes {
            get;
        }

        public IRouter Build() {
            var routeCollection = new RouteCollection();

            foreach (var route in Routes) {
                routeCollection.Add(route);
            }

            return routeCollection;
        }
    }
}


text:
package com.devskiller.friendly_id.jackson;

import java.util.UUID;

import com.fasterxml.jackson.databind.deser.std.UUIDDeserializer;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
import com.fasterxml.jackson.databind.ser.std.UUIDSerializer;

public class FriendlyIdAnnotationIntrospector extends JacksonAnnotationIntrospector {

	private static final long serialVersionUID = 1L;

	@Override
	public Object findSerializer(Annotated annotatedMethod) {
		IdFormat annotation = _findAnnotation(annotatedMethod, IdFormat.class);
		if (annotatedMethod.getRawType() == UUID.class) {
			if (annotation != null) {
				switch (annotation.value()) {
					case RAW:
						return UUIDSerializer.class;
					case URL62:
						return FriendlyIdSerializer.class;
				}
			}
			return FriendlyIdSerializer.class;
		} else {
			return null;
		}
	}

	@Override
	public Object findDeserializer(Annotated annotatedMethod) {
		IdFormat annotation = _findAnnotation(annotatedMethod, IdFormat.class);
		if (rawDeserializationType(annotatedMethod) == UUID.class) {
			if (annotation != null) {
				switch (annotation.value()) {
					case RAW:
						return UUIDDeserializer.class;
					case URL62:
						return FriendlyIdDeserializer.class;
				}
			}
			return FriendlyIdDeserializer.class;
		} else {
			return null;
		}
	}

	private Class<?> rawDeserializationType(Annotated a) {
		if (a instanceof AnnotatedMethod) {
			AnnotatedMethod am = (AnnotatedMethod) a;
			if (am.getParameterCount() == 1) {
				return am.getRawParameterType(0);
			}
		}
		return a.getRawType();
	}
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Moq;
using System.Data.Entity;

namespace Web.Tests
{
    public static class Helpers
    {
        public static DbSet<T> ToDbSet<T>(this List<T> sourceList) where T : class
        {
            var queryable = sourceList.AsQueryable();

            var dbSet = new Mock<DbSet<T>>();
            dbSet.As<IQueryable<T>>().Setup(m => m.Provider).Returns(queryable.Provider);
            dbSet.As<IQueryable<T>>().Setup(m => m.Expression).Returns(queryable.Expression);
            dbSet.As<IQueryable<T>>().Setup(m => m.ElementType).Returns(queryable.ElementType);
            dbSet.As<IQueryable<T>>().Setup(m => m.GetEnumerator()).Returns(() => queryable.GetEnumerator());
            dbSet.Setup(d => d.Add(It.IsAny<T>())).Callback<T>(sourceList.Add);
            dbSet.Setup(d => d.AddRange(It.IsAny<IEnumerable<T>>())).Callback<IEnumerable<T>>(sourceList.AddRange);

            return dbSet.Object;
        }
    }

    public static class Rand
    {
        private static readonly Random RandomGen = new Random(DateTime.Now.Millisecond);
        public static int NextInt()
        {
            return RandomGen.Next();
        }
    }

}


text: jboss-cli.sh --connect --command="undeploy MyWebApp.war"


text:
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;

namespace Nest
{
	/// <summary>
	/// Provides GetMany extensions that make it easier to get many documents given a list of ids
	/// </summary>
	public static class GetManyExtensions
	{
		/// <summary>
		/// Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing).
		/// The response includes a docs array with all the fetched documents, each element similar in structure to a document
		/// provided by the get API.
		/// <para> </para>>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html
		/// </summary>
		/// <typeparam name="T">The type used to infer the default index and typename</typeparam>
		/// <param name="client"></param>
		/// <param name="ids">IEnumerable of ids as string for the documents to fetch</param>
		/// <param name="index">Optionally override the default inferred index name for T</param>
		/// <param name="type">Optionally overiide the default inferred typename for T</param>
		public static IEnumerable<IMultiGetHit<T>> GetMany<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)
			where T : class
		{
			var result = client.MultiGet(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)));
			return result.GetMany<T>(ids);
		}

		/// <summary>
		/// Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing).
		/// The response includes a docs array with all the fetched documents, each element similar in structure to a document
		/// provided by the get API.
		/// <para> </para>>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html
		/// </summary>
		/// <typeparam name="T">The type used to infer the default index and typename</typeparam>
		/// <param name="client"></param>
		/// <param name="ids">IEnumerable of ids as ints for the documents to fetch</param>
		/// <param name="index">Optionally override the default inferred index name for T</param>
		/// <param name="type">Optionally overiide the default inferred typename for T</param>
		public static IEnumerable<IMultiGetHit<T>> GetMany<T>(this IElasticClient client, IEnumerable<int> ids, string index = null, string type = null)
			where T : class
		{
			return client.GetMany<T>(ids.Select(i => i.ToString(CultureInfo.InvariantCulture)), index, type);
		}

		/// <summary>
		/// Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing).
		/// The response includes a docs array with all the fetched documents, each element similar in structure to a document
		/// provided by the get API.
		/// <para> </para>>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html
		/// </summary>
		/// <typeparam name="T">The type used to infer the default index and typename</typeparam>
		/// <param name="client"></param>
		/// <param name="ids">IEnumerable of ids as string for the documents to fetch</param>
		/// <param name="index">Optionally override the default inferred index name for T</param>
		/// <param name="type">Optionally overiide the default inferred typename for T</param>
		public static Task<IEnumerable<IMultiGetHit<T>>> GetManyAsync<T>(this IElasticClient client, IEnumerable<string> ids, string index = null, string type = null)
			where T : class
		{
			return client.MultiGetAsync(s => s.GetMany<T>(ids, (gs, i) => gs.Index(index).Type(type)))
				.ContinueWith(t => t.Result.GetMany<T>(ids));
		}

		/// <summary>
		/// Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing).
		/// The response includes a docs array with all the fetched documents, each element similar in structure to a document
		/// provided by the get API.
		/// <para> </para>>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-multi-get.html
		/// </summary>
		/// <typeparam name="T">The type used to infer the default index and typename</typeparam>
		/// <param name="client"></param>
		/// <param name="ids">IEnumerable of ids as ints for the documents to fetch</param>
		/// <param name="index">Optionally override the default inferred index name for T</param>
		/// <param name="type">Optionally overiide the default inferred typename for T</param>
		public static Task<IEnumerable<IMultiGetHit<T>>> GetManyAsync<T>(this IElasticClient client, IEnumerable<int> ids, string index = null, string type = null)
			where T : class
		{
			return client.GetManyAsync<T>(ids.Select(i => i.ToString(CultureInfo.InvariantCulture)), index, type);
		}
	}
}


text:
import { jsx, createContainer, property, render } from "@xania/view";
import { TableStore, DataRow } from "./table-store";

interface JumbotronProps {
  store: TableStore;
}

function Jumbotron(props: JumbotronProps) {
  const { store } = props;

  return (

XaniaJS-"keyed"

              <button
                click={store.create1000Rows}
                type="button"
                class="btn btn-primary btn-block"
                id="run"
              >
                Create 1,000 rows
              </button>

              <button
                click={store.create10000Rows}
                type="button"
                class="btn btn-primary btn-block"
                id="runlots"
              >
                Create 10,000 rows
              </button>

              <button
                click={store.append1000Rows}
                type="button"
                class="btn btn-primary btn-block"
                id="add"
              >
                Append 1,000 rows
              </button>

              <button
                click={store.updateEvery10thRow}
                type="button"
                class="btn btn-primary btn-block"
                id="update"
              >
                Update every 10th row
              </button>

              <button
                click={store.clear}
                type="button"
                class="btn btn-primary btn-block"
                id="clear"
              >
                Clear
              </button>

              <button
                click={store.swapRows}
                type="button"
                class="btn btn-primary btn-block"
                id="swaprows"
              >
                Swap Rows
              </button>

  );
}

function Container() {
  const rows = createContainer<DataRow>();
  const store = new TableStore(rows);
  return (

        <Jumbotron store={store} />

{rows.map(Row(store))}

  );
}

function Row(store: TableStore) {
  return (

      {property("id")}

          {property("label")}

  );
}

// interface InputProps<T> {
//   value: State<T>;
// }

// function Input<T>(props: InputProps<T>) {
//   const tpl = jsx.factory;
//   const { value } = props;
//   return <input value={value} keyup={onKeyUp} />;

//   function onKeyUp({ target }) {
//     value.update(target.value);
//   }
// }

const main = document.getElementById("main");
render(main, <Container />);


text:
import * as angular from 'angular';

import {tech} from './tech';
import {techs} from './techs';

export const techsModule = 'techs';

angular
  .module(techsModule, [])
  .component('fountainTech', tech)
  .component('fountainTechs', techs);


text:
// Generated from /POI/java/org/apache/poi/poifs/crypt/binaryrc4/BinaryRC4EncryptionHeader.java

#pragma once

#include <org/apache/poi/poifs/crypt/binaryrc4/fwd-POI.hpp>
#include <org/apache/poi/util/fwd-POI.hpp>
#include <org/apache/poi/poifs/crypt/EncryptionHeader.hpp>
#include <org/apache/poi/poifs/crypt/standard/EncryptionRecord.hpp>
#include <java/lang/Cloneable.hpp>

struct default_init_tag;

class poi::poifs::crypt::binaryrc4::BinaryRC4EncryptionHeader
    : public ::poi::poifs::crypt::EncryptionHeader
    , public virtual ::poi::poifs::crypt::standard::EncryptionRecord
    , public virtual ::java::lang::Cloneable
{

public:
    typedef ::poi::poifs::crypt::EncryptionHeader super;
protected:
    void ctor();

public:
    void write(::poi::util::LittleEndianByteArrayOutputStream* littleendianbytearrayoutputstream) override;
    BinaryRC4EncryptionHeader* clone() /* throws(CloneNotSupportedException) */ override;

    // Generated

public: /* protected */
    BinaryRC4EncryptionHeader();
protected:
    BinaryRC4EncryptionHeader(const ::default_init_tag&);

public:
    static ::java::lang::Class *class_();

private:
    virtual ::java::lang::Class* getClass0();
};


text:
/* eslint-env mocha */
import A from 'assert';
import curryArgs from './curryArgs';
import util from '../../../lib/util';

describe('function._internal.curryArgs(input)', () => {
  it('returns "input" if its length is greater than 0', () => {
    [[1, 2], util.arrayLike(1, 2)].forEach((input) => {
      A.deepEqual(curryArgs(input), input);
    });
  });

  it('returns an array holding "undefined" if "value" is empty', () => {
    const assert = value => A.deepEqual(curryArgs(value), [undefined]);
    assert([]);
    assert(util.arrayLike());
  });
});


text:
layout: post
status: publish
published: true
title: Minha mãe e irmão (Paulo Neto) em Sydney
author:
  display_name: admin
  login: admin
  email: fabiopereira.me@gmail.com
  url: http://
author_login: admin
author_email: fabiopereira.me@gmail.com
author_url: http://
wordpress_id: 38
wordpress_url: http://fabiopereira.me/blogpt/?p=38
date: '2009-03-19 04:57:54 +1100'
date_gmt: '2009-03-19 11:57:54 +1100'
categories:
- Uncategorized
tags: []
comments:
- id: 26
  author: PAULO NETO
  author_email: paulonetotam@gmail.com
  author_url: http://www.dropsmagazine.com.br
  date: '2009-03-19 22:06:48 +1100'
  date_gmt: '2009-03-20 05:06:48 +1100'
  content: "Heeeeey, meu irmão lindoooo!\r\nEssa viagem, como eu já
    lhe disse, foi com certeza uma das 5 melhores coisas que já fiz em minha
    vida TODA!\r\nObrigado por cada momento e cada minuto e cada conversa e cada risada.\r\nTe
    amo muito. Muito mesmo!\r\nSaudade batendo forte aqui em SP!"
- id: 27
  author: Arthur Lucena
  author_email: arthurlucena@gmail.com
  author_url: http://twitter.com/arthurlucena
  date: '2009-03-20 09:02:02 +1100'
  date_gmt: '2009-03-20 16:02:02 +1100'
  content: "Caracas... Paulo está, somehow, different.\r\nBom, anyway, muito
    legal dona Mariângela e Paulo Neto ter dado um \"pulinho\" ai na Austrália.
    Espero que tenha curtido bastante a estadia deles por ai.\r\n\r\nAquele abraço,
    mutxatxo\r\no/"
- id: 29
  author: RaiulBaztepo
  author_email: zxkbhio8@mail.ru
  author_url: ''
  date: '2009-03-31 19:54:30 +1100'
  date_gmt: '2009-04-01 02:54:30 +1100'
  content: "Hello!\r\nVery Interesting post! Thank you for such interesting resource!
    \r\nPS: Sorry for my bad english, I'v just started to learn this language ;)\r\nSee
    you! \r\nYour, Raiul Baztepo"
- id: 177
  author: PiterKokoniz
  author_email: photbaphmam@gmail.com
  author_url: http://dev.winamp.com/w/index.php?title=Special:Contributions&limit=112&target=Aldor4
  date: '2009-04-08 14:07:06 +1000'
  date_gmt: '2009-04-08 21:07:06 +1000'
  content: "Hello !!! ;)\r\nI am Piter Kokoniz. Just want to tell, that I'v found
    your blog very interesting\r\nAnd want to ask you: what was the reasson for you
    to start this blog?\r\nSorry for my bad english:)\r\nThank you!\r\nYour Piter
    Kokoniz, from Latvia"
- id: 886
  author: wuinso
  author_email: puqqxs@wnkyrz.com
  author_url: http://idfejpijrwbu.com/
  date: '2009-07-12 14:38:36 +1000'
  date_gmt: '2009-07-12 21:38:36 +1000'
  content: eDNAz9  cpmhytgwjsnf,
    [url=http://zefihszhtoef.com/]zefihszhtoef[/url], [link=http://qmlesamfhlny.com/]qmlesamfhlny[/link],
    http://evjsxmauhhxr.com/
- id: 887
  author: rrrcew
  author_email: rifasy@ewfcll.com
  author_url: http://zvcznuajikoa.com/
  date: '2009-07-13 06:11:08 +1000'
  date_gmt: '2009-07-13 13:11:08 +1000'
  content: Fm25ML  qsmaqrivmcfb,
    [url=http://xrglxrzwwsyn.com/]xrglxrzwwsyn[/url], [link=http://nekaxmzxjknr.com/]nekaxmzxjknr[/link],
    http://iqofsnbxxisq.com/
- id: 944
  author: Clomid
  author_email: if45inio457@mail.com
  author_url: http://buy-clomid-online.blog.friendster.com#1
  date: '2009-08-13 07:09:53 +1000'
  date_gmt: '2009-08-13 14:09:53 +1000'
  content: wellbutrin
    online  - wellbutrin buy clomid online   - clomid buy xenical  - xenical xenical online  - xenical orlistat buy propecia online   - propecia buy adipex  - adipex order ambien  - ambien buy valium online   - valium buy tramadol  - tramadol fioricet online  - fioricet
- id: 958
  author: buy clomid
  author_email: summer387@gmail.com
  author_url: http://buy-clomid-online.blog.friendster.com/#1
  date: '2009-08-20 06:32:01 +1000'
  date_gmt: '2009-08-20 13:32:01 +1000'
  content: "sehat gandhinagar whisker dissect indor deutsche ecological \r\nLontermento
    mentilianos"
- id: 980
  author: kaoktrtxc
  author_email: ikawcq@pkqebd.com
  author_url: http://pezynqkkyenc.com/
  date: '2009-08-23 23:55:58 +1000'
  date_gmt: '2009-08-24 06:55:58 +1000'
  content: BMtvIO  coecdscxmnvx,
    [url=http://clubskovzxnh.com/]clubskovzxnh[/url], [link=http://vewlwmybhyrj.com/]vewlwmybhyrj[/link],
    http://gunxicrawpcr.com/
---

Março de 2009 ficará na minha lembrança como um dos melhores meses da minha vida. Espero que na lembrança da minha mãe e do meu irmão também, que vieram me visitar em Sydney.

Foi uma viagem fantástica... 10 dias de diversão, turismo, matando a saudade da família, conversas... Tudo foi absolutamente perfeito!!!

Criei 4 Albuns com as fotos...

Album 1 - Sydney Tower, Hyde Park

Album 2 - Zoo, Aquarium IMAX

Album 3 - Milsons Point OperaHouse and Botanic Gardens

Album 4 - WatsonsBay Pancakes and Bondi Beach

Olha aí um preview das fotos...

Saudaaaaaades, Muitas saudaaaaades

Amo vcs!!!! Muuuuito!!!

Planejamento da Viagem:

Hyde Park:

Opera House, passeando de Ferry:

Darling Harbour:

Zoo:

Aquarium:

Zoo:

Milson's Point:

Milson's Point:

Opera House:

Watson's Bay:

Watson's Bay:

Pancakes on The Rocks:

Bondi Beach:


text:
#region Usings

using System;
using JetBrains.Annotations;

#endregion

namespace Extend
{
    /// <summary>
    ///     Class containing some extension methods for <see cref="double" />.
    /// </summary>
    public static partial class DoubleEx
    {
        /// <summary>
        ///     Returns the given Double value as minutes.
        /// </summary>
        /// <param name="value">The Double value.</param>
        /// <returns>Returns the given Double value as minutes.</returns>
        [Pure]
        [PublicAPI]
        public static TimeSpan ToMinutes( this Double value )
            => TimeSpan.FromMinutes( value );
    }
}


text:
namespace Google.Cloud.AssuredWorkloads.V1.Snippets
{
    // [START assuredworkloads_v1_generated_AssuredWorkloadsService_GetWorkload_sync_flattened]
    using Google.Cloud.AssuredWorkloads.V1;

    public sealed partial class GeneratedAssuredWorkloadsServiceClientSnippets
    {
        /// <summary>Snippet for GetWorkload</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public void GetWorkload()
        {
            // Create client
            AssuredWorkloadsServiceClient assuredWorkloadsServiceClient = AssuredWorkloadsServiceClient.Create();
            // Initialize request argument(s)
            string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/workloads/[WORKLOAD]";
            // Make the request
            Workload response = assuredWorkloadsServiceClient.GetWorkload(name);
        }
    }
    // [END assuredworkloads_v1_generated_AssuredWorkloadsService_GetWorkload_sync_flattened]
}


text:
from sys import winver
from sys import winver as baz
from sys.fob import winver
from sys.fob import winver as baz
from ...fob import oar
from ....fob import oar
from ......fob import oar
from .......fob import oar
from fob import (fob as oar, baz as quox)


text:
.class public Landroid/app/ActivityManager$TaskThumbnail;
.super Ljava/lang/Object;
.source "ActivityManager.java"

# interfaces
.implements Landroid/os/Parcelable;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/app/ActivityManager;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x9
    name = "TaskThumbnail"
.end annotation

# static fields
.field public static final CREATOR:Landroid/os/Parcelable$Creator;
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "Landroid/os/Parcelable$Creator",
            "<",
            "Landroid/app/ActivityManager$TaskThumbnail;",
            ">;"
        }
    .end annotation
.end field

# instance fields
.field public mainThumbnail:Landroid/graphics/Bitmap;

.field public thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

# direct methods
.method static constructor <clinit>()V
    .locals 1

    .prologue
    .line 1325
    new-instance v0, Landroid/app/ActivityManager$TaskThumbnail$1;

    invoke-direct {v0}, Landroid/app/ActivityManager$TaskThumbnail$1;-><init>()V

    sput-object v0, Landroid/app/ActivityManager$TaskThumbnail;->CREATOR:Landroid/os/Parcelable$Creator;

    return-void
.end method

.method public constructor <init>()V
    .locals 0

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

    .line 1288
    return-void
.end method

.method private constructor <init>(Landroid/os/Parcel;)V
    .locals 0
    .param p1, "source"    # Landroid/os/Parcel;

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

    .line 1335
    invoke-virtual {p0, p1}, Landroid/app/ActivityManager$TaskThumbnail;->readFromParcel(Landroid/os/Parcel;)V

    .line 1336
    return-void
.end method

.method synthetic constructor <init>(Landroid/os/Parcel;Landroid/app/ActivityManager$1;)V
    .locals 0
    .param p1, "x0"    # Landroid/os/Parcel;
    .param p2, "x1"    # Landroid/app/ActivityManager$1;

    .prologue
    .line 1283
    invoke-direct {p0, p1}, Landroid/app/ActivityManager$TaskThumbnail;-><init>(Landroid/os/Parcel;)V

    return-void
.end method

# virtual methods
.method public describeContents()I
    .locals 1

    .prologue
    .line 1291
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    if-eqz v0, :cond_0

    .line 1292
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    invoke-virtual {v0}, Landroid/os/ParcelFileDescriptor;->describeContents()I

    move-result v0

    .line 1294
    :goto_0
    return v0

    :cond_0
    const/4 v0, 0x0

    goto :goto_0
.end method

.method public readFromParcel(Landroid/os/Parcel;)V
    .locals 2
    .param p1, "source"    # Landroid/os/Parcel;

    .prologue
    const/4 v1, 0x0

    .line 1313
    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I

    move-result v0

    if-eqz v0, :cond_0

    .line 1314
    sget-object v0, Landroid/graphics/Bitmap;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v0, p1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Landroid/graphics/Bitmap;

    iput-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->mainThumbnail:Landroid/graphics/Bitmap;

    .line 1318
    :goto_0
    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I

    move-result v0

    if-eqz v0, :cond_1

    .line 1319
    sget-object v0, Landroid/os/ParcelFileDescriptor;->CREATOR:Landroid/os/Parcelable$Creator;

    invoke-interface {v0, p1}, Landroid/os/Parcelable$Creator;->createFromParcel(Landroid/os/Parcel;)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Landroid/os/ParcelFileDescriptor;

    iput-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    .line 1323
    :goto_1
    return-void

    .line 1316
    :cond_0
    iput-object v1, p0, Landroid/app/ActivityManager$TaskThumbnail;->mainThumbnail:Landroid/graphics/Bitmap;

    goto :goto_0

    .line 1321
    :cond_1
    iput-object v1, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    goto :goto_1
.end method

.method public writeToParcel(Landroid/os/Parcel;I)V
    .locals 3
    .param p1, "dest"    # Landroid/os/Parcel;
    .param p2, "flags"    # I

    .prologue
    const/4 v2, 0x1

    const/4 v1, 0x0

    .line 1298
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->mainThumbnail:Landroid/graphics/Bitmap;

    if-eqz v0, :cond_0

    .line 1299
    invoke-virtual {p1, v2}, Landroid/os/Parcel;->writeInt(I)V

    .line 1300
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->mainThumbnail:Landroid/graphics/Bitmap;

    invoke-virtual {v0, p1, p2}, Landroid/graphics/Bitmap;->writeToParcel(Landroid/os/Parcel;I)V

    .line 1304
    :goto_0
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    if-eqz v0, :cond_1

    .line 1305
    invoke-virtual {p1, v2}, Landroid/os/Parcel;->writeInt(I)V

    .line 1306
    iget-object v0, p0, Landroid/app/ActivityManager$TaskThumbnail;->thumbnailFileDescriptor:Landroid/os/ParcelFileDescriptor;

    invoke-virtual {v0, p1, p2}, Landroid/os/ParcelFileDescriptor;->writeToParcel(Landroid/os/Parcel;I)V

    .line 1310
    :goto_1
    return-void

    .line 1302
    :cond_0
    invoke-virtual {p1, v1}, Landroid/os/Parcel;->writeInt(I)V

    goto :goto_0

    .line 1308
    :cond_1
    invoke-virtual {p1, v1}, Landroid/os/Parcel;->writeInt(I)V

    goto :goto_1
.end method


text:
import createRenderer from "../index.js";
import createContext from "pex-context";
import { sphere } from "primitive-geometry";
import random from "pex-random";
import { vec3, quat } from "pex-math";
import createGUI from "pex-gui";

const ctx = createContext();
const renderer = createRenderer(ctx);
const gui = createGUI(ctx);
gui.addHeader("Settings");

const cameraEntity = renderer.entity([
  renderer.transform({ position: [0, 0, 3] }),
  renderer.camera({
    exposure: 1,
    fov: Math.PI / 2,
    aspect: ctx.gl.drawingBufferWidth / ctx.gl.drawingBufferHeight,
  }),
  renderer.orbiter({ element: ctx.gl.canvas }),
  renderer.postProcessing({
    ssao: true,
    ssaoRadius: 1,
    bloom: true,
    bloomRadius: 0.5,
    bloomThreshold: 99,
    bloomIntensity: 1,
  }),
]);
renderer.add(cameraEntity);

const directionalLightEntity = renderer.entity(
  [
    renderer.transform({
      position: [1, 1, 1],
      rotation: quat.fromTo(
        quat.create(),
        [0, 0, 1],
        vec3.normalize([-1, -1, -1])
      ),
    }),

    renderer.material({
      baseColor: [1, 1, 0, 1],
    }),
    renderer.directionalLight({
      color: [1, 1, 1, 1],
      intensity: 4,
      castShadows: true,
    }), //,
    //renderer.lightHelper()
  ],
  ["cell0"]
);
renderer.add(directionalLightEntity);

random.seed(3);
for (let i = 0; i < 64; i++) {
  const emit = random.chance(0.2);
  const sphereEntity = renderer.entity([
    renderer.transform({
      position: random.vec3(2),
    }),
    renderer.geometry(sphere({ radius: emit ? 0.25 : 0.5 })),
    renderer.material({
      //baseColor: emit ? [3.15, 2.3, 0.3, 1] : [1, 1, 1, 1],
      baseColor: [0, 0, 0, 1],
      emissiveColor: emit ? [3.15, 2.3, 0.3, 1] : [0, 0, 0, 1],
      metallic: 0,
      roughness: 0.85,
      castShadows: true,
      receiveShadows: true,
    }),
  ]);
  renderer.add(sphereEntity);
}

const skyboxEntity = renderer.entity([
  renderer.skybox({
    sunPosition: [1, 1, 1],
  }),
]);
renderer.add(skyboxEntity);

const reflectionProbeEntity = renderer.entity([renderer.reflectionProbe()]);
renderer.add(reflectionProbeEntity);

ctx.frame(() => {
  const now = Date.now() * 0.0005;

  const skybox = skyboxEntity.getComponent("Skybox");
  skybox.set({
    //sunPosition: [1 * Math.cos(now), 1, 1 * Math.sin(now)]
  });

  renderer.draw();
  gui.draw();

  window.dispatchEvent(new CustomEvent("pex-screenshot"));
});


text:
Other resources for ``clifford``
--------------------------------

Slide Decks
~~~~~~~~~~~

 * `Installation <https://slides.com/hugohadfield/installing-python-and-clifford#/>`_
 * `Conformal Geometric Algebra with Python, Part 1 <https://slides.com/hugohadfield/cgapython#/>`_
 * `Conformal Geometric Algebra with Python, Part 2 <https://slides.com/hugohadfield/cgapython-3#/>`_

Videos
~~~~~~
 * `Intro to Clifford <https://www.youtube.com/watch?v=P2ZxxoS5YD0>`_

Other resources for Geometric Algebra
-------------------------------------

If you think Geometric Algebra looks interesting and want to learn more, check out these websites and textbooks

Links
~~~~~

* |galgebra|_
* `The Cambridge University Geometric Algebra Research Group home page <http://www.mrao.cam.ac.uk/~clifford>`_
* David Hestenes' `Geometric Calculus R & D Home Page <http://geocalc.clas.asu.edu/>`_

.. |galgebra| replace:: ``galgebra``, a symbolic geometric algebra module for Python
.. _galgebra: https://github.com/pygae/galgebra

Introductory textbooks
~~~~~~~~~~~~~~~~~~~~~~

* `Geometric Algebra for Physicists <http://www.mrao.cam.ac.uk/~cjld1/pages/book.htm>`_, by Doran and Lasenby
* `Geometric Algebra for Computer Science <https://dl.acm.org/doi/book/10.5555/1610323>`_, by Dorst, Fontijne and Mann
* `New Foundations for Classical Mechanics <http://geocalc.clas.asu.edu/html/NFCM.html>`_, by David Hestenes


text:
a littile game write by pure html5

Online Game: <http://zanephptest.sinaapp.com/upsidedown/>

Help: slide on the screen in the direction of the first falling block to remove it.


text:
package usage

import (
	"testing"

	"github.com/tsukanov/steamhistory/collector/apps"
)

func TestHistoryRecorder(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping history recorder test in short mode.")
	}

	// Adding apps so we can record their usage data
	err := apps.UpdateMetadata()
	if err != nil {
		t.Error(err)
	}

	// Recording
	err = RecordHistory()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkHistoryRecorder(b *testing.B) {
	if testing.Short() {
		b.Skip("Skipping history recorder benchmark in short mode.")
	}

	// Adding apps so we can record their usage data
	err := apps.UpdateMetadata()
	if err != nil {
		b.Error(err)
	}

	// Recording
	err = RecordHistory()
	if err != nil {
		b.Error(err)
	}
}


text:
@interface PodsDummy_Pods_GVPackages_Example : NSObject
@end
@implementation PodsDummy_Pods_GVPackages_Example
@end


text:
package main

import (
  "net/http"
  "encoding/json"

  "github.com/mrcrilly/remindme"
)

func GetHandler(w http.ResponseWriter, r *http.Request) {
  var err error
  var getrsp GetResponse
  var tmpbk *remindme.Bookmark
  var jsondata []byte

  tmpbk, err = remindme.NewBookmark("http://mcrilly.me/", "Michael Crilly")
  checkError(err)

  getrsp.Unread = append(getrsp.Unread, tmpbk)
  getrsp.Read = nil

  jsondata, err = json.Marshal(getrsp)
  checkError(err)

  _, err = w.Write(jsondata)
  checkError(err)
}

func PostHandler(w http.ResponseWriter, r *http.Request) {

}

func DeleteHandler(w http.ResponseWriter, r *http.Request) {

}


text:
<?php
namespace Rs\Json\Patch\Operations;

use Rs\Json\Patch\Operations;

class AddTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @test
     * @expectedException Rs\Json\Patch\InvalidOperationException
     * @expectedExceptionMessage Mandatory value property not set
     */
    public function missingManadatoryOperationKeyShouldThrowExpectedException()
    {
        $operation = new \stdClass;
        $operation->salue = 17;
        $operation->path = '/a/b/d';

        $addOperation = new Add($operation);
    }
    /**
     * @test
     * @dataProvider addProvider
     */
    public function shouldAddObjectMemberAsExpected($providerData)
    {
        $targetJson = $providerData['given-json'];
        $expectedJson = $providerData['expected-json'];
        $operation = $providerData['add-operation'];

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     */
    public function shouldAddNestedObjectMemberAsExpected()
    {
        $targetJson = '{"foo":"bar"}';
        $expectedJson = '{"foo":"bar","child":{"grandchild": {}}}';

        $value = new \stdClass;
        $value->grandchild = new \stdClass;

        $operation = new \stdClass;
        $operation->path = '/child';
        $operation->value = $value;

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     */
    public function shouldAddArrayElementAsExpected()
    {
        $targetJson = '{"foo":["bar","baz"]}';
        $expectedJson = '{"foo":["bar","qux","baz"]}';

        $operation = new \stdClass;
        $operation->path = '/foo/1';
        $operation->value = 'qux';

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     */
    public function shouldAddArrayElementToTheEndAsExpected()
    {
        $targetJson = '{"foo":"bar","baz":{"boo":["bar","baz"]}}';
        $expectedJson = '{"foo":"bar","baz":{"boo":["bar","baz","qux"]}}';

        $operation = new \stdClass;
        $operation->path = '/baz/boo/-';
        $operation->value = 'qux';

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     */
    public function shouldAddAnArrayValueAsExpected()
    {
        $targetJson = '{"foo":["bar"]}';
        $expectedJson = '{"foo":["bar", ["abc","def"]]}';

        $operation = new \stdClass;
        $operation->path = '/foo/-';
        $operation->value = array('abc', 'def');

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     */
    public function shouldAddAnArrayValueToSpecificIndexAsExpected()
    {
        $targetJson     = '{"foo":[{"name": "bar"},{"name": "baz"}]}';
        $expectedJson   = '{"foo":[{"name": "bar"},{"name": "new"},{"name": "baz"}]}';

        $operation = new \stdClass;
        $operation->path = '/foo/1';
        $operation->value = array('name' => 'new');

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }
    /**
     * @test
     * @dataProvider tooLargeArrayIndexProvider
     */
    public function shouldNotAddArrayElementWhenUsingATooLargeIndex($providerData)
    {
        $expectedJson = $targetJson = $providerData['given-json'];

        $operation = $providerData['add-operation'];

        $addOperation = new Add($operation);

        $this->assertJsonStringEqualsJsonString(
            $expectedJson,
            $addOperation->perform($targetJson)
        );
    }

    /**
     * @return array
     */
    public function addProvider()
    {
        return array(
            array(array(
                'given-json' => '{"foo":"bar"}',
                'expected-json' => '{"baz":"qux","foo":"bar"}',
                'add-operation' => (object) array('path' => '/baz', 'value' => 'qux', 'xyz' => 123),
            )),
            array(array(
                'given-json' => '{"foo":"bar"}',
                'expected-json' => '{"foo":"bar"}',
                'add-operation' => (object) array('path' => '/baz/bat', 'value' => 'qux'),
            )),
            array(array(
                'given-json' => '{"foo":"bar"}',
                'expected-json' => '{"foo":"qux"}',
                'add-operation' => (object) array('path' => '/foo', 'value' => 'qux'),
            )),
            array(array(
                'given-json' => '{"foo":["bar","baz"]}',
                'expected-json' => '{"foo":["bar","qux","baz"]}',
                'add-operation' => (object) array('path' => '/foo/1', 'value' => 'qux'),
            )),
            array(array(
                'given-json' => '{"a":{"foo":1}}',
                'expected-json' => '{"a":{"foo":1,"boo":100}}',
                'add-operation' => (object) array('path' => '/a/boo', 'value' => 100),
            )),
            array(array(
                'given-json' => '{"q":{"bar":2}}',
                'expected-json' => '{"q":{"bar":2}}',
                'add-operation' => (object) array('path' => '/a/b', 'value' => 100),
            )),
        );
    }
    /**
     * @return array
     */
    public function tooLargeArrayIndexProvider()
    {
        return array(
            array(array(
                'given-json' => '{"foo":["bar","baz","qux"]}',
                'add-operation' => (object) array('path' => '/foo/4', 'value' => 'non-set-able'),
            )),
            array(array(
                'given-json' => '{"foo":{"moo":["bar","baz","qux"]}}',
                'add-operation' => (object) array('path' => '/foo/moo/7', 'value' => 'non-set-able'),
            )),
        );
    }
}


text:
class WikiPagesController < ApplicationController
  acts_as_wiki_pages_controller
  accept_formats :html

  def edit_allowed?
    return false unless logged_in?
    return true if current_user.is_admin?
    if CONFIG.home_page_wiki_path && @page.path == CONFIG.home_page_wiki_path
      return false unless current_user.uri =~ /#{FakeView.root_url}/
    end
    current_user.is_curator?
  end

  def history_allowed?
    logged_in?
  end

  def setup_page
    if params[:path].blank?
      redirect_to root_url
    else
      super
    end
  end
end


text:
require 'liquid/metrics/reporter'

module Metrics
  class LoggerReporter < Reporter

    def initialize(logger)
      super
      @logger = logger
      @marker = "metrics:"
    end

    def report_gauge(name, gauge)
      @logger.info(@marker, super)
    end

    def report_counter(name, counter)
      @logger.info(@marker, super)
    end

    def report_histogram(name, histogram)
      @logger.info(@marker, super)
    end

    def report_meter(name, meter)
      @logger.info(@marker, super)
    end

    def report_timer(name, timer)
      @logger.info(@marker, super)
    end

  end
end


text:
<xml>

<!--
The API key provide here should also be entered when
registering this custom integration in Workfront under
		Setup > Documents > Custom Integrations.

		Replace "change_me" with an API key of your choosing.
		<api-key>change_me</api-key>

		< You may define more than one API key >
		<api-key>value</api-key>
-->

	<api-keys>
		<api-key>123456</api-key>
		<api-key>1111111</api-key>
	</api-keys>
	<mapped-directories>
		<!--
		A list of directories to publish.  These directories
		can reside locally or on a mapped network drive.

		Replace the paths below with path(s) on your network.
		-->

		<path>~/</path>
		<path>/usr/share/texinfo</path>
	</mapped-directories>
	<apply-authentication>false</apply-authentication>
</xml>


text:
# frozen_string_literal: true

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

# Auto-generated by gapic-generator-ruby. DO NOT EDIT!

module Google
  module Cloud
    module VpcAccess
      module V1
        # Definition of a Serverless VPC Access connector.
        # @!attribute [rw] name
        #   @return [::String]
        #     The resource name in the format `projects/*/locations/*/connectors/*`.
        # @!attribute [rw] network
        #   @return [::String]
        #     Name of a VPC network.
        # @!attribute [rw] ip_cidr_range
        #   @return [::String]
        #     The range of internal addresses that follows RFC 4632 notation.
        #     Example: `10.132.0.0/28`.
        # @!attribute [r] state
        #   @return [::Google::Cloud::VpcAccess::V1::Connector::State]
        #     Output only. State of the VPC access connector.
        # @!attribute [rw] min_throughput
        #   @return [::Integer]
        #     Minimum throughput of the connector in Mbps. Default and min is 200.
        # @!attribute [rw] max_throughput
        #   @return [::Integer]
        #     Maximum throughput of the connector in Mbps. Default is 300, max is 1000.
        # @!attribute [r] connected_projects
        #   @return [::Array<::String>]
        #     Output only. List of projects using the connector.
        # @!attribute [rw] subnet
        #   @return [::Google::Cloud::VpcAccess::V1::Connector::Subnet]
        #     The subnet in which to house the VPC Access Connector.
        # @!attribute [rw] machine_type
        #   @return [::String]
        #     Machine type of VM Instance underlying connector. Default is e2-micro
        # @!attribute [rw] min_instances
        #   @return [::Integer]
        #     Minimum value of instances in autoscaling group underlying the connector.
        # @!attribute [rw] max_instances
        #   @return [::Integer]
        #     Maximum value of instances in autoscaling group underlying the connector.
        class Connector
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods

          # The subnet in which to house the connector
          # @!attribute [rw] name
          #   @return [::String]
          #     Subnet name (relative, not fully qualified).
          #     E.g. if the full subnet selfLink is
          #     https://compute.googleapis.com/compute/v1/projects/\\{project}/regions/\\{region}/subnetworks/\\{subnetName}
          #     the correct input for this field would be \\{subnetName}
          # @!attribute [rw] project_id
          #   @return [::String]
          #     Project in which the subnet exists.
          #     If not set, this project is assumed to be the project for which
          #     the connector create request was issued.
          class Subnet
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end

          # State of a connector.
          module State
            # Invalid state.
            STATE_UNSPECIFIED = 0

            # Connector is deployed and ready to receive traffic.
            READY = 1

            # An Insert operation is in progress. Transient condition.
            CREATING = 2

            # A Delete operation is in progress. Transient condition.
            DELETING = 3

            # Connector is in a bad state, manual deletion recommended.
            ERROR = 4

            # The connector is being updated.
            UPDATING = 5
          end
        end

        # Request for creating a Serverless VPC Access connector.
        # @!attribute [rw] parent
        #   @return [::String]
        #     Required. The project and location in which the configuration should be created,
        #     specified in the format `projects/*/locations/*`.
        # @!attribute [rw] connector_id
        #   @return [::String]
        #     Required. The ID to use for this connector.
        # @!attribute [rw] connector
        #   @return [::Google::Cloud::VpcAccess::V1::Connector]
        #     Required. Resource to create.
        class CreateConnectorRequest
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end

        # Request for getting a Serverless VPC Access connector.
        # @!attribute [rw] name
        #   @return [::String]
        #     Required. Name of a Serverless VPC Access connector to get.
        class GetConnectorRequest
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end

        # Request for listing Serverless VPC Access connectors in a location.
        # @!attribute [rw] parent
        #   @return [::String]
        #     Required. The project and location from which the routes should be listed.
        # @!attribute [rw] page_size
        #   @return [::Integer]
        #     Maximum number of functions to return per call.
        # @!attribute [rw] page_token
        #   @return [::String]
        #     Continuation token.
        class ListConnectorsRequest
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end

        # Response for listing Serverless VPC Access connectors.
        # @!attribute [rw] connectors
        #   @return [::Array<::Google::Cloud::VpcAccess::V1::Connector>]
        #     List of Serverless VPC Access connectors.
        # @!attribute [rw] next_page_token
        #   @return [::String]
        #     Continuation token.
        class ListConnectorsResponse
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end

        # Request for deleting a Serverless VPC Access connector.
        # @!attribute [rw] name
        #   @return [::String]
        #     Required. Name of a Serverless VPC Access connector to delete.
        class DeleteConnectorRequest
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end

        # Metadata for google.longrunning.Operation.
        # @!attribute [r] method
        #   @return [::String]
        #     Output only. Method that initiated the operation e.g.
        #     google.cloud.vpcaccess.v1.Connectors.CreateConnector.
        # @!attribute [r] create_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. Time when the operation was created.
        # @!attribute [r] end_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. Time when the operation completed.
        # @!attribute [r] target
        #   @return [::String]
        #     Output only. Name of the resource that this operation is acting on e.g.
        #     projects/my-project/locations/us-central1/connectors/v1.
        class OperationMetadata
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods
        end
      end
    end
  end
end