Datasets:

google

/

code_x_glue_cc_code_to_code_trans

like 5

public Charset detectedCharset() {throw new UnsupportedOperationException();}

public virtual java.nio.charset.Charset detectedCharset(){throw new System.NotSupportedException();}

public RightMarginRecord clone() {return copy();}

public override Object Clone(){RightMarginRecord rec = new RightMarginRecord();rec.field_1_margin = this.field_1_margin;return rec;}

public ListTrafficPoliciesResult listTrafficPolicies(ListTrafficPoliciesRequest request) {request = beforeClientExecution(request);return executeListTrafficPolicies(request);}

public virtual ListTrafficPoliciesResponse ListTrafficPolicies(ListTrafficPoliciesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTrafficPoliciesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTrafficPoliciesResponseUnmarshaller.Instance;return Invoke<ListTrafficPoliciesResponse>(request, options);}

public DeleteKeyPairRequest(String keyName) {setKeyName(keyName);}

public DeleteKeyPairRequest(string keyName){_keyName = keyName;}

public void setElement(int index, byte[] element) {if (emptyComplexPart) {return;}int actualSize = getActualSizeOfElements(getSizeOfElements());System.arraycopy( element, 0, getComplexData(), FIXED_SIZE + index * actualSize, actualSize);}

public void SetElement(int index, byte[] element){int actualSize = GetActualSizeOfElements(SizeOfElements);Array.Copy(element, 0, _complexData, FIXED_SIZE + index * actualSize, actualSize);}

public FieldDoc(int doc, float score, Object[] fields) {super(doc, score);this.fields = fields;}

public FieldDoc(int doc, float score, object[] fields): base(doc, score){this.fields = fields;}

public TreeFilter clone() {return new Binary(a.clone(), b.clone());}

public override RevFilter Clone(){return new OrRevFilter.Binary(a.Clone(), b.Clone());}

public void fillTo(int toIndex, long val) {while (count < toIndex)add(val);}

public virtual void FillTo(int toIndex, long val){while (count < toIndex){Add(val);}}

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;values[valuesOffset++] = byte0 >>> 5;values[valuesOffset++] = (byte0 >>> 2) & 7;final long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | (byte1 >>> 7);values[valuesOffset++] = (byte1 >>> 4) & 7;values[valuesOffset++] = (byte1 >>> 1) & 7;final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | (byte2 >>> 6);values[valuesOffset++] = (byte2 >>> 3) & 7;values[valuesOffset++] = byte2 & 7;}}

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;values[valuesOffset++] = (long)((ulong)byte0 >> 5);values[valuesOffset++] = ((long)((ulong)byte0 >> 2)) & 7;long byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | ((long)((ulong)byte1 >> 7));values[valuesOffset++] = ((long)((ulong)byte1 >> 4)) & 7;values[valuesOffset++] = ((long)((ulong)byte1 >> 1)) & 7;long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | ((long)((ulong)byte2 >> 6));values[valuesOffset++] = ((long)((ulong)byte2 >> 3)) & 7;values[valuesOffset++] = byte2 & 7;}}

public RawText getResultContents() {return resultContents;}

public virtual RawText GetResultContents(){return resultContents;}

public void setMaxShingleSize(int maxShingleSize) {if (maxShingleSize < 2) {throw new IllegalArgumentException("Max shingle size must be >= 2");}this.maxShingleSize = maxShingleSize;}

public void SetMaxShingleSize(int maxShingleSize){if (maxShingleSize < 2){throw new System.ArgumentException("Max shingle size must be >= 2");}this.maxShingleSize = maxShingleSize;}

public FieldInfo(RecordInputStream in) {_isxvi = in.readShort();_isxvd = in.readShort();_idObj = in.readShort();}

public FieldInfo(RecordInputStream in1){_isxvi = in1.ReadShort();_isxvd = in1.ReadShort();_idObj = in1.ReadShort();}

public DescribeDBEngineVersionsResult describeDBEngineVersions(DescribeDBEngineVersionsRequest request) {request = beforeClientExecution(request);return executeDescribeDBEngineVersions(request);}

public virtual DescribeDBEngineVersionsResponse DescribeDBEngineVersions(DescribeDBEngineVersionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeDBEngineVersionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeDBEngineVersionsResponseUnmarshaller.Instance;return Invoke<DescribeDBEngineVersionsResponse>(request, options);}

public DBSnapshot copyDBSnapshot(CopyDBSnapshotRequest request) {request = beforeClientExecution(request);return executeCopyDBSnapshot(request);}

public virtual CopyDBSnapshotResponse CopyDBSnapshot(CopyDBSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyDBSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyDBSnapshotResponseUnmarshaller.Instance;return Invoke<CopyDBSnapshotResponse>(request, options);}

public DFA(DecisionState atnStartState, int decision) {this.atnStartState = atnStartState;this.decision = decision;boolean precedenceDfa = false;if (atnStartState instanceof StarLoopEntryState) {if (((StarLoopEntryState)atnStartState).isPrecedenceDecision) {precedenceDfa = true;DFAState precedenceState = new DFAState(new ATNConfigSet());precedenceState.edges = new DFAState[0];precedenceState.isAcceptState = false;precedenceState.requiresFullContext = false;this.s0 = precedenceState;}}this.precedenceDfa = precedenceDfa;}

public DFA(DecisionState atnStartState, int decision){this.atnStartState = atnStartState;this.decision = decision;this.precedenceDfa = false;if (atnStartState is StarLoopEntryState && ((StarLoopEntryState)atnStartState).isPrecedenceDecision){this.precedenceDfa = true;DFAState precedenceState = new DFAState(new ATNConfigSet());precedenceState.edges = new DFAState[0];precedenceState.isAcceptState = false;precedenceState.requiresFullContext = false;this.s0 = precedenceState;}}

public QueryParserTokenManager(CharStream stream){input_stream = stream;}

public QueryParserTokenManager(ICharStream stream){m_input_stream = stream;}

public String toString() {return "<group>" + "\n" + getChild().toString() + "\n</group>";}

public override string ToString(){return "<group>" + "\n" + GetChild().ToString() + "\n</group>";}

public UpdateResolverRuleResult updateResolverRule(UpdateResolverRuleRequest request) {request = beforeClientExecution(request);return executeUpdateResolverRule(request);}

public virtual UpdateResolverRuleResponse UpdateResolverRule(UpdateResolverRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateResolverRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateResolverRuleResponseUnmarshaller.Instance;return Invoke<UpdateResolverRuleResponse>(request, options);}

public int compareTo(BytesRef other) {return Arrays.compareUnsigned(this.bytes, this.offset, this.offset + this.length,other.bytes, other.offset, other.offset + other.length);}

public int CompareTo(BytesRef other){return utf8SortedAsUnicodeSortOrder.Compare(this, other);}

public void rewind() {ns.removeAllElements();ks.setLength(0);cur = root;run();}

public virtual void Rewind(){ns.Clear();ks.Length = 0;cur = outerInstance.m_root;Run();}

public ModifyWorkspaceAccessPropertiesResult modifyWorkspaceAccessProperties(ModifyWorkspaceAccessPropertiesRequest request) {request = beforeClientExecution(request);return executeModifyWorkspaceAccessProperties(request);}

public virtual ModifyWorkspaceAccessPropertiesResponse ModifyWorkspaceAccessProperties(ModifyWorkspaceAccessPropertiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyWorkspaceAccessPropertiesRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyWorkspaceAccessPropertiesResponseUnmarshaller.Instance;return Invoke<ModifyWorkspaceAccessPropertiesResponse>(request, options);}

public DescribeFleetAttributesResult describeFleetAttributes(DescribeFleetAttributesRequest request) {request = beforeClientExecution(request);return executeDescribeFleetAttributes(request);}

public virtual DescribeFleetAttributesResponse DescribeFleetAttributes(DescribeFleetAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetAttributesResponseUnmarshaller.Instance;return Invoke<DescribeFleetAttributesResponse>(request, options);}

public CreateBuildResult createBuild(CreateBuildRequest request) {request = beforeClientExecution(request);return executeCreateBuild(request);}

public virtual CreateBuildResponse CreateBuild(CreateBuildRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateBuildRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateBuildResponseUnmarshaller.Instance;return Invoke<CreateBuildResponse>(request, options);}

public static FloatBuffer wrap(float[] array, int start, int floatCount) {Arrays.checkOffsetAndCount(array.length, start, floatCount);FloatBuffer buf = new ReadWriteFloatArrayBuffer(array);buf.position = start;buf.limit = start + floatCount;return buf;}

public static java.nio.FloatBuffer wrap(float[] array_1, int start, int floatCount){java.util.Arrays.checkOffsetAndCount(array_1.Length, start, floatCount);java.nio.FloatBuffer buf = new java.nio.ReadWriteFloatArrayBuffer(array_1);buf._position = start;buf._limit = start + floatCount;return buf;}

public String toString() {StringBuilder result = new StringBuilder();DateFormatTokenizer tokenizer = new DateFormatTokenizer(format);String token;while( ( token = tokenizer.getNextToken() ) != null ) {if( result.length() > 0 ) {result.append( ", " );}result.append("[").append(token).append("]");}return result.toString();}

public override string ToString(){StringBuilder result = new StringBuilder();DateFormatTokenizer tokenizer = new DateFormatTokenizer(format);string token;while ((token = tokenizer.GetNextToken()) != null){if (result.Length > 0){result.Append(", ");}result.Append("[").Append(token).Append("]");}return result.ToString();}

public byte readByte() {return data[pos++];}

public override byte ReadByte(){return data[pos++];}

public CreateDatasetResult createDataset(CreateDatasetRequest request) {request = beforeClientExecution(request);return executeCreateDataset(request);}

public virtual CreateDatasetResponse CreateDataset(CreateDatasetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDatasetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDatasetResponseUnmarshaller.Instance;return Invoke<CreateDatasetResponse>(request, options);}

public BytesRef next() {termOrd++;if (termOrd < terms.length) {return setTerm();} else {return null;}}

public override BytesRef Next(){termOrd++;if (termOrd < outerInstance.terms.Length){return SetTerm();}else{return null;}}

public static FontCharset valueOf(int value){return (value < 0 || value >= _table.length) ? null :_table[value];}

public static FontCharset ValueOf(int value){if(value>=0&&value<=255)return _table[value];return null;}

public static String escape(String s) {StringBuilder sb = new StringBuilder();for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);if (c == '\\' || c == '+' || c == '-' || c == '!' || c == '(' || c == ')'|| c == ':' || c == '^' || c == '[' || c == ']' || c == '\"'|| c == '{' || c == '}' || c == '~' || c == '*' || c == '?'|| c == '|' || c == '&' || c == '/') {sb.append('\\');}sb.append(c);}return sb.toString();}

public static string Escape(string s){StringBuilder sb = new StringBuilder();for (int i = 0; i < s.Length; i++){char c = s[i];if (c == '\\' || c == '+' || c == '-' || c == '!' || c == '(' || c == ')'|| c == ':' || c == '^' || c == '[' || c == ']' || c == '\"'|| c == '{' || c == '}' || c == '~' || c == '*' || c == '?'|| c == '|' || c == '&' || c == '/'){sb.Append('\\');}sb.Append(c);}return sb.ToString();}

public RejectVpcEndpointConnectionsResult rejectVpcEndpointConnections(RejectVpcEndpointConnectionsRequest request) {request = beforeClientExecution(request);return executeRejectVpcEndpointConnections(request);}

public virtual RejectVpcEndpointConnectionsResponse RejectVpcEndpointConnections(RejectVpcEndpointConnectionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RejectVpcEndpointConnectionsRequestMarshaller.Instance;options.ResponseUnmarshaller = RejectVpcEndpointConnectionsResponseUnmarshaller.Instance;return Invoke<RejectVpcEndpointConnectionsResponse>(request, options);}

public V next() { return nextEntry().value; }

public override V next(){return this.nextEntry().value;}

public ShingleAnalyzerWrapper(Analyzer delegate,int minShingleSize,int maxShingleSize,String tokenSeparator,boolean outputUnigrams,boolean outputUnigramsIfNoShingles,String fillerToken) {super(delegate.getReuseStrategy());this.delegate = delegate;if (maxShingleSize < 2) {throw new IllegalArgumentException("Max shingle size must be >= 2");}this.maxShingleSize = maxShingleSize;if (minShingleSize < 2) {throw new IllegalArgumentException("Min shingle size must be >= 2");}if (minShingleSize > maxShingleSize) {throw new IllegalArgumentException("Min shingle size must be <= max shingle size");}this.minShingleSize = minShingleSize;this.tokenSeparator = (tokenSeparator == null ? "" : tokenSeparator);this.outputUnigrams = outputUnigrams;this.outputUnigramsIfNoShingles = outputUnigramsIfNoShingles;this.fillerToken = fillerToken;}

public ShingleAnalyzerWrapper(Analyzer @delegate, int minShingleSize, int maxShingleSize,string tokenSeparator, bool outputUnigrams, bool outputUnigramsIfNoShingles, string fillerToken): base(@delegate.Strategy){this.@delegate = @delegate;if (maxShingleSize < 2){throw new ArgumentOutOfRangeException("Max shingle size must be >= 2");}this.maxShingleSize = maxShingleSize;if (minShingleSize < 2){throw new ArgumentOutOfRangeException("Min shingle size must be >= 2");}if (minShingleSize > maxShingleSize){throw new ArgumentOutOfRangeException("Min shingle size must be <= max shingle size");}this.minShingleSize = minShingleSize;this.tokenSeparator = (tokenSeparator == null ? "" : tokenSeparator);this.outputUnigrams = outputUnigrams;this.outputUnigramsIfNoShingles = outputUnigramsIfNoShingles;this.fillerToken = fillerToken;}

public CreateInterconnectResult createInterconnect(CreateInterconnectRequest request) {request = beforeClientExecution(request);return executeCreateInterconnect(request);}

public virtual CreateInterconnectResponse CreateInterconnect(CreateInterconnectRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateInterconnectRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateInterconnectResponseUnmarshaller.Instance;return Invoke<CreateInterconnectResponse>(request, options);}

public DeleteTrafficMirrorTargetResult deleteTrafficMirrorTarget(DeleteTrafficMirrorTargetRequest request) {request = beforeClientExecution(request);return executeDeleteTrafficMirrorTarget(request);}

public virtual DeleteTrafficMirrorTargetResponse DeleteTrafficMirrorTarget(DeleteTrafficMirrorTargetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTrafficMirrorTargetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTrafficMirrorTargetResponseUnmarshaller.Instance;return Invoke<DeleteTrafficMirrorTargetResponse>(request, options);}

public UpdateMonitoringScheduleResult updateMonitoringSchedule(UpdateMonitoringScheduleRequest request) {request = beforeClientExecution(request);return executeUpdateMonitoringSchedule(request);}

public virtual UpdateMonitoringScheduleResponse UpdateMonitoringSchedule(UpdateMonitoringScheduleRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMonitoringScheduleRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMonitoringScheduleResponseUnmarshaller.Instance;return Invoke<UpdateMonitoringScheduleResponse>(request, options);}

public DeleteGatewayGroupResult deleteGatewayGroup(DeleteGatewayGroupRequest request) {request = beforeClientExecution(request);return executeDeleteGatewayGroup(request);}

public virtual DeleteGatewayGroupResponse DeleteGatewayGroup(DeleteGatewayGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteGatewayGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteGatewayGroupResponseUnmarshaller.Instance;return Invoke<DeleteGatewayGroupResponse>(request, options);}

public ListStackSetOperationsResult listStackSetOperations(ListStackSetOperationsRequest request) {request = beforeClientExecution(request);return executeListStackSetOperations(request);}

public virtual ListStackSetOperationsResponse ListStackSetOperations(ListStackSetOperationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListStackSetOperationsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListStackSetOperationsResponseUnmarshaller.Instance;return Invoke<ListStackSetOperationsResponse>(request, options);}

public ListOfOutputs(Outputs<T> outputs) {this.outputs = outputs;}

public ListOfOutputs(Outputs<T> outputs){this.outputs = outputs;}

public ExceedsLimit(long limit, long size) {this.limit = limit;this.size = size;}

public ExceedsLimit(long limit, long size){this.limit = limit;this.size = size;}

public GetIndustryInfoRequest() {super("industry-brain", "2018-07-12", "GetIndustryInfo");setProtocol(ProtocolType.HTTPS);}

public GetIndustryInfoRequest(): base("industry-brain", "2018-07-12", "GetIndustryInfo"){Protocol = ProtocolType.HTTPS;}

public CreateVpnGatewayRequest(String type) {setType(type);}

public CreateVpnGatewayRequest(GatewayType type){_type = type;}

public int compareTo(PointTransitions other) {return point - other.point;}

public int CompareTo(PointTransitions other){return point - other.point;}

public DeleteQueuedReservedInstancesResult deleteQueuedReservedInstances(DeleteQueuedReservedInstancesRequest request) {request = beforeClientExecution(request);return executeDeleteQueuedReservedInstances(request);}

public virtual DeleteQueuedReservedInstancesResponse DeleteQueuedReservedInstances(DeleteQueuedReservedInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteQueuedReservedInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteQueuedReservedInstancesResponseUnmarshaller.Instance;return Invoke<DeleteQueuedReservedInstancesResponse>(request, options);}

public static final AbbreviatedObjectId fromString(String str) {if (str.length() > Constants.OBJECT_ID_STRING_LENGTH)throw new IllegalArgumentException(MessageFormat.format(JGitText.get().invalidId, str));final byte[] b = Constants.encodeASCII(str);return fromHexString(b, 0, b.length);}

public static NGit.AbbreviatedObjectId FromString(string str){if (str.Length > Constants.OBJECT_ID_STRING_LENGTH){throw new ArgumentException(MessageFormat.Format(JGitText.Get().invalidId, str));}byte[] b = Constants.EncodeASCII(str);return FromHexString(b, 0, b.Length);}

public final int getByte(int index) {int w;switch (index >> 2) {case 0:w = w1;break;case 1:w = w2;break;case 2:w = w3;break;case 3:w = w4;break;case 4:w = w5;break;default:throw new ArrayIndexOutOfBoundsException(index);}return (w >>> (8 * (3 - (index & 3)))) & 0xff;}

public int GetByte(int index){int w;switch (index >> 2){case 0:{w = w1;break;}case 1:{w = w2;break;}case 2:{w = w3;break;}case 3:{w = w4;break;}case 4:{w = w5;break;}default:{throw Sharpen.Extensions.CreateIndexOutOfRangeException(index);}}return ((int)(((uint)w) >> (8 * (3 - (index & 3))))) & unchecked((int)(0xff));}

public SpanFirstBuilder(SpanQueryBuilder factory) {this.factory = factory;}

public SpanFirstBuilder(ISpanQueryBuilder factory){this.factory = factory;}

public DescribeInstancesResult describeInstances(DescribeInstancesRequest request) {request = beforeClientExecution(request);return executeDescribeInstances(request);}

public virtual DescribeInstancesResponse DescribeInstances(DescribeInstancesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInstancesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInstancesResponseUnmarshaller.Instance;return Invoke<DescribeInstancesResponse>(request, options);}

public DescribeProjectsResult describeProjects(DescribeProjectsRequest request) {request = beforeClientExecution(request);return executeDescribeProjects(request);}

public virtual DescribeProjectsResponse DescribeProjects(DescribeProjectsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeProjectsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeProjectsResponseUnmarshaller.Instance;return Invoke<DescribeProjectsResponse>(request, options);}

public static String toHexString(String s) {StringBuilder sb = new StringBuilder();for(int i=0;i<s.length();i++) {char ch = s.charAt(i);if (i > 0) {sb.append(' ');}if (ch < 128) {sb.append(ch);} else {if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {sb.append("H:");} else if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {sb.append("L:");} else if (ch > UNI_SUR_LOW_END) {if (ch == 0xffff) {sb.append("F:");} else {sb.append("E:");}}sb.append("0x").append(Integer.toHexString(ch));}}return sb.toString();}

public static string ToHexString(string s){var sb = new StringBuilder();for (int i = 0; i < s.Length; i++){char ch = s[i];if (i > 0){sb.Append(' ');}if (ch < 128){sb.Append(ch);}else{if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END){sb.Append("H:");}else if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END){sb.Append("L:");}else if (ch > UNI_SUR_LOW_END){if (ch == 0xffff){sb.Append("F:");}else{sb.Append("E:");}}sb.Append("0x" + ((short)ch).ToString("X"));}}return sb.ToString();}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {double result;try {double d0 = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = Math.log(d0) / LOG_10_TO_BASE_e;NumericFunction.checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){double result;try{double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = Math.Log(d0) / NumericFunction.LOG_10_TO_BASE_e;NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}

public long byteCount(int packedIntsVersion, int valueCount, int bitsPerValue) {assert bitsPerValue >= 0 && bitsPerValue <= 64 : bitsPerValue;return 8L * longCount(packedIntsVersion, valueCount, bitsPerValue);}

public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue){return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);}

public Policy(String id, Collection<Statement> statements) {this(id);setStatements(statements);}

public Policy(string id, IList<Statement> statements){this.id = id;this.statements = statements;}

public FunctionQuery(ValueSource func) {this.func=func;}

public FunctionQuery(ValueSource func){this.func = func;}

public UpdateGameServerResult updateGameServer(UpdateGameServerRequest request) {request = beforeClientExecution(request);return executeUpdateGameServer(request);}

public virtual UpdateGameServerResponse UpdateGameServer(UpdateGameServerRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGameServerRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGameServerResponseUnmarshaller.Instance;return Invoke<UpdateGameServerResponse>(request, options);}

public GetDetectorVersionResult getDetectorVersion(GetDetectorVersionRequest request) {request = beforeClientExecution(request);return executeGetDetectorVersion(request);}

public virtual GetDetectorVersionResponse GetDetectorVersion(GetDetectorVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDetectorVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDetectorVersionResponseUnmarshaller.Instance;return Invoke<GetDetectorVersionResponse>(request, options);}

public void addField(String fieldName, String text, Analyzer analyzer) {if (fieldName == null)throw new IllegalArgumentException("fieldName must not be null");if (text == null)throw new IllegalArgumentException("text must not be null");if (analyzer == null)throw new IllegalArgumentException("analyzer must not be null");TokenStream stream = analyzer.tokenStream(fieldName, text);storeTerms(getInfo(fieldName, defaultFieldType), stream,analyzer.getPositionIncrementGap(fieldName), analyzer.getOffsetGap(fieldName));}

public virtual void AddField(string fieldName, string text, Analyzer analyzer){if (fieldName == null){throw new System.ArgumentException("fieldName must not be null");}if (text == null){throw new System.ArgumentException("text must not be null");}if (analyzer == null){throw new System.ArgumentException("analyzer must not be null");}TokenStream stream;try{stream = analyzer.GetTokenStream(fieldName, text);}catch (IOException ex){throw new Exception(ex.ToString(), ex);}AddField(fieldName, stream, 1.0f, analyzer.GetPositionIncrementGap(fieldName), analyzer.GetOffsetGap(fieldName));}

public boolean isEnabled(String component) {return false;}

public override bool IsEnabled(string component){return false;}

public long next() {final long idx = 1 + (ord / indexInterval);if (idx >= fieldIndex.numIndexTerms) {return -1;}ord += indexInterval;final long offset = fieldIndex.termOffsets.get(idx);final int length = (int) (fieldIndex.termOffsets.get(1+idx) - offset);termBytesReader.fillSlice(term, fieldIndex.termBytesStart + offset, length);return fieldIndex.termsStart + fieldIndex.termsDictOffsets.get(idx);}

public override long Next(){int idx = 1 + (int)(ord / outerInstance.totalIndexInterval);if (idx >= fieldIndex.numIndexTerms){return -1;}ord += outerInstance.totalIndexInterval;long offset = fieldIndex.termOffsets.Get(idx);int length = (int)(fieldIndex.termOffsets.Get(1 + idx) - offset);outerInstance.termBytesReader.FillSlice(term, fieldIndex.termBytesStart + offset, length);return fieldIndex.termsStart + fieldIndex.termsDictOffsets.Get(idx);}

public DisassociateMemberFromGroupResult disassociateMemberFromGroup(DisassociateMemberFromGroupRequest request) {request = beforeClientExecution(request);return executeDisassociateMemberFromGroup(request);}

public virtual DisassociateMemberFromGroupResponse DisassociateMemberFromGroup(DisassociateMemberFromGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateMemberFromGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateMemberFromGroupResponseUnmarshaller.Instance;return Invoke<DisassociateMemberFromGroupResponse>(request, options);}

public UnmergedPathException(DirCacheEntry dce) {super(MessageFormat.format(JGitText.get().unmergedPath, dce.getPathString()));entry = dce;}

public UnmergedPathException(DirCacheEntry dce) : base(MessageFormat.Format(JGitText.Get().unmergedPath, dce.PathString)){entry = dce;}

public Name(NameRecord nameRecord, int index) {_nameRecord = nameRecord;_index = index;}

public Name(NameRecord nameRecord, int index){_nameRecord = nameRecord;_index = index;}

public void add(ET object) {if (expectedModCount == list.modCount) {Link<ET> next = link.next;Link<ET> newLink = new Link<ET>(object, link, next);link.next = newLink;next.previous = newLink;link = newLink;lastLink = null;pos++;expectedModCount++;list.size++;list.modCount++;} else {throw new ConcurrentModificationException();}}

public void add(ET @object){if (expectedModCount == list.modCount){java.util.LinkedList.Link<ET> next_1 = link.next;java.util.LinkedList.Link<ET> newLink = new java.util.LinkedList.Link<ET>(@object, link, next_1);link.next = newLink;next_1.previous = newLink;link = newLink;lastLink = null;pos++;expectedModCount++;list._size++;list.modCount++;}else{throw new java.util.ConcurrentModificationException();}}

public final ByteOrder order() {return order;}

public java.nio.ByteOrder order(){return _order;}

public ValueFiller getValueFiller() {return new ValueFiller() {private final MutableValueStr mval = new MutableValueStr();@Override

public override ValueFiller GetValueFiller(){return new ValueFillerAnonymousInnerClassHelper(this);}

public SubmoduleInitCommand addPath(String path) {paths.add(path);return this;}

public virtual NGit.Api.SubmoduleInitCommand AddPath(string path){paths.AddItem(path);return this;}

public DeleteInterconnectResult deleteInterconnect(DeleteInterconnectRequest request) {request = beforeClientExecution(request);return executeDeleteInterconnect(request);}

public virtual DeleteInterconnectResponse DeleteInterconnect(DeleteInterconnectRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInterconnectRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInterconnectResponseUnmarshaller.Instance;return Invoke<DeleteInterconnectResponse>(request, options);}

public Credential(String keyId, String secret) {this.accessKeyId = keyId;this.accessSecret = secret;this.refreshDate = new Date();}

public Credential(string keyId, string secret){AccessKeyId = keyId;AccessSecret = secret;RefreshDate = DateTime.UtcNow;}

public DeleteRepoWebhookRequest() {super("cr", "2016-06-07", "DeleteRepoWebhook", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/webhooks/[WebhookId]");setMethod(MethodType.DELETE);}

public DeleteRepoWebhookRequest(): base("cr", "2016-06-07", "DeleteRepoWebhook", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/webhooks/[WebhookId]";Method = MethodType.DELETE;}

public DeleteDeviceResult deleteDevice(DeleteDeviceRequest request) {request = beforeClientExecution(request);return executeDeleteDevice(request);}

public virtual DeleteDeviceResponse DeleteDevice(DeleteDeviceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDeviceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDeviceResponseUnmarshaller.Instance;return Invoke<DeleteDeviceResponse>(request, options);}

public CreateEventBusResult createEventBus(CreateEventBusRequest request) {request = beforeClientExecution(request);return executeCreateEventBus(request);}

public virtual CreateEventBusResponse CreateEventBus(CreateEventBusRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEventBusRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEventBusResponseUnmarshaller.Instance;return Invoke<CreateEventBusResponse>(request, options);}

public boolean isEnabled() {return enabled;}

public virtual bool IsEnabled(){return enabled;}

public boolean isSigned() {return signed;}

public virtual bool IsSigned(){return signed;}

public DeleteRuleVersionResult deleteRuleVersion(DeleteRuleVersionRequest request) {request = beforeClientExecution(request);return executeDeleteRuleVersion(request);}

public virtual DeleteRuleVersionResponse DeleteRuleVersion(DeleteRuleVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRuleVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRuleVersionResponseUnmarshaller.Instance;return Invoke<DeleteRuleVersionResponse>(request, options);}

public long seek(long ord) {throw new UnsupportedOperationException();}

public override long Seek(long ord){throw new NotSupportedException();}

public CreateAppCookieStickinessPolicyRequest(String loadBalancerName, String policyName, String cookieName) {setLoadBalancerName(loadBalancerName);setPolicyName(policyName);setCookieName(cookieName);}

public CreateAppCookieStickinessPolicyRequest(string loadBalancerName, string policyName, string cookieName){_loadBalancerName = loadBalancerName;_policyName = policyName;_cookieName = cookieName;}

public BlameCommand setDiffAlgorithm(DiffAlgorithm diffAlgorithm) {this.diffAlgorithm = diffAlgorithm;return this;}

public virtual NGit.Api.BlameCommand SetDiffAlgorithm(DiffAlgorithm diffAlgorithm){this.diffAlgorithm = diffAlgorithm;return this;}

public DisassociateSkillFromUsersResult disassociateSkillFromUsers(DisassociateSkillFromUsersRequest request) {request = beforeClientExecution(request);return executeDisassociateSkillFromUsers(request);}

public virtual DisassociateSkillFromUsersResponse DisassociateSkillFromUsers(DisassociateSkillFromUsersRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateSkillFromUsersRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateSkillFromUsersResponseUnmarshaller.Instance;return Invoke<DisassociateSkillFromUsersResponse>(request, options);}

public PatchIdDiffFormatter() {super(new DigestOutputStream(NullOutputStream.INSTANCE,Constants.newMessageDigest()));digest = ((DigestOutputStream) getOutputStream()).getMessageDigest();}

public PatchIdDiffFormatter() : base(new DigestOutputStream(NullOutputStream.INSTANCE, Constants.NewMessageDigest())){digest = ((DigestOutputStream)GetOutputStream()).GetMessageDigest();}

public SendMessageResult sendMessage(SendMessageRequest request) {request = beforeClientExecution(request);return executeSendMessage(request);}

public virtual SendMessageResponse SendMessage(SendMessageRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendMessageRequestMarshaller.Instance;options.ResponseUnmarshaller = SendMessageResponseUnmarshaller.Instance;return Invoke<SendMessageResponse>(request, options);}

public static ParsePathType pathType(Path f) {int pathLength = 0;while (f != null && f.getFileName() != null && ++pathLength < MAX_PATH_LENGTH) {ParsePathType ppt = pathName2Type.get(f.getFileName().toString().toUpperCase(Locale.ROOT));if (ppt!=null) {return ppt;}f = f.getParent();}return DEFAULT_PATH_TYPE;}

public static ParsePathType PathType(FileInfo f){int pathLength = 0;ParsePathType? ppt;if (pathName2Type.TryGetValue(f.Name.ToUpperInvariant(), out ppt) && ppt != null){return ppt.Value;}DirectoryInfo parentDir = f.Directory;while (parentDir != null && ++pathLength < MAX_PATH_LENGTH){if (pathName2Type.TryGetValue(parentDir.Name.ToUpperInvariant(), out ppt) && ppt != null){return ppt.Value;}parentDir = parentDir.Parent;}return DEFAULT_PATH_TYPE;}

public static long estimateIndexSize(int sourceLength) {return sourceLength + (sourceLength * 3 / 4);}

public static long EstimateIndexSize(int sourceLength){return sourceLength + (sourceLength * 3 / 4);}

public UpdateDashboardPermissionsResult updateDashboardPermissions(UpdateDashboardPermissionsRequest request) {request = beforeClientExecution(request);return executeUpdateDashboardPermissions(request);}

public virtual UpdateDashboardPermissionsResponse UpdateDashboardPermissions(UpdateDashboardPermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDashboardPermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDashboardPermissionsResponseUnmarshaller.Instance;return Invoke<UpdateDashboardPermissionsResponse>(request, options);}

public String formatAsString() {switch (_cellType) {case NUMERIC:return String.valueOf(_numberValue);case STRING:return '"' + _textValue + '"';case BOOLEAN:return _booleanValue ? "TRUE" : "FALSE";case ERROR:return ErrorEval.getText(_errorCode);default:return "<error unexpected cell type " + _cellType + ">";}}

public String FormatAsString(){switch (_cellType){case CellType.Numeric:string result = _numberValue.ToString(CultureInfo.InvariantCulture);return result;case CellType.String:return '"' + _textValue + '"';case CellType.Boolean:return _boolValue ? "TRUE" : "FALSE";case CellType.Error:return ErrorEval.GetText(_errorCode);}return "<error unexpected cell type " + _cellType + ">";}

public final void add(RevFlagSet set) {flags |= set.mask;}

public void Add(RevFlagSet set){flags |= set.mask;}

public URIish setHost(String n) {final URIish r = new URIish(this);r.host = n;return r;}

public virtual NGit.Transport.URIish SetHost(string n){NGit.Transport.URIish r = new NGit.Transport.URIish(this);r.host = n;return r;}

public void clearFormulaEntry() {CellCacheEntry[] usedCells = _sensitiveInputCells;if (usedCells != null) {for (int i = usedCells.length-1; i>=0; i--) {usedCells[i].clearConsumingCell(this);}}_sensitiveInputCells = null;clearValue();}

public void ClearFormulaEntry(){CellCacheEntry[] usedCells = _sensitiveInputCells;if (usedCells != null){for (int i = usedCells.Length - 1; i >= 0; i--){usedCells[i].ClearConsumingCell(this);}}_sensitiveInputCells = null;ClearValue();}

public GetDiskSnapshotResult getDiskSnapshot(GetDiskSnapshotRequest request) {request = beforeClientExecution(request);return executeGetDiskSnapshot(request);}

public virtual GetDiskSnapshotResponse GetDiskSnapshot(GetDiskSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDiskSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDiskSnapshotResponseUnmarshaller.Instance;return Invoke<GetDiskSnapshotResponse>(request, options);}

public DescribeIpv6PoolsResult describeIpv6Pools(DescribeIpv6PoolsRequest request) {request = beforeClientExecution(request);return executeDescribeIpv6Pools(request);}

public virtual DescribeIpv6PoolsResponse DescribeIpv6Pools(DescribeIpv6PoolsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIpv6PoolsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIpv6PoolsResponseUnmarshaller.Instance;return Invoke<DescribeIpv6PoolsResponse>(request, options);}

public UpdateDetectorResult updateDetector(UpdateDetectorRequest request) {request = beforeClientExecution(request);return executeUpdateDetector(request);}

public virtual UpdateDetectorResponse UpdateDetector(UpdateDetectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDetectorRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDetectorResponseUnmarshaller.Instance;return Invoke<UpdateDetectorResponse>(request, options);}

public DeleteInstanceResult deleteInstance(DeleteInstanceRequest request) {request = beforeClientExecution(request);return executeDeleteInstance(request);}

public virtual DeleteInstanceResponse DeleteInstance(DeleteInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteInstanceResponseUnmarshaller.Instance;return Invoke<DeleteInstanceResponse>(request, options);}

public ListThreatIntelSetsResult listThreatIntelSets(ListThreatIntelSetsRequest request) {request = beforeClientExecution(request);return executeListThreatIntelSets(request);}

public virtual ListThreatIntelSetsResponse ListThreatIntelSets(ListThreatIntelSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListThreatIntelSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListThreatIntelSetsResponseUnmarshaller.Instance;return Invoke<ListThreatIntelSetsResponse>(request, options);}

public ExportClientVpnClientConfigurationResult exportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request) {request = beforeClientExecution(request);return executeExportClientVpnClientConfiguration(request);}

public virtual ExportClientVpnClientConfigurationResponse ExportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = ExportClientVpnClientConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = ExportClientVpnClientConfigurationResponseUnmarshaller.Instance;return Invoke<ExportClientVpnClientConfigurationResponse>(request, options);}

public float currentScore(int docId, String field, int start, int end, int numPayloadsSeen, float currentScore, float currentPayloadScore) {if (numPayloadsSeen == 0) {return currentPayloadScore;} else {return Math.max(currentPayloadScore, currentScore);}}

public override float CurrentScore(int docId, string field, int start, int end, int numPayloadsSeen, float currentScore, float currentPayloadScore){if (numPayloadsSeen == 0){return currentPayloadScore;}else{return Math.Max(currentPayloadScore, currentScore);}}

public CreateDBParameterGroupRequest(String dBParameterGroupName, String dBParameterGroupFamily, String description) {setDBParameterGroupName(dBParameterGroupName);setDBParameterGroupFamily(dBParameterGroupFamily);setDescription(description);}

public CreateDBParameterGroupRequest(string dbParameterGroupName, string dbParameterGroupFamily, string description){_dbParameterGroupName = dbParameterGroupName;_dbParameterGroupFamily = dbParameterGroupFamily;_description = description;}

public void add(int forwardId, int backwardId, int cost) {int offset = (backwardId * forwardSize + forwardId) * 2;costs.putShort(offset, (short) cost);}

public void Add(int forwardId, int backwardId, int cost){this.costs[backwardId][forwardId] = (short)cost;}

public boolean isPeeled() {return true;}

public override bool IsPeeled(){return true;}

public CreateTransitVirtualInterfaceResult createTransitVirtualInterface(CreateTransitVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeCreateTransitVirtualInterface(request);}

public virtual CreateTransitVirtualInterfaceResponse CreateTransitVirtualInterface(CreateTransitVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTransitVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTransitVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<CreateTransitVirtualInterfaceResponse>(request, options);}

public BatchDetectSentimentResult batchDetectSentiment(BatchDetectSentimentRequest request) {request = beforeClientExecution(request);return executeBatchDetectSentiment(request);}

public virtual BatchDetectSentimentResponse BatchDetectSentiment(BatchDetectSentimentRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchDetectSentimentRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchDetectSentimentResponseUnmarshaller.Instance;return Invoke<BatchDetectSentimentResponse>(request, options);}

public boolean equals(Object o) {if ( o==null || !(o instanceof Interval) ) {return false;}Interval other = (Interval)o;return this.a==other.a && this.b==other.b;}

public override bool Equals(object o){if (!(o is Antlr4.Runtime.Misc.Interval)){return false;}Antlr4.Runtime.Misc.Interval other = (Antlr4.Runtime.Misc.Interval)o;return this.a == other.a && this.b == other.b;}