text:
var fs            = require('fs')
  , path          = require('path')
  , underscore    = require('underscore')
  , defaultConfig = require(path.join(__dirname, '..', '..', 'config', 'default.json'))
  , configFile    = null
  , config        = {};

module.exports    = {
  config: {
    cleverAuthConfigPrompt: {
      options: {
        questions: [
          // Environment
          {
            type    : 'list',
            config  : 'authConfig.environment',
            message : 'What environment is this configuration for?',
            choices : [
              { name: 'LOCAL' },
              { name: 'TEST' },
              { name: 'DEV' },
              { name: 'STAG' },
              { name: 'PROD' }
            ],
            default : process.env.NODE_ENV ? process.env.NODE_ENV.toUpperCase() : 'LOCAL',
            filter  : function(env) {
              underscore.extend(config, defaultConfig);

              configFile = path.resolve(path.join(process.cwd(), 'config', env.toLowerCase() + '.json'));

              if (fs.existsSync(configFile)) {
                underscore.extend(config, require(configFile));

                Object.keys(defaultConfig['clever-auth']).forEach(function(key) {
                  if (typeof config['clever-auth'][key] === 'undefined') {
                    config['clever-auth'][key] = defaultConfig['clever-auth'][key];
                  }
                });
              }

              return true;
            }
          },
          // Secret Key
          {
            type    : 'input',
            config  : 'authConfig.secretKey',
            message : 'Secret key used to secure your passport sessions',
            default : function() {
              var secretKey = config['clever-auth'].secretKey !== '' ? config['clever-auth'].secretKey : '';

              if (secretKey === '') {
                var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

                for(var i=0; i < 20; i++) {
                  secretKey += possible.charAt(Math.floor(Math.random() * possible.length));
                }
              }

              return secretKey;
            }
          },
          // Session Store
          {
            type    : 'list',
            config  : 'authConfig.store',
            message : 'Session Storage Driver',
            choices : [
              { name: 'redis' },
              { name: 'memcache' },
              { name: 'in-memory' }
            ],
            default : function() {
              return config['clever-auth'].store !== '' ? config['clever-auth'].store : 'redis';
            }
          },

          // Redis Session Store
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'redis';
            },
            config  : 'authConfig.redis.host',
            message : 'Redis host',
            default : function() {
              return config['clever-auth'].redis.host !== '' ? config['clever-auth'].redis.host : 'localhost';
            }
          },
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'redis';
            },
            config  : 'authConfig.redis.port',
            message : 'Redis port',
            default : function() {
              return config['clever-auth'].redis.port !== '' ? config['clever-auth'].redis.port : '6379';
            }
          },
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'redis';
            },
            config  : 'authConfig.redis.prefix',
            message : 'Redis prefix',
            default : function() {
              return config['clever-auth'].redis.prefix !== '' ? config['clever-auth'].redis.prefix : '';
            }
          },
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'redis';
            },
            config  : 'authConfig.redis.key',
            message : 'Redis key',
            default : function() {
              return config['clever-auth'].redis.key !== '' ? config['clever-auth'].redis.key : '';
            }
          },

          // Memcached Session Store
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'memcache';
            },
            config  : 'authConfig.memcache.host',
            message : 'Memcache host',
            default : function() {
              return config['clever-auth'].memcache.host !== '' ? config['clever-auth'].memcache.host : 'localhost';
            }
          },
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'memcache';
            },
            config  : 'authConfig.memcache.port',
            message : 'Memcache port',
            default : function() {
              return config['clever-auth'].memcache.port !== '' ? config['clever-auth'].memcache.port : '11211';
            }
          },
          {
            type    : 'input',
            when    : function(answers) {
              return answers['authConfig.store'] === 'memcache';
            },
            config  : 'authConfig.memcache.prefix',
            message : 'Memcache prefix',
            default : function() {
              return config['clever-auth'].memcache.prefix !== '' ? config['clever-auth'].memcache.prefix : '';
            }
          }
        ]
      }
    }
  },
  register: function(grunt) {
    grunt.loadNpmTasks('grunt-prompt');

    grunt.registerTask('prompt:cleverAuthConfig', ['prompt:cleverAuthConfigPrompt', 'createCleverAuthConfig']);
    grunt.registerTask('createCleverAuthConfig', 'Adds the config for cleverAuth to the designated environment', function createCleverAuthConfig() {
      var conf = grunt.config('authConfig');

      delete conf.environment;

      config['clever-auth'] = underscore.extend(config['clever-auth'], conf);

      if (config['clever-auth'].store !== 'redis') {
        delete config['clever-auth'].redis;
      }

      if (config['clever-auth'].store !== 'memcache') {
        delete config['clever-auth'].memcache;
      }

      fs.writeFileSync(configFile, JSON.stringify(config, null, '  '));
    });
  }
};


text:
package com.dianping.cat.report.page.metric.task;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.unidal.lookup.annotation.Named;

@Named(type = BaselineCreator.class)
public class DefaultBaselineCreator implements BaselineCreator {

	public double computeAvg(List<Double> data) {
		Collections.sort(data);
		int length = data.size();
		double value = 0;
		int middle = length / 2;

		if (length % 2 == 0) {
			value = (data.get(middle - 1) + data.get(middle)) / 2;
		} else {
			value = data.get(middle);
		}

		int size = 0;
		double sum = 0;

		for (double d : data) {
			if (d > value * 3 || d < value / 3) {
				continue;
			} else {
				size++;
				sum = sum + d;
			}
		}
		return sum / size;
	}

	@Override
	public double[] createBaseLine(List<double[]> valueList, List<Double> weights, int number) {
		double[] result = new double[number];

		for (int i = 0; i < number; i++) {
			double totalValue = 0;
			double totalWeight = 0;

			for (int j = 0; j < valueList.size(); j++) {
				double[] values = valueList.get(j);
				double weight = weights.get(j);

				if (values[i] > 0) {
					totalValue += values[i] * weight;
					totalWeight += weight;
				}
			}
			if (totalWeight == 0) {
				if (i != 0) {
					result[i] = result[i - 1];
				} else {
					result[i] = 0;
				}
			} else {
				result[i] = totalValue / totalWeight;
			}
		}
		return denoise(result, 30);
	}

	public double[] denoise(double[] data, int mixNumber) {
		if (mixNumber <= 2) {
			return data;
		}
		int number = data.length;
		double[] result = new double[number];
		boolean first = true;
		boolean last = false;

		for (int i = 0; i < number - mixNumber; i++) {
			if (i == number - mixNumber - 1) {
				last = true;
			}

			List<Double> mixNumbers = new ArrayList<Double>();
			for (int j = 0; j < mixNumber; j++) {
				int position = i + j;

				mixNumbers.add(data[position]);
			}
			double avg = computeAvg(mixNumbers);
			result[i + mixNumber / 2] = avg;

			if (first) {
				first = false;

				for (int k = 0; k < mixNumber / 2; k++) {
					result[k] = avg;
				}
			}
			if (last) {
				for (int k = i + mixNumber / 2 + 1; k < number; k++) {
					result[k] = avg;
				}
			}
		}
		return result;
	}

}

redpajama_set_name: RedPajamaGithub


text:
<?php

/**
 * @category   Zend
 * @package    Zend_Service
 * @subpackage DeveloperGarden
 * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @author     Marco Kaiser
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Zend_Service_DeveloperGarden_BaseUserService_AccountBalance
{
    /**
     * @var integer
     */
    public $Account = null;

    /**
     * @var integer $Credits
     */
    public $Credits = null;

    /**
     * returns the account id
     *
     * @return integer
     */
    public function getAccount()
    {
        return $this->Account;
    }

    /**
     * returns the credits
     *
     * @return integer
     */
    public function getCredits()
    {
        return $this->Credits;
    }
}


text:
import type { Node as ReactNode } from 'react';

export type RenderCallback = {
  // $FlowFixMe
  render: (data: any) => ReactNode;
}

export type Entry = {
  getIn: (string[]) => string;
}

export type WidgetFor = (string) => string;

export type PageContext = {
  tag: string,
  category: string,
  currentPage: number,
  prevPagePath: string,
  nextPagePath: string,
  hasPrevPage: boolean,
  hasNextPage: boolean
};

export type Node = {
  fields: {
    slug: string,
    categorySlug?: string,
    tagSlugs?: string[]
  },
  frontmatter: {
    date: string,
    description?: string,
    category?: string,
    tags?: string[],
    title: string,
    socialImage?: {
      publicURL: string
    }
  },
  html: string,
  id: string
};

export type Edge = {
  node: Node
};

export type Edges = Array<Edge>;

export type AllMarkdownRemark = {
  allMarkdownRemark: {
    edges: Edges,
  },
  group: {
    fieldValue: string,
    totalCount: number
  }[]
};

export type MarkdownRemark = Node;


text:
package com.jetbrains.jython;

import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
import com.intellij.testFramework.JavaResolveTestCase;
import com.intellij.testFramework.PsiTestUtil;
import com.intellij.testFramework.TestDataPath;
import com.intellij.util.containers.ContainerUtil;
import com.jetbrains.python.PythonHelpersLocator;
import com.jetbrains.python.psi.PyFile;
import org.jetbrains.annotations.NotNull;

import java.util.List;

/**
 * @author yole
 */
@TestDataPath("$CONTENT_ROOT/../testData/resolve/pyToJava/")
public class PyToJavaResolveTest extends JavaResolveTestCase {
  private PsiElement resolve() throws Exception {
    PsiReference ref = configureByFile(getTestName(false) + ".py");
    return ref.resolve();
  }

  public void testSimple() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiClass);
    assertEquals("java.util.ArrayList", ((PsiClass) target).getQualifiedName());
  }

  public void testMethod() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiMethod);
    assertEquals("java.util.ArrayList", ((PsiMethod) target).getContainingClass().getQualifiedName());
  }

  public void testField() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiField);
    assertEquals("java.lang.System", ((PsiField) target).getContainingClass().getQualifiedName());
  }

  public void testReturnValue() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiMethod);
    assertEquals(CommonClassNames.JAVA_UTIL_LIST, ((PsiMethod) target).getContainingClass().getQualifiedName());
  }

  public void testPackageType() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiClass);
    assertEquals("java.util.ArrayList", ((PsiClass) target).getQualifiedName());
  }

  public void testJavaPackage() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiPackage);
    assertEquals("java", ((PsiPackage) target).getQualifiedName());
  }

  public void testJavaLangPackage() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiPackage);
    assertEquals("java.lang", ((PsiPackage) target).getQualifiedName());
  }

  public void testSuperMethod() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiMethod);
    assertEquals("size", ((PsiMethod) target).getName());
  }

  public void testFieldType() throws Exception {
    PsiElement target = resolve();
    assertTrue(target instanceof PsiMethod);
    assertEquals("println", ((PsiMethod) target).getName());
  }

  // PY-23265, PY-23857
  public void testPurePythonSymbolsFirst() throws Exception {
    final LocalFileSystem fs = LocalFileSystem.getInstance();
    final VirtualFile tmpDir = fs.findFileByIoFile(createTempDirectory());
    copyDirContentsTo(fs.findFileByPath(getTestDataPath() + getTestName(true)), tmpDir);
    PsiTestUtil.addSourceRoot(getModule(), tmpDir.findChild("src"));

    final PsiReference ref = configureByFile(getTestName(true) + "/src/main.py", tmpDir);
    final PsiPolyVariantReference multiRef = (PsiPolyVariantReference)ref;
    final ResolveResult[] results = multiRef.multiResolve(false);
    final List<PsiElement> targets = ContainerUtil.map(results, ResolveResult::getElement);

    assertSize(2, targets);
    assertInstanceOf(targets.get(0), PyFile.class);
    assertInstanceOf(targets.get(1), PsiPackage.class);
  }

  @NotNull
  @Override
  protected String getTestDataPath() {
    return PythonHelpersLocator.getPythonCommunityPath() + "/testData/resolve/pyToJava/";
  }
}


text:
class Channel
  include DataMapper::Resource
  property :id, Serial
  property :name, String, :length => 512
  timestamps :at

  validates_presence_of :name

  has n, :applications
  has n, :configurations

  class Entity < Grape::Entity
    expose :id, :name
    expose :applications, :using => Application::Entity
    expose :configurations, :using => Configuration::Entity
  end
end


text:
START_ATF_NAMESPACE
    #pragma pack(push, 8)
    struct strFILE
    {
        strFILEVtbl *vfptr;
        char *m_pLoadStr;
        char *m_pReadStr;
        unsigned int m_dwLoadSize;
    public:
        bool load(char* pszFileName);
        int read_line_count();
        strFILE();
        void ctor_strFILE();
        bool word(char* poutszWord);
        bool word(long double* pdoutVal);
        bool word(float* pfoutVal);
        bool word(int* pnoutVal);
        ~strFILE();
        void dtor_strFILE();
    };
    #pragma pack(pop)
    static_assert(ATF::checkSize<strFILE, 32>(), "strFILE");
END_ATF_NAMESPACE


text:
<?php

namespace jugger\db\tools;

class MysqlColumnInfo implements ColumnInfoInterface
{
    public $data;

    public function __construct(array $data)
    {
        $this->data = $data;
    }

    public function getName(): string
    {
        return $this->data['Field'];
    }

    public function getType(): string
    {
        $type = $this->data['Type'];

        if (preg_match('/^int\(.*/', $type)) {
            return self::TYPE_INT;
        }
        if (preg_match('/^char\(.*/', $type)) {
            return self::TYPE_TEXT;
        }
        if (preg_match('/^varchar\(.*/', $type)) {
            return self::TYPE_TEXT;
        }

        switch ($type) {
            case 'text':
                return self::TYPE_TEXT;
            case 'blob':
                return self::TYPE_BLOB;
            case 'value':
                return self::TYPE_FLOAT;
            case 'date':
            case 'timestamp':
                return self::TYPE_DATETIME;
            default:
                return self::TYPE_TEXT;
        }
    }

    public function getSize(): int
    {
        $type = $this->data['Type'];
        $size = 0;
        if (preg_match('/.+\((\d+).+$/', $type, $m)) {
            $size = (int) $m[1];
        }

        return $size;
    }

    public function getKey(): int
    {
        switch ($this->data['Key']) {
            case 'PRI':
                return self::KEY_PRIMARY;
            case 'UNI':
                return self::KEY_UNIQUE;
            default:
                return -1;
        }
    }

    public function getIsNull(): bool
    {
        return $this->data['Null'] == "YES";
    }

    public function getDefault(): string
    {
        return (string) $this->data['Default'];
    }

    public function getOther(): string
    {
        return $this->data["Extra"];
    }
}


text:
package com.amazonaws.services.ec2.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.Request;
import com.amazonaws.DefaultRequest;
import com.amazonaws.http.HttpMethodName;
import com.amazonaws.services.ec2.model.*;
import com.amazonaws.transform.Marshaller;
import com.amazonaws.util.StringUtils;

/**
 * DeleteCoipCidrRequest Marshaller
 */

@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class DeleteCoipCidrRequestMarshaller implements Marshaller<Request<DeleteCoipCidrRequest>, DeleteCoipCidrRequest> {

    public Request<DeleteCoipCidrRequest> marshall(DeleteCoipCidrRequest deleteCoipCidrRequest) {

        if (deleteCoipCidrRequest == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        Request<DeleteCoipCidrRequest> request = new DefaultRequest<DeleteCoipCidrRequest>(deleteCoipCidrRequest, "AmazonEC2");
        request.addParameter("Action", "DeleteCoipCidr");
        request.addParameter("Version", "2016-11-15");
        request.setHttpMethod(HttpMethodName.POST);

        if (deleteCoipCidrRequest.getCidr() != null) {
            request.addParameter("Cidr", StringUtils.fromString(deleteCoipCidrRequest.getCidr()));
        }

        if (deleteCoipCidrRequest.getCoipPoolId() != null) {
            request.addParameter("CoipPoolId", StringUtils.fromString(deleteCoipCidrRequest.getCoipPoolId()));
        }

        return request;
    }

}


text:
import fileinput

"""Prints short hashes of files in a datafile generated with the file_counts.py
script."""

for line in fileinput.input():
    hsh, count, size = line.strip().split("  ")
    sh = int(hsh, 16) >> (160 - 13)
    print(sh)


text:
#!/bin/sh

# (C) 2002-2003 Dan Allen and Stefan Kamphausen

# Written by Dan Allen <dan@mojavelinux.com>
# - small additions by Stefan Kamphausen
# - better completion code by Robi Malik robi.malik@nexgo.de
# - trailing path support by Damon Harper <ds+dev-cdargs@usrbin.ca> Feb 2006

# Globals
CDARGS_SORT=0   # set to 1 if you want mark to sort the list
CDARGS_NODUPS=1 # set to 1 if you want mark to delete dups

# --------------------------------------------- #
# Run the cdargs program to get the target      #
# directory to be used in the various context   #
# This is the fundamental core of the           #
# bookmarking idea.  An alias or substring is   #
# expected and upon receiving one it either     #
# resolves the alias if it exists or opens a    #
# curses window with the narrowed down options  #
# waiting for the user to select one.           #
#                                               #
# @param  string alias                          #
#                                               #
# @access private                               #
# @return 0 on success, >0 on failure           #
# --------------------------------------------- #
function _cdargs_get_dir ()
{
    local bookmark extrapath
    # if there is one exact match (possibly with extra path info after it),
    # then just use that match without calling cdargs
    if [ -e "$HOME/.cdargs" ]; then
        dir=`grep "^$1 " "$HOME/.cdargs"`
        if [ -z "$dir" ]; then
            bookmark="${1/\/*/}"
            if [ "$bookmark" != "$1" ]; then
                dir=`grep "^$bookmark " "$HOME/.cdargs"`
                extrapath=`echo "$1" | sed 's#^[^/]*/#/#'`
            fi
        fi
        [ -n "$dir" ] && dir=`echo "$dir" | sed 's/^[^ ]* //'`
    fi
    if [ -z "$dir" -o "$dir" != "${dir/
/}" ]; then
        # okay, we need cdargs to resolve this one.
        # note: intentionally retain any extra path to add back to selection.
        dir=
        if cdargs --noresolve "${1/\/*/}"; then
            dir=`cat "$HOME/.cdargsresult"`
            rm -f "$HOME/.cdargsresult";
        fi
    fi
    if [ -z "$dir" ]; then
        echo "Aborted: no directory selected" >&2
        return 1
    fi
    [ -n "$extrapath" ] && dir="$dir$extrapath"
    if [ ! -d "$dir" ]; then
        echo "Failed: no such directory '$dir'" >&2
        return 2
    fi
}

# --------------------------------------------- #
# Perform the command (cp or mv) using the      #
# cdargs bookmark alias as the target directory #
#                                               #
# @param  string command argument list          #
#                                               #
# @access private                               #
# @return void                                  #
# --------------------------------------------- #
function _cdargs_exec ()
{
    local arg dir i last call_with_browse

    # Get the last option which will be the bookmark alias
    eval last=\${$#};

    # Resolve the bookmark alias.  If it cannot resolve, the
    # curses window will come up at which point a directory
    # will need to be choosen.  After selecting a directory,
    # the function will continue and $_cdargs_dir will be set.
    if [ -e $last ]; then
        last=
    fi
    if _cdargs_get_dir "$last"; then
        # For each argument save the last, move the file given in
        # the argument to the resolved cdargs directory
        i=1;
        for arg; do
            if [ $i -lt $# ]; then
                $command "$arg" "$dir";
            fi
            let i=$i+1;
        done
    fi
}

# --------------------------------------------- #
# Prepare to move file list into the cdargs     #
# target directory                              #
#                                               #
# @param  string command argument list          #
#                                               #
# @access public                                #
# @return void                                  #
# --------------------------------------------- #
function mvb ()
{
    local command

    command='mv -i';
    _cdargs_exec $*;
}

# --------------------------------------------- #
# Prepare to copy file list into the cdargs     #
# target directory                              #
#                                               #
# @param  string command argument list          #
#                                               #
# @access public                                #
# @return void                                  #
# --------------------------------------------- #
function cpb ()
{
    local command

    command='cp -i';
    _cdargs_exec $*;
}

# --------------------------------------------- #
# Change directory to the cdargs target         #
# directory                                     #
#                                               #
# @param  string alias                          #
#                                               #
# @access public                                #
# @return void                                  #
# --------------------------------------------- #
function cdb ()
{
    local dir

    _cdargs_get_dir "$1" && cd "$dir" && echo `pwd`;
}
alias cb='cdb'
alias cv='cdb'

# --------------------------------------------- #
# Mark the current directory with alias         #
# provided and store as a cdargs bookmark       #
# directory                                     #
#                                               #
# @param  string alias                          #
#                                               #
# @access public                                #
# @return void                                  #
# --------------------------------------------- #
function mark ()
{
    local tmpfile

    # first clear any bookmarks with this same alias, if file exists
    if [[ "$CDARGS_NODUPS" && -e "$HOME/.cdargs" ]]; then
        tmpfile=`echo ${TEMP:-${TMPDIR:-/tmp}} | sed -e "s/\\/$//"`
        tmpfile=$tmpfile/cdargs.$USER.$$.$RANDOM
        grep -v "^$1 " "$HOME/.cdargs" > $tmpfile && 'mv' -f $tmpfile "$HOME/.cdargs";
    fi
    # add the alias to the list of bookmarks
    cdargs --add=":$1:`pwd`";
    # sort the resulting list
    if [ "$CDARGS_SORT" ]; then
        sort -o "$HOME/.cdargs" "$HOME/.cdargs";
    fi
}
# Oh, no! Not overwrite 'm' for stefan! This was
# the very first alias I ever wrote in my un*x
# carreer and will always be aliased to less...
# alias m='mark'

# --------------------------------------------- #
# Mark the current directory with alias         #
# provided and store as a cdargs bookmark       #
# directory but do not overwrite previous       #
# bookmarks with same name                      #
#                                               #
# @param  string alias                          #
#                                               #
# @access public                                #
# @return void                                  #
# author: SKa                                   #
# --------------------------------------------- #
function ca ()
{
    # add the alias to the list of bookmarks
    cdargs --add=":$1:`pwd`";
}

# --------------------------------------------- #
# Bash programming completion for cdargs        #
# Sets the $COMPREPLY list for complete         #
#                                               #
# @param  string substring of alias             #
#                                               #
# @access private                               #
# @return void                                  #
# --------------------------------------------- #
function _cdargs_aliases ()
{
    local cur bookmark dir strip oldIFS
    COMPREPLY=()
    if [ -e "$HOME/.cdargs" ]; then
        cur=${COMP_WORDS[COMP_CWORD]}
        if [ "$cur" != "${cur/\//}" ]; then # if at least one /
            bookmark="${cur/\/*/}"
            dir=`grep "^$bookmark " "$HOME/.cdargs" | sed 's#^[^ ]* ##'`
            if [ -n "$dir" -a "$dir" = "${dir/
/}" -a -d "$dir" ]; then
                strip="${dir//?/.}"
                oldIFS="$IFS"
                IFS='
'
                COMPREPLY=( $(
                    compgen -d "$dir`echo "$cur" | sed 's#^[^/]*##'`" \
                        | sed -e "s/^$strip/$bookmark/" -e "s/\([^\/a-zA-Z0-9#%_+\\\\,.-]\)/\\\\\\1/g" ) )
                IFS="$oldIFS"
            fi
        else
            COMPREPLY=( $( (echo $cur ; cat "$HOME/.cdargs") | \
                           awk 'BEGIN {first=1}
                                 {if (first) {cur=$0; l=length(cur); first=0}
                                 else if (substr($1,1,l) == cur) {print $1}}' ) )
        fi
    fi
    return 0
}

# --------------------------------------------- #
# Bash programming completion for cdargs        #
# Set up completion (put in a function just so  #
# `nospace' can be a local variable)            #
#                                               #
# @param  none                                  #
#                                               #
# @access private                               #
# @return void                                  #
# --------------------------------------------- #
_cdargs_complete() {
  local nospace=
  [ "${BASH_VERSINFO[0]}" -ge 3 -o \( "${BASH_VERSINFO[0]}" = 2 -a \( "${BASH_VERSINFO[1]}" = 05a -o "${BASH_VERSINFO[1]}" = 05b \) \) ] && nospace='-o nospace'
  complete $nospace -S / -X '*/' -F _cdargs_aliases cv cb cdb
}

_cdargs_complete


text:
<?xml version="1.0" encoding="UTF-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- 按下状态 -->
    <item android:drawable="@drawable/seekbar_progress_pressed" android:state_pressed="true"/>

    <!-- 普通无焦点状态 -->
    <item android:drawable="@drawable/seekbar_progress_normal" android:state_focused="false" android:state_pressed="false"/>

</selector>


text:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

namespace SnowVillage
{
    public class Moon : BaseRenderable
    {
        /// <summary>
        /// 위치
        /// </summary>
        private static Point initPos = new Point(0, 0);

        /// <summary>
        /// 이미지
        /// </summary>
        private static Bitmap image = Properties.Resources.Moon;

        #region 싱글톤 코드

        private static Moon instance;

        private Moon()
        {
            //달을 중앙 정렬 시킨다. 그냥 멋을 위해서
            pos.X = (GlobalConsts.CanvasSize.Width - image.Width) / 2 ;
            pos.Y = (GlobalConsts.CanvasSize.Height - image.Height) / 2;
        }

        public static Moon Instance()
        {
            if (instance == null)
                instance = new Moon();

            return instance;
        }

        #endregion

        public override void Render(Graphics canvas)
        {
            Point worldPoint = GetWorldPoint();
            canvas.DrawImage(Image, worldPoint.X, worldPoint.Y, Image.Width, Image.Height);

            base.Render(canvas);
        }

        public static Point InitPos
        {
            get
            {
                return initPos;
            }

            set
            {
                initPos = value;
            }
        }

        public static Bitmap Image
        {
            get
            {
                return image;
            }

            set
            {
                image = value;
            }
        }
    }
}


text:
/* CSS file */
@namespace s "library://ns.adobe.com/flex/spark";
@namespace mx "library://ns.adobe.com/flex/mx";

.centerBold {
	fontWeight: bold;
	textAlign: center;
}

mx|Alert {
	color : #000000;
	/*	backgroundAlpha: 0;*/
	backgroundColor: #ffffff;
	fontWeight:bold;
	fontFamily: Arial;
	borderAlpha: 0.1;
	cornerRadius: 5;
	borderColor: #23aae2;
	chromeColor: #23aae2;
	title-style-name : "title";
}
global
{
	chrome-color: #23aae2;
	font-family: Arial;
	font-weight: normal;
}
.myHeaderStyles {
	color: red;
	fontWeight: bold;
	background-color:red;
	background-disabled-color:red;
	area-fill:true;

}


text:
import { Command } from '@expo/commander';
import aws from 'aws-sdk';
import chalk from 'chalk';
import fs from 'fs-extra';
import inquirer from 'inquirer';
import path from 'path';

import { EXPO_DIR } from '../Constants';
import askForPlatformAsync from '../utils/askForPlatformAsync';
import askForSdkVersionAsync from '../utils/askForSDKVersionAsync';
import { link } from '../Formatter';
import Git from '../Git';
import logger from '../Logger';
import { modifySdkVersionsAsync, getSdkVersionsAsync } from '../Versions';
import { ClientBuilder, ClientBuildFlavor, Platform } from '../client-build/types';
import IosClientBuilder from '../client-build/IosClientBuilder';
import AndroidClientBuilder from '../client-build/AndroidClientBuilder';
import { getNewestSDKVersionAsync } from '../ProjectVersions';

const s3Client = new aws.S3({ region: 'us-east-1' });
const { yellow, blue, magenta } = chalk;

type ActionOptions = {
  platform?: Platform;
  release: boolean;
  flavor: ClientBuildFlavor;
};

const flavors = ['versioned', 'unversioned'];

export default (program: Command) => {
  program
    .command('client-build')
    .alias('cb')
    .description(
      'Builds Expo client for iOS simulator or APK for Android, uploads the archive to S3 and saves its url to versions endpoint.'
    )
    .option('-p, --platform [string]', 'Platform for which the client will be built.')
    .option(
      '-r, --release',
      'Whether to upload and release the client build to staging versions endpoint.',
      false
    )
    .option(
      '-f, --flavor [string]',
      `Which build flavor to use. Possible values: ${flavors}`,
      flavors[0]
    )
    .asyncAction(main);
};

async function main(options: ActionOptions) {
  const platform = options.platform || (await askForPlatformAsync());
  const sdkBranchVersion = await Git.getSDKVersionFromBranchNameAsync();

  if (options.release && !sdkBranchVersion) {
    throw new Error(`Client builds can be released only from the release branch!`);
  }
  if (!Object.values(ClientBuildFlavor).includes(options.flavor)) {
    throw new Error(`Flavor "${options.flavor}" is not valid, use one of: ${flavors}`);
  }

  const builder = getBuilderForPlatform(platform);
  const sdkVersion =
    sdkBranchVersion ||
    (await askForSdkVersionAsync(platform, await getNewestSDKVersionAsync(platform)));
  const appVersion = await builder.getAppVersionAsync();

  await buildOrUseCacheAsync(builder, options.flavor);

  if (sdkVersion && options.release) {
    await uploadAsync(builder, sdkVersion, appVersion);
    await releaseAsync(builder, sdkVersion, appVersion);
  }
}

function getBuilderForPlatform(platform: Platform): ClientBuilder {
  switch (platform) {
    case 'ios':
      return new IosClientBuilder();
    case 'android':
      return new AndroidClientBuilder();
    default: {
      throw new Error(`Platform "${platform}" is not supported yet!`);
    }
  }
}

async function askToRecreateSimulatorBuildAsync(): Promise<boolean> {
  if (process.env.CI) {
    return false;
  }
  const { createNew } = await inquirer.prompt<{ createNew: boolean }>([
    {
      type: 'confirm',
      name: 'createNew',
      message: 'Do you want to create a fresh one?',
      default: true,
    },
  ]);
  return createNew;
}

async function askToOverrideBuildAsync(): Promise<boolean> {
  if (process.env.CI) {
    // we should never override anything in CI, too easy to accidentally mess something up in prod
    return false;
  }
  const { override } = await inquirer.prompt<{ override: boolean }>([
    {
      type: 'confirm',
      name: 'override',
      message: 'Do you want to override it?',
      default: true,
    },
  ]);
  return override;
}

async function buildOrUseCacheAsync(
  builder: ClientBuilder,
  flavor: ClientBuildFlavor
): Promise<void> {
  const appPath = builder.getAppPath();

  // Build directory already exists, we could reuse that one — especially useful on the CI.
  if (await fs.pathExists(appPath)) {
    const relativeAppPath = path.relative(EXPO_DIR, appPath);
    logger.info(`Client build already exists at ${magenta.bold(relativeAppPath)}`);

    if (!(await askToRecreateSimulatorBuildAsync())) {
      logger.info('Skipped building the app, using cached build instead...');
      return;
    }
  }
  await builder.buildAsync(flavor);
}

async function uploadAsync(
  builder: ClientBuilder,
  sdkVersion: string,
  appVersion: string
): Promise<void> {
  const sdkVersions = await getSdkVersionsAsync(sdkVersion);

  // Target app url already defined in versions endpoint.
  // We make this check to reduce the risk of unintentional overrides.
  if (sdkVersions?.[`${builder.platform}ClientUrl`] === builder.getClientUrl(appVersion)) {
    logger.info(`Build ${yellow.bold(appVersion)} is already defined in versions endpoint.`);
    logger.info('The new build would be uploaded onto the same URL.');

    if (!(await askToOverrideBuildAsync())) {
      logger.warn('Refused overriding the build, exiting the proces...');
      process.exit(0);
      return;
    }
  }
  logger.info(`Uploading ${yellow.bold(appVersion)} build`);

  await builder.uploadBuildAsync(s3Client, appVersion);
}

async function releaseAsync(
  builder: ClientBuilder,
  sdkVersion: string,
  appVersion: string
): Promise<void> {
  const clientUrl = builder.getClientUrl(appVersion);

  logger.info(
    `Updating versions endpoint with client url ${blue.bold(link(clientUrl, clientUrl))}`
  );

  await updateClientUrlAndVersionAsync(builder, sdkVersion, appVersion);
}

async function updateClientUrlAndVersionAsync(
  builder: ClientBuilder,
  sdkVersion: string,
  appVersion: string
) {
  await modifySdkVersionsAsync(sdkVersion, (sdkVersions) => {
    sdkVersions[`${builder.platform}ClientUrl`] = builder.getClientUrl(appVersion);
    sdkVersions[`${builder.platform}ClientVersion`] = appVersion;
    return sdkVersions;
  });
}


text:
#include <cppmanip/clangutil/getFunctionFromAstInSelection.hpp>
#include "ParsedFunction.hpp"
#include <cppmanip/boundary/ExtractMethodError.hpp>
#include <gmock/gmock.h>
#include "../gtestdef.hpp"
#include <memory>

using namespace testing;

namespace cppmanip
{
namespace clangutil
{

struct getFunctionFromAstInSelectionTest : testing::Test
{
    std::unique_ptr<test::ParsedFunction> func;
    GetFunctionStatements getFunctionStatements;

    getFunctionFromAstInSelectionTest()
    {
        getFunctionStatements = [this](clang::FunctionDecl& f) { return getFunctionStatementsMocked(f); };
        ALLOWING_FCALL(getFunctionStatementsMocked(_)).WillRepeatedly(Return(ast::Statements()));
    }

    void parse(const std::string& source)
    {
        func.reset(new test::ParsedFunction(source));
    }
    void assertFunctionAtOffsetContainsSelection(ast::SourceOffset offset, ast::SourceOffsetRange range)
    {
        ASSERT_EQ(offset, getFunctionFromAstInSelection(func->getASTContext(), range, getFunctionStatements)->getDefinitionOffset())
            << range;
    }
    void assertFailsForSelection(ast::SourceOffsetRange range)
    {
        ASSERT_THROW(getFunctionFromAstInSelection(func->getASTContext(), range, getFunctionStatements), boundary::ExtractMethodError)
            << range;
    }

    MOCK_METHOD1(getFunctionStatementsMocked, ast::Statements(clang::FunctionDecl& ));
};

TEST_F(getFunctionFromAstInSelectionTest, should_get_the_function_containing_given_selection)
{
    parse("void f()\n{\n  /*here*/\n}\n");
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(0, { 11, 19 }));
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(0, { 13, 13 }));
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(0, { 9, 10 }));
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(0, { 22, 23 }));
}

TEST_F(getFunctionFromAstInSelectionTest, should_fail_when_the_selection_is_not_overlapping_the_body)
{
    parse("void f()\n{\n /*...*/\n}\n");
    assertFailsForSelection({1, 9});
    assertFailsForSelection({21, 22});
}

TEST_F(getFunctionFromAstInSelectionTest, should_search_through_all_the_functions)
{
    parse("void f()\n{\n \n}\nvoid g()\n{\n /*here*/ \n}\nvoid h()\n{\n \n}\n");
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(15, { 27, 35 }));
}

TEST_F(getFunctionFromAstInSelectionTest, should_ignore_functions_without_bodies)
{
    parse("void f(); void g(); void h() { \n }"); // \n is needed because of clang bug
    ASSERT_NO_THROW(assertFunctionAtOffsetContainsSelection(20, { 30, 30 }));
}

TEST_F(getFunctionFromAstInSelectionTest, should_return_all_statements_of_the_function)
{
    parse("void f() {\nint x; int y = x + 2; }");
    ast::Statements stmts(7);
    EXPECT_FCALL(getFunctionStatementsMocked(Ref(*func->getDecl()))).WillRepeatedly(Return(stmts));
    ASSERT_TRUE(stmts == *getFunctionFromAstInSelection(func->getASTContext(), { 11, 11 }, getFunctionStatements)->getStatements());
}

}
}


text:
/**
 * @author Jon Carey
 * @author Dan Nuffer
 */

#ifndef OW_INDEX_HPP_INCLUDE_GUARD_
#define OW_INDEX_HPP_INCLUDE_GUARD_
#include "OW_config.h"
#include "OW_String.hpp"
#include "OW_IntrusiveReference.hpp"
#include "OW_IntrusiveCountableBase.hpp"

namespace OW_NAMESPACE
{

struct IndexEntry;
class Index;
typedef IntrusiveReference<Index> IndexRef;

/**
 * The Index class is simply an interface class that helps facilitate a
 * pluggable architecture for an indexing scheme on file. All Index
 * objects will be used to maintain an index on some file. The only data ever
 * associated with the key of the index will be a long value that will be
 * used as an offset into a file. The implementor of the Index class must
 * implement the createIndexObject class. This class will be called to get
 * new Index objects that will later be deleted by the caller.
 * The intention is  for the implementor to create a sub-class of Index and
 * have createIndexObject be the factory for those object.
 */
class OW_HDB_API Index : public IntrusiveCountableBase
{
public:
	/**
	 * Destroy this Index object. This will close the index file if it
	 * is open.
	 */
	virtual ~Index();
	enum EDuplicateKeysFlag
	{
		E_NO_DUPLICATES,
		E_ALLDUPLICATES
	};
	/**
	 * Open the given index file.
	 * @param fileName	The file name for the index file. If the file name
	 * has an extension, it will be removed. The name of the index file will
	 * be the base of fileName with the extension ".ndx".
	 * @exception IndexException If the file cannot be created or opened.
	 */
	virtual void open(const char* fileName, EDuplicateKeysFlag allowDuplicates = E_NO_DUPLICATES) = 0;
	/**
	 * Close the underlying index file if it is open.
	 */
	virtual void close() = 0;
	/**
	 * Position the cursor on the 1st entry in the index or the first record
	 * with a given key.
	 *
	 * @param key	The key to find the first occurence of. If NULL is given,
	 * the 1st entry of the index is returned, otherwise the first entry that
	 * has a key that is greater than or equal to the key parameter.
	 *
	 * @return An IndexEntry that contains information about the 1st entry
	 * in the index on success. On failure the returned IndexEntry will be
	 * null.
	 *
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual IndexEntry findFirst(const char* key=0) = 0;
	/**
	 * Position the cursor on the next entry in the index.
	 * @return An IndexEntry that contains information about the current
	 * entry in the index on success. On failure the returned IndexEntry
	 * will be null.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual IndexEntry findNext() = 0;
	/**
	 * Position the cursor on the previous entry in the index.
	 * @return An IndexEntry that contains information about the current
	 * entry in the index on success. On failure the returned IndexEntry
	 * will be null.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual IndexEntry findPrev() = 0;
	/**
	 * Position the cursor on the index entry associated a specified key.
	 * @return An IndexEntry that contains information about the current
	 * entry in the index on success. On failure the returned IndexEntry
	 * will be null.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual IndexEntry find(const char* key) = 0;
	/**
	 * Add an entry to the index.
	 * @param key		The key for the index entry to add.
	 * @param offset	The offset value for the index entry to add.
	 * @return true if an index entry was created in the index file. false if
	 * the index entry was already on file.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual bool add(const char* key, Int32 offset) = 0;
	/**
	 * Remove an entry from the index.
	 * @param key	The key of the index entry to remove.
	 * @param offset The value for the offset field of the index entry to remove.
	 *					  This parm is meaningless unless the index allows duplicate
	 *					  keys.
	 * @return true if the index entry was removed from the index file. false if
	 * the index entry could not be found.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual bool remove(const char* key, Int32 offset=-1L) = 0;
	/**
	 * Update an index entry.
	 * @param key			The key of the index entry to update.
	 * @param newOffset	The new value for the index entry.
	 * @return true if the record was updated. false if the record was not
	 * found.
	 * @exception IndexException If the index file hasn't been opened.
	 */
	virtual bool update(const char* key, Int32 newOffset) = 0;
	/**
	 * Flush all changes to the underlying index file.
	 */
	virtual void flush();
	/**
	 * Create dynamically allocated instances of a sub-class of Indexer.
	 * This method must be implemented by whomever desires to implement an
	 * Indexer sub-class.
	 * @return An instance of a sub-class of Indexer.
	 */
	static IndexRef createIndexObject();
};
//////////////////////////////////////////////////////////////////////////////
struct OW_HDB_API IndexEntry
{
	/**
	 * Create a null IndexEntry
	 */
	IndexEntry() : key(), offset(-1) {}
	/**
	 * Create an IndexEntry with the given key and offset
	 * @param k	The key for this index entry.
	 * @param o	The offset associated with the given key.
	 */
	IndexEntry(const String& k, Int32 o) :
		key(k), offset(o) {}

	typedef Int32 IndexEntry::*safe_bool;
	/**
	 * @return true if this IndexEntry contains a value.
	 */
	operator safe_bool() const { return (offset != -1 && !key.empty()) ? &IndexEntry::offset : 0; }
	bool operator!() const { return !(offset != -1 && !key.empty()); }
	/**
	 * The key associated with this index entry. If it has a zero length, this
	 * should be considered an invalid IndexEntry.
	 */
	String key;
	/**
	 * The offset associated with this index entry. If this is -1L, this should
	 * be considered an invalid IndexEntry.
	 */
	Int32 offset;
};

} // end namespace OW_NAMESPACE

#endif


text:
import re
import sys
import json
import requests
from time import sleep
from bs4 import BeautifulSoup

class NckuCrawler(object):

	def __init__(self):
		self.l =[]
		self.start = int(sys.argv[1])
		self.end = int(sys.argv[2])

	#自定清除格式1
	def format(self,unformat):
		try:
			format = unformat.encode('raw_unicode_escape').decode('utf-8').replace(' ', '').replace('\n', '').replace('\t', '')
			return format
		except:
			pass

	#自定清除格式1
	def format2(self,unformat):
		try:
			format = unformat.encode('raw_unicode_escape').decode('utf-8').replace('\n', '').replace('\t', '')
			return format
		except:
			pass

	def crawler(self,start,end):
		for key in range(start,end):
			print( 'index is '+str(key) )
			url = "http://web.ncku.edu.tw/files/501-1000-1048-"+str(key)+".php"
			resp = requests.get(url=url)
			soup = BeautifulSoup(resp.text)
			for tag in soup.find_all("tr",class_=re.compile("row_0")):
				date = self.format( tag.contents[1].string )
				title = self.format2( tag.find("a") )
				organization = self.format( tag.contents[5].string )
				dic = {"日期":date,"標題":title,"公告單位":organization}
				print(dic)
				self.l.append(dic)
				sleep(0.1)
			sleep(3)

	def storage(self,l):
		json_data = json.dumps(l,ensure_ascii=False)
		with open('ncku.json', 'w') as f:
			f.write(json_data)

	def run(self):
		self.crawler(self.start,self.end)
		self.storage(self.l)

#主函數
def main() :
    nckuCrawler = NckuCrawler()
    nckuCrawler.run()

if __name__ == '__main__' :
    main()


text:
package workspacesiface

import (
	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/aws/aws-sdk-go/aws"
	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/aws/aws-sdk-go/aws/request"
	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/aws/aws-sdk-go/service/workspaces"
)

// WorkSpacesAPI provides an interface to enable mocking the
// workspaces.WorkSpaces service client's API operation,
// paginators, and waiters. This make unit testing your code that calls out
// to the SDK's service client's calls easier.
//
// The best way to use this interface is so the SDK's service client's calls
// can be stubbed out for unit testing your code with the SDK without needing
// to inject custom request handlers into the SDK's request pipeline.
//
//	// myFunc uses an SDK service client to make a request to
//	// Amazon WorkSpaces.
//	func myFunc(svc workspacesiface.WorkSpacesAPI) bool {
//	    // Make svc.AssociateConnectionAlias request
//	}
//
//	func main() {
//	    sess := session.New()
//	    svc := workspaces.New(sess)
//
//	    myFunc(svc)
//	}
//
// In your _test.go file:
//
//	// Define a mock struct to be used in your unit tests of myFunc.
//	type mockWorkSpacesClient struct {
//	    workspacesiface.WorkSpacesAPI
//	}
//	func (m *mockWorkSpacesClient) AssociateConnectionAlias(input *workspaces.AssociateConnectionAliasInput) (*workspaces.AssociateConnectionAliasOutput, error) {
//	    // mock response/functionality
//	}
//
//	func TestMyFunc(t *testing.T) {
//	    // Setup Test
//	    mockSvc := &mockWorkSpacesClient{}
//
//	    myfunc(mockSvc)
//
//	    // Verify myFunc's functionality
//	}
//
// It is important to note that this interface will have breaking changes
// when the service model is updated and adds new API operations, paginators,
// and waiters. Its suggested to use the pattern above for testing, or using
// tooling to generate mocks to satisfy the interfaces.
type WorkSpacesAPI interface {
	AssociateConnectionAlias(*workspaces.AssociateConnectionAliasInput) (*workspaces.AssociateConnectionAliasOutput, error)
	AssociateConnectionAliasWithContext(aws.Context, *workspaces.AssociateConnectionAliasInput, ...request.Option) (*workspaces.AssociateConnectionAliasOutput, error)
	AssociateConnectionAliasRequest(*workspaces.AssociateConnectionAliasInput) (*request.Request, *workspaces.AssociateConnectionAliasOutput)

	AssociateIpGroups(*workspaces.AssociateIpGroupsInput) (*workspaces.AssociateIpGroupsOutput, error)
	AssociateIpGroupsWithContext(aws.Context, *workspaces.AssociateIpGroupsInput, ...request.Option) (*workspaces.AssociateIpGroupsOutput, error)
	AssociateIpGroupsRequest(*workspaces.AssociateIpGroupsInput) (*request.Request, *workspaces.AssociateIpGroupsOutput)

	AuthorizeIpRules(*workspaces.AuthorizeIpRulesInput) (*workspaces.AuthorizeIpRulesOutput, error)
	AuthorizeIpRulesWithContext(aws.Context, *workspaces.AuthorizeIpRulesInput, ...request.Option) (*workspaces.AuthorizeIpRulesOutput, error)
	AuthorizeIpRulesRequest(*workspaces.AuthorizeIpRulesInput) (*request.Request, *workspaces.AuthorizeIpRulesOutput)

	CopyWorkspaceImage(*workspaces.CopyWorkspaceImageInput) (*workspaces.CopyWorkspaceImageOutput, error)
	CopyWorkspaceImageWithContext(aws.Context, *workspaces.CopyWorkspaceImageInput, ...request.Option) (*workspaces.CopyWorkspaceImageOutput, error)
	CopyWorkspaceImageRequest(*workspaces.CopyWorkspaceImageInput) (*request.Request, *workspaces.CopyWorkspaceImageOutput)

	CreateConnectClientAddIn(*workspaces.CreateConnectClientAddInInput) (*workspaces.CreateConnectClientAddInOutput, error)
	CreateConnectClientAddInWithContext(aws.Context, *workspaces.CreateConnectClientAddInInput, ...request.Option) (*workspaces.CreateConnectClientAddInOutput, error)
	CreateConnectClientAddInRequest(*workspaces.CreateConnectClientAddInInput) (*request.Request, *workspaces.CreateConnectClientAddInOutput)

	CreateConnectionAlias(*workspaces.CreateConnectionAliasInput) (*workspaces.CreateConnectionAliasOutput, error)
	CreateConnectionAliasWithContext(aws.Context, *workspaces.CreateConnectionAliasInput, ...request.Option) (*workspaces.CreateConnectionAliasOutput, error)
	CreateConnectionAliasRequest(*workspaces.CreateConnectionAliasInput) (*request.Request, *workspaces.CreateConnectionAliasOutput)

	CreateIpGroup(*workspaces.CreateIpGroupInput) (*workspaces.CreateIpGroupOutput, error)
	CreateIpGroupWithContext(aws.Context, *workspaces.CreateIpGroupInput, ...request.Option) (*workspaces.CreateIpGroupOutput, error)
	CreateIpGroupRequest(*workspaces.CreateIpGroupInput) (*request.Request, *workspaces.CreateIpGroupOutput)

	CreateTags(*workspaces.CreateTagsInput) (*workspaces.CreateTagsOutput, error)
	CreateTagsWithContext(aws.Context, *workspaces.CreateTagsInput, ...request.Option) (*workspaces.CreateTagsOutput, error)
	CreateTagsRequest(*workspaces.CreateTagsInput) (*request.Request, *workspaces.CreateTagsOutput)

	CreateUpdatedWorkspaceImage(*workspaces.CreateUpdatedWorkspaceImageInput) (*workspaces.CreateUpdatedWorkspaceImageOutput, error)
	CreateUpdatedWorkspaceImageWithContext(aws.Context, *workspaces.CreateUpdatedWorkspaceImageInput, ...request.Option) (*workspaces.CreateUpdatedWorkspaceImageOutput, error)
	CreateUpdatedWorkspaceImageRequest(*workspaces.CreateUpdatedWorkspaceImageInput) (*request.Request, *workspaces.CreateUpdatedWorkspaceImageOutput)

	CreateWorkspaceBundle(*workspaces.CreateWorkspaceBundleInput) (*workspaces.CreateWorkspaceBundleOutput, error)
	CreateWorkspaceBundleWithContext(aws.Context, *workspaces.CreateWorkspaceBundleInput, ...request.Option) (*workspaces.CreateWorkspaceBundleOutput, error)
	CreateWorkspaceBundleRequest(*workspaces.CreateWorkspaceBundleInput) (*request.Request, *workspaces.CreateWorkspaceBundleOutput)

	CreateWorkspaces(*workspaces.CreateWorkspacesInput) (*workspaces.CreateWorkspacesOutput, error)
	CreateWorkspacesWithContext(aws.Context, *workspaces.CreateWorkspacesInput, ...request.Option) (*workspaces.CreateWorkspacesOutput, error)
	CreateWorkspacesRequest(*workspaces.CreateWorkspacesInput) (*request.Request, *workspaces.CreateWorkspacesOutput)

	DeleteClientBranding(*workspaces.DeleteClientBrandingInput) (*workspaces.DeleteClientBrandingOutput, error)
	DeleteClientBrandingWithContext(aws.Context, *workspaces.DeleteClientBrandingInput, ...request.Option) (*workspaces.DeleteClientBrandingOutput, error)
	DeleteClientBrandingRequest(*workspaces.DeleteClientBrandingInput) (*request.Request, *workspaces.DeleteClientBrandingOutput)

	DeleteConnectClientAddIn(*workspaces.DeleteConnectClientAddInInput) (*workspaces.DeleteConnectClientAddInOutput, error)
	DeleteConnectClientAddInWithContext(aws.Context, *workspaces.DeleteConnectClientAddInInput, ...request.Option) (*workspaces.DeleteConnectClientAddInOutput, error)
	DeleteConnectClientAddInRequest(*workspaces.DeleteConnectClientAddInInput) (*request.Request, *workspaces.DeleteConnectClientAddInOutput)

	DeleteConnectionAlias(*workspaces.DeleteConnectionAliasInput) (*workspaces.DeleteConnectionAliasOutput, error)
	DeleteConnectionAliasWithContext(aws.Context, *workspaces.DeleteConnectionAliasInput, ...request.Option) (*workspaces.DeleteConnectionAliasOutput, error)
	DeleteConnectionAliasRequest(*workspaces.DeleteConnectionAliasInput) (*request.Request, *workspaces.DeleteConnectionAliasOutput)

	DeleteIpGroup(*workspaces.DeleteIpGroupInput) (*workspaces.DeleteIpGroupOutput, error)
	DeleteIpGroupWithContext(aws.Context, *workspaces.DeleteIpGroupInput, ...request.Option) (*workspaces.DeleteIpGroupOutput, error)
	DeleteIpGroupRequest(*workspaces.DeleteIpGroupInput) (*request.Request, *workspaces.DeleteIpGroupOutput)

	DeleteTags(*workspaces.DeleteTagsInput) (*workspaces.DeleteTagsOutput, error)
	DeleteTagsWithContext(aws.Context, *workspaces.DeleteTagsInput, ...request.Option) (*workspaces.DeleteTagsOutput, error)
	DeleteTagsRequest(*workspaces.DeleteTagsInput) (*request.Request, *workspaces.DeleteTagsOutput)

	DeleteWorkspaceBundle(*workspaces.DeleteWorkspaceBundleInput) (*workspaces.DeleteWorkspaceBundleOutput, error)
	DeleteWorkspaceBundleWithContext(aws.Context, *workspaces.DeleteWorkspaceBundleInput, ...request.Option) (*workspaces.DeleteWorkspaceBundleOutput, error)
	DeleteWorkspaceBundleRequest(*workspaces.DeleteWorkspaceBundleInput) (*request.Request, *workspaces.DeleteWorkspaceBundleOutput)

	DeleteWorkspaceImage(*workspaces.DeleteWorkspaceImageInput) (*workspaces.DeleteWorkspaceImageOutput, error)
	DeleteWorkspaceImageWithContext(aws.Context, *workspaces.DeleteWorkspaceImageInput, ...request.Option) (*workspaces.DeleteWorkspaceImageOutput, error)
	DeleteWorkspaceImageRequest(*workspaces.DeleteWorkspaceImageInput) (*request.Request, *workspaces.DeleteWorkspaceImageOutput)

	DeregisterWorkspaceDirectory(*workspaces.DeregisterWorkspaceDirectoryInput) (*workspaces.DeregisterWorkspaceDirectoryOutput, error)
	DeregisterWorkspaceDirectoryWithContext(aws.Context, *workspaces.DeregisterWorkspaceDirectoryInput, ...request.Option) (*workspaces.DeregisterWorkspaceDirectoryOutput, error)
	DeregisterWorkspaceDirectoryRequest(*workspaces.DeregisterWorkspaceDirectoryInput) (*request.Request, *workspaces.DeregisterWorkspaceDirectoryOutput)

	DescribeAccount(*workspaces.DescribeAccountInput) (*workspaces.DescribeAccountOutput, error)
	DescribeAccountWithContext(aws.Context, *workspaces.DescribeAccountInput, ...request.Option) (*workspaces.DescribeAccountOutput, error)
	DescribeAccountRequest(*workspaces.DescribeAccountInput) (*request.Request, *workspaces.DescribeAccountOutput)

	DescribeAccountModifications(*workspaces.DescribeAccountModificationsInput) (*workspaces.DescribeAccountModificationsOutput, error)
	DescribeAccountModificationsWithContext(aws.Context, *workspaces.DescribeAccountModificationsInput, ...request.Option) (*workspaces.DescribeAccountModificationsOutput, error)
	DescribeAccountModificationsRequest(*workspaces.DescribeAccountModificationsInput) (*request.Request, *workspaces.DescribeAccountModificationsOutput)

	DescribeClientBranding(*workspaces.DescribeClientBrandingInput) (*workspaces.DescribeClientBrandingOutput, error)
	DescribeClientBrandingWithContext(aws.Context, *workspaces.DescribeClientBrandingInput, ...request.Option) (*workspaces.DescribeClientBrandingOutput, error)
	DescribeClientBrandingRequest(*workspaces.DescribeClientBrandingInput) (*request.Request, *workspaces.DescribeClientBrandingOutput)

	DescribeClientProperties(*workspaces.DescribeClientPropertiesInput) (*workspaces.DescribeClientPropertiesOutput, error)
	DescribeClientPropertiesWithContext(aws.Context, *workspaces.DescribeClientPropertiesInput, ...request.Option) (*workspaces.DescribeClientPropertiesOutput, error)
	DescribeClientPropertiesRequest(*workspaces.DescribeClientPropertiesInput) (*request.Request, *workspaces.DescribeClientPropertiesOutput)

	DescribeConnectClientAddIns(*workspaces.DescribeConnectClientAddInsInput) (*workspaces.DescribeConnectClientAddInsOutput, error)
	DescribeConnectClientAddInsWithContext(aws.Context, *workspaces.DescribeConnectClientAddInsInput, ...request.Option) (*workspaces.DescribeConnectClientAddInsOutput, error)
	DescribeConnectClientAddInsRequest(*workspaces.DescribeConnectClientAddInsInput) (*request.Request, *workspaces.DescribeConnectClientAddInsOutput)

	DescribeConnectionAliasPermissions(*workspaces.DescribeConnectionAliasPermissionsInput) (*workspaces.DescribeConnectionAliasPermissionsOutput, error)
	DescribeConnectionAliasPermissionsWithContext(aws.Context, *workspaces.DescribeConnectionAliasPermissionsInput, ...request.Option) (*workspaces.DescribeConnectionAliasPermissionsOutput, error)
	DescribeConnectionAliasPermissionsRequest(*workspaces.DescribeConnectionAliasPermissionsInput) (*request.Request, *workspaces.DescribeConnectionAliasPermissionsOutput)

	DescribeConnectionAliases(*workspaces.DescribeConnectionAliasesInput) (*workspaces.DescribeConnectionAliasesOutput, error)
	DescribeConnectionAliasesWithContext(aws.Context, *workspaces.DescribeConnectionAliasesInput, ...request.Option) (*workspaces.DescribeConnectionAliasesOutput, error)
	DescribeConnectionAliasesRequest(*workspaces.DescribeConnectionAliasesInput) (*request.Request, *workspaces.DescribeConnectionAliasesOutput)

	DescribeIpGroups(*workspaces.DescribeIpGroupsInput) (*workspaces.DescribeIpGroupsOutput, error)
	DescribeIpGroupsWithContext(aws.Context, *workspaces.DescribeIpGroupsInput, ...request.Option) (*workspaces.DescribeIpGroupsOutput, error)
	DescribeIpGroupsRequest(*workspaces.DescribeIpGroupsInput) (*request.Request, *workspaces.DescribeIpGroupsOutput)

	DescribeTags(*workspaces.DescribeTagsInput) (*workspaces.DescribeTagsOutput, error)
	DescribeTagsWithContext(aws.Context, *workspaces.DescribeTagsInput, ...request.Option) (*workspaces.DescribeTagsOutput, error)
	DescribeTagsRequest(*workspaces.DescribeTagsInput) (*request.Request, *workspaces.DescribeTagsOutput)

	DescribeWorkspaceBundles(*workspaces.DescribeWorkspaceBundlesInput) (*workspaces.DescribeWorkspaceBundlesOutput, error)
	DescribeWorkspaceBundlesWithContext(aws.Context, *workspaces.DescribeWorkspaceBundlesInput, ...request.Option) (*workspaces.DescribeWorkspaceBundlesOutput, error)
	DescribeWorkspaceBundlesRequest(*workspaces.DescribeWorkspaceBundlesInput) (*request.Request, *workspaces.DescribeWorkspaceBundlesOutput)

	DescribeWorkspaceBundlesPages(*workspaces.DescribeWorkspaceBundlesInput, func(*workspaces.DescribeWorkspaceBundlesOutput, bool) bool) error
	DescribeWorkspaceBundlesPagesWithContext(aws.Context, *workspaces.DescribeWorkspaceBundlesInput, func(*workspaces.DescribeWorkspaceBundlesOutput, bool) bool, ...request.Option) error

	DescribeWorkspaceDirectories(*workspaces.DescribeWorkspaceDirectoriesInput) (*workspaces.DescribeWorkspaceDirectoriesOutput, error)
	DescribeWorkspaceDirectoriesWithContext(aws.Context, *workspaces.DescribeWorkspaceDirectoriesInput, ...request.Option) (*workspaces.DescribeWorkspaceDirectoriesOutput, error)
	DescribeWorkspaceDirectoriesRequest(*workspaces.DescribeWorkspaceDirectoriesInput) (*request.Request, *workspaces.DescribeWorkspaceDirectoriesOutput)

	DescribeWorkspaceDirectoriesPages(*workspaces.DescribeWorkspaceDirectoriesInput, func(*workspaces.DescribeWorkspaceDirectoriesOutput, bool) bool) error
	DescribeWorkspaceDirectoriesPagesWithContext(aws.Context, *workspaces.DescribeWorkspaceDirectoriesInput, func(*workspaces.DescribeWorkspaceDirectoriesOutput, bool) bool, ...request.Option) error

	DescribeWorkspaceImagePermissions(*workspaces.DescribeWorkspaceImagePermissionsInput) (*workspaces.DescribeWorkspaceImagePermissionsOutput, error)
	DescribeWorkspaceImagePermissionsWithContext(aws.Context, *workspaces.DescribeWorkspaceImagePermissionsInput, ...request.Option) (*workspaces.DescribeWorkspaceImagePermissionsOutput, error)
	DescribeWorkspaceImagePermissionsRequest(*workspaces.DescribeWorkspaceImagePermissionsInput) (*request.Request, *workspaces.DescribeWorkspaceImagePermissionsOutput)

	DescribeWorkspaceImages(*workspaces.DescribeWorkspaceImagesInput) (*workspaces.DescribeWorkspaceImagesOutput, error)
	DescribeWorkspaceImagesWithContext(aws.Context, *workspaces.DescribeWorkspaceImagesInput, ...request.Option) (*workspaces.DescribeWorkspaceImagesOutput, error)
	DescribeWorkspaceImagesRequest(*workspaces.DescribeWorkspaceImagesInput) (*request.Request, *workspaces.DescribeWorkspaceImagesOutput)

	DescribeWorkspaceSnapshots(*workspaces.DescribeWorkspaceSnapshotsInput) (*workspaces.DescribeWorkspaceSnapshotsOutput, error)
	DescribeWorkspaceSnapshotsWithContext(aws.Context, *workspaces.DescribeWorkspaceSnapshotsInput, ...request.Option) (*workspaces.DescribeWorkspaceSnapshotsOutput, error)
	DescribeWorkspaceSnapshotsRequest(*workspaces.DescribeWorkspaceSnapshotsInput) (*request.Request, *workspaces.DescribeWorkspaceSnapshotsOutput)

	DescribeWorkspaces(*workspaces.DescribeWorkspacesInput) (*workspaces.DescribeWorkspacesOutput, error)
	DescribeWorkspacesWithContext(aws.Context, *workspaces.DescribeWorkspacesInput, ...request.Option) (*workspaces.DescribeWorkspacesOutput, error)
	DescribeWorkspacesRequest(*workspaces.DescribeWorkspacesInput) (*request.Request, *workspaces.DescribeWorkspacesOutput)

	DescribeWorkspacesPages(*workspaces.DescribeWorkspacesInput, func(*workspaces.DescribeWorkspacesOutput, bool) bool) error
	DescribeWorkspacesPagesWithContext(aws.Context, *workspaces.DescribeWorkspacesInput, func(*workspaces.DescribeWorkspacesOutput, bool) bool, ...request.Option) error

	DescribeWorkspacesConnectionStatus(*workspaces.DescribeWorkspacesConnectionStatusInput) (*workspaces.DescribeWorkspacesConnectionStatusOutput, error)
	DescribeWorkspacesConnectionStatusWithContext(aws.Context, *workspaces.DescribeWorkspacesConnectionStatusInput, ...request.Option) (*workspaces.DescribeWorkspacesConnectionStatusOutput, error)
	DescribeWorkspacesConnectionStatusRequest(*workspaces.DescribeWorkspacesConnectionStatusInput) (*request.Request, *workspaces.DescribeWorkspacesConnectionStatusOutput)

	DisassociateConnectionAlias(*workspaces.DisassociateConnectionAliasInput) (*workspaces.DisassociateConnectionAliasOutput, error)
	DisassociateConnectionAliasWithContext(aws.Context, *workspaces.DisassociateConnectionAliasInput, ...request.Option) (*workspaces.DisassociateConnectionAliasOutput, error)
	DisassociateConnectionAliasRequest(*workspaces.DisassociateConnectionAliasInput) (*request.Request, *workspaces.DisassociateConnectionAliasOutput)

	DisassociateIpGroups(*workspaces.DisassociateIpGroupsInput) (*workspaces.DisassociateIpGroupsOutput, error)
	DisassociateIpGroupsWithContext(aws.Context, *workspaces.DisassociateIpGroupsInput, ...request.Option) (*workspaces.DisassociateIpGroupsOutput, error)
	DisassociateIpGroupsRequest(*workspaces.DisassociateIpGroupsInput) (*request.Request, *workspaces.DisassociateIpGroupsOutput)

	ImportClientBranding(*workspaces.ImportClientBrandingInput) (*workspaces.ImportClientBrandingOutput, error)
	ImportClientBrandingWithContext(aws.Context, *workspaces.ImportClientBrandingInput, ...request.Option) (*workspaces.ImportClientBrandingOutput, error)
	ImportClientBrandingRequest(*workspaces.ImportClientBrandingInput) (*request.Request, *workspaces.ImportClientBrandingOutput)

	ImportWorkspaceImage(*workspaces.ImportWorkspaceImageInput) (*workspaces.ImportWorkspaceImageOutput, error)
	ImportWorkspaceImageWithContext(aws.Context, *workspaces.ImportWorkspaceImageInput, ...request.Option) (*workspaces.ImportWorkspaceImageOutput, error)
	ImportWorkspaceImageRequest(*workspaces.ImportWorkspaceImageInput) (*request.Request, *workspaces.ImportWorkspaceImageOutput)

	ListAvailableManagementCidrRanges(*workspaces.ListAvailableManagementCidrRangesInput) (*workspaces.ListAvailableManagementCidrRangesOutput, error)
	ListAvailableManagementCidrRangesWithContext(aws.Context, *workspaces.ListAvailableManagementCidrRangesInput, ...request.Option) (*workspaces.ListAvailableManagementCidrRangesOutput, error)
	ListAvailableManagementCidrRangesRequest(*workspaces.ListAvailableManagementCidrRangesInput) (*request.Request, *workspaces.ListAvailableManagementCidrRangesOutput)

	MigrateWorkspace(*workspaces.MigrateWorkspaceInput) (*workspaces.MigrateWorkspaceOutput, error)
	MigrateWorkspaceWithContext(aws.Context, *workspaces.MigrateWorkspaceInput, ...request.Option) (*workspaces.MigrateWorkspaceOutput, error)
	MigrateWorkspaceRequest(*workspaces.MigrateWorkspaceInput) (*request.Request, *workspaces.MigrateWorkspaceOutput)

	ModifyAccount(*workspaces.ModifyAccountInput) (*workspaces.ModifyAccountOutput, error)
	ModifyAccountWithContext(aws.Context, *workspaces.ModifyAccountInput, ...request.Option) (*workspaces.ModifyAccountOutput, error)
	ModifyAccountRequest(*workspaces.ModifyAccountInput) (*request.Request, *workspaces.ModifyAccountOutput)

	ModifyClientProperties(*workspaces.ModifyClientPropertiesInput) (*workspaces.ModifyClientPropertiesOutput, error)
	ModifyClientPropertiesWithContext(aws.Context, *workspaces.ModifyClientPropertiesInput, ...request.Option) (*workspaces.ModifyClientPropertiesOutput, error)
	ModifyClientPropertiesRequest(*workspaces.ModifyClientPropertiesInput) (*request.Request, *workspaces.ModifyClientPropertiesOutput)

	ModifySelfservicePermissions(*workspaces.ModifySelfservicePermissionsInput) (*workspaces.ModifySelfservicePermissionsOutput, error)
	ModifySelfservicePermissionsWithContext(aws.Context, *workspaces.ModifySelfservicePermissionsInput, ...request.Option) (*workspaces.ModifySelfservicePermissionsOutput, error)
	ModifySelfservicePermissionsRequest(*workspaces.ModifySelfservicePermissionsInput) (*request.Request, *workspaces.ModifySelfservicePermissionsOutput)

	ModifyWorkspaceAccessProperties(*workspaces.ModifyWorkspaceAccessPropertiesInput) (*workspaces.ModifyWorkspaceAccessPropertiesOutput, error)
	ModifyWorkspaceAccessPropertiesWithContext(aws.Context, *workspaces.ModifyWorkspaceAccessPropertiesInput, ...request.Option) (*workspaces.ModifyWorkspaceAccessPropertiesOutput, error)
	ModifyWorkspaceAccessPropertiesRequest(*workspaces.ModifyWorkspaceAccessPropertiesInput) (*request.Request, *workspaces.ModifyWorkspaceAccessPropertiesOutput)

	ModifyWorkspaceCreationProperties(*workspaces.ModifyWorkspaceCreationPropertiesInput) (*workspaces.ModifyWorkspaceCreationPropertiesOutput, error)
	ModifyWorkspaceCreationPropertiesWithContext(aws.Context, *workspaces.ModifyWorkspaceCreationPropertiesInput, ...request.Option) (*workspaces.ModifyWorkspaceCreationPropertiesOutput, error)
	ModifyWorkspaceCreationPropertiesRequest(*workspaces.ModifyWorkspaceCreationPropertiesInput) (*request.Request, *workspaces.ModifyWorkspaceCreationPropertiesOutput)

	ModifyWorkspaceProperties(*workspaces.ModifyWorkspacePropertiesInput) (*workspaces.ModifyWorkspacePropertiesOutput, error)
	ModifyWorkspacePropertiesWithContext(aws.Context, *workspaces.ModifyWorkspacePropertiesInput, ...request.Option) (*workspaces.ModifyWorkspacePropertiesOutput, error)
	ModifyWorkspacePropertiesRequest(*workspaces.ModifyWorkspacePropertiesInput) (*request.Request, *workspaces.ModifyWorkspacePropertiesOutput)

	ModifyWorkspaceState(*workspaces.ModifyWorkspaceStateInput) (*workspaces.ModifyWorkspaceStateOutput, error)
	ModifyWorkspaceStateWithContext(aws.Context, *workspaces.ModifyWorkspaceStateInput, ...request.Option) (*workspaces.ModifyWorkspaceStateOutput, error)
	ModifyWorkspaceStateRequest(*workspaces.ModifyWorkspaceStateInput) (*request.Request, *workspaces.ModifyWorkspaceStateOutput)

	RebootWorkspaces(*workspaces.RebootWorkspacesInput) (*workspaces.RebootWorkspacesOutput, error)
	RebootWorkspacesWithContext(aws.Context, *workspaces.RebootWorkspacesInput, ...request.Option) (*workspaces.RebootWorkspacesOutput, error)
	RebootWorkspacesRequest(*workspaces.RebootWorkspacesInput) (*request.Request, *workspaces.RebootWorkspacesOutput)

	RebuildWorkspaces(*workspaces.RebuildWorkspacesInput) (*workspaces.RebuildWorkspacesOutput, error)
	RebuildWorkspacesWithContext(aws.Context, *workspaces.RebuildWorkspacesInput, ...request.Option) (*workspaces.RebuildWorkspacesOutput, error)
	RebuildWorkspacesRequest(*workspaces.RebuildWorkspacesInput) (*request.Request, *workspaces.RebuildWorkspacesOutput)

	RegisterWorkspaceDirectory(*workspaces.RegisterWorkspaceDirectoryInput) (*workspaces.RegisterWorkspaceDirectoryOutput, error)
	RegisterWorkspaceDirectoryWithContext(aws.Context, *workspaces.RegisterWorkspaceDirectoryInput, ...request.Option) (*workspaces.RegisterWorkspaceDirectoryOutput, error)
	RegisterWorkspaceDirectoryRequest(*workspaces.RegisterWorkspaceDirectoryInput) (*request.Request, *workspaces.RegisterWorkspaceDirectoryOutput)

	RestoreWorkspace(*workspaces.RestoreWorkspaceInput) (*workspaces.RestoreWorkspaceOutput, error)
	RestoreWorkspaceWithContext(aws.Context, *workspaces.RestoreWorkspaceInput, ...request.Option) (*workspaces.RestoreWorkspaceOutput, error)
	RestoreWorkspaceRequest(*workspaces.RestoreWorkspaceInput) (*request.Request, *workspaces.RestoreWorkspaceOutput)

	RevokeIpRules(*workspaces.RevokeIpRulesInput) (*workspaces.RevokeIpRulesOutput, error)
	RevokeIpRulesWithContext(aws.Context, *workspaces.RevokeIpRulesInput, ...request.Option) (*workspaces.RevokeIpRulesOutput, error)
	RevokeIpRulesRequest(*workspaces.RevokeIpRulesInput) (*request.Request, *workspaces.RevokeIpRulesOutput)

	StartWorkspaces(*workspaces.StartWorkspacesInput) (*workspaces.StartWorkspacesOutput, error)
	StartWorkspacesWithContext(aws.Context, *workspaces.StartWorkspacesInput, ...request.Option) (*workspaces.StartWorkspacesOutput, error)
	StartWorkspacesRequest(*workspaces.StartWorkspacesInput) (*request.Request, *workspaces.StartWorkspacesOutput)

	StopWorkspaces(*workspaces.StopWorkspacesInput) (*workspaces.StopWorkspacesOutput, error)
	StopWorkspacesWithContext(aws.Context, *workspaces.StopWorkspacesInput, ...request.Option) (*workspaces.StopWorkspacesOutput, error)
	StopWorkspacesRequest(*workspaces.StopWorkspacesInput) (*request.Request, *workspaces.StopWorkspacesOutput)

	TerminateWorkspaces(*workspaces.TerminateWorkspacesInput) (*workspaces.TerminateWorkspacesOutput, error)
	TerminateWorkspacesWithContext(aws.Context, *workspaces.TerminateWorkspacesInput, ...request.Option) (*workspaces.TerminateWorkspacesOutput, error)
	TerminateWorkspacesRequest(*workspaces.TerminateWorkspacesInput) (*request.Request, *workspaces.TerminateWorkspacesOutput)

	UpdateConnectClientAddIn(*workspaces.UpdateConnectClientAddInInput) (*workspaces.UpdateConnectClientAddInOutput, error)
	UpdateConnectClientAddInWithContext(aws.Context, *workspaces.UpdateConnectClientAddInInput, ...request.Option) (*workspaces.UpdateConnectClientAddInOutput, error)
	UpdateConnectClientAddInRequest(*workspaces.UpdateConnectClientAddInInput) (*request.Request, *workspaces.UpdateConnectClientAddInOutput)

	UpdateConnectionAliasPermission(*workspaces.UpdateConnectionAliasPermissionInput) (*workspaces.UpdateConnectionAliasPermissionOutput, error)
	UpdateConnectionAliasPermissionWithContext(aws.Context, *workspaces.UpdateConnectionAliasPermissionInput, ...request.Option) (*workspaces.UpdateConnectionAliasPermissionOutput, error)
	UpdateConnectionAliasPermissionRequest(*workspaces.UpdateConnectionAliasPermissionInput) (*request.Request, *workspaces.UpdateConnectionAliasPermissionOutput)

	UpdateRulesOfIpGroup(*workspaces.UpdateRulesOfIpGroupInput) (*workspaces.UpdateRulesOfIpGroupOutput, error)
	UpdateRulesOfIpGroupWithContext(aws.Context, *workspaces.UpdateRulesOfIpGroupInput, ...request.Option) (*workspaces.UpdateRulesOfIpGroupOutput, error)
	UpdateRulesOfIpGroupRequest(*workspaces.UpdateRulesOfIpGroupInput) (*request.Request, *workspaces.UpdateRulesOfIpGroupOutput)

	UpdateWorkspaceBundle(*workspaces.UpdateWorkspaceBundleInput) (*workspaces.UpdateWorkspaceBundleOutput, error)
	UpdateWorkspaceBundleWithContext(aws.Context, *workspaces.UpdateWorkspaceBundleInput, ...request.Option) (*workspaces.UpdateWorkspaceBundleOutput, error)
	UpdateWorkspaceBundleRequest(*workspaces.UpdateWorkspaceBundleInput) (*request.Request, *workspaces.UpdateWorkspaceBundleOutput)

	UpdateWorkspaceImagePermission(*workspaces.UpdateWorkspaceImagePermissionInput) (*workspaces.UpdateWorkspaceImagePermissionOutput, error)
	UpdateWorkspaceImagePermissionWithContext(aws.Context, *workspaces.UpdateWorkspaceImagePermissionInput, ...request.Option) (*workspaces.UpdateWorkspaceImagePermissionOutput, error)
	UpdateWorkspaceImagePermissionRequest(*workspaces.UpdateWorkspaceImagePermissionInput) (*request.Request, *workspaces.UpdateWorkspaceImagePermissionOutput)
}

var _ WorkSpacesAPI = (*workspaces.WorkSpaces)(nil)


text:
<!DOCTYPE html>

  <title>angular-spotify demo!</title>

  <button ng-click="login()">Login with Spotify</button>

  <input type="text" ng-model="searchartist" ng-change="searchArtist()" placeholder="Search for an artist">

          {{artist.name}}


text:
module SessionsHelper

  # Registers the given user as logged in.
  def log_in(user)
    session[:user_id] = user.id
  end

  # Returns the current logged-in user (if any).
  def current_user
    @current_user ||= User.find_by(id: session[:user_id])
  end

  # Returns true if a user is logged in. False otherwise.
  def logged_in?
    !current_user.nil?
  end

  # Logs out the current user
  def log_out
    session.delete(:user_id)
    @current_user = nil
  end
end


text:
% nplot   = 1;
% figpath = ['graphs'];
%
% run clean_fig_data_folder
if (exist('numRuns') == 0)
    numRuns = 100;
end
dataDir = '../data/hist-data/';
run parameters
dataFileFull2 = [dataDir dataFile2 dataFileSuffix];
csvrange = [rowStart colStart rowStart+numRuns-1 colStart+2];
DATA1 = csvread(dataFileFull,rowStart,colStart,csvrange);
DATA2 = csvread(dataFileFull2,rowStart,colStart,csvrange);
psi1 = abs((DATA1(:,3)-pi/2)*180/pi);
psi2 = abs((DATA2(:,3)-pi/2)*180/pi);

figure
dataPsi = nhist({psi1, psi2},'legend',{dataFile, dataFile2},'pdf','box','location','NorthOutside');
hold on;
StartingAng = plot(startPsi, 0, '*');

xlabel('|Pronucleus Rotation| (deg)');
ylabel('PDF of Runs');


text:
layout: page
title: Flex Angel Music Conference
date: 2016-05-24
author: Marie Andrews
tags: weekly links, java
status: published
summary: Aenean a lacus mi. Cras non faucibus.
banner: images/banner/leisure-03.jpg
booking:
  startDate: 03/01/2019
  endDate: 03/02/2019
  ctyhocn: CNYMBHX
  groupCode: FAMC
published: true
---
Aenean quis mauris nunc. Nullam nec velit vestibulum dui convallis sagittis. Vestibulum non quam felis. Vestibulum commodo arcu turpis, ac accumsan libero dapibus eget. Cras molestie arcu vel ante faucibus, quis eleifend arcu gravida. Integer euismod, risus at imperdiet ultricies, ex sapien faucibus nisl, pellentesque semper nibh dolor in libero. Quisque eu quam vitae sem volutpat posuere. Maecenas odio orci, rhoncus et euismod in, volutpat ut eros. Mauris id tellus in ex tincidunt euismod quis id erat. Cras laoreet ipsum in enim lobortis luctus. Etiam vel ultricies nulla, sit amet congue erat.

* Donec eget ante ut nunc fermentum interdum ac ut quam
* Nunc egestas mauris sit amet orci finibus, non sollicitudin est pretium
* Cras non est nec orci blandit laoreet.

Vestibulum at tortor nunc. Duis iaculis, urna id sagittis elementum, nunc lacus cursus eros, at tristique massa sapien in arcu. Integer convallis sit amet nisl id rhoncus. Nam luctus, tortor tempor sollicitudin porttitor, metus quam maximus mi, in feugiat dolor arcu vel lectus. In ut tincidunt urna, vitae egestas tellus. Praesent nec diam ipsum. Nunc laoreet mollis cursus.


text:
using System;
using WebServer.ByTheCakeApplication.Infrastructure;
using WebServer.ByTheCakeApplication.Services;
using WebServer.ByTheCakeApplication.Services.Interfaces;
using WebServer.ByTheCakeApplication.ViewModels;
using WebServer.ByTheCakeApplication.ViewModels.Account;
using WebServer.Server.Http;
using WebServer.Server.Http.Contracts;
using WebServer.Server.Http.Response;

namespace WebServer.ByTheCakeApplication.Controllers
{
    public class AccountController : Controller
    {
        private const string RegisterView = @"account\register";
        private const string LoginView = @"account\login";

        private readonly IUserService users;

        public AccountController()
        {
            this.users = new UserService();
        }

        public IHttpResponse Register()
        {
            this.SetDefaultViewData();
            return this.FileViewResponse(RegisterView);
        }

        public IHttpResponse Register(IHttpRequest req, RegisterUserViewModel model)
        {
            this.SetDefaultViewData();

            if (model.Username.Length < 3
                || model.Password.Length < 3
                || model.ConfirmPassword != model.Password)
            {
                this.AddError("Invalid user details");

                return this.FileViewResponse(RegisterView);
            }

            var success = this.users.Create(model.Username, model.Password);

            if (success)
            {
                this.LoginUser(req, model.Username);

                return new RedirectResponse("/");
            }
            else
            {
                this.AddError("This username is taken");

                return this.FileViewResponse(RegisterView);
            }
        }

        public IHttpResponse Login()
        {
            this.SetDefaultViewData();
            return this.FileViewResponse(LoginView);
        }

        public IHttpResponse Login(IHttpRequest req, LoginViewModel model)
        {
            if (string.IsNullOrWhiteSpace(model.Username) || string.IsNullOrWhiteSpace(model.Password))
            {
                this.AddError("You have empty fields");

                return this.FileViewResponse(LoginView);
            }

            var success = this.users.Find(model.Username, model.Password);

            if (success)
            {
                this.LoginUser(req, model.Username);

                return new RedirectResponse("/");
            }
            else
            {
                this.AddError("Invalid user details");

                return this.FileViewResponse(LoginView);
            }
        }

        public IHttpResponse Profile(IHttpRequest req)
        {
            if (!req.Session.Contains(SessionStorage.CurrentUserKey))
            {
                throw new InvalidOperationException("There is no logged in user.");
            }

            var username = req.Session.Get<string>(SessionStorage.CurrentUserKey);

            var profile = this.users.Profile(username);

            if (profile == null)
            {
                throw new InvalidOperationException($"The user {username} could not be found in the database.");
            }

            this.ViewData["username"] = profile.Username;
            this.ViewData["registrationDate"] = profile.RegistrationDate.ToShortDateString();
            this.ViewData["totalOrders"] = profile.TotalOrders.ToString();

            return this.FileViewResponse(@"account\profile");
        }

        public IHttpResponse Logout(IHttpRequest req)
        {
            req.Session.Clear();

            return new RedirectResponse("/login");
        }

        private void SetDefaultViewData() => this.ViewData["authDisplay"] = "none";

        private void LoginUser(IHttpRequest req, string username)
        {
            req.Session.Add(SessionStorage.CurrentUserKey, username);
            req.Session.Add(SessionStorage.SessionKey, new ShoppingCart());
        }
    }
}


text:
package org.semanticweb.ontop.beyondql.approximation;

import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.model.OWLObjectIntersectionOf;
import org.semanticweb.owlapi.model.OWLObjectPropertyExpression;

import com.google.common.base.Joiner;

public class IRIUtils {

	private static final String conceptSeparator = "_and_";

	/**************************************************************************
	 * Adds a suffix to the original IRI
	 *
	 * @param iri
	 *            the original IRI
	 * @param suffix
	 *            the suffix to add
	 *************************************************************************/
	static public IRI createIRIWithSuffix(IRI iri, String suffix) {
		String uriStr = iri.toString();
		if (uriStr.endsWith(".owl"))
			uriStr = uriStr.substring(0, uriStr.length() - ".owl".length())
					+ "_" + suffix + ".owl";
		else
			uriStr = uriStr + "_" + suffix + ".owl";
		IRI new_iri = IRI.create(uriStr);

		return new_iri;
	}

	protected static String extractConceptNames(OWLClassExpression clazz) {
		String conceptNames = "";
		if (clazz instanceof OWLClass) {
			conceptNames = extractPredicateName(clazz.asOWLClass());
		} else if (clazz instanceof OWLObjectIntersectionOf ){
			conceptNames = extractConceptNamesFromConjunction((OWLObjectIntersectionOf)clazz);
		}
		return conceptNames;
	}

	/**
	 * We assume that clazz is a conjunction of atomic concepts
	 *
	 * @param clazz
	 * @return
	 */
	protected static String extractConceptNamesFromConjunction(
			OWLObjectIntersectionOf clazz) {

//        StringWriter writer = new StringWriter();
//        ManchesterOWLSyntaxObjectRenderer renderer = new ManchesterOWLSyntaxObjectRenderer(writer, new SimpleShortFormProvider());
//        clazz.accept(renderer);
//
//        String className = writer.toString();
//        String newName = className.replaceAll("\\(","").replaceAll("\\)","").replaceAll("\\s+", "_");
//
//        return newName;

		Set<OWLClassExpression> operands = ((OWLObjectIntersectionOf) clazz)
				.getOperands();

		// we sort the names of the operands so that the string
		// is the same for equivalent concepts
		SortedSet<String> operandNames = new TreeSet<>();
		for (OWLClassExpression op : operands) {
			operandNames.add(extractPredicateName(op.asOWLClass()));
		}
		String conceptNames = Joiner.on(conceptSeparator).join(operandNames);

		return conceptNames;
	}

	protected static String extractPredicateName(OWLClass clazz) {
		String name = clazz.getIRI().getFragment();
		if (name == null) {
			String iri = clazz.getIRI().toString();
			name = iri.substring(iri.indexOf('#')+1, iri.length());
		}
		return name;
	}

	protected static String extractPrefix(OWLClass clazz) {
		return clazz.getIRI().getNamespace();
	}

	protected static String extractPredicateName(OWLObjectPropertyExpression prop) {
		String predName = "";
		if(prop.isAnonymous()) {
			predName = prop.getNamedProperty().getIRI().getFragment();
		} else {
			predName = prop.asOWLObjectProperty().getIRI().getFragment();
		}
		return predName;
	}

	protected static String extractPrefix(OWLObjectPropertyExpression prop) {
		String prefix = "";
		if(prop.isAnonymous()) {
			prefix = prop.getNamedProperty().getIRI().getNamespace();
		} else {
			prefix = prop.asOWLObjectProperty().getIRI().getNamespace();
		}
		return prefix;
	}

}


text:
/* Styling for zamboni's admin. */

/* Cycle table row backgrounds. */
table tr {
    background: #ecf7fb;
}

table tr:nth-child(odd) {
    background: #d9eff6;
}

#masthead h1 a {
    text-decoration: none;
}

.amo-header {
    min-height: 50px;
}

.header-search {
    display: none;
}

#header #title a {
    color: #d64203;
}

#title {
    margin: 1.5em 0 .9em;
}

/* Django does weird things to align forms and the transbox looks off.  This
 * makes it look ok.
.trans {
    float: left;
}
*/

/* Override the Django body.login background. */
html body.login {
    background: inherit;
}

/* Remove fieldset styling on the admin. */
fieldset {
    padding: 0;
}

.footerlogo {
    display: none;
}

#admin-validation form label,
#admin-validation form span {
    display: block;
    float: left;
}
#admin-validation form label {
    padding: 0 1em;
    width: 10em;
}
#admin-validation form #label-application {
    width: 5em;
}
#admin-validation form #elem-application {
    width: 8em;
}
#admin-validation form #label-target_version {
    width: 7em;
}
#admin-validation form #elem-finish_email,
#admin-validation form #elem-finish_email input {
    width: 13em;
}
#admin-validation form span {
    width: 14em;
}
#admin-validation form .form-row {
    clear: both;
    height: 2.5em;
}
#admin-validation .errorlist li {
    list-style: disc;
    margin-left: 2em;
}
#admin-validation .errorlist li li {
    list-style: none;
    margin-left: 1em;
}
#admin-validation .errorlist ul {
    margin-bottom: 1em;
}
#admin-validation .errorlist ul ul {
    margin: 0;
}
.validation-intro {
    padding: 0.5em;
}
.validation-intro p, .validation-intro ul {
    margin-bottom: 0;
}
.validation-intro ul li {
    list-style: disc;
    margin-left: 2em;
}
div.popup input[type="text"] {
    width: 588px;
}

.job-status {
    color: #777777;
    font-size: 11px;
    margin-top: 4px;
}

.job-status-bar {
    background-color: #F2F2F2;
    -moz-border-radius: 3px;
    -webkit-border-radius: 3px;
    border-radius: 3px;
    height: 13px;
    border: 1px solid #3D6DB5;
}

.job-status-bar div {
    background-color: #8BC5FA;
    -moz-border-radius: 3px;
    -webkit-border-radius: 3px;
    border-radius: 3px;
    width: 0%;
    height: 13px;
}

#admin-fetch-langpacks {
    text-align: center;
    margin-bottom: 1.5em;
}

a.headerlink {
    color: #ccc;
    font-size: 1.1em;
    margin-left: 6px;
    padding: 0 4px 0 4px;
    text-decoration: none;
    border: none;
    visibility: hidden;
    font-style: none;
}
a.headerlink:hover {
    color: #c60f0f;
    border: none;
}
:-moz-any(h1,h2,h3,h4,h5,h6):hover a.headerlink {
  visibility: visible;
}

#content {
    display: table;
}

#content.colM, #content.flex {
    display: block;
}

section {
    display: table-cell;
}

section dl {
    -moz-column-count: 3;
}

aside {
    padding-left: 3em;
    display: table-cell;
}

fieldset.module {
    border: 0;
}

.form-row {
    margin: 12px 0;
}

/* Fix yes/no images for Firefox or fix the django image path (hah!). */
#changelist-form #result_list td img[alt=False]:after,
#changelist-form #result_list td img[alt=True]:after {
    background: #fff url(../../img/admin/icon-no.gif) no-repeat center center;
    content: "";
    position: absolute;
    float: right;
    width: 31px;
    height: 18px;
    margin-left: -26px;
}
#changelist-form #result_list .row1 td img[alt=False]:after,
#changelist-form #result_list .row1 td img[alt=True]:after {
    background-color: #D9EFF6;
}
#changelist-form #result_list td img[alt=True]:after {
    background-image: url(../../img/admin/icon-yes.gif);
    width: 35px;
}
#changelist-form #result_list td img[alt=True],
#changelist-form #result_list td img[alt=False] {
    background: url(../../img/admin/icon-no.gif) no-repeat center center;
    /* Webkit hack...if the icon width is less than the broken image icon. */
    width: 15px;
    height: 18px;
}
#changelist-form #result_list td img[alt=True] {
    background: url(../../img/admin/icon-yes.gif) no-repeat center center;
}


text:
#ifndef REALM_TEST_UTIL_CHECK_SYSTEM_ERROR_HPP
#define REALM_TEST_UTIL_CHECK_SYSTEM_ERROR_HPP

#include <system_error>

#include "unit_test.hpp"

#define CHECK_SYSTEM_ERROR(expr, error_code) CHECK_THROW_EX(expr, std::system_error, e.code() == error_code)

#endif // REALM_TEST_UTIL_CHECK_SYSTEM_ERROR_HPP


text:
import React from 'react';
import Reflux from 'reflux';
import BlogActions from '../actions/blog';
import BlogStore from '../stores/blog';
import NewPost from '../components/NewPost';
import PostsList from '../components/PostsList';

export default React.createClass({
  mixins: [
    Reflux.connect(BlogStore)
  ],

  componentDidMount() {
    BlogActions.getPosts();
  },

  render() {
    return (

React JS Blog
                     by Green Pioneer & Harry

Create A New Post

        <NewPost
          title={ this.state.newPost.title }
          content={ this.state.newPost.content }
          updateTitle={ BlogActions.newPostInput.bind(this, 'title') }
          updateContent={ BlogActions.newPostInput.bind(this, 'content') }
          onSubmit={ BlogActions.addPost } />
        <PostsList
          posts={ this.state.posts }/>

    );
  }
});