Datasets:

google

/

code_x_glue_cc_code_to_code_trans

like 7

public static String getInflectedFormTranslation(String s) {return inflFormTranslations.get(s);}

public static string GetInflectedFormTranslation(string s){string result;inflFormTranslations.TryGetValue(s, out result);return result;}

public static ErrPtg valueOf(int code) {switch(FormulaError.forInt(code)) {case DIV0: return DIV_ZERO;case NA: return N_A;case NAME: return NAME_INVALID;case NULL: return NULL_INTERSECTION;case NUM: return NUM_ERROR;case REF: return REF_INVALID;case VALUE: return VALUE_INVALID;default:throw new RuntimeException("Unexpected error code (" + code + ")");}}

public static ErrPtg ValueOf(int code){switch (code){case HSSFErrorConstants.ERROR_DIV_0: return DIV_ZERO;case HSSFErrorConstants.ERROR_NA: return N_A;case HSSFErrorConstants.ERROR_NAME: return NAME_INVALID;case HSSFErrorConstants.ERROR_NULL: return NULL_INTERSECTION;case HSSFErrorConstants.ERROR_NUM: return NUM_ERROR;case HSSFErrorConstants.ERROR_REF: return REF_INVALID;case HSSFErrorConstants.ERROR_VALUE: return VALUE_INVALID;}throw new InvalidOperationException("Unexpected error code (" + code + ")");}

public GetBasePathMappingResult getBasePathMapping(GetBasePathMappingRequest request) {request = beforeClientExecution(request);return executeGetBasePathMapping(request);}

public virtual GetBasePathMappingResponse GetBasePathMapping(GetBasePathMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBasePathMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBasePathMappingResponseUnmarshaller.Instance;return Invoke<GetBasePathMappingResponse>(request, options);}

public void fromObjectId(AnyObjectId src) {this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}

public virtual void FromObjectId(AnyObjectId src){this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}

public static List<? extends Tree> getAncestors(Tree t) {if ( t.getParent()==null ) return Collections.emptyList();List<Tree> ancestors = new ArrayList<Tree>();t = t.getParent();while ( t!=null ) {ancestors.add(0, t); t = t.getParent();}return ancestors;}

public static IList<ITree> GetAncestors(ITree t){if (t.Parent == null){return Collections.EmptyList<ITree>();}IList<ITree> ancestors = new List<ITree>();t = t.Parent;while (t != null){ancestors.Insert(0, t);t = t.Parent;}return ancestors;}

public GetUsagePlanResult getUsagePlan(GetUsagePlanRequest request) {request = beforeClientExecution(request);return executeGetUsagePlan(request);}

public virtual GetUsagePlanResponse GetUsagePlan(GetUsagePlanRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetUsagePlanRequestMarshaller.Instance;options.ResponseUnmarshaller = GetUsagePlanResponseUnmarshaller.Instance;return Invoke<GetUsagePlanResponse>(request, options);}

public UpdateLoadBalancerAttributeResult updateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request) {request = beforeClientExecution(request);return executeUpdateLoadBalancerAttribute(request);}

public virtual UpdateLoadBalancerAttributeResponse UpdateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateLoadBalancerAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateLoadBalancerAttributeResponseUnmarshaller.Instance;return Invoke<UpdateLoadBalancerAttributeResponse>(request, options);}

public void addResult(int n, boolean isRelevant, long docNameExtractTime) {if (Math.abs(numPoints+1 - n) > 1E-6) {throw new IllegalArgumentException("point "+n+" illegal after "+numPoints+" points!");}if (isRelevant) {numGoodPoints+=1;recallPoints.add(new RecallPoint(n,numGoodPoints));if (recallPoints.size()==1 && n<=5) { mrr = 1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant) {pReleventSum += p;}if (n<pAt.length) {pAt[n] = p;}recall = maxGoodPoints<=0 ? p : numGoodPoints/maxGoodPoints;docNamesExtractTime += docNameExtractTime;}

public virtual void AddResult(int n, bool isRelevant, long docNameExtractTime){if (Math.Abs(numPoints + 1 - n) > 1E-6){throw new ArgumentException("point " + n + " illegal after " + numPoints + " points!");}if (isRelevant){numGoodPoints += 1;recallPoints.Add(new RecallPoint(n, numGoodPoints));if (recallPoints.Count == 1 && n <= 5){ mrr = 1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant){pReleventSum += p;}if (n < pAt.Length){pAt[n] = p;}recall = maxGoodPoints <= 0 ? p : numGoodPoints / maxGoodPoints;docNamesExtractTime += docNameExtractTime;}

public UpdateExperimentResult updateExperiment(UpdateExperimentRequest request) {request = beforeClientExecution(request);return executeUpdateExperiment(request);}

public virtual UpdateExperimentResponse UpdateExperiment(UpdateExperimentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance;return Invoke<UpdateExperimentResponse>(request, options);}

public String toString() {return "(" + a.toString() + " AND " + b.toString() + ")";}

public override string ToString(){return "(" + a.ToString() + " OR " + b.ToString() + ")";}

public String getAccessKeyId() {return accessKeyId;}

public string GetAccessKeyId(){return accessKeyId;}

public GetBulkPublishDetailsResult getBulkPublishDetails(GetBulkPublishDetailsRequest request) {request = beforeClientExecution(request);return executeGetBulkPublishDetails(request);}

public virtual GetBulkPublishDetailsResponse GetBulkPublishDetails(GetBulkPublishDetailsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBulkPublishDetailsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBulkPublishDetailsResponseUnmarshaller.Instance;return Invoke<GetBulkPublishDetailsResponse>(request, options);}

public static byte[] grow(byte[] array) {return grow(array, 1 + array.length);}

public static float[] Grow(float[] array){return Grow(array, 1 + array.Length);}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2) {double result;try {result = evaluate(evalArg(arg0, srcRowIndex, srcColumnIndex), evalArg(arg1, srcRowIndex, srcColumnIndex), evalArg(arg2, srcRowIndex, srcColumnIndex));} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2){double result;try{result = Evaluate(EvalArg(arg0, srcRowIndex, srcColumnIndex), EvalArg(arg1, srcRowIndex, srcColumnIndex), EvalArg(arg2, srcRowIndex, srcColumnIndex));}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}

public static final int hash32(final byte[] data, int offset, int len) {return MurmurHash2.hash(data, 0x9747b28c, offset, len);}

public static int Hash32(byte[] data, int offset, int len){return Hash(data, unchecked((int)0x9747b28c), offset, len);}

public static Formula create(Ptg[] ptgs) {if (ptgs == null || ptgs.length < 1) {return EMPTY;}int totalSize = Ptg.getEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.serializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.getEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}

public static Formula Create(Ptg[] ptgs){if (ptgs == null || ptgs.Length < 1){return EMPTY;}int totalSize = Ptg.GetEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.SerializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.GetEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}

public String toString(String field){return null;}

public override string ToString(string field){return null;}

public static int deleteN(char s[], int pos, int len, int nChars) {assert pos + nChars <= len;if (pos + nChars < len) { System.arraycopy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}

public static int DeleteN(char[] s, int pos, int len, int nChars){Debug.Assert(pos + nChars <= len);if (pos + nChars < len) {Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}

public ThreadSafeProgressMonitor(ProgressMonitor pm) {this.pm = pm;this.lock = new ReentrantLock();this.mainThread = Thread.currentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = new Semaphore(0);}

public ThreadSafeProgressMonitor(ProgressMonitor pm){this.pm = pm;this.Lock = new ReentrantLock();this.mainThread = Sharpen.Thread.CurrentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = Sharpen.Extensions.CreateSemaphore(0);}

public SendMessageBatchRequestEntry(String id, String messageBody) {setId(id);setMessageBody(messageBody);}

public SendMessageBatchRequestEntry(string id, string messageBody){_id = id;_messageBody = messageBody;}

public DescribeAddressResult describeAddress(DescribeAddressRequest request) {request = beforeClientExecution(request);return executeDescribeAddress(request);}

public virtual DescribeAddressResponse DescribeAddress(DescribeAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAddressResponseUnmarshaller.Instance;return Invoke<DescribeAddressResponse>(request, options);}

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

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

public DescribeRuleResult describeRule(DescribeRuleRequest request) {request = beforeClientExecution(request);return executeDescribeRule(request);}

public virtual DescribeRuleResponse DescribeRule(DescribeRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRuleResponseUnmarshaller.Instance;return Invoke<DescribeRuleResponse>(request, options);}

public final RevObject getObject() {return object;}

public RevObject GetObject(){return @object;}

public JapaneseIterationMarkCharFilterFactory(Map<String,String> args) {super(args);normalizeKanji = getBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = getBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public JapaneseIterationMarkCharFilterFactory(IDictionary<string, string> args): base(args){normalizeKanji = GetBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = GetBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (args.Count > 0){throw new ArgumentException("Unknown parameters: " + args);}}

public char previous() {if (--index < start) {index = start;return DONE;} else {return current();}}

public override char Previous(){if (--index < start){index = start;return Done;}else{return Current;}}

public LoggingConfig(String bucket, String prefix) {setBucket(bucket);setPrefix(prefix);}

public LoggingConfig(string bucket, string prefix){_bucket = bucket;_prefix = prefix;}

public static String createSafeSheetName(final String nameProposal) {return createSafeSheetName(nameProposal, ' ');}

public static String CreateSafeSheetName(String nameProposal){return CreateSafeSheetName(nameProposal, ' ');}

public PutMetricAlarmResult putMetricAlarm(PutMetricAlarmRequest request) {request = beforeClientExecution(request);return executePutMetricAlarm(request);}

public virtual PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutMetricAlarmRequestMarshaller.Instance;options.ResponseUnmarshaller = PutMetricAlarmResponseUnmarshaller.Instance;return Invoke<PutMetricAlarmResponse>(request, options);}

public CreateExclusionsPreviewResult createExclusionsPreview(CreateExclusionsPreviewRequest request) {request = beforeClientExecution(request);return executeCreateExclusionsPreview(request);}

public virtual CreateExclusionsPreviewResponse CreateExclusionsPreview(CreateExclusionsPreviewRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateExclusionsPreviewRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateExclusionsPreviewResponseUnmarshaller.Instance;return Invoke<CreateExclusionsPreviewResponse>(request, options);}

public OutputStream getRawStream() {return buf;}

public virtual OutputStream GetRawStream(){return buf;}

public int getThreads() {return threads;}

public virtual int GetThreads(){return threads;}

public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final int byte0 = blocks[blocksOffset++] & 0xFF;final int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | (byte1 >>> 2);final int byte2 = blocks[blocksOffset++] & 0xFF;final int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | (byte3 >>> 4);final int byte4 = blocks[blocksOffset++] & 0xFF;final int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | (byte5 >>> 6);final int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}

public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | ((int)((uint)byte1 >> 2));int byte2 = blocks[blocksOffset++] & 0xFF;int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | ((int)((uint)byte3 >> 4));int byte4 = blocks[blocksOffset++] & 0xFF;int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | ((int)((uint)byte5 >> 6));int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}

public boolean eof() {assert upto + bufferOffset <= endIndex;return upto + bufferOffset == endIndex;}

public bool Eof(){Debug.Assert(upto + BufferOffset <= EndIndex);return upto + BufferOffset == EndIndex;}

public ClientException(String message) {super(message);this.setErrorType(ErrorType.Client);}

public ClientException(string message) : base(message){ErrorMessage = message;}

public static NumberRecord[] convertRKRecords(MulRKRecord mrk) {NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];for (int k = 0; k < mrk.getNumColumns(); k++) {NumberRecord nr = new NumberRecord();nr.setColumn((short) (k + mrk.getFirstColumn()));nr.setRow(mrk.getRow());nr.setXFIndex(mrk.getXFAt(k));nr.setValue(mrk.getRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}

public static NumberRecord[] ConvertRKRecords(MulRKRecord mrk){NumberRecord[] mulRecs = new NumberRecord[mrk.NumColumns];for (int k = 0; k < mrk.NumColumns; k++){NumberRecord nr = new NumberRecord();nr.Column = ((short)(k + mrk.FirstColumn));nr.Row = (mrk.Row);nr.XFIndex = (mrk.GetXFAt(k));nr.Value = (mrk.GetRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}

public List<ReceiveCommand> getCommands() {return Collections.unmodifiableList(commands);}

public virtual IList<ReceiveCommand> GetCommands(){return Sharpen.Collections.UnmodifiableList(commands);}

public UpdateVoiceConnectorResult updateVoiceConnector(UpdateVoiceConnectorRequest request) {request = beforeClientExecution(request);return executeUpdateVoiceConnector(request);}

public virtual UpdateVoiceConnectorResponse UpdateVoiceConnector(UpdateVoiceConnectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateVoiceConnectorRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateVoiceConnectorResponseUnmarshaller.Instance;return Invoke<UpdateVoiceConnectorResponse>(request, options);}

public static String getText(int errorCode) {if(FormulaError.isValidCode(errorCode)) {return FormulaError.forInt(errorCode).getString();}return "~non~std~err(" + errorCode + ")~";}

public static String GetText(int errorCode){if (FormulaError.IsValidCode(errorCode)){return FormulaError.ForInt(errorCode).String;}return "~non~std~err(" + errorCode + ")~";}

public long nextOrd() {long v = ord;ord = NO_MORE_ORDS;return v;}

public override long NextOrd(){if (set){return NO_MORE_ORDS;}else{set = true;return @in.GetOrd(docID);}}

public EntityResolver getEntityResolver () {return (theEntityResolver == this) ? null : theEntityResolver;}

public void close (){lock (this.mBlock) {if (this.mParseState != null) {this.mParseState.Dispose ();this.mParseState = null;this.mBlock.decOpenCountLocked ();}}}

public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex) {if (sheetIndex < 0) {throw new IllegalArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}

public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex){if (sheetIndex < 0){throw new ArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}

public DBSecurityGroup authorizeDBSecurityGroupIngress(AuthorizeDBSecurityGroupIngressRequest request) {request = beforeClientExecution(request);return executeAuthorizeDBSecurityGroupIngress(request);}

public virtual AuthorizeDBSecurityGroupIngressResponse AuthorizeDBSecurityGroupIngress(AuthorizeDBSecurityGroupIngressRequest request){var options = new InvokeOptions();options.RequestMarshaller = AuthorizeDBSecurityGroupIngressRequestMarshaller.Instance;options.ResponseUnmarshaller = AuthorizeDBSecurityGroupIngressResponseUnmarshaller.Instance;return Invoke<AuthorizeDBSecurityGroupIngressResponse>(request, options);}

@Override public V put(K key, V value) {if (key == null) {return putValueForNullKey(value);}int hash = secondaryHash(key.hashCode());HashMapEntry<K, V>[] tab = table;int index = hash & (tab.length - 1);for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {if (e.hash == hash && key.equals(e.key)) {preModify(e);V oldValue = e.value;e.value = value;return oldValue;}}modCount++;if (size++ > threshold) {tab = doubleCapacity();index = hash & (tab.length - 1);}addNewEntry(key, value, hash, index);return null;}

public override V put(K key, V value){if ((object)key == null){return putValueForNullKey(value);}int hash = secondaryHash(key.GetHashCode());java.util.HashMap.HashMapEntry<K, V>[] tab = table;int index = hash & (tab.Length - 1);{for (java.util.HashMap.HashMapEntry<K, V> e = tab[index]; e != null; e = e.next){if (e.hash == hash && key.Equals(e.key)){preModify(e);V oldValue = e.value;e.value = value;return oldValue;}}}modCount++;if (_size++ > threshold){tab = doubleCapacity();index = hash & (tab.Length - 1);}addNewEntry(key, value, hash, index);return default(V);}

public GetTrafficPolicyInstanceResult getTrafficPolicyInstance(GetTrafficPolicyInstanceRequest request) {request = beforeClientExecution(request);return executeGetTrafficPolicyInstance(request);}

public virtual GetTrafficPolicyInstanceResponse GetTrafficPolicyInstance(GetTrafficPolicyInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTrafficPolicyInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTrafficPolicyInstanceResponseUnmarshaller.Instance;return Invoke<GetTrafficPolicyInstanceResponse>(request, options);}

public Message(Content subject, Body body) {setSubject(subject);setBody(body);}

public Message(Content subject, Body body){_subject = subject;_body = body;}

public LbsDropData() {_str = "";_unused = 0;}

public LbsDropData(){_str = "";_unused = 0;}

public Deleted3DPxg(String sheetName) {this(-1, sheetName);}

public Deleted3DPxg(String sheetName): this(-1, sheetName){;}

public String getName() {return "simple-two-way-in-core"; }

public override string GetName(){return "simple-two-way-in-core";}

public RevTree parseTree(AnyObjectId id)throws MissingObjectException, IncorrectObjectTypeException,IOException {RevObject c = peel(parseAny(id));final RevTree t;if (c instanceof RevCommit)t = ((RevCommit) c).getTree();else if (!(c instanceof RevTree))throw new IncorrectObjectTypeException(id.toObjectId(),Constants.TYPE_TREE);elset = (RevTree) c;parseHeaders(t);return t;}

public virtual RevTree ParseTree(AnyObjectId id){RevObject c = Peel(ParseAny(id));RevTree t;if (c is RevCommit){t = ((RevCommit)c).Tree;}else{if (!(c is RevTree)){throw new IncorrectObjectTypeException(id.ToObjectId(), Constants.TYPE_TREE);}else{t = (RevTree)c;}}ParseHeaders(t);return t;}

public DisableFastSnapshotRestoresResult disableFastSnapshotRestores(DisableFastSnapshotRestoresRequest request) {request = beforeClientExecution(request);return executeDisableFastSnapshotRestores(request);}

public virtual DisableFastSnapshotRestoresResponse DisableFastSnapshotRestores(DisableFastSnapshotRestoresRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisableFastSnapshotRestoresRequestMarshaller.Instance;options.ResponseUnmarshaller = DisableFastSnapshotRestoresResponseUnmarshaller.Instance;return Invoke<DisableFastSnapshotRestoresResponse>(request, options);}

public int size() {return size;}

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

public CreateStreamResult createStream(CreateStreamRequest request) {request = beforeClientExecution(request);return executeCreateStream(request);}

public virtual CreateStreamResponse CreateStream(CreateStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateStreamResponseUnmarshaller.Instance;return Invoke<CreateStreamResponse>(request, options);}

public String replaceAll(String replacement) {reset();StringBuffer buffer = new StringBuffer(input.length());while (find()) {appendReplacement(buffer, replacement);}return appendTail(buffer).toString();}

public string replaceAll(string replacement){reset();java.lang.StringBuffer buffer = new java.lang.StringBuffer(input.Length);while (find()){appendReplacement(buffer, replacement);}return appendTail(buffer).ToString();}

public DeregisterInstanceEventNotificationAttributesResult deregisterInstanceEventNotificationAttributes(DeregisterInstanceEventNotificationAttributesRequest request) {request = beforeClientExecution(request);return executeDeregisterInstanceEventNotificationAttributes(request);}

public virtual DeregisterInstanceEventNotificationAttributesResponse DeregisterInstanceEventNotificationAttributes(DeregisterInstanceEventNotificationAttributesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterInstanceEventNotificationAttributesRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterInstanceEventNotificationAttributesResponseUnmarshaller.Instance;return Invoke<DeregisterInstanceEventNotificationAttributesResponse>(request, options);}

public int getDepth() {return depth;}

public virtual int GetDepth(){return depth;}

public long get() {if (position == limit) {throw new BufferUnderflowException();}return byteBuffer.getLong(position++ * SizeOf.LONG);}

public override long get(){if (_position == _limit){throw new java.nio.BufferUnderflowException();}return byteBuffer.getLong(_position++ * libcore.io.SizeOf.LONG);}

public boolean isEmpty() {return ConcurrentHashMap.this.isEmpty();}

public override bool isEmpty(){return this._enclosing._size == 0;}

public void addName(NameRecord name) {_definedNames.add(name);int idx = findFirstRecordLocBySid(ExternSheetRecord.sid);if (idx == -1) idx = findFirstRecordLocBySid(SupBookRecord.sid);if (idx == -1) idx = findFirstRecordLocBySid(CountryRecord.sid);int countNames = _definedNames.size();_workbookRecordList.add(idx + countNames, name);}

public void AddName(NameRecord name){_definedNames.Add(name);int idx = FindFirstRecordLocBySid(ExternSheetRecord.sid);if (idx == -1) idx = FindFirstRecordLocBySid(SupBookRecord.sid);if (idx == -1) idx = FindFirstRecordLocBySid(CountryRecord.sid);int countNames = _definedNames.Count;_workbookRecordList.Add(idx + countNames, name);}

public void sort(RevSort s, boolean use) {assertNotStarted();if (use)sorting.add(s);elsesorting.remove(s);if (sorting.size() > 1)sorting.remove(RevSort.NONE);else if (sorting.isEmpty())sorting.add(RevSort.NONE);}

public virtual void Sort(RevSort s, bool use){AssertNotStarted();if (use){sorting.AddItem(s);}else{sorting.Remove(s);}if (sorting.Count > 1){sorting.Remove(RevSort.NONE);}else{if (sorting.Count == 0){sorting.AddItem(RevSort.NONE);}}}

public String toString() {return "D";}

public override string ToString(){return "D";}

public DisassociateSkillGroupFromRoomResult disassociateSkillGroupFromRoom(DisassociateSkillGroupFromRoomRequest request) {request = beforeClientExecution(request);return executeDisassociateSkillGroupFromRoom(request);}

public virtual DisassociateSkillGroupFromRoomResponse DisassociateSkillGroupFromRoom(DisassociateSkillGroupFromRoomRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateSkillGroupFromRoomRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateSkillGroupFromRoomResponseUnmarshaller.Instance;return Invoke<DisassociateSkillGroupFromRoomResponse>(request, options);}

public static byte[] encodeASCII(long s) {return encodeASCII(Long.toString(s));}

public static byte[] EncodeASCII(long s){return EncodeASCII(System.Convert.ToString(s));}

public void setData(byte[] b) {setData(b,0,b.length);}

public void SetData(byte[] b){SetData(b, 0, b.Length);}

public void removeLinksDirty() {remove1stProperty(PropertyIDMap.PID_LINKSDIRTY);}

public void RemoveLinksDirty(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_LINKSDIRTY);}

final public void OptionalWeights(SrndQuery q) throws ParseException {Token weight=null;label_8:while (true) {switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {case CARAT:;break;default:jj_la1[9] = jj_gen;break label_8;}jj_consume_token(CARAT);weight = jj_consume_token(NUMBER);float f;try {f = Float.parseFloat(weight.image);} catch (Exception floatExc) {{if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image + " (" + floatExc + ")");}}if (f <= 0.0) {{if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image);}}q.setWeight(f * q.getWeight()); }}

public void OptionalWeights(SrndQuery q){Token weight = null;while (true){switch ((jj_ntk == -1) ? Jj_ntk() : jj_ntk){case RegexpToken.CARAT:;break;default:jj_la1[9] = jj_gen;goto label_8;}Jj_consume_token(RegexpToken.CARAT);weight = Jj_consume_token(RegexpToken.NUMBER);float f;try{f = float.Parse(weight.Image);}catch (Exception floatExc){{ if (true) throw new ParseException(boostErrorMessage + weight.Image + " (" + floatExc + ")"); }}if (f <= 0.0){{ if (true) throw new ParseException(boostErrorMessage + weight.Image); }}q.Weight = (f * q.Weight); }label_8: ;}

public ListLogPatternSetsResult listLogPatternSets(ListLogPatternSetsRequest request) {request = beforeClientExecution(request);return executeListLogPatternSets(request);}

public virtual ListLogPatternSetsResponse ListLogPatternSets(ListLogPatternSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListLogPatternSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListLogPatternSetsResponseUnmarshaller.Instance;return Invoke<ListLogPatternSetsResponse>(request, options);}

public String toString() {return "<field start='" + this.begin + "' end='" + this.end + "' field='"+ this.field + "' text='" + this.text + "'/>";}

public override string ToString(){return "<field start='" + this.m_begin + "' end='" + this.m_end + "' field='"+ this.m_field + "' text='" + this.m_text + "'/>";}

public ListAssessmentTargetsResult listAssessmentTargets(ListAssessmentTargetsRequest request) {request = beforeClientExecution(request);return executeListAssessmentTargets(request);}

public virtual ListAssessmentTargetsResponse ListAssessmentTargets(ListAssessmentTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAssessmentTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAssessmentTargetsResponseUnmarshaller.Instance;return Invoke<ListAssessmentTargetsResponse>(request, options);}

public HSSFFontFormatting getFontFormatting() {return getFontFormatting(false);}

public IFontFormatting GetFontFormatting(){return GetFontFormatting(false);}

public UpdateRoomResult updateRoom(UpdateRoomRequest request) {request = beforeClientExecution(request);return executeUpdateRoom(request);}

public virtual UpdateRoomResponse UpdateRoom(UpdateRoomRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRoomRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRoomResponseUnmarshaller.Instance;return Invoke<UpdateRoomResponse>(request, options);}

public ListLexiconsResult listLexicons(ListLexiconsRequest request) {request = beforeClientExecution(request);return executeListLexicons(request);}

public virtual ListLexiconsResponse ListLexicons(ListLexiconsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListLexiconsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListLexiconsResponseUnmarshaller.Instance;return Invoke<ListLexiconsResponse>(request, options);}

public boolean equals( Object o ) {return o instanceof KpStemmer;}

public override bool Equals(object o){return o is KpStemmer;}

public void write(String str, int offset, int count) {String sub = str.substring(offset, offset + count);buf.append(sub);}

public override void write(string str, int offset, int count){string sub = Sharpen.StringHelper.Substring(str, offset, offset + count);buf.append(sub);}

public PackLock(File packFile, FS fs) {final File p = packFile.getParentFile();final String n = packFile.getName();keepFile = new File(p, n.substring(0, n.length() - 5) + ".keep"); }

public PackLock(FilePath packFile, FS fs){FilePath p = packFile.GetParentFile();string n = packFile.GetName();keepFile = new FilePath(p, Sharpen.Runtime.Substring(n, 0, n.Length - 5) + ".keep");this.fs = fs;}

public CreatePublicKeyResult createPublicKey(CreatePublicKeyRequest request) {request = beforeClientExecution(request);return executeCreatePublicKey(request);}

public virtual CreatePublicKeyResponse CreatePublicKey(CreatePublicKeyRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePublicKeyRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePublicKeyResponseUnmarshaller.Instance;return Invoke<CreatePublicKeyResponse>(request, options);}

public PersonIdent getRefLogIdent() {return refLogIdent;}

public virtual PersonIdent GetRefLogIdent(){return refLogIdent;}

public boolean equals(Object o) {if (this == o) {return true;}if (!(o instanceof EscherComplexProperty)) {return false;}EscherComplexProperty escherComplexProperty = (EscherComplexProperty) o;return Arrays.equals(complexData, escherComplexProperty.complexData);}

public override bool Equals(Object o){if (this == o) return true;if (!(o is EscherComplexProperty)) return false;EscherComplexProperty escherComplexProperty = (EscherComplexProperty)o;if (!Arrays.Equals(_complexData, escherComplexProperty._complexData)) return false;return true;}

public void unread(int oneByte) throws IOException {if (buf == null) {throw new IOException();}if (pos == 0) {throw new IOException("Pushback buffer full");}buf[--pos] = (byte) oneByte;}

public virtual void unread(int oneByte){if (buf == null){throw new System.IO.IOException();}if (pos == 0){throw new System.IO.IOException("Pushback buffer full");}buf[--pos] = unchecked((byte)oneByte);}

public GetSegmentImportJobsResult getSegmentImportJobs(GetSegmentImportJobsRequest request) {request = beforeClientExecution(request);return executeGetSegmentImportJobs(request);}

public virtual GetSegmentImportJobsResponse GetSegmentImportJobs(GetSegmentImportJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetSegmentImportJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetSegmentImportJobsResponseUnmarshaller.Instance;return Invoke<GetSegmentImportJobsResponse>(request, options);}

public VerifyEmailAddressResult verifyEmailAddress(VerifyEmailAddressRequest request) {request = beforeClientExecution(request);return executeVerifyEmailAddress(request);}

public virtual VerifyEmailAddressResponse VerifyEmailAddress(VerifyEmailAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = VerifyEmailAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = VerifyEmailAddressResponseUnmarshaller.Instance;return Invoke<VerifyEmailAddressResponse>(request, options);}

public GetTagsResult getTags(GetTagsRequest request) {request = beforeClientExecution(request);return executeGetTags(request);}

public virtual GetTagsResponse GetTags(GetTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTagsResponseUnmarshaller.Instance;return Invoke<GetTagsResponse>(request, options);}

public String toString(){StringBuilder sb = new StringBuilder();sb.append( text ).append( '(' );for( Toffs to : termsOffsets )sb.append( to.toString() );sb.append( ')' );return sb.toString();}

public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append(text).Append('(');foreach (Toffs to in termsOffsets)sb.Append(to.ToString());sb.Append(')');return sb.ToString();}

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

public override TreeFilter Clone(){return new OrTreeFilter.Binary(a.Clone(), b.Clone());}

public StandardTokenizerImpl(java.io.Reader in) {this.zzReader = in;}

public StandardTokenizerImpl(TextReader @in){this.zzReader = @in;}

public MoPenFindGroupRequest() {super("MoPen", "2018-02-11", "MoPenFindGroup", "mopen");setProtocol(ProtocolType.HTTPS);setMethod(MethodType.POST);}

public MoPenFindGroupRequest(): base("MoPen", "2018-02-11", "MoPenFindGroup", "mopen", "openAPI"){Protocol = ProtocolType.HTTPS;Method = MethodType.POST;}

public static BreakIterator getLineInstance() {return getLineInstance(Locale.getDefault());}

public static java.text.BreakIterator getLineInstance(){return getLineInstance(System.Globalization.CultureInfo.CurrentCulture);}

public boolean exists() {return true;}

public virtual bool Exists(){return true;}

public LongBuffer asReadOnlyBuffer() {LongToByteBufferAdapter buf = new LongToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf.limit = limit;buf.position = position;buf.mark = mark;buf.byteBuffer.order = byteBuffer.order;return buf;}

public override java.nio.LongBuffer asReadOnlyBuffer(){java.nio.LongToByteBufferAdapter buf = new java.nio.LongToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());buf._limit = _limit;buf._position = _position;buf._mark = _mark;buf.byteBuffer._order = byteBuffer._order;return buf;}

public void writeBytes(byte[] b, int offset, int length) {assert b.length >= offset + length;if (length == 0) {return;}if (upto == blockSize) {if (currentBlock != null) {addBlock(currentBlock);}currentBlock = new byte[blockSize];upto = 0;}final int offsetEnd = offset + length;while(true) {final int left = offsetEnd - offset;final int blockLeft = blockSize - upto;if (blockLeft < left) {System.arraycopy(b, offset, currentBlock, upto, blockLeft);addBlock(currentBlock);currentBlock = new byte[blockSize];upto = 0;offset += blockLeft;} else {System.arraycopy(b, offset, currentBlock, upto, left);upto += left;break;}}}

public override void WriteBytes(byte[] b, int offset, int length){Debug.Assert(b.Length >= offset + length);if (length == 0){return;}if (outerInstance.upto == outerInstance.blockSize){if (outerInstance.currentBlock != null){outerInstance.blocks.Add(outerInstance.currentBlock);outerInstance.blockEnd.Add(outerInstance.upto);}outerInstance.currentBlock = new byte[outerInstance.blockSize];outerInstance.upto = 0;}int offsetEnd = offset + length;while (true){int left = offsetEnd - offset;int blockLeft = outerInstance.blockSize - outerInstance.upto;if (blockLeft < left){System.Buffer.BlockCopy(b, offset, outerInstance.currentBlock, outerInstance.upto, blockLeft);outerInstance.blocks.Add(outerInstance.currentBlock);outerInstance.blockEnd.Add(outerInstance.blockSize);outerInstance.currentBlock = new byte[outerInstance.blockSize];outerInstance.upto = 0;offset += blockLeft;}else{System.Buffer.BlockCopy(b, offset, outerInstance.currentBlock, outerInstance.upto, left);outerInstance.upto += left;break;}}}

public ByteBuffer putFloat(float value) {throw new ReadOnlyBufferException();}

public override java.nio.ByteBuffer putFloat(float value){throw new System.NotImplementedException();}

public Class<?> getArgumentClass() {return arg;}

public virtual System.Type getArgumentClass(){return arg;}

public GetVaultAccessPolicyResult getVaultAccessPolicy(GetVaultAccessPolicyRequest request) {request = beforeClientExecution(request);return executeGetVaultAccessPolicy(request);}

public virtual GetVaultAccessPolicyResponse GetVaultAccessPolicy(GetVaultAccessPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetVaultAccessPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = GetVaultAccessPolicyResponseUnmarshaller.Instance;return Invoke<GetVaultAccessPolicyResponse>(request, options);}

public GetReusableDelegationSetLimitResult getReusableDelegationSetLimit(GetReusableDelegationSetLimitRequest request) {request = beforeClientExecution(request);return executeGetReusableDelegationSetLimit(request);}

public virtual GetReusableDelegationSetLimitResponse GetReusableDelegationSetLimit(GetReusableDelegationSetLimitRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReusableDelegationSetLimitRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReusableDelegationSetLimitResponseUnmarshaller.Instance;return Invoke<GetReusableDelegationSetLimitResponse>(request, options);}

public int compareTo( WeightedPhraseInfo other ) {int diff = getStartOffset() - other.getStartOffset();if ( diff != 0 ) {return diff;}diff = getEndOffset() - other.getEndOffset();if ( diff != 0 ) {return diff;}return (int) Math.signum( getBoost() - other.getBoost() );}

public virtual int CompareTo(WeightedPhraseInfo other){int diff = StartOffset - other.StartOffset;if (diff != 0){return diff;}diff = EndOffset - other.EndOffset;if (diff != 0){return diff;}return (int)Math.Sign(Boost - other.Boost);}

public StopRelationalDatabaseResult stopRelationalDatabase(StopRelationalDatabaseRequest request) {request = beforeClientExecution(request);return executeStopRelationalDatabase(request);}

public virtual StopRelationalDatabaseResponse StopRelationalDatabase(StopRelationalDatabaseRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopRelationalDatabaseRequestMarshaller.Instance;options.ResponseUnmarshaller = StopRelationalDatabaseResponseUnmarshaller.Instance;return Invoke<StopRelationalDatabaseResponse>(request, options);}

public void clear() {Arrays.fill(blocks, 0L);}

public override void Clear(){Arrays.Fill(blocks, 0L);}

public UpdateScriptResult updateScript(UpdateScriptRequest request) {request = beforeClientExecution(request);return executeUpdateScript(request);}

public virtual UpdateScriptResponse UpdateScript(UpdateScriptRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateScriptRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateScriptResponseUnmarshaller.Instance;return Invoke<UpdateScriptResponse>(request, options);}

public InterpreterRuleContext(ParserRuleContext parent,int invokingStateNumber,int ruleIndex){super(parent, invokingStateNumber);this.ruleIndex = ruleIndex;}

public InterpreterRuleContext(ParserRuleContext parent, int invokingStateNumber, int ruleIndex): base(parent, invokingStateNumber){this.ruleIndex = ruleIndex;}

public CreateFileSystemFromBackupResult createFileSystemFromBackup(CreateFileSystemFromBackupRequest request) {request = beforeClientExecution(request);return executeCreateFileSystemFromBackup(request);}

public virtual CreateFileSystemFromBackupResponse CreateFileSystemFromBackup(CreateFileSystemFromBackupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateFileSystemFromBackupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateFileSystemFromBackupResponseUnmarshaller.Instance;return Invoke<CreateFileSystemFromBackupResponse>(request, options);}