Datasets:

google

/

code_x_glue_cc_code_to_code_trans

like 5

public CreateAccountResult createAccount(CreateAccountRequest request) {request = beforeClientExecution(request);return executeCreateAccount(request);}

public virtual CreateAccountResponse CreateAccount(CreateAccountRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateAccountRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateAccountResponseUnmarshaller.Instance;return Invoke<CreateAccountResponse>(request, options);}

public Map.Entry<K,V> next() {HashEntry<K,V> e = super.nextEntry();return new WriteThroughEntry(e.key, e.value);}

public override java.util.MapClass.Entry<K, V> next(){return this.nextEntry();}

public BaseRef(RefEval re) {_refEval = re;_areaEval = null;_firstRowIndex = re.getRow();_firstColumnIndex = re.getColumn();_height = 1;_width = 1;}

public BaseRef(RefEval re){_refEval = re;_areaEval = null;_firstRowIndex = re.Row;_firstColumnIndex = re.Column;_height = 1;_width = 1;}

public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long block = blocks[blocksOffset++];for (int shift = 62; shift >= 0; shift -= 2) {values[valuesOffset++] = (block >>> shift) & 3;}}}

public override void Decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long block = blocks[blocksOffset++];for (int shift = 62; shift >= 0; shift -= 2){values[valuesOffset++] = ((long)((ulong)block >> shift)) & 3;}}}

public void unrollRecursionContexts(ParserRuleContext _parentctx) {_precedenceStack.pop();_ctx.stop = _input.LT(-1);ParserRuleContext retctx = _ctx; if ( _parseListeners != null ) {while ( _ctx != _parentctx ) {triggerExitRuleEvent();_ctx = (ParserRuleContext)_ctx.parent;}}else {_ctx = _parentctx;}retctx.parent = _parentctx;if (_buildParseTrees && _parentctx != null) {_parentctx.addChild(retctx);}}

public virtual void UnrollRecursionContexts(ParserRuleContext _parentctx){_precedenceStack.RemoveAt(_precedenceStack.Count - 1);_ctx.Stop = _input.LT(-1);ParserRuleContext retctx = _ctx;if (_parseListeners != null){while (_ctx != _parentctx){TriggerExitRuleEvent();_ctx = (ParserRuleContext)_ctx.Parent;}}else{_ctx = _parentctx;}retctx.Parent = _parentctx;if (_buildParseTrees && _parentctx != null){_parentctx.AddChild(retctx);}}

public CancelBundleTaskRequest(String bundleId) {setBundleId(bundleId);}

public CancelBundleTaskRequest(string bundleId){_bundleId = bundleId;}

public void add(CharsRef input, CharsRef output, boolean includeOrig) {add(input, countWords(input), output, countWords(output), includeOrig);}

public virtual void Add(CharsRef input, CharsRef output, bool includeOrig){Add(input, CountWords(input), output, CountWords(output), includeOrig);}

public SetIdentityDkimEnabledResult setIdentityDkimEnabled(SetIdentityDkimEnabledRequest request) {request = beforeClientExecution(request);return executeSetIdentityDkimEnabled(request);}

public virtual SetIdentityDkimEnabledResponse SetIdentityDkimEnabled(SetIdentityDkimEnabledRequest request){var options = new InvokeOptions();options.RequestMarshaller = SetIdentityDkimEnabledRequestMarshaller.Instance;options.ResponseUnmarshaller = SetIdentityDkimEnabledResponseUnmarshaller.Instance;return Invoke<SetIdentityDkimEnabledResponse>(request, options);}

public GetResolverEndpointResult getResolverEndpoint(GetResolverEndpointRequest request) {request = beforeClientExecution(request);return executeGetResolverEndpoint(request);}

public virtual GetResolverEndpointResponse GetResolverEndpoint(GetResolverEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetResolverEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = GetResolverEndpointResponseUnmarshaller.Instance;return Invoke<GetResolverEndpointResponse>(request, options);}

public void setText(String value) {string = value;start = offset = 0;end = value.length();}

public void setText(string value){@string = value;start = offset = 0;end = value.Length;}

public String toString() {return toString(0);}

public override string ToString(){return ToString(0);}

public void adjustIndex(int offset) {_firstSheetIndex += offset;_lastSheetIndex += offset;}

public void AdjustIndex(int offset){_firstSheetIndex += offset;_lastSheetIndex += offset;}

public GalicianStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public GalicianStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

public ListRepositoryAssociationsResult listRepositoryAssociations(ListRepositoryAssociationsRequest request) {request = beforeClientExecution(request);return executeListRepositoryAssociations(request);}

public virtual ListRepositoryAssociationsResponse ListRepositoryAssociations(ListRepositoryAssociationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListRepositoryAssociationsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListRepositoryAssociationsResponseUnmarshaller.Instance;return Invoke<ListRepositoryAssociationsResponse>(request, options);}

public void setParams(String params) {super.setParams(params);maxNumSegments = (int)Double.parseDouble(params);}

public override void SetParams(string @params){base.SetParams(@params);maxNumSegments = (int)double.Parse(@params, CultureInfo.InvariantCulture);}

public char getChar() {return (char) getShort();}

public override char getChar(){return (char)getShort();}

public void next(int delta) {if (delta == 1) {prevPtr = currPtr;currPtr = nextPtr;if (!eof())parseEntry();return;}final int end = raw.length;int ptr = nextPtr;while (--delta > 0 && ptr != end) {prevPtr = ptr;while (raw[ptr] != 0)ptr++;ptr += OBJECT_ID_LENGTH + 1;}if (delta != 0)throw new ArrayIndexOutOfBoundsException(delta);currPtr = ptr;if (!eof())parseEntry();}

public override void Next(int delta){if (delta == 1){prevPtr = currPtr;currPtr = nextPtr;if (!Eof){ParseEntry();}return;}int end = raw.Length;int ptr = nextPtr;while (--delta > 0 && ptr != end){prevPtr = ptr;while (raw[ptr] != 0){ptr++;}ptr += Constants.OBJECT_ID_LENGTH + 1;}if (delta != 0){throw Sharpen.Extensions.CreateIndexOutOfRangeException(delta);}currPtr = ptr;if (!Eof){ParseEntry();}}

public Type getType() {return type;}

public virtual ReceiveCommand.Type GetType(){return type;}

public CharBuffer duplicate() {return copy(this, mark);}

public override java.nio.CharBuffer duplicate(){return copy(this, _mark);}

public NGramFilterFactory(Map<String, String> args) {super(args);minGramSize = requireInt(args, "minGramSize");maxGramSize = requireInt(args, "maxGramSize");preserveOriginal = getBoolean(args, "preserveOriginal", NGramTokenFilter.DEFAULT_PRESERVE_ORIGINAL);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public NGramFilterFactory(IDictionary<string, string> args): base(args){minGramSize = GetInt32(args, "minGramSize", NGramTokenFilter.DEFAULT_MIN_NGRAM_SIZE);maxGramSize = GetInt32(args, "maxGramSize", NGramTokenFilter.DEFAULT_MAX_NGRAM_SIZE);if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

public AddRoleToDBClusterResult addRoleToDBCluster(AddRoleToDBClusterRequest request) {request = beforeClientExecution(request);return executeAddRoleToDBCluster(request);}

public virtual AddRoleToDBClusterResponse AddRoleToDBCluster(AddRoleToDBClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddRoleToDBClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = AddRoleToDBClusterResponseUnmarshaller.Instance;return Invoke<AddRoleToDBClusterResponse>(request, options);}

public BlameGenerator setTextComparator(RawTextComparator comparator) {textComparator = comparator;return this;}

public virtual NGit.Blame.BlameGenerator SetTextComparator(RawTextComparator comparator){textComparator = comparator;return this;}

public PatternCaptureGroupFilterFactory(Map<String,String> args) {super(args);pattern = getPattern(args, "pattern");preserveOriginal = args.containsKey("preserve_original") ? Boolean.parseBoolean(args.get("preserve_original")) : true;}

public PatternCaptureGroupFilterFactory(IDictionary<string, string> args): base(args){pattern = GetPattern(args, "pattern");preserveOriginal = args.TryGetValue("preserve_original", out string value) ? bool.Parse(value) : true;}

public CreateObjectResult createObject(CreateObjectRequest request) {request = beforeClientExecution(request);return executeCreateObject(request);}

public virtual CreateObjectResponse CreateObject(CreateObjectRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateObjectRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateObjectResponseUnmarshaller.Instance;return Invoke<CreateObjectResponse>(request, options);}

@Override public String getActions() { return null; }

public override string getActions(){return null;}

public void onChanged() {if (mAdapter != null) {post(new Runnable() {@Override

public override void onChanged(){if (this._enclosing.isShowing()){this._enclosing.show();}}

public CreateResourceGroupResult createResourceGroup(CreateResourceGroupRequest request) {request = beforeClientExecution(request);return executeCreateResourceGroup(request);}

public virtual CreateResourceGroupResponse CreateResourceGroup(CreateResourceGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateResourceGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateResourceGroupResponseUnmarshaller.Instance;return Invoke<CreateResourceGroupResponse>(request, options);}

public static RevFilter has(RevFlag a) {final RevFlagSet s = new RevFlagSet();s.add(a);return new HasAll(s);}

public static RevFilter Has(RevFlag a){RevFlagSet s = new RevFlagSet();s.AddItem(a);return new RevFlagFilter.HasAll(s);}

@Override public int size() {return totalSize;}

public override int size(){return this._enclosing._size;}

public void write(LittleEndianOutput out) {out.writeByte(sid + getPtgClass());out.writeShort(field_1_index_extern_sheet);out.writeInt(unused1);}

public override void Write(ILittleEndianOutput out1){out1.WriteByte(sid + PtgClass);out1.WriteShort(field_1_index_extern_sheet);out1.WriteInt(unused1);}

public String toString() {return this.getClass().getSimpleName() + "@" + directory + " lockFactory=" + lockFactory;}

public override string ToString(){return this.GetType().Name + "@" + m_directory + " lockFactory=" + LockFactory;}

public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {switch (args.length) {case 3:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);case 4:return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}return ErrorEval.VALUE_INVALID;}

public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){switch (args.Length){case 3:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2]);case 4:return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}return ErrorEval.VALUE_INVALID;}

public CancelDataRepositoryTaskResult cancelDataRepositoryTask(CancelDataRepositoryTaskRequest request) {request = beforeClientExecution(request);return executeCancelDataRepositoryTask(request);}

public virtual CancelDataRepositoryTaskResponse CancelDataRepositoryTask(CancelDataRepositoryTaskRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelDataRepositoryTaskRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelDataRepositoryTaskResponseUnmarshaller.Instance;return Invoke<CancelDataRepositoryTaskResponse>(request, options);}

public DateFormatTokenizer(String format) {this.format = format;}

public DateFormatTokenizer(string format){this.format = format;}

public static int getBiasedExponent(long rawBits) {return Math.toIntExact((rawBits & EXPONENT_MASK) >> EXPONENT_SHIFT);}

public static int GetBiasedExponent(long rawBits){return (int)((rawBits & EXPONENT_MASK) >> EXPONENT_SHIFT);}

public String toString() {return "IB " + distribution.toString() + "-" + lambda.toString()+ normalization.toString();}

public override string ToString(){return "IB " + m_distribution.ToString() + "-" + m_lambda.ToString() + m_normalization.ToString();}

public String getName() {return name;}

public string GetName(){return name;}

public boolean inContext(String context) {return false;}

public virtual bool InContext(string context){return false;}

public String toString() {String desc;File directory = getDirectory();if (directory != null)desc = directory.getPath();elsedesc = getClass().getSimpleName() + "-" + System.identityHashCode(this);return "Repository[" + desc + "]"; }

public override string ToString(){string desc;if (Directory != null){desc = Directory.GetPath();}else{desc = GetType().Name + "-" + Runtime.IdentityHashCode(this);}return "Repository[" + desc + "]";}

public int serialize(int offset, byte [] data) {LittleEndian.putInt(data, offset+0, field_13_border_styles1);LittleEndian.putInt(data, offset+4, field_14_border_styles2);return 8;}

public int Serialize(int offset, byte[] data){LittleEndian.PutInt(data, offset, field_13_border_styles1);offset += 4;LittleEndian.PutInt(data, offset, field_14_border_styles2);offset += 4;return 8;}

public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int j = 0; j < iterations; ++j) {final byte block = blocks[blocksOffset++];values[valuesOffset++] = (block >>> 7) & 1;values[valuesOffset++] = (block >>> 6) & 1;values[valuesOffset++] = (block >>> 5) & 1;values[valuesOffset++] = (block >>> 4) & 1;values[valuesOffset++] = (block >>> 3) & 1;values[valuesOffset++] = (block >>> 2) & 1;values[valuesOffset++] = (block >>> 1) & 1;values[valuesOffset++] = block & 1;}}

public override void Decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int j = 0; j < iterations; ++j){var block = blocks[blocksOffset++];values[valuesOffset++] = ((int)((uint)block >> 7)) & 1;values[valuesOffset++] = ((int)((uint)block >> 6)) & 1;values[valuesOffset++] = ((int)((uint)block >> 5)) & 1;values[valuesOffset++] = ((int)((uint)block >> 4)) & 1;values[valuesOffset++] = ((int)((uint)block >> 3)) & 1;values[valuesOffset++] = ((int)((uint)block >> 2)) & 1;values[valuesOffset++] = ((int)((uint)block >> 1)) & 1;values[valuesOffset++] = block & 1;}}

public PipedWriter(PipedReader destination) throws IOException {super(destination);connect(destination);}

public PipedWriter(java.io.PipedReader destination) : base(destination){throw new System.NotImplementedException();}

public String dequote(byte[] in, int ip, int ie) {boolean inquote = false;final byte[] r = new byte[ie - ip];int rPtr = 0;while (ip < ie) {final byte b = in[ip++];switch (b) {case '\'':inquote = !inquote;continue;case '\\':if (inquote || ip == ie)r[rPtr++] = b; elser[rPtr++] = in[ip++];continue;default:r[rPtr++] = b;continue;}}return RawParseUtils.decode(UTF_8, r, 0, rPtr);}

public override string Dequote(byte[] @in, int ip, int ie){bool inquote = false;byte[] r = new byte[ie - ip];int rPtr = 0;while (ip < ie){byte b = @in[ip++];switch (b){case (byte)('\''):{inquote = !inquote;continue;goto case (byte)('\\');}case (byte)('\\'):{if (inquote || ip == ie){r[rPtr++] = b;}else{r[rPtr++] = @in[ip++];}continue;goto default;}default:{r[rPtr++] = b;continue;break;}}}return RawParseUtils.Decode(Constants.CHARSET, r, 0, rPtr);}

public Status getStatus() {return myStatus;}

public virtual CheckoutResult.Status GetStatus(){return myStatus;}

public DeltaRecord(RecordInputStream in) {field_1_max_change = in.readDouble();}

public DeltaRecord(RecordInputStream in1){field_1_max_change = in1.ReadDouble();}

public void serialize(LittleEndianOutput out) {out.writeShort(getCount());}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Count);}

public ListPartsRequest(String vaultName, String uploadId) {setVaultName(vaultName);setUploadId(uploadId);}

public ListPartsRequest(string vaultName, string uploadId){_vaultName = vaultName;_uploadId = uploadId;}

public void set(int index, long value) {final int o = index >>> 2;final int b = index & 3;final int shift = b << 4;blocks[o] = (blocks[o] & ~(65535L << shift)) | (value << shift);}

public override void Set(int index, long value){int o = (int)((uint)index >> 2);int b = index & 3;int shift = b << 4;blocks[o] = (blocks[o] & ~(65535L << shift)) | (value << shift);}

public void setRunInBackground(int deltaPri) {runInBackground = true;this.deltaPri = deltaPri;}

public virtual void SetRunInBackground(int deltaPri){runInBackground = true;this.deltaPri = deltaPri;}

public TeeInputStream(InputStream src, OutputStream dst) {this.src = src;this.dst = dst;}

public TeeInputStream(InputStream src, OutputStream dst){this.src = src;this.dst = dst;}

public void addChild(final Property property)throws IOException{String name = property.getName();if (_children_names.contains(name)){throw new IOException("Duplicate name \"" + name + "\"");}_children_names.add(name);_children.add(property);}

public void AddChild(Property property){String name = property.Name;if (_children_names.Contains(name)){throw new IOException("Duplicate name \"" + name + "\"");}_children_names.Add(name);_children.Add(property);}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {int result;if (arg0 instanceof TwoDEval) {result = ((TwoDEval) arg0).getWidth();} else if (arg0 instanceof RefEval) {result = 1;} else { return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){int result;if (arg0 is AreaEval){result = ((AreaEval)arg0).Width;}else if (arg0 is RefEval){result = 1;}else{ return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}

public ListModelsResult listModels(ListModelsRequest request) {request = beforeClientExecution(request);return executeListModels(request);}

public virtual ListModelsResponse ListModels(ListModelsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListModelsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListModelsResponseUnmarshaller.Instance;return Invoke<ListModelsResponse>(request, options);}

public ExtensionQuery(QueryParser topLevelParser, String field, String rawQueryString) {this.field = field;this.rawQueryString = rawQueryString;this.topLevelParser = topLevelParser;}

public ExtensionQuery(Classic.QueryParser topLevelParser, string field, string rawQueryString){this.Field = field;this.RawQueryString = rawQueryString;this.TopLevelParser = topLevelParser;}

public String toString() {return resourceDescription;}

public override string ToString(){return resourceDescription;}

public GetDeploymentInstanceResult getDeploymentInstance(GetDeploymentInstanceRequest request) {request = beforeClientExecution(request);return executeGetDeploymentInstance(request);}

public virtual GetDeploymentInstanceResponse GetDeploymentInstance(GetDeploymentInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDeploymentInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDeploymentInstanceResponseUnmarshaller.Instance;return Invoke<GetDeploymentInstanceResponse>(request, options);}

public MappingCharFilterFactory(Map<String,String> args) {super(args);mapping = get(args, "mapping");if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public MappingCharFilterFactory(IDictionary<string, string> args) : base(args){mapping = Get(args, "mapping");if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

public boolean promptPassphrase(String msg) {CredentialItem.StringType v = newPrompt(msg);if (provider.get(uri, v)) {passphrase = v.getValue();return true;}passphrase = null;return false;}

public virtual bool PromptPassphrase(string msg){CredentialItem.StringType v = NewPrompt(msg);if (provider.Get(uri, v)){passphrase = v.GetValue();return true;}else{passphrase = null;return false;}}

public DescribeReservedDBInstancesResult describeReservedDBInstances() {return describeReservedDBInstances(new DescribeReservedDBInstancesRequest());}

public virtual DescribeReservedDBInstancesResponse DescribeReservedDBInstances(){return DescribeReservedDBInstances(new DescribeReservedDBInstancesRequest());}

public UnsubscribeFromDatasetResult unsubscribeFromDataset(UnsubscribeFromDatasetRequest request) {request = beforeClientExecution(request);return executeUnsubscribeFromDataset(request);}

public virtual UnsubscribeFromDatasetResponse UnsubscribeFromDataset(UnsubscribeFromDatasetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UnsubscribeFromDatasetRequestMarshaller.Instance;options.ResponseUnmarshaller = UnsubscribeFromDatasetResponseUnmarshaller.Instance;return Invoke<UnsubscribeFromDatasetResponse>(request, options);}

public int available() throws IOException {if (buf == null) {throw new IOException();}return buf.length - pos + in.available();}

public override int available(){if (buf == null){throw new System.IO.IOException();}return buf.Length - pos + @in.available();}

@Override public V remove(Object key) {return isInBounds(key) ? TreeMap.this.remove(key) : null;}

public override V remove(object key){return this.isInBounds(key) ? this._enclosing.remove(key) : default(V);}

public void insertSST() {LOG.log(DEBUG, "creating new SST via insertSST!");sst = new SSTRecord();records.add(records.size() - 1, createExtendedSST());records.add(records.size() - 2, sst);}

public void InsertSST(){sst = new SSTRecord();records.Add(records.Count- 1, CreateExtendedSST());records.Add(records.Count - 2, sst);}

public AddApplicationCloudWatchLoggingOptionResult addApplicationCloudWatchLoggingOption(AddApplicationCloudWatchLoggingOptionRequest request) {request = beforeClientExecution(request);return executeAddApplicationCloudWatchLoggingOption(request);}

public virtual AddApplicationCloudWatchLoggingOptionResponse AddApplicationCloudWatchLoggingOption(AddApplicationCloudWatchLoggingOptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = AddApplicationCloudWatchLoggingOptionRequestMarshaller.Instance;options.ResponseUnmarshaller = AddApplicationCloudWatchLoggingOptionResponseUnmarshaller.Instance;return Invoke<AddApplicationCloudWatchLoggingOptionResponse>(request, options);}

public ListCampaignsResult listCampaigns(ListCampaignsRequest request) {request = beforeClientExecution(request);return executeListCampaigns(request);}

public virtual ListCampaignsResponse ListCampaigns(ListCampaignsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListCampaignsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListCampaignsResponseUnmarshaller.Instance;return Invoke<ListCampaignsResponse>(request, options);}

public void execute(Lexer lexer) {lexer.more();}

public void Execute(Lexer lexer){lexer.More();}

public SetFaceCoverRequest() {super("CloudPhoto", "2017-07-11", "SetFaceCover", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

public SetFaceCoverRequest(): base("CloudPhoto", "2017-07-11", "SetFaceCover", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}

public GetInstanceAccessResult getInstanceAccess(GetInstanceAccessRequest request) {request = beforeClientExecution(request);return executeGetInstanceAccess(request);}

public virtual GetInstanceAccessResponse GetInstanceAccess(GetInstanceAccessRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetInstanceAccessRequestMarshaller.Instance;options.ResponseUnmarshaller = GetInstanceAccessResponseUnmarshaller.Instance;return Invoke<GetInstanceAccessResponse>(request, options);}

public void clear() {value = null;}

public override void Clear(){value = null;}

public GetFederationTokenResult getFederationToken(GetFederationTokenRequest request) {request = beforeClientExecution(request);return executeGetFederationToken(request);}

public virtual GetFederationTokenResponse GetFederationToken(GetFederationTokenRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFederationTokenRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFederationTokenResponseUnmarshaller.Instance;return Invoke<GetFederationTokenResponse>(request, options);}

public int first() {currentSentence = 0;text.setIndex(text.getBeginIndex());return current();}

public override int First(){currentSentence = 0;text.SetIndex(text.BeginIndex);return Current;}

public QueryPhraseMap getFieldTermMap( String fieldName, String term ){QueryPhraseMap rootMap = getRootMap( fieldName );return rootMap == null ? null : rootMap.subMap.get( term );}

public virtual QueryPhraseMap GetFieldTermMap(string fieldName, string term){QueryPhraseMap rootMap = GetRootMap(fieldName);if (rootMap == null) return null;rootMap.subMap.TryGetValue(term, out QueryPhraseMap result);return result;}

@Override public boolean contains(Object object) {if (object instanceof Multiset.Entry) {Multiset.Entry<?> entry = (Multiset.Entry<?>) object;Object element = entry.getElement();int entryCount = entry.getCount();return entryCount > 0 && count(element) == entryCount;}return false;}

public override bool contains(object o){if (!(o is java.util.MapClass.Entry<K, V>)){return false;}java.util.MapClass.Entry<object, object> e = (java.util.MapClass.Entry<object, object>)o;return this._enclosing.containsMapping(e.getKey(), e.getValue());}

public DeleteLexiconResult deleteLexicon(DeleteLexiconRequest request) {request = beforeClientExecution(request);return executeDeleteLexicon(request);}

public virtual DeleteLexiconResponse DeleteLexicon(DeleteLexiconRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLexiconRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLexiconResponseUnmarshaller.Instance;return Invoke<DeleteLexiconResponse>(request, options);}

public DomainMetadataResult domainMetadata(DomainMetadataRequest request) {request = beforeClientExecution(request);return executeDomainMetadata(request);}

public virtual DomainMetadataResponse DomainMetadata(DomainMetadataRequest request){var options = new InvokeOptions();options.RequestMarshaller = DomainMetadataRequestMarshaller.Instance;options.ResponseUnmarshaller = DomainMetadataResponseUnmarshaller.Instance;return Invoke<DomainMetadataResponse>(request, options);}

public RevFlag getReinterestingFlag() {return REINTERESTING;}

public RevFlag GetReinterestingFlag(){return REINTERESTING;}

public static void advise(FileDescriptor fd, long offset, long len, int advise) throws IOException {final int code = posix_fadvise(fd, offset, len, advise);if (code != 0) {throw new RuntimeException("posix_fadvise failed code=" + code);}}

public static void advise(FileDescriptor fd, long offset, long len, int advise) throws IOException{int code = posix_fadvise(fd, offset, len, advise);if (code != 0){throw new Exception("posix_fadvise failed code=" + code);}}

public DeleteSchemaResult deleteSchema(DeleteSchemaRequest request) {request = beforeClientExecution(request);return executeDeleteSchema(request);}

public virtual DeleteSchemaResponse DeleteSchema(DeleteSchemaRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSchemaRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSchemaResponseUnmarshaller.Instance;return Invoke<DeleteSchemaResponse>(request, options);}

public CreateBatchInferenceJobResult createBatchInferenceJob(CreateBatchInferenceJobRequest request) {request = beforeClientExecution(request);return executeCreateBatchInferenceJob(request);}

public virtual CreateBatchInferenceJobResponse CreateBatchInferenceJob(CreateBatchInferenceJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateBatchInferenceJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateBatchInferenceJobResponseUnmarshaller.Instance;return Invoke<CreateBatchInferenceJobResponse>(request, options);}

public BitField(final int mask){_mask = mask;int count = 0;int bit_pattern = mask;if (bit_pattern != 0){while ((bit_pattern & 1) == 0){count++;bit_pattern >>= 1;}}_shift_count = count;}

public BitField(int mask){this._mask = mask;int num = 0;int num2 = mask;if (num2 != 0){while ((num2 & 1) == 0){num++;num2 = num2 >> 1;}}this._shift_count = num;}

public boolean failed() {return !failingPaths.isEmpty();}

public virtual bool Failed(){return failingPaths.Count > 0;}

public String toString() {StringBuilder b = new StringBuilder();for(int i=0;i<len;i++) {if (i > 0) {b.append(' ');}b.append(Integer.toBinaryString(bytes[i].value));}return b.toString();}

public override string ToString(){StringBuilder b = new StringBuilder();for (int i = 0; i < len; i++){if (i > 0){b.Append(' ');}b.Append(bytes[i].Value.ToBinaryString());}return b.ToString();}

public final void remove() {if (modCount != expectedModCount)throw new ConcurrentModificationException();if (lastReturned == null)throw new IllegalStateException();LinkedHashMap.this.remove(lastReturned.key);lastReturned = null;expectedModCount = modCount;}

public virtual void remove(){if (this._enclosing.modCount != this.expectedModCount){throw new java.util.ConcurrentModificationException();}if (this.lastReturned == null){throw new System.InvalidOperationException();}this._enclosing.remove(this.lastReturned.key);this.lastReturned = null;this.expectedModCount = this._enclosing.modCount;}

public boolean shouldBeRecursive() {return path.shouldBeRecursive() || ANY_DIFF.shouldBeRecursive();}

public override bool ShouldBeRecursive(){return path.ShouldBeRecursive() || ANY_DIFF.ShouldBeRecursive();}

public DeleteQueueRequest(String queueUrl) {setQueueUrl(queueUrl);}

public DeleteQueueRequest(string queueUrl){_queueUrl = queueUrl;}

public ExternalName getExternalName(int externSheetIndex, int externNameIndex) {String nameName = linkTable.resolveNameXText(externSheetIndex, externNameIndex, this);if(nameName == null) {return null;}int ix = linkTable.resolveNameXIx(externSheetIndex, externNameIndex);return new ExternalName(nameName, externNameIndex, ix);}

public ExternalName GetExternalName(int externSheetIndex, int externNameIndex){String nameName = linkTable.ResolveNameXText(externSheetIndex, externNameIndex, this);if (nameName == null){return null;}int ix = linkTable.ResolveNameXIx(externSheetIndex, externNameIndex);return new ExternalName(nameName, externNameIndex, ix);}

public RegisterUserResult registerUser(RegisterUserRequest request) {request = beforeClientExecution(request);return executeRegisterUser(request);}

public virtual RegisterUserResponse RegisterUser(RegisterUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterUserRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterUserResponseUnmarshaller.Instance;return Invoke<RegisterUserResponse>(request, options);}

public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int j = 0; j < iterations; ++j) {values[valuesOffset++] = blocks[blocksOffset++] & 0xFF;}}

public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int j = 0; j < iterations; ++j){values[valuesOffset++] = blocks[blocksOffset++] & 0xFF;}}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {return fixed(arg0, new NumberEval(2), BoolEval.FALSE, srcRowIndex, srcColumnIndex);}

public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){return doFixed(arg0, new NumberEval(2), BoolEval.FALSE, srcRowIndex, srcColumnIndex);}

public final byte[] array() {return protectedArray();}

public sealed override object array(){return protectedArray();}

public int readUByte() {byte[] buf = new byte[1];try {checkEOF(read(buf), 1);} catch (IOException e) {throw new RuntimeException(e);}return LittleEndian.getUByte(buf);}

public int ReadUByte(){int ch;try{ch = in1.ReadByte();}catch (IOException e){throw new RuntimeException(e);}CheckEOF(ch);return ch;}

public static AttrPtg createSkip(int dist) {return new AttrPtg(optiSkip.set(0), dist, null, -1);}

public static AttrPtg CreateSkip(int dist){return new AttrPtg(optiSkip.Set(0), dist, null, -1);}

public DescribeUserHierarchyGroupResult describeUserHierarchyGroup(DescribeUserHierarchyGroupRequest request) {request = beforeClientExecution(request);return executeDescribeUserHierarchyGroup(request);}

public virtual DescribeUserHierarchyGroupResponse DescribeUserHierarchyGroup(DescribeUserHierarchyGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeUserHierarchyGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeUserHierarchyGroupResponseUnmarshaller.Instance;return Invoke<DescribeUserHierarchyGroupResponse>(request, options);}

public User(String path, String userName, String userId, String arn, java.util.Date createDate) {setPath(path);setUserName(userName);setUserId(userId);setArn(arn);setCreateDate(createDate);}

public User(string path, string userName, string userId, string arn, DateTime createDate){_path = path;_userName = userName;_userId = userId;_arn = arn;_createDate = createDate;}

public OpenNLPLemmatizerFilter create(TokenStream in) {try {NLPLemmatizerOp lemmatizerOp = OpenNLPOpsFactory.getLemmatizer(dictionaryFile, lemmatizerModelFile);return new OpenNLPLemmatizerFilter(in, lemmatizerOp);} catch (IOException e) {throw new RuntimeException(e);}}

public override TokenStream Create(TokenStream input){try{NLPLemmatizerOp lemmatizerOp = OpenNLPOpsFactory.GetLemmatizer(dictionaryFile, lemmatizerModelFile);return new OpenNLPLemmatizerFilter(input, lemmatizerOp);}catch (IOException e){throw new Exception(e.ToString(), e);}}

public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;final long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 4) | (byte1 >>> 4);final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;}}

public override void Decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long byte0 = blocks[blocksOffset++] & 0xFF;long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 4) | ((long)((ulong)byte1 >> 4));long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;}}

public RebootInstanceRequest() {super("HPC", "2016-06-03", "RebootInstance", "hpc");setMethod(MethodType.POST);}

public RebootInstanceRequest(): base("HPC", "2016-06-03", "RebootInstance"){Method = MethodType.POST;}

public ListContainerInstancesResult listContainerInstances(ListContainerInstancesRequest request) {request = beforeClientExecution(request);return executeListContainerInstances(request);}

public virtual ListContainerInstancesResponse ListContainerInstances(ListContainerInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListContainerInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListContainerInstancesResponseUnmarshaller.Instance;return Invoke<ListContainerInstancesResponse>(request, options);}

public ListClustersResult listClusters(ListClustersRequest request) {request = beforeClientExecution(request);return executeListClusters(request);}

public virtual ListClustersResponse ListClusters(ListClustersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListClustersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListClustersResponseUnmarshaller.Instance;return Invoke<ListClustersResponse>(request, options);}

public static boolean equals(boolean[] array1, boolean[] array2) {if (array1 == array2) {return true;}if (array1 == null || array2 == null || array1.length != array2.length) {return false;}for (int i = 0; i < array1.length; i++) {if (array1[i] != array2[i]) {return false;}}return true;}

public static bool equals(bool[] array1, bool[] array2){if (array1 == array2){return true;}if (array1 == null || array2 == null || array1.Length != array2.Length){return false;}{for (int i = 0; i < array1.Length; i++){if (array1[i] != array2[i]){return false;}}}return true;}