text:
module Twilio
  module REST
    class Conversations < Domain
      class V1 < Version
        class ServiceContext < InstanceContext
          class UserList < ListResource
            ##
            # Initialize the UserList
            # @param [Version] version Version that contains the resource
            # @param [String] chat_service_sid The SID of the {Conversation
            #   Service}[https://www.twilio.com/docs/conversations/api/service-resource] the
            #   User resource is associated with.
            # @return [UserList] UserList
            def initialize(version, chat_service_sid: nil)
              super(version)

              # Path Solution
              @solution = {chat_service_sid: chat_service_sid}
              @uri = "/Services/#{@solution[:chat_service_sid]}/Users"
            end

            ##
            # Create the UserInstance
            # @param [String] identity The application-defined string that uniquely identifies
            #   the resource's User within the {Conversation
            #   Service}[https://www.twilio.com/docs/conversations/api/service-resource]. This
            #   value is often a username or an email address, and is case-sensitive.
            # @param [String] friendly_name The string that you assigned to describe the
            #   resource.
            # @param [String] attributes The JSON Object string that stores
            #   application-specific data. If attributes have not been set, `{}` is returned.
            # @param [String] role_sid The SID of a service-level
            #   {Role}[https://www.twilio.com/docs/conversations/api/role-resource] to assign to
            #   the user.
            # @param [user.WebhookEnabledType] x_twilio_webhook_enabled The
            #   X-Twilio-Webhook-Enabled HTTP request header
            # @return [UserInstance] Created UserInstance
            def create(identity: nil, friendly_name: :unset, attributes: :unset, role_sid: :unset, x_twilio_webhook_enabled: :unset)
              data = Twilio::Values.of({
                  'Identity' => identity,
                  'FriendlyName' => friendly_name,
                  'Attributes' => attributes,
                  'RoleSid' => role_sid,
              })
              headers = Twilio::Values.of({'X-Twilio-Webhook-Enabled' => x_twilio_webhook_enabled, })

              payload = @version.create('POST', @uri, data: data, headers: headers)

              UserInstance.new(@version, payload, chat_service_sid: @solution[:chat_service_sid], )
            end

            ##
            # Lists UserInstance records from the API as a list.
            # Unlike stream(), this operation is eager and will load `limit` records into
            # memory before returning.
            # @param [Integer] limit Upper limit for the number of records to return. stream()
            #    guarantees to never return more than limit.  Default is no limit
            # @param [Integer] page_size Number of records to fetch per request, when
            #    not set will use the default value of 50 records.  If no page_size is defined
            #    but a limit is defined, stream() will attempt to read the limit with the most
            #    efficient page size, i.e. min(limit, 1000)
            # @return [Array] Array of up to limit results
            def list(limit: nil, page_size: nil)
              self.stream(limit: limit, page_size: page_size).entries
            end

            ##
            # Streams UserInstance records from the API as an Enumerable.
            # This operation lazily loads records as efficiently as possible until the limit
            # is reached.
            # @param [Integer] limit Upper limit for the number of records to return. stream()
            #    guarantees to never return more than limit. Default is no limit.
            # @param [Integer] page_size Number of records to fetch per request, when
            #    not set will use the default value of 50 records. If no page_size is defined
            #    but a limit is defined, stream() will attempt to read the limit with the most
            #    efficient page size, i.e. min(limit, 1000)
            # @return [Enumerable] Enumerable that will yield up to limit results
            def stream(limit: nil, page_size: nil)
              limits = @version.read_limits(limit, page_size)

              page = self.page(page_size: limits[:page_size], )

              @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
            end

            ##
            # When passed a block, yields UserInstance records from the API.
            # This operation lazily loads records as efficiently as possible until the limit
            # is reached.
            def each
              limits = @version.read_limits

              page = self.page(page_size: limits[:page_size], )

              @version.stream(page,
                              limit: limits[:limit],
                              page_limit: limits[:page_limit]).each {|x| yield x}
            end

            ##
            # Retrieve a single page of UserInstance records from the API.
            # Request is executed immediately.
            # @param [String] page_token PageToken provided by the API
            # @param [Integer] page_number Page Number, this value is simply for client state
            # @param [Integer] page_size Number of records to return, defaults to 50
            # @return [Page] Page of UserInstance
            def page(page_token: :unset, page_number: :unset, page_size: :unset)
              params = Twilio::Values.of({
                  'PageToken' => page_token,
                  'Page' => page_number,
                  'PageSize' => page_size,
              })

              response = @version.page('GET', @uri, params: params)

              UserPage.new(@version, response, @solution)
            end

            ##
            # Retrieve a single page of UserInstance records from the API.
            # Request is executed immediately.
            # @param [String] target_url API-generated URL for the requested results page
            # @return [Page] Page of UserInstance
            def get_page(target_url)
              response = @version.domain.request(
                  'GET',
                  target_url
              )
              UserPage.new(@version, response, @solution)
            end

            ##
            # Provide a user friendly representation
            def to_s
              '#<Twilio.Conversations.V1.UserList>'
            end
          end

          class UserPage < Page
            ##
            # Initialize the UserPage
            # @param [Version] version Version that contains the resource
            # @param [Response] response Response from the API
            # @param [Hash] solution Path solution for the resource
            # @return [UserPage] UserPage
            def initialize(version, response, solution)
              super(version, response)

              # Path Solution
              @solution = solution
            end

            ##
            # Build an instance of UserInstance
            # @param [Hash] payload Payload response from the API
            # @return [UserInstance] UserInstance
            def get_instance(payload)
              UserInstance.new(@version, payload, chat_service_sid: @solution[:chat_service_sid], )
            end

            ##
            # Provide a user friendly representation
            def to_s
              '<Twilio.Conversations.V1.UserPage>'
            end
          end

          class UserContext < InstanceContext
            ##
            # Initialize the UserContext
            # @param [Version] version Version that contains the resource
            # @param [String] chat_service_sid The SID of the {Conversation
            #   Service}[https://www.twilio.com/docs/conversations/api/service-resource] to
            #   fetch the User resource from.
            # @param [String] sid The SID of the User resource to fetch. This value can be
            #   either the `sid` or the `identity` of the User resource to fetch.
            # @return [UserContext] UserContext
            def initialize(version, chat_service_sid, sid)
              super(version)

              # Path Solution
              @solution = {chat_service_sid: chat_service_sid, sid: sid, }
              @uri = "/Services/#{@solution[:chat_service_sid]}/Users/#{@solution[:sid]}"

              # Dependents
              @user_conversations = nil
            end

            ##
            # Update the UserInstance
            # @param [String] friendly_name The string that you assigned to describe the
            #   resource.
            # @param [String] attributes The JSON Object string that stores
            #   application-specific data. If attributes have not been set, `{}` is returned.
            # @param [String] role_sid The SID of a service-level
            #   {Role}[https://www.twilio.com/docs/conversations/api/role-resource] to assign to
            #   the user.
            # @param [user.WebhookEnabledType] x_twilio_webhook_enabled The
            #   X-Twilio-Webhook-Enabled HTTP request header
            # @return [UserInstance] Updated UserInstance
            def update(friendly_name: :unset, attributes: :unset, role_sid: :unset, x_twilio_webhook_enabled: :unset)
              data = Twilio::Values.of({
                  'FriendlyName' => friendly_name,
                  'Attributes' => attributes,
                  'RoleSid' => role_sid,
              })
              headers = Twilio::Values.of({'X-Twilio-Webhook-Enabled' => x_twilio_webhook_enabled, })

              payload = @version.update('POST', @uri, data: data, headers: headers)

              UserInstance.new(
                  @version,
                  payload,
                  chat_service_sid: @solution[:chat_service_sid],
                  sid: @solution[:sid],
              )
            end

            ##
            # Delete the UserInstance
            # @param [user.WebhookEnabledType] x_twilio_webhook_enabled The
            #   X-Twilio-Webhook-Enabled HTTP request header
            # @return [Boolean] true if delete succeeds, false otherwise
            def delete(x_twilio_webhook_enabled: :unset)
              headers = Twilio::Values.of({'X-Twilio-Webhook-Enabled' => x_twilio_webhook_enabled, })

               @version.delete('DELETE', @uri, headers: headers)
            end

            ##
            # Fetch the UserInstance
            # @return [UserInstance] Fetched UserInstance
            def fetch
              payload = @version.fetch('GET', @uri)

              UserInstance.new(
                  @version,
                  payload,
                  chat_service_sid: @solution[:chat_service_sid],
                  sid: @solution[:sid],
              )
            end

            ##
            # Access the user_conversations
            # @return [UserConversationList]
            # @return [UserConversationContext] if conversation_sid was passed.
            def user_conversations(conversation_sid=:unset)
              raise ArgumentError, 'conversation_sid cannot be nil' if conversation_sid.nil?

              if conversation_sid != :unset
                return UserConversationContext.new(
                    @version,
                    @solution[:chat_service_sid],
                    @solution[:sid],
                    conversation_sid,
                )
              end

              unless @user_conversations
                @user_conversations = UserConversationList.new(
                    @version,
                    chat_service_sid: @solution[:chat_service_sid],
                    user_sid: @solution[:sid],
                )
              end

              @user_conversations
            end

            ##
            # Provide a user friendly representation
            def to_s
              context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
              "#<Twilio.Conversations.V1.UserContext #{context}>"
            end

            ##
            # Provide a detailed, user friendly representation
            def inspect
              context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
              "#<Twilio.Conversations.V1.UserContext #{context}>"
            end
          end

          class UserInstance < InstanceResource
            ##
            # Initialize the UserInstance
            # @param [Version] version Version that contains the resource
            # @param [Hash] payload payload that contains response from Twilio
            # @param [String] chat_service_sid The SID of the {Conversation
            #   Service}[https://www.twilio.com/docs/conversations/api/service-resource] the
            #   User resource is associated with.
            # @param [String] sid The SID of the User resource to fetch. This value can be
            #   either the `sid` or the `identity` of the User resource to fetch.
            # @return [UserInstance] UserInstance
            def initialize(version, payload, chat_service_sid: nil, sid: nil)
              super(version)

              # Marshaled Properties
              @properties = {
                  'sid' => payload['sid'],
                  'account_sid' => payload['account_sid'],
                  'chat_service_sid' => payload['chat_service_sid'],
                  'role_sid' => payload['role_sid'],
                  'identity' => payload['identity'],
                  'friendly_name' => payload['friendly_name'],
                  'attributes' => payload['attributes'],
                  'is_online' => payload['is_online'],
                  'is_notifiable' => payload['is_notifiable'],
                  'date_created' => Twilio.deserialize_iso8601_datetime(payload['date_created']),
                  'date_updated' => Twilio.deserialize_iso8601_datetime(payload['date_updated']),
                  'url' => payload['url'],
                  'links' => payload['links'],
              }

              # Context
              @instance_context = nil
              @params = {'chat_service_sid' => chat_service_sid, 'sid' => sid || @properties['sid'], }
            end

            ##
            # Generate an instance context for the instance, the context is capable of
            # performing various actions.  All instance actions are proxied to the context
            # @return [UserContext] UserContext for this UserInstance
            def context
              unless @instance_context
                @instance_context = UserContext.new(@version, @params['chat_service_sid'], @params['sid'], )
              end
              @instance_context
            end

            ##
            # @return [String] The unique string that identifies the resource
            def sid
              @properties['sid']
            end

            ##
            # @return [String] The SID of the Account that created the resource
            def account_sid
              @properties['account_sid']
            end

            ##
            # @return [String] The SID of the Conversation Service that the resource is associated with
            def chat_service_sid
              @properties['chat_service_sid']
            end

            ##
            # @return [String] The SID of a service-level Role assigned to the user
            def role_sid
              @properties['role_sid']
            end

            ##
            # @return [String] The string that identifies the resource's User
            def identity
              @properties['identity']
            end

            ##
            # @return [String] The string that you assigned to describe the resource
            def friendly_name
              @properties['friendly_name']
            end

            ##
            # @return [String] The JSON Object string that stores application-specific data
            def attributes
              @properties['attributes']
            end

            ##
            # @return [Boolean] Whether the User is actively connected to this Conversations Service and online
            def is_online
              @properties['is_online']
            end

            ##
            # @return [Boolean] Whether the User has a potentially valid Push Notification registration for this Conversations Service
            def is_notifiable
              @properties['is_notifiable']
            end

            ##
            # @return [Time] The ISO 8601 date and time in GMT when the resource was created
            def date_created
              @properties['date_created']
            end

            ##
            # @return [Time] The ISO 8601 date and time in GMT when the resource was last updated
            def date_updated
              @properties['date_updated']
            end

            ##
            # @return [String] An absolute URL for this user.
            def url
              @properties['url']
            end

            ##
            # @return [String] The links
            def links
              @properties['links']
            end

            ##
            # Update the UserInstance
            # @param [String] friendly_name The string that you assigned to describe the
            #   resource.
            # @param [String] attributes The JSON Object string that stores
            #   application-specific data. If attributes have not been set, `{}` is returned.
            # @param [String] role_sid The SID of a service-level
            #   {Role}[https://www.twilio.com/docs/conversations/api/role-resource] to assign to
            #   the user.
            # @param [user.WebhookEnabledType] x_twilio_webhook_enabled The
            #   X-Twilio-Webhook-Enabled HTTP request header
            # @return [UserInstance] Updated UserInstance
            def update(friendly_name: :unset, attributes: :unset, role_sid: :unset, x_twilio_webhook_enabled: :unset)
              context.update(
                  friendly_name: friendly_name,
                  attributes: attributes,
                  role_sid: role_sid,
                  x_twilio_webhook_enabled: x_twilio_webhook_enabled,
              )
            end

            ##
            # Delete the UserInstance
            # @param [user.WebhookEnabledType] x_twilio_webhook_enabled The
            #   X-Twilio-Webhook-Enabled HTTP request header
            # @return [Boolean] true if delete succeeds, false otherwise
            def delete(x_twilio_webhook_enabled: :unset)
              context.delete(x_twilio_webhook_enabled: x_twilio_webhook_enabled, )
            end

            ##
            # Fetch the UserInstance
            # @return [UserInstance] Fetched UserInstance
            def fetch
              context.fetch
            end

            ##
            # Access the user_conversations
            # @return [user_conversations] user_conversations
            def user_conversations
              context.user_conversations
            end

            ##
            # Provide a user friendly representation
            def to_s
              values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
              "<Twilio.Conversations.V1.UserInstance #{values}>"
            end

            ##
            # Provide a detailed, user friendly representation
            def inspect
              values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
              "<Twilio.Conversations.V1.UserInstance #{values}>"
            end
          end
        end
      end
    end
  end
end


text:
clear
echo "
 _____             _         _    _          _
|     |___ ___ ___| |_ ___ _| |  | |_ _ _   |_|
|   --|  _| -_| .'|  _| -_| . |  | . | | |   _
|_____|_| |___|__,|_| |___|___|  |___|_  |  |_|
                                     |___|

 _____ _       _     _           _              _____    __    _____
|     | |_ ___|_|___| |_ ___ ___| |_ ___ ___   |     |__|  |  |   __|___ ___ _ _
|   --|   |  _| |_ -|  _| . | . |   | -_|  _|  | | | |  |  |  |  |  |  _| .'| | |
|_____|_|_|_| |_|___|_| |___|  _|_|_|___|_|    |_|_|_|_____|  |_____|_| |__,|_  |
                            |_|                                             |___|

| ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄|
|    GREAT ENGINEERS      |
|     DO NOT GROW ON      |
|         TREES           |
|_______________|
          (\_❀) ||
          (•ㅅ•) ||
          /   づ

https://raw.githubusercontent.com/c2theg/srvBuilds/master/install_LEMP-latest.sh

INSTALLS  LEMP (Linux* Nginx Memcache PHP (Latest - 7.4)

\r\n \r\n
Version:  1.5.1                             \r\n
Last Updated:  4/4/2022
\r\n \r\n
Updating system first..."

#---- Add Repo's -----
sudo add-apt-repository -y ppa:chris-lea/nginx-devel
sudo LC_ALL=C.UTF-8 add-apt-repository -y ppa:ondrej/php

#--- Create Filesystem  ----
mkdir "/media/data/"
mkdir "/var/www/html/"
mkdir "/var/log/nginx/"

#----- Update ------
sudo -E apt-get -y update
#wait
#sudo -E apt-get upgrade -y
#wait
echo "Downloading required dependencies...\r\n\r\n"
#--------------------------------------------------------------------------------------------
#sudo apt-get -y dist-upgrade
wait
sudo apt-get install -y ntp ntpdate ssh openssh-server screen whois traceroute htop sysstat iptraf iftop speedometer ncdu nload
#---- Email -----
#wait
#sudo apt-get install -y postfix procmail postfix-pcre sasl2-bin postfix-cdb postfix-doc
# dovecot-core postfix-mysql
#wait
#wget -O "main.cf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/main.cf"
#mv main.cf /etc/postfix/main.cf
#/etc/init.d/postfix restart
#---------- PYTHON STUFF ----------------------------------
#sudo apt-get install -y python2-virtualenv python3-virtualenv libicu-dev python-software-properties python python-pip python-dev python3-setuptools
#wait
#--- PHP ---
sudo apt-get install -y openssl-blacklist ssl-cert libmcrypt-dev mcrypt
sudo apt-get install -y php7.4 php7.4-cli php7.4-fpm php7.4-curl php7.4-json php7.4-gd php7.4-mysql php7.4-mbstring php7.4-dev zip unzip
sudo apt-get install -y php7.4-common php7.4-opcache php7.4-readline php7.4-soap php7.4-ldap php7.4-pear php-xdebug php-apcu php-ssh2 php-geoip php7.4-bcmath php7.4-zip php7.4-xml php-xml php-mailparse php7.4-bz2 php7.4-xmlrpc php7.4-mcrypt
sudo apt-get install -y php7.4-memcached
wait
#--- pear ---
# https://pear.php.net/manual/en/installation.getting.php
wget http://pear.php.net/go-pear.phar
php go-pear.phar
sudo pear channel-update pear.php.net
sudo pecl channel-update pecl.php.net

sudo pear install mail Net_SMTP Auth_SASL2-0.1.0 mail_mime
sudo apt-get install -y php7.4-mongodb php-mongodb
pecl install mongodb
pear install PEAR

#--- extras ---
sudo apt-get install -y libcurl4-openssl-dev pkg-config libssl-dev libsslcommon2-dev libmysqlclient-dev

#--- install Composer ---
# https://getcomposer.org/download/
# To find packages, visit:  https://packagist.org/explore/
# ------------
wget https://raw.githubusercontent.com/c2theg/srvBuilds/master/install_php_composer.sh
chmod u+x install_php_composer.sh
sudo ./install_php_composer.sh
#php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
#php -r "if (hash_file('sha384', 'composer-setup.php') === '93b54496392c062774670ac18b134c3b3a95e5a5e5c8f1a9f115f203b75bf9a129d5daa8ba6a13e2cc8a1da0806388a8') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
#php composer-setup.php
#php -r "unlink('composer-setup.php');"
# Composer (version 1.8.0) successfully installed to: /usr/lib/php/20170718/composer.phar
# Use it: php composer.phar
#--------------------------------------

#--- Memcached ----
sudo apt-get install -y memcached
wait

cd ~
if [ -s "memcached.conf" ]
then
	echo "Deleting file  memcached.conf "
	rm memcached.conf
fi
echo "Downloading Memcache Config"
wget -O "memcached.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/memcached.conf"
wait
sudo mv "memcached.conf" "/etc/memcached.conf"
wait
echo "Memcache Config Download Complete"
wait
echo "Restarting memcache service..."
sudo /etc/init.d/memcached restart
wait
#------- NGINX --------
sudo apt-get install -y nginx nginx-common nginx-full fcgiwrap gcc make libpcre3-dev zlib1g-dev
#sudo apt-get install -y nginx-plus-module-geoip2
#sudo apt-get -y install nginx-pagespeed
#-- Download PHP Configs ---
#sudo chmod +x /etc/init.d/php-fastcgi && /etc/init.d/php-fastcgi start  && update-rc.d php-fastcgi defaults
cd ~
echo "Downloading PHP-Fastcgi Config"
wget -O "php-fastcgi" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/php-fastcgi.sh"
wait
sudo mv "php-fastcgi" "/etc/init.d/php-fastcgi"
wait
sudo chmod +x /etc/init.d/php-fastcgi && /etc/init.d/php-fastcgi start && update-rc.d php-fastcgi defaults

if [ -s "/etc/php/7.4/fpm/php.ini" ]
then
	echo "Deleting file: PHP.ini config "
	rm /etc/php/7.4/fpm/php.ini
	rm /etc/php/7.4/fpm/php-fpm.conf
	rm /media/data/php_browscap.ini
fi
wait
echo "Downloading PHP-FPM Configs"
wget -O  "php.ini" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/php.ini"
sudo mv "php.ini" "/etc/php/7.4/fpm/php.ini"
wait
#--------------------------------------------------
wget -O "php-fpm.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/php-fpm-7.4.conf"
sudo mv "php-fpm.conf" "/etc/php/7.4/fpm/php-fpm.conf"
wait
#--------------------------------------------------
wget -O "php_browscap.ini" "https://browscap.org/stream?q=PHP_BrowsCapINI"
sudo mv "php_browscap.ini" "/media/data/php_browscap.ini"
wait
echo "PHP-FPM Configs download complete"
#---------------------------------------------------------------------------------------------------------
if [ -s "/etc/nginx/nginx.conf" ]
then
	echo "Deleting file nginx config "
	rm /etc/nginx/nginx.conf
	rm nginx.conf
fi
echo "Downloading Nginx Config"
wget -O "nginx_global_filetypes.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx_global_filetypes.conf"
wget -O "nginx_global_logging.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx_global_logging.conf"
wget -O "nginx_global_security.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx_global_security.conf"
wget -O "nginx_global_tls.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx_global_tls.conf"
wget -O "nginx.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx.conf"
#-- sample page --
wget -O "index.html" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/index.html"
wget -O "custom_404.html" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/custom_404.html"
wget -O "custom_50x.html" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/custom_50x.html"
wget -O "nginx.png" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/nginx.png"
wget -O "f5-logo-tagline-right-solid-rgb-1.png" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/f5-logo-tagline-right-solid-rgb-1.png"

#-- Move Files --
sudo mv "nginx_global_filetypes.conf" "/etc/nginx/snippets/nginx_global_filetypes.conf"
sudo mv "nginx_global_logging.conf" "/etc/nginx/snippets/nginx_global_logging.conf"
sudo mv "nginx_global_security.conf" "/etc/nginx/snippets/nginx_global_security.conf"
sudo mv "nginx_global_tls.conf" "/etc/nginx/snippets/nginx_global_tls.conf"
sudo mv "nginx.conf" "/etc/nginx/nginx.conf"
#-- sample page --
sudo mv "index.html" "/usr/share/nginx/html/index.html"
sudo mv "custom_404.html" "/usr/share/nginx/html/custom_404.html"
sudo mv "custom_50x.html" "/usr/share/nginx/html/custom_50x.html"
sudo mv "nginx.png" "/usr/share/nginx/html/nginx.png"
sudo mv "f5-logo-tagline-right-solid-rgb-1.png" "/usr/share/nginx/html/f5-logo-tagline-right-solid-rgb-1.png"

wait
echo "Nginx Config Download Complete"

echo "Downloading Basic HTTP/HTTPS Website Config"
#wget -O "site1.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/site1.conf"
wget -O "site1_80443.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/site1_80443.conf"
wait
sudo mv "site1_80443.conf" "/etc/nginx/sites-enabled/site1_80443.conf"
wait
if [ -s "/etc/nginx/sites-enabled/default" ]
then
	echo "Deleting file  nginx default config "
	rm "/etc/nginx/sites-enabled/default"
fi
wait
echo "Basic HTTP/HTTPS Website Config Download Complete"
#---------------------------------------------------------------------------------------------------------
#echo "SSL-TLS HTTP Website Config"
#wget -O "site1_tls.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/site1_tls.conf"
#wait
#sudo mv "site1_tls.conf" "/etc/nginx/sites-available/site1_tls.conf"
#wait
#echo "SSL-TLS HTTP Website Config Download Complete"
#---------------------------------------------------------------------------------------------------------
#echo "Pagespeed Config"
#wget "pagespeed.conf" "https://raw.githubusercontent.com/c2theg/srvBuilds/master/configs/configs/pagespeed.conf"
#wait
#sudo mv "pagespeed.conf" "/etc/nginx/conf.d/pagespeed.conf"
#wait
#echo " Download Complete"
#---------------------------------------------------------------------------------------------------------
sudo chmod -R 755 /media/data/ && sudo chown -R www-data:www-data /media/data/
sudo chmod -R 755 /usr/share/nginx/html/ && sudo chown -R www-data:www-data /usr/share/nginx/html/

wait
echo "Restarting Nginx... "
/etc/init.d/nginx restart

echo "Restarting PHP-FPM... "
/etc/init.d/php7.4-fpm restart
echo "Done All! \r\n \r\n"

echo "You will need to update the NGINX config at:  /etc/nginx/sites-enabled/ \r\n \r\n"

redpajama_set_name: RedPajamaGithub


text:
require.config({ enable_ozma: true });

/* @source mod/watch.js */;

define('mod/watch', [
  "jquery"
], function($){

  $(function() {
    var watch_btn = $("#watch-btn");
    var countLabel = $('#watched-count');
    var proj_id = watch_btn.attr("proj_id");

    var updateLabelBy = function (n) {
        var count = Number(countLabel.text()) || 0;
        if (count === 0 && n <= 0) { return; }

        count += n;
        countLabel.text(count.toString());
    };

    watch_btn.click(function() {

      if(watch_btn.hasClass('watch')) {
        $.post("/watch/"+proj_id, function(data) {
          if (!data.error) {
            watch_btn.text('Unwatch');
            watch_btn.addClass('unwatch');
            watch_btn.removeClass('watch');
            updateLabelBy(1);
          } else {
            // show error notification to user
            show_error("关注失败");
          }
        });
      }
      else{
        $.ajax("/watch/"+proj_id, {
          type: "DELETE",
          success: function(data) {
            if (!data.error) {
              watch_btn.text('Watch');
              watch_btn.addClass('watch');
              watch_btn.removeClass('unwatch');
              updateLabelBy(-1);
            } else {
              show_error("取消关注失败");
            }
          },
          error: function(e) {
            show_error("取消关注失败");
          }
        });
      }
    });

    function show_success(msg) {
        var successDiv = $(".navbar .success");
        if (successDiv.size() === 0 ) {
            successDiv= $("
").addClass("success").addClass("alert-success");
            $("div.navbar").append(successDiv);
        }
        successDiv.html(msg);
        successDiv.fadeOut(1500, function () {
            $(this).remove();
        });
    }

    function show_error(msg) {
        var errorDiv = $(".navbar .error");
        if (errorDiv.size() === 0 ) {
            errorDiv = $("
").addClass("error").addClass("alert-error");
            $("div.navbar").append(errorDiv);
        }
        errorDiv.html(msg);
    }

  });
});

/* @source lib/jquery.scrollTo.js */;

/*!
 * jQuery.ScrollTo
 * Copyright (c) 2007-2013 Ariel Flesler - afleslergmail<d>com | http://flesler.blogspot.com
 * Dual licensed under MIT and GPL.
 *
 * @projectDescription Easy element scrolling using jQuery.
 * http://flesler.blogspot.com/2007/10/jqueryscrollto.html
 * @author Ariel Flesler
 * @version 1.4.7

 * @id jQuery.scrollTo
 * @id jQuery.fn.scrollTo
 * @param {String, Number, DOMElement, jQuery, Object} target Where to scroll the matched elements.
 *	  The different options for target are:
 *		- A number position (will be applied to all axes).
 *		- A string position ('44', '100px', '+=90', etc ) will be applied to all axes
 *		- A jQuery/DOM element ( logically, child of the element to scroll )
 *		- A string selector, that will be relative to the element to scroll ( 'li:eq(2)', etc )
 *		- A hash { top:x, left:y }, x and y can be any kind of number/string like above.
 *		- A percentage of the container's dimension/s, for example: 50% to go to the middle.
 *		- The string 'max' for go-to-end.
 * @param {Number, Function} duration The OVERALL length of the animation, this argument can be the settings object instead.
 * @param {Object,Function} settings Optional set of settings or the onAfter callback.
 *	 @option {String} axis Which axis must be scrolled, use 'x', 'y', 'xy' or 'yx'.
 *	 @option {Number, Function} duration The OVERALL length of the animation.
 *	 @option {Boolean} interrupt If true, the scrolling animation will stop on user scroll
 *	 @option {String} easing The easing method for the animation.
 *	 @option {Boolean} margin If true, the margin of the target element will be deducted from the final position.
 *	 @option {Object, Number} offset Add/deduct from the end position. One number for both axes or { top:x, left:y }.
 *	 @option {Object, Number} over Add/deduct the height/width multiplied by 'over', can be { top:x, left:y } when using both axes.
 *	 @option {Boolean} queue If true, and both axis are given, the 2nd axis will only be animated after the first one ends.
 *	 @option {Function} onAfter Function to be called after the scrolling ends.
 *	 @option {Function} onAfterFirst If queuing is activated, this function will be called after the first scrolling ends.
 * @return {jQuery} Returns the same jQuery object, for chaining.
 *
 * @desc Scroll to a fixed position
 * @example $('#container').scrollTo( 340 );
 *
 * @desc Scroll relatively to the actual position
 * @example $('#container').scrollTo( '+=340px', { axis:'y' } );
 *
 * @desc Scroll using a selector (relative to the scrolled element)
 * @example $(window).scrollTo( 'p.paragraph:eq(2)', 500, { easing:'swing', queue:true, axis:'xy' } );
 *
 * @desc Scroll to a DOM element (same for jQuery object)
 * @example $(window).scrollTo( document.getElementById('element'), { duration:500, axis:'x', onAfter:function() {
 *				alert('scrolled!!');
 *			}});
 *
 * @desc Scroll on both axes, to different values
 * @example $('div').scrollTo( { top: 300, left:'+=200' }, { axis:'xy', offset:-20 } );
 */

;(function( $ ) {

	var $scrollTo = $.scrollTo = function( target, duration, settings ) {
		return $(window).scrollTo( target, duration, settings );
	};

	$scrollTo.defaults = {
		axis:'xy',
		duration: parseFloat($.fn.jquery) >= 1.3 ? 0 : 1,
		limit:true
	};

	// Returns the element that needs to be animated to scroll the window.
	// Kept for backwards compatibility (specially for localScroll & serialScroll)
	$scrollTo.window = function( scope ) {
		return $(window)._scrollable();
	};

	// Hack, hack, hack :)
	// Returns the real elements to scroll (supports window/iframes, documents and regular nodes)
	$.fn._scrollable = function() {
		return this.map(function() {
			var elem = this,
				isWin = !elem.nodeName || $.inArray( elem.nodeName.toLowerCase(), ['iframe','#document','html','body'] ) != -1;

				if (!isWin)
					return elem;

			var doc = (elem.contentWindow || elem).document || elem.ownerDocument || elem;

			return /webkit/i.test(navigator.userAgent) || doc.compatMode == 'BackCompat' ?
				doc.body :
				doc.documentElement;
		});
	};

	$.fn.scrollTo = function( target, duration, settings ) {
		if (typeof duration == 'object') {
			settings = duration;
			duration = 0;
		}
		if (typeof settings == 'function')
			settings = { onAfter:settings };

		if (target == 'max')
			target = 9e9;

		settings = $.extend( {}, $scrollTo.defaults, settings );
		// Speed is still recognized for backwards compatibility
		duration = duration || settings.duration;
		// Make sure the settings are given right
		settings.queue = settings.queue && settings.axis.length > 1;

		if (settings.queue)
			// Let's keep the overall duration
			duration /= 2;
		settings.offset = both( settings.offset );
		settings.over = both( settings.over );

		return this._scrollable().each(function() {
			// Null target yields nothing, just like jQuery does
			if (target == null) return;

			var elem = this,
				$elem = $(elem),
				targ = target, toff, attr = {},
				win = $elem.is('html,body');

			switch (typeof targ) {
				// A number will pass the regex
				case 'number':
				case 'string':
					if (/^([+-]=?)?\d+(\.\d+)?(px|%)?$/.test(targ)) {
						targ = both( targ );
						// We are done
						break;
					}
					// Relative selector, no break!
					targ = $(targ,this);
					if (!targ.length) return;
				case 'object':
					// DOMElement / jQuery
					if (targ.is || targ.style)
						// Get the real position of the target
						toff = (targ = $(targ)).offset();
			}
			$.each( settings.axis.split(''), function( i, axis ) {
				var Pos	= axis == 'x' ? 'Left' : 'Top',
					pos = Pos.toLowerCase(),
					key = 'scroll' + Pos,
					old = elem[key],
					max = $scrollTo.max(elem, axis);

				if (toff) {// jQuery / DOMElement
					attr[key] = toff[pos] + ( win ? 0 : old - $elem.offset()[pos] );

					// If it's a dom element, reduce the margin
					if (settings.margin) {
						attr[key] -= parseInt(targ.css('margin'+Pos)) || 0;
						attr[key] -= parseInt(targ.css('border'+Pos+'Width')) || 0;
					}

					attr[key] += settings.offset[pos] || 0;

					if(settings.over[pos])
						// Scroll to a fraction of its width/height
						attr[key] += targ[axis=='x'?'width':'height']() * settings.over[pos];
				} else {
					var val = targ[pos];
					// Handle percentage values
					attr[key] = val.slice && val.slice(-1) == '%' ?
						parseFloat(val) / 100 * max
						: val;
				}

				// Number or 'number'
				if (settings.limit && /^\d+$/.test(attr[key]))
					// Check the limits
					attr[key] = attr[key] <= 0 ? 0 : Math.min( attr[key], max );

				// Queueing axes
				if (!i && settings.queue) {
					// Don't waste time animating, if there's no need.
					if (old != attr[key])
						// Intermediate animation
						animate( settings.onAfterFirst );
					// Don't animate this axis again in the next iteration.
					delete attr[key];
				}
			});

			animate( settings.onAfter );

			function animate( callback ) {
				$elem.animate( attr, duration, settings.easing, callback && function() {
					callback.call(this, targ, settings);
				});
			};

		}).end();
	};

	// Max scrolling position, works on quirks mode
	// It only fails (not too badly) on IE, quirks mode.
	$scrollTo.max = function( elem, axis ) {
		var Dim = axis == 'x' ? 'Width' : 'Height',
			scroll = 'scroll'+Dim;

		if (!$(elem).is('html,body'))
			return elem[scroll] - $(elem)[Dim.toLowerCase()]();

		var size = 'client' + Dim,
			html = elem.ownerDocument.documentElement,
			body = elem.ownerDocument.body;

		return Math.max( html[scroll], body[scroll] )
			 - Math.min( html[size]  , body[size]   );
	};

	function both( val ) {
		return typeof val == 'object' ? val : { top:val, left:val };
	};

})( jQuery );
/* autogeneration */
define("jquery-scrollto", [], function(){});

/* @source  */;

define('jquery-scrollto', 'lib/jquery.scrollTo.js');
require(['jquery', 'jquery-unobstrusive', 'jquery-scrollto', 'mod/watch', 'jquery-tooltipster'], function($){
    $('.btn-details').tooltipster({
        content: $('
If this feature opening. When open a new pull request, all flake8 errors found ' +
                   'by Telchar will send to CODE. visit Telchar
'),
        minWidth: 300,
        maxWidth: 300,
        position: 'right',
        interactive: true
    });

    $('.mute').on('click', function (e) {
        var target = $(this);
        $.ajax({
            type: "GET",
            url: target.data('href'),
            dataType: "json",
            success: function (rs) {
                if (rs.r === 0) {
                    var $muteOn = $('.mute-on'),
                        $muteOff = $('.mute-off');
                    if (rs.status === 0) {
                        $muteOn.removeClass('btn-success');
                        $muteOff.addClass('btn-warning');
                    } else {
                        $muteOn.addClass('btn-success');
                        $muteOff.removeClass('btn-warning');
                    }
                }
            }
        });
    });

    $(".js-hook-target").on('click', function (e) {
        var target = $(this);
        var group = $(".js-hook-group");
        target.parents("li").removeClass("selected");
        target.parents("li").addClass("selected");
        group.hide();
        $(this.hash).show().scrollTo();
        e.preventDefault();
    });
});


text:
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

import Control.Applicative ((<$>),(<*>))
import Control.Monad (when,filterM)
import Control.Monad.Trans.Maybe
import Data.Configurator as C
import qualified Data.List as L
import Data.Maybe (catMaybes,isNothing)
import Data.UUID.V4 (nextRandom)
import System.Directory -- (doesDirectoryExist, copyFile, getHomeDirectory, getTemporaryDirectory, removeFile)
import System.Console.CmdArgs
import System.Directory.Tree (AnchoredDirTree(..), DirTree(..), build, flattenDir)
import System.FilePath (makeRelative, splitFileName, takeExtension, (</>))
import System.Process (system,readProcess)

isHtml = ( == ".html") <$> takeExtension

isFile (File _ _) = True
isFile _ = False

takeFile x | isFile x = (Just . file) x
takeFile x | otherwise = Nothing

data HaddockReplace = Replace { buildpath :: String
                              , config :: FilePath }
                   deriving (Show,Data,Typeable)

replace :: FilePath -> HaddockReplace
replace dothaddock =
  Replace { buildpath = def &= typ "TARGETFILEDIR" &= argPos 0
          , config = dothaddock
          }

mode :: FilePath -> HaddockReplace
mode dothaddock = modes [replace dothaddock]

prepareDirectory :: FilePath -> IO ()
prepareDirectory fp = do
  let (dir,_) = splitFileName fp
  b <- doesDirectoryExist dir
  when (not b) $ system ("mkdir -p " ++ dir) >> return ()

processFile :: (FilePath,FilePath) -> String -> FilePath -> FilePath -> IO ()
processFile (doc1,doc2) url src tgt = do
  uuid <- nextRandom
  tdir <- getTemporaryDirectory
  let tfile = tdir </> (show uuid)
  readProcess "simplereplace" [ "+RTS", "-K100M", "-RTS"
                              , doc1, url, src, tfile] ""
  readProcess "simplereplace" ["+RTS", "-K100M", "-RTS"
                              , doc2, url, tfile, tgt] ""
  removeFile tfile

isUpdated :: (FilePath,FilePath) -> IO Bool
isUpdated (ofp,nfp) = do
  b <- doesFileExist nfp
  if not b
    then return True
    else do
      otime <- getModificationTime ofp
      ntime <- getModificationTime nfp
      return (otime > ntime)

main :: IO ()
main = do
  dothaddock <- (</> ".haddock") <$> getHomeDirectory
  params <- cmdArgs (mode dothaddock)

  cfg <- load [Required (config params)]
  Just (rootpath,urlbase,doc1,doc2) :: Maybe (FilePath,FilePath,FilePath,FilePath)
    <- runMaybeT $ do
         (,,,) <$> MaybeT (C.lookup cfg "rootpath")
               <*> MaybeT (C.lookup cfg "urlbase")
               <*> MaybeT (C.lookup cfg "doc1")
               <*> MaybeT (C.lookup cfg "doc2")

  (r :/ r') <- build rootpath
  let files = catMaybes . map takeFile . flattenDir $ r'
      -- htmlfiles = filter isHtml files
      pairs = map ((,) <$> id
                   <*> (buildpath params </>) . makeRelative rootpath)
                  files
      swappedpairs = map (\(x,y)->(y,x)) pairs

  (b :/ b') <- build (buildpath params)
  let filesInTarget = catMaybes . map takeFile . flattenDir $ b'
      willbeerased = filter (\x -> isNothing (L.lookup x swappedpairs )) filesInTarget
  mapM_ removeFile willbeerased
  updatedpairs <- filterM isUpdated pairs

  -- mapM_ print updatedpairs
  mapM_ (prepareDirectory . snd) updatedpairs
  mapM_ (\x -> print x >> uncurry (processFile (doc1,doc2) urlbase) x) updatedpairs


text:
typedef enum
{
	BubbleTypeLefthand = 0,
	BubbleTypeRighthand,
}
BubbleType;

// A UIView that shows a speech bubble
@interface SpeechBubbleView : UIView

// Calculates how big the speech bubble needs to be to fit the specified text
+ (CGSize)sizeForText:(NSString*)text;

// Configures the speech bubble
- (void)setText:(NSString*)text bubbleType:(BubbleType)bubbleType;

@end


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <title></title>

    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">

    <link href="../../css/header.css" rel="stylesheet">

                <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
                    Toggle navigation

                </button>
                Polar Data Visualizations

Bar Chart

Word Cloud

Bubble Chart

Line Chart

Dendrogram

Chord Diagram

Developed by: TEAM 16 - Aravind Ram, Girish Rao & Sandeep Kulkarni


text:
package com.amihaiemil.charles.rest.model;

import javax.json.Json;

import org.hamcrest.MatcherAssert;
import org.hamcrest.Matchers;
import org.junit.Test;

/**
 * Unit tests for {@link IssueCommentNotification}
 * @author Mihai Andronache (amihaiemil@gmail.com)
 * @version $Id$
 * @since 1.0.2
 *
 */
public final class IssueCommentNotificationTestCase {

    /**
     * A IssueCommentNotification has an issue number.
     */
    @Test
    public void hasIssueNumber() {
        final Notification notification = new IssueCommentNotification(
            Json.createObjectBuilder()
                .add(
                    "issue",
                    Json.createObjectBuilder().add("number", 456).build()
                )
                .build()
        );
        MatcherAssert.assertThat(notification.issueNumber(), Matchers.is(456));
    }

    /**
     * A IssueCommentNotification has a repository fullname.
     */
    @Test
    public void hasRepoFullName() {
        final Notification notification = new IssueCommentNotification(
            Json.createObjectBuilder()
                .add(
                    "repository",
                    Json.createObjectBuilder().add("full_name", "jeff/test").build()
                )
                .build()
        );
        MatcherAssert.assertThat(notification.repoFullName(), Matchers.equalTo("jeff/test"));
    }

    /**
     * A IssueCommentNotification has all its attributes.
     */
    @Test
    public void isComplete() {
        final Notification notification = new IssueCommentNotification(
            Json.createObjectBuilder()
                .add(
                    "issue",
                    Json.createObjectBuilder().add("number", 899).build()
                )
                .add(
                    "repository",
                    Json.createObjectBuilder().add("full_name", "jeff/test").build()
                )
                .build()
        );
        MatcherAssert.assertThat(notification.issueNumber(), Matchers.is(899));
        MatcherAssert.assertThat(notification.repoFullName(), Matchers.equalTo("jeff/test"));
    }
}


text:
<?php

namespace Owl\Di;

interface ContainerInterface
{

    /**
     * @param string $name
     * @param mixed $definition
     */
    public function setService($name, $definition);

    /**
     * @param string $name
     * @param mixed $definition
     */
    public function set($name, $definition);

    /**
     * @param string $name
     * @return bool
     */
    public function has($name);

    /**
     * @param string $name
     * @return object
     */
    public function get($name);

    /**
     * @param string $name
     * @return object
     */
    public function getService($name);

}


text:
namespace util {
	VkCommandBuffer createCommandBuffer(VkDevice device, VkCommandPool cmdPool, VkCommandBufferLevel level, bool begin) {
		VkCommandBuffer cmdBuffer;

		VkCommandBufferAllocateInfo cmdBufAllocateInfo =
			vkTools::initializers::commandBufferAllocateInfo(
				cmdPool,
				level,
				1);

		VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &cmdBuffer));

		// If requested, also start the new command buffer
		if (begin) {
			VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
			VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
		}

		return cmdBuffer;
	}

	void flushCommandBuffer(VkDevice device, VkCommandPool cmdPool, VkCommandBuffer commandBuffer, VkQueue queue, bool free) {
		if (commandBuffer == VK_NULL_HANDLE) {
			return;
		}

		VK_CHECK_RESULT(vkEndCommandBuffer(commandBuffer));

		VkSubmitInfo submitInfo = {};
		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submitInfo.commandBufferCount = 1;
		submitInfo.pCommandBuffers = &commandBuffer;

		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
		VK_CHECK_RESULT(vkQueueWaitIdle(queue));

		if (free) {
			vkFreeCommandBuffers(device, cmdPool, 1, &commandBuffer);
		}
	}

	VkPipelineShaderStageCreateInfo loadShader(VkDevice device, std::string fileName, VkShaderStageFlagBits stage, std::vector<VkShaderModule> *cleanupList) {
		VkPipelineShaderStageCreateInfo shaderStage = {};
		shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
		shaderStage.stage = stage;
		shaderStage.module = vkTools::loadShader(fileName.c_str(), device, stage);
		shaderStage.pName = "main";
		assert(shaderStage.module != NULL);
		if (cleanupList != NULL) {
			cleanupList->push_back(shaderStage.module);
		}
		return shaderStage;
	}

	const std::string getAssetPath() {
		return "./../data/";
	}
}


text:
<?php

namespace Rds\Request\V20140815;

class ModifyDBInstanceNetworkTypeRequest extends \RpcAcsRequest
{
	function  __construct()
	{
		parent::__construct("Rds", "2014-08-15", "ModifyDBInstanceNetworkType", "rds", "openAPI");
		$this->setMethod("POST");
	}

	private  $resourceOwnerId;

	private  $resourceOwnerAccount;

	private  $ownerAccount;

	private  $ownerId;

	private  $vSwitchId;

	private  $privateIpAddress;

	private  $retainClassic;

	private  $classicExpiredDays;

	private  $vPCId;

	private  $dBInstanceId;

	private  $readWriteSplittingPrivateIpAddress;

	private  $instanceNetworkType;

	private  $readWriteSplittingClassicExpiredDays;

	public function getResourceOwnerId() {
		return $this->resourceOwnerId;
	}

	public function setResourceOwnerId($resourceOwnerId) {
		$this->resourceOwnerId = $resourceOwnerId;
		$this->queryParameters["ResourceOwnerId"]=$resourceOwnerId;
	}

	public function getResourceOwnerAccount() {
		return $this->resourceOwnerAccount;
	}

	public function setResourceOwnerAccount($resourceOwnerAccount) {
		$this->resourceOwnerAccount = $resourceOwnerAccount;
		$this->queryParameters["ResourceOwnerAccount"]=$resourceOwnerAccount;
	}

	public function getOwnerAccount() {
		return $this->ownerAccount;
	}

	public function setOwnerAccount($ownerAccount) {
		$this->ownerAccount = $ownerAccount;
		$this->queryParameters["OwnerAccount"]=$ownerAccount;
	}

	public function getOwnerId() {
		return $this->ownerId;
	}

	public function setOwnerId($ownerId) {
		$this->ownerId = $ownerId;
		$this->queryParameters["OwnerId"]=$ownerId;
	}

	public function getVSwitchId() {
		return $this->vSwitchId;
	}

	public function setVSwitchId($vSwitchId) {
		$this->vSwitchId = $vSwitchId;
		$this->queryParameters["VSwitchId"]=$vSwitchId;
	}

	public function getPrivateIpAddress() {
		return $this->privateIpAddress;
	}

	public function setPrivateIpAddress($privateIpAddress) {
		$this->privateIpAddress = $privateIpAddress;
		$this->queryParameters["PrivateIpAddress"]=$privateIpAddress;
	}

	public function getRetainClassic() {
		return $this->retainClassic;
	}

	public function setRetainClassic($retainClassic) {
		$this->retainClassic = $retainClassic;
		$this->queryParameters["RetainClassic"]=$retainClassic;
	}

	public function getClassicExpiredDays() {
		return $this->classicExpiredDays;
	}

	public function setClassicExpiredDays($classicExpiredDays) {
		$this->classicExpiredDays = $classicExpiredDays;
		$this->queryParameters["ClassicExpiredDays"]=$classicExpiredDays;
	}

	public function getVPCId() {
		return $this->vPCId;
	}

	public function setVPCId($vPCId) {
		$this->vPCId = $vPCId;
		$this->queryParameters["VPCId"]=$vPCId;
	}

	public function getDBInstanceId() {
		return $this->dBInstanceId;
	}

	public function setDBInstanceId($dBInstanceId) {
		$this->dBInstanceId = $dBInstanceId;
		$this->queryParameters["DBInstanceId"]=$dBInstanceId;
	}

	public function getReadWriteSplittingPrivateIpAddress() {
		return $this->readWriteSplittingPrivateIpAddress;
	}

	public function setReadWriteSplittingPrivateIpAddress($readWriteSplittingPrivateIpAddress) {
		$this->readWriteSplittingPrivateIpAddress = $readWriteSplittingPrivateIpAddress;
		$this->queryParameters["ReadWriteSplittingPrivateIpAddress"]=$readWriteSplittingPrivateIpAddress;
	}

	public function getInstanceNetworkType() {
		return $this->instanceNetworkType;
	}

	public function setInstanceNetworkType($instanceNetworkType) {
		$this->instanceNetworkType = $instanceNetworkType;
		$this->queryParameters["InstanceNetworkType"]=$instanceNetworkType;
	}

	public function getReadWriteSplittingClassicExpiredDays() {
		return $this->readWriteSplittingClassicExpiredDays;
	}

	public function setReadWriteSplittingClassicExpiredDays($readWriteSplittingClassicExpiredDays) {
		$this->readWriteSplittingClassicExpiredDays = $readWriteSplittingClassicExpiredDays;
		$this->queryParameters["ReadWriteSplittingClassicExpiredDays"]=$readWriteSplittingClassicExpiredDays;
	}

}


text:
WebGL Conformance Test Harness
==============================

Simple test harness to automate execution of WebGL conformance tests across
several browsers.

Installation
------------

Make sure you have a reasonably new [Node.JS installed](http://nodejs.org/),
then run:

    cd <WebGL>/other/test-runner
    npm install

Once installed you may need to adjust the paths in
`test-runner/config.json` to ensure they are correct for your system. The
Linux paths in particular are especially likely to need adjustment. On
Windows the paths will need to be adjusted if you have done a per-user
installation of Chrome, rather than a machine-wide installation. The test
runner tries the paths in the list one by one until it finds one that exists.

Running
-------

    cd <WebGL>/other
    node ./test-runner

Run with `--help` to see command line options.

Currently supported browser configurations:

    Chrome
    ChromeCanary
    Chromium
    Firefox
    Safari

NOTE: The Safari configuration is able to execute the tests, but has
several known issues, including potentially interfering with an
already-running instance of the browser. Make sure you quit Safari before
running this test harness against Safari.

The configurations above use the browser's default mechanism for rendering
WebGL. Both Firefox and Chrome by default use the ANGLE library on Windows, and
OpenGL on Mac and Linux platforms. You can force the use of OpenGL on Windows
using the following browser configurations:

    ChromeWinOpenGL
    ChromeCanaryWinOpenGL
    ChromiumWinOpenGL
    FirefoxWinOpenGL

The test runner supports following browser configurations on Android:

    Chrome

NOTE: The platform argument needs to be explicitly passed as 'remote-android'
to run tests remotely on android. To do this, you need the following:

  - Rooted android device connected to linux host machine
  - Chrome application installed on connected device
  - Android SDK installed on your host linux machine
  - 'adb' in your system path
  - The 'ant' build system installed in case you want to modify the prebuilt
    port forwarder apk, see ./android/PortForwarderService/README for more
    details.

The Android test runner has some limitations: it does not detect browser
crashes, and the Chrome configuration overwrites command line parameters set for
Chrome in /data/local/chrome-command-line.

Example invocations:

    node ./test-runner
    node ./test-runner --version 1.0.1 --browser Chrome
    node ./test-runner --browser Chrome --platform remote-android

Results
-------

Returns exit code 0 if all tests passed in all browser configurations.
Returns non-zero exit code otherwise.

The exit code can be tested via the $? variable in most Unix shells, and
via the %errorlevel% pseudo environment variable in the Windows Command
Prompt. See:
http://stackoverflow.com/questions/334879/how-do-i-get-the-application-exit-code-from-a-windows-command-line

Test results are output as plain text files into
`<WebGL>/other/test-runner/output`


text:
package info.gianlucacosta.chronos.ast.exceptions

class DuplicateParameterException(val procedureName: String, val param: String) extends DuplicateIdentifierException(
  s"Duplicate parameter '${param}' for procedure '${procedureName}'"
)


text:
<?php

/**
 * @group formatting
 */
class Tests_Formatting_Slashit extends WP_UnitTestCase {
	function test_backslashes_middle_numbers() {
		$this->assertEquals("\\a-!9\\a943\\b\\c", backslashit("a-!9a943bc"));
	}

	function test_backslashes_alphas() {
		$this->assertEquals("\\a943\\b\\c", backslashit("a943bc"));
	}

	function test_double_backslashes_leading_numbers() {
		$this->assertEquals("\\\\95", backslashit("95"));
	}

	function test_removes_trailing_slashes() {
		$this->assertEquals("a", untrailingslashit("a/"));
		$this->assertEquals("a", untrailingslashit("a////"));
	}

	/**
	 * @ticket 22267
	 */
	function test_removes_trailing_backslashes() {
		$this->assertEquals("a", untrailingslashit("a\\"));
		$this->assertEquals("a", untrailingslashit("a\\\\\\\\"));
	}

	/**
	 * @ticket 22267
	 */
	function test_removes_trailing_mixed_slashes() {
		$this->assertEquals("a", untrailingslashit("a/\\"));
		$this->assertEquals("a", untrailingslashit("a\\/\\///\\\\//"));
	}

	function test_adds_trailing_slash() {
		$this->assertEquals("a/", trailingslashit("a"));
	}

	function test_does_not_add_trailing_slash_if_one_exists() {
		$this->assertEquals("a/", trailingslashit("a/"));
	}

	/**
	 * @ticket 22267
	 */
	function test_converts_trailing_backslash_to_slash_if_one_exists() {
		$this->assertEquals("a/", trailingslashit("a\\"));
	}
}


text:
smalltalk.addPackage('Helios-Commands-Browser');
smalltalk.addClass('HLBrowserCommand', smalltalk.HLToolCommand, [], 'Helios-Commands-Browser');

smalltalk.addMethod(
smalltalk.method({
selector: "isValidFor:",
fn: function (aModel){
var self=this;
return smalltalk.withContext(function($ctx1) {
var $1;
$1=_st(aModel)._isBrowserModel();
return $1;
}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},smalltalk.HLBrowserCommand.klass)})},
messageSends: ["isBrowserModel"]}),
smalltalk.HLBrowserCommand.klass);

smalltalk.addClass('HLBrowserGoToCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');

smalltalk.addMethod(
smalltalk.method({
selector: "isValidFor:",
fn: function (aModel){
var self=this;
return smalltalk.withContext(function($ctx1) {
var $1;
$1=_st(aModel)._isBrowserModel();
return $1;
}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},smalltalk.HLBrowserGoToCommand.klass)})},
messageSends: ["isBrowserModel"]}),
smalltalk.HLBrowserGoToCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "g";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLBrowserGoToCommand.klass)})},
messageSends: []}),
smalltalk.HLBrowserGoToCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Go to";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLBrowserGoToCommand.klass)})},
messageSends: []}),
smalltalk.HLBrowserGoToCommand.klass);

smalltalk.addClass('HLGoToClassesCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._focusOnClasses();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToClassesCommand)})},
messageSends: ["focusOnClasses", "model"]}),
smalltalk.HLGoToClassesCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "c";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToClassesCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToClassesCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Classes";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToClassesCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToClassesCommand.klass);

smalltalk.addClass('HLGoToMethodsCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._focusOnMethods();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToMethodsCommand)})},
messageSends: ["focusOnMethods", "model"]}),
smalltalk.HLGoToMethodsCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "m";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToMethodsCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToMethodsCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Methods";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToMethodsCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToMethodsCommand.klass);

smalltalk.addClass('HLGoToPackagesCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._focusOnPackages();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToPackagesCommand)})},
messageSends: ["focusOnPackages", "model"]}),
smalltalk.HLGoToPackagesCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "p";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToPackagesCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToPackagesCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Packages";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToPackagesCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToPackagesCommand.klass);

smalltalk.addClass('HLGoToProtocolsCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._focusOnProtocols();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToProtocolsCommand)})},
messageSends: ["focusOnProtocols", "model"]}),
smalltalk.HLGoToProtocolsCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "t";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToProtocolsCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToProtocolsCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Protocols";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToProtocolsCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToProtocolsCommand.klass);

smalltalk.addClass('HLGoToSourceCodeCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._focusOnSourceCode();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToSourceCodeCommand)})},
messageSends: ["focusOnSourceCode", "model"]}),
smalltalk.HLGoToSourceCodeCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "s";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLGoToSourceCodeCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToSourceCodeCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Source code";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLGoToSourceCodeCommand.klass)})},
messageSends: []}),
smalltalk.HLGoToSourceCodeCommand.klass);

smalltalk.addClass('HLEditCommentCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._editComment();
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLEditCommentCommand)})},
messageSends: ["editComment", "model"]}),
smalltalk.HLEditCommentCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "isActive",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
var $1;
$1=_st(_st(self._model())._showComment())._and_((function(){
return smalltalk.withContext(function($ctx2) {
return _st(_st(self._model())._selectedClass())._notNil();
}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
return $1;
}, function($ctx1) {$ctx1.fill(self,"isActive",{},smalltalk.HLEditCommentCommand)})},
messageSends: ["and:", "notNil", "selectedClass", "model", "showComment"]}),
smalltalk.HLEditCommentCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "d";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLEditCommentCommand.klass)})},
messageSends: []}),
smalltalk.HLEditCommentCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Edit documentation";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLEditCommentCommand.klass)})},
messageSends: []}),
smalltalk.HLEditCommentCommand.klass);

smalltalk.addClass('HLToggleCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "t";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Toggle";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleCommand.klass);

smalltalk.addClass('HLToggleClassCommentCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._showComment_(_st(_st(self._model())._showComment())._not());
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleClassCommentCommand)})},
messageSends: ["showComment:", "not", "showComment", "model"]}),
smalltalk.HLToggleClassCommentCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "d";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleClassCommentCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleClassCommentCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Documentation";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleClassCommentCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleClassCommentCommand.klass);

smalltalk.addClass('HLToggleClassSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._showInstance_(false);
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleClassSideCommand)})},
messageSends: ["showInstance:", "model"]}),
smalltalk.HLToggleClassSideCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "c";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleClassSideCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleClassSideCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Class side";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleClassSideCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleClassSideCommand.klass);

smalltalk.addClass('HLToggleInstanceSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
smalltalk.addMethod(
smalltalk.method({
selector: "execute",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
_st(self._model())._showInstance_(true);
return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleInstanceSideCommand)})},
messageSends: ["showInstance:", "model"]}),
smalltalk.HLToggleInstanceSideCommand);

smalltalk.addMethod(
smalltalk.method({
selector: "key",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "i";
}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLToggleInstanceSideCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleInstanceSideCommand.klass);

smalltalk.addMethod(
smalltalk.method({
selector: "label",
fn: function (){
var self=this;
return smalltalk.withContext(function($ctx1) {
return "Instance side";
}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLToggleInstanceSideCommand.klass)})},
messageSends: []}),
smalltalk.HLToggleInstanceSideCommand.klass);


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="3dp">

    <me.himanshusoni.chatmessageview.ChatMessageView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:cmv_arrowGravity="start"
        app:cmv_arrowPosition="left"
        android:id="@+id/chatMessageView"
        app:cmv_backgroundColor="#8800bcd4"
        app:cmv_backgroundColorPressed="#ff00bcd4"
        app:cmv_contentPadding="3dp"
        app:cmv_cornerRadius="3dp"
        app:cmv_showArrow="true">

        <ImageView
            android:layout_width="64dp"
            android:layout_height="64dp"
            android:background="#aaffffff"
            android:src="@drawable/dzw" />
    </me.himanshusoni.chatmessageview.ChatMessageView>

</LinearLayout>