Created
July 9, 2018 15:36
-
-
Save tristantarrant/5249f40e37e8518c89d89a0cb4b4912d to your computer and use it in GitHub Desktop.
Generated HotRodDecoder.java
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| package org.infinispan.server.hotrod; | |
| import java.util.List; | |
| import io.netty.buffer.ByteBuf; | |
| import io.netty.channel.ChannelHandlerContext; | |
| import java.time.ZonedDateTime; | |
| import java.time.temporal.Temporal; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import java.util.concurrent.Executor; | |
| import org.infinispan.commons.tx.XidImpl; | |
| import org.infinispan.counter.api.CounterConfiguration; | |
| import org.infinispan.counter.util.EncodeUtil; | |
| import org.infinispan.manager.EmbeddedCacheManager; | |
| import org.infinispan.metadata.Metadata; | |
| import org.infinispan.server.hotrod.tx.ControlByte; | |
| public class HotRodDecoder extends BaseDecoder { | |
| private int state; | |
| private int requestBytes; | |
| private boolean hr2x_bool; | |
| private byte hr2x_xidLength; | |
| private Metadata hr2x_expiration; | |
| private byte hr2x_timeUnits; | |
| private List< byte[]> hr2x_filterParams; | |
| private int hr2x_numEntries; | |
| private String hr2x_iterationId; | |
| private int hr2x_offset; | |
| private byte hr2x_controlByte; | |
| private ByteBuf hr2x_chunkBytes; | |
| private long hr2x_updateValue; | |
| private byte[] hr2x_fixedArray; | |
| private byte hr2x_txMarker; | |
| private byte[] hr2x_queryBytes; | |
| private byte hr2x_counterFlags; | |
| private boolean hr2x_useRawEvents; | |
| private int hr2x_chunkLength; | |
| private long hr2x_expectValue; | |
| private ByteBuf hr2x_readable; | |
| private boolean hr2x_includeCurrentState; | |
| private String hr2x_taskParam; | |
| private String hr2x_taskName; | |
| private long hr2x_lowerBound; | |
| private byte[] hr2x_taskParamValue; | |
| private String hr2x_cacheName; | |
| private ByteBuf hr2x_chunkedValue; | |
| private int hr2x_vInt; | |
| private byte[] hr2x_key; | |
| private long hr2x_initialValue; | |
| private int hr2x_batchSize; | |
| private HotRodHeader hr2x_header; | |
| private int hr2x_scope; | |
| private long hr2x_lifespanLong; | |
| private int hr2x_numModifications; | |
| private Map< String, byte[]> hr2x_taskParams; | |
| private byte[] hr2x_param; | |
| private byte[] hr2x_array; | |
| private int hr2x_flags; | |
| private String hr2x_authMech; | |
| private byte[] hr2x_authResponse; | |
| private byte[] hr2x_listenerId; | |
| private int hr2x_listenerInterests; | |
| private byte hr2x_numParams; | |
| private byte[] hr2x_segmentMask; | |
| private byte hr2x_magic; | |
| private int hr2x_xidFormat; | |
| private int hr2x_maxIdleInt; | |
| private String hr2x_filterFactory; | |
| private long hr2x_maxIdleLong; | |
| private boolean hr2x_onePhaseCommit; | |
| private long hr2x_entryVersion; | |
| private HotRodOperation hr2x_operation; | |
| private boolean hr2x_includeMetadata; | |
| private long hr2x_upperBound; | |
| private byte hr2x_opCode; | |
| private Map< byte[], byte[]> hr2x_entryMap; | |
| private long hr2x_messageId; | |
| private long hr2x_vLong; | |
| private List< byte[]> hr2x_filterConverterParams; | |
| private byte hr2x_version; | |
| private String hr2x_converterFactory; | |
| private int hr2x_numKeys; | |
| private int hr2x_signedVInt; | |
| private byte[] hr2x_branchId; | |
| private String hr2x_filterConverterFactory; | |
| private String hr2x_string; | |
| private long hr2x_versionRead; | |
| private byte hr2x_byte; | |
| private byte[] hr2x_transactionId; | |
| private int hr2x_lifespanInt; | |
| private String hr2x_counterName; | |
| private TransactionWrite hr2x_modification; | |
| private byte hr2x_intelligence; | |
| private long hr2x_long; | |
| private List< byte[]> hr2x_converterParams; | |
| private CounterConfiguration.Builder hr2x_counterConfiguration; | |
| private byte[] hr2x_value; | |
| private byte hr2x_branchLength; | |
| private int hr2x_topologyId; | |
| private Set< byte[]> hr2x_keys; | |
| private XidImpl hr2x_xid; | |
| private List< TransactionWrite> hr2x_modifications; | |
| private String hr2x_optionalString; | |
| private byte[] hr2x_optionalArray; | |
| private final boolean accessLogging ; | |
| private Temporal requestStart ; | |
| private boolean deadEnd = false ; | |
| public HotRodDecoder ( ContextProvider cp , EmbeddedCacheManager cacheManager , Executor executor , HotRodServer server ){ | |
| super ( cp , cacheManager , executor , server ); | |
| accessLogging = server.accessLogging ().isEnabled(); | |
| } | |
| @ Override protected HotRodHeader getHeader (){ | |
| if ( accessLogging && hr2x_header != null ){ | |
| return new AccessLoggingHeader ( hr2x_header , auth.getSubject ( hr2x_operation ), hr2x_key , requestBytes , requestStart ); | |
| } | |
| else { | |
| return hr2x_header ; | |
| } | |
| } | |
| @Override | |
| public void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) throws Exception { | |
| int pos = buf.readerIndex(); | |
| try { | |
| while (switch1_0(buf)); | |
| } catch (Throwable t) { | |
| exceptionally(t); | |
| } finally { | |
| requestBytes += buf.readerIndex() - pos; | |
| } | |
| } | |
| private boolean switch1_0(ByteBuf buf) throws Exception { | |
| switch (state >> 6) { | |
| case 0: return switch0(buf); | |
| case 1: return switch1(buf); | |
| case 2: return switch2(buf); | |
| case 3: return switch3(buf); | |
| case 4: return switch4(buf); | |
| default: throw new IllegalStateException(); | |
| } | |
| } | |
| private boolean switch0(ByteBuf buf) throws Exception { | |
| byte b; | |
| int pos; | |
| switch (state) { | |
| case 0: | |
| // | |
| reset(); | |
| state = 1; | |
| // fallthrough | |
| case 1: | |
| // | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_magic = hr2x_byte; | |
| state = 2; | |
| // fallthrough | |
| case 2: | |
| // hr2x.request | |
| if ( accessLogging ){ | |
| requestStart = ZonedDateTime.now (); | |
| } | |
| ; | |
| state = 3; | |
| // fallthrough | |
| case 3: | |
| // hr2x.request | |
| if (hr2x_magic != org.infinispan.server.hotrod.Constants.MAGIC_REQ ) { | |
| state = 5; | |
| return true; | |
| } | |
| deadEnd = false ; | |
| state = 6; | |
| return true; | |
| case 4: | |
| // hr2x.request | |
| if ( trace ) log.tracef ("Parsed header: %s", hr2x_header ); | |
| state = 15; | |
| return true; | |
| case 5: | |
| // hr2x.request/hr2x.header | |
| throw new InvalidMagicIdException ("Error reading magic byte or message id: "+ hr2x_magic ); | |
| case 6: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_messageId = hr2x_vLong; | |
| state = 7; | |
| // fallthrough | |
| case 7: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_version = hr2x_byte; | |
| state = 8; | |
| // fallthrough | |
| case 8: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_opCode = hr2x_byte; | |
| hr2x_operation = HotRodOperation.fromRequestOpCode ( hr2x_byte ); | |
| state = 9; | |
| // fallthrough | |
| case 9: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_cacheName = hr2x_string; | |
| state = 10; | |
| // fallthrough | |
| case 10: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_flags = hr2x_vInt; | |
| state = 11; | |
| // fallthrough | |
| case 11: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_intelligence = hr2x_byte; | |
| state = 12; | |
| // fallthrough | |
| case 12: | |
| // hr2x.request/hr2x.header | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_topologyId = hr2x_vInt; | |
| state = 13; | |
| // fallthrough | |
| case 13: | |
| // hr2x.request/hr2x.header | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_20 ) { | |
| state = 14; | |
| return true; | |
| } | |
| hr2x_txMarker = 0; | |
| hr2x_header = new HotRodHeader ( hr2x_operation , hr2x_version , hr2x_messageId , hr2x_cacheName , hr2x_flags , hr2x_intelligence , hr2x_topologyId ); | |
| state = 4; | |
| return true; | |
| case 14: | |
| // hr2x.request/hr2x.header/hr2x.txMarker | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_txMarker = hr2x_byte; | |
| hr2x_header = new HotRodHeader ( hr2x_operation , hr2x_version , hr2x_messageId , hr2x_cacheName , hr2x_flags , hr2x_intelligence , hr2x_topologyId ); | |
| state = 4; | |
| return true; | |
| case 15: | |
| // hr2x.request | |
| switch (hr2x_opCode) { | |
| case org.infinispan.server.hotrod.HotRodConstants.PUT_REQUEST : | |
| state = 16; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_REQUEST : | |
| state = 26; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PUT_IF_ABSENT_REQUEST : | |
| state = 28; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REPLACE_REQUEST : | |
| state = 38; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REPLACE_IF_UNMODIFIED_REQUEST : | |
| state = 48; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REMOVE_REQUEST : | |
| state = 59; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REMOVE_IF_UNMODIFIED_REQUEST : | |
| state = 61; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.CONTAINS_KEY_REQUEST : | |
| state = 64; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_WITH_VERSION : | |
| state = 66; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.CLEAR_REQUEST : | |
| state = 68; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.STATS_REQUEST : | |
| state = 69; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PING_REQUEST : | |
| state = 70; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.BULK_GET_REQUEST : | |
| state = 71; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_WITH_METADATA : | |
| state = 73; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.BULK_GET_KEYS_REQUEST : | |
| state = 75; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.QUERY_REQUEST : | |
| state = 77; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.AUTH_MECH_LIST_REQUEST : | |
| state = 79; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.AUTH_REQUEST : | |
| state = 80; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.ADD_CLIENT_LISTENER_REQUEST : | |
| state = 83; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REMOVE_CLIENT_LISTENER_REQUEST : | |
| state = 117; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.SIZE_REQUEST : | |
| state = 119; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.EXEC_REQUEST : | |
| state = 120; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PUT_ALL_REQUEST : | |
| state = 128; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_ALL_REQUEST : | |
| state = 142; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.ITERATION_START_REQUEST : | |
| state = 148; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.ITERATION_NEXT_REQUEST : | |
| state = 159; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.ITERATION_END_REQUEST : | |
| state = 161; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_STREAM_REQUEST : | |
| state = 163; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PUT_STREAM_REQUEST : | |
| state = 166; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PREPARE_TX : | |
| state = 182; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COMMIT_TX : | |
| state = 208; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.ROLLBACK_TX : | |
| state = 216; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_CREATE_REQUEST : | |
| state = 224; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_GET_CONFIGURATION_REQUEST : | |
| state = 236; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_IS_DEFINED_REQUEST : | |
| state = 238; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_ADD_AND_GET_REQUEST : | |
| state = 240; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_RESET_REQUEST : | |
| state = 243; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_GET_REQUEST : | |
| state = 245; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_CAS_REQUEST : | |
| state = 247; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_ADD_LISTENER_REQUEST : | |
| state = 251; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_REMOVE_LISTENER_REQUEST : | |
| state = 254; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_REMOVE_REQUEST : | |
| state = 257; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.COUNTER_GET_NAMES_REQUEST : | |
| state = 259; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_MULTIMAP_REQUEST : | |
| state = 260; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.GET_MULTIMAP_WITH_METADATA_REQUEST : | |
| state = 262; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.PUT_MULTIMAP_REQUEST : | |
| state = 264; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REMOVE_KEY_MULTIMAP_REQUEST : | |
| state = 274; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.REMOVE_ENTRY_MULTIMAP_REQUEST : | |
| state = 276; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.SIZE_MULTIMAP_REQUEST : | |
| state = 286; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.CONTAINS_ENTRY_REQUEST : | |
| state = 287; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.CONTAINS_KEY_MULTIMAP_REQUEST : | |
| state = 297; | |
| return true; | |
| case org.infinispan.server.hotrod.HotRodConstants.CONTAINS_VALUE_MULTIMAP_REQUEST : | |
| state = 299; | |
| return true; | |
| default: | |
| throw new HotRodUnknownOperationException ("Unknown operation "+ hr2x_opCode , hr2x_version , hr2x_messageId ); | |
| } | |
| case 16: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 17; | |
| // fallthrough | |
| case 17: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 19; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 21; | |
| return true; | |
| case 18: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 25; | |
| return true; | |
| case 19: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 20; | |
| // fallthrough | |
| case 20: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 18; | |
| return true; | |
| case 21: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 23; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 22; | |
| // fallthrough | |
| case 22: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 24; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 18; | |
| return true; | |
| case 23: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 22; | |
| return true; | |
| case 24: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 18; | |
| return true; | |
| case 25: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.put ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 26: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 27; | |
| // fallthrough | |
| case 27: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.get ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 28: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 29; | |
| // fallthrough | |
| case 29: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 31; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 33; | |
| return true; | |
| case 30: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 37; | |
| return true; | |
| case 31: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 32; | |
| // fallthrough | |
| case 32: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 30; | |
| return true; | |
| case 33: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 35; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 34; | |
| // fallthrough | |
| case 34: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 36; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 30; | |
| return true; | |
| case 35: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 34; | |
| return true; | |
| case 36: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 30; | |
| return true; | |
| case 37: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.putIfAbsent ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 38: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 39; | |
| // fallthrough | |
| case 39: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 41; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 43; | |
| return true; | |
| case 40: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 47; | |
| return true; | |
| case 41: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 42; | |
| // fallthrough | |
| case 42: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 40; | |
| return true; | |
| case 43: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 45; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 44; | |
| // fallthrough | |
| case 44: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 46; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 40; | |
| return true; | |
| case 45: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 44; | |
| return true; | |
| case 46: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 40; | |
| return true; | |
| case 47: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.replace ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 48: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 49; | |
| // fallthrough | |
| case 49: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 51; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 53; | |
| return true; | |
| case 50: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_entryVersion = hr2x_long; | |
| state = 57; | |
| return true; | |
| case 51: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 52; | |
| // fallthrough | |
| case 52: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 50; | |
| return true; | |
| case 53: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 55; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 54; | |
| // fallthrough | |
| case 54: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 56; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 50; | |
| return true; | |
| case 55: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 54; | |
| return true; | |
| case 56: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 50; | |
| return true; | |
| case 57: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 58; | |
| // fallthrough | |
| case 58: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.replaceIfUnmodified ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_entryVersion , hr2x_value , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 59: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 60; | |
| // fallthrough | |
| case 60: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.remove ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 61: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 62; | |
| // fallthrough | |
| case 62: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_entryVersion = hr2x_long; | |
| state = 63; | |
| // fallthrough | |
| case 63: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.removeIfUnmodified ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_entryVersion ); | |
| state = 0; | |
| return true; | |
| } | |
| return true; | |
| } | |
| private boolean switch1(ByteBuf buf) throws Exception { | |
| byte b; | |
| int pos; | |
| switch (state) { | |
| case 64: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 65; | |
| // fallthrough | |
| case 65: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.containsKey ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 66: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 67; | |
| // fallthrough | |
| case 67: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.get ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 68: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.clear ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 69: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.stats ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 70: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.ping ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 71: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numKeys = hr2x_vInt; | |
| state = 72; | |
| // fallthrough | |
| case 72: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.bulkGet ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_numKeys ); | |
| state = 0; | |
| return true; | |
| case 73: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 74; | |
| // fallthrough | |
| case 74: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.getWithMetadata ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ,0); | |
| state = 0; | |
| return true; | |
| case 75: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_scope = hr2x_vInt; | |
| state = 76; | |
| // fallthrough | |
| case 76: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.bulkGetKeys ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_scope ); | |
| state = 0; | |
| return true; | |
| case 77: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_queryBytes = hr2x_array; | |
| state = 78; | |
| // fallthrough | |
| case 78: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.query ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_queryBytes ); | |
| state = 0; | |
| return true; | |
| case 79: | |
| // hr2x.request/hr2x.parameters | |
| auth.authMechList ( hr2x_header ); | |
| state = 0; | |
| return true; | |
| case 80: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_authMech = hr2x_string; | |
| state = 81; | |
| // fallthrough | |
| case 81: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_authResponse = hr2x_array; | |
| state = 82; | |
| // fallthrough | |
| case 82: | |
| // hr2x.request/hr2x.parameters | |
| auth.auth ( hr2x_header , hr2x_authMech , hr2x_authResponse ); | |
| state = 0; | |
| return true; | |
| case 83: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_listenerId = hr2x_array; | |
| state = 84; | |
| // fallthrough | |
| case 84: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_bool = org.infinispan.server.hotrod.Intrinsics.bool(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_includeCurrentState = hr2x_bool; | |
| state = 85; | |
| // fallthrough | |
| case 85: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version >= org.infinispan.server.hotrod.HotRodConstants.VERSION_21 ) { | |
| state = 87; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_filterFactory = hr2x_string; | |
| state = 102; | |
| return true; | |
| case 86: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version >= org.infinispan.server.hotrod.HotRodConstants.VERSION_26 ) { | |
| state = 116; | |
| return true; | |
| } | |
| hr2x_listenerInterests = 0; | |
| state = 115; | |
| return true; | |
| case 87: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_filterFactory = hr2x_string; | |
| state = 88; | |
| // fallthrough | |
| case 88: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| if (! hr2x_filterFactory.isEmpty()) { | |
| state = 90; | |
| return true; | |
| } | |
| hr2x_filterParams = null ; | |
| state = 89; | |
| // fallthrough | |
| case 89: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_converterFactory = hr2x_string; | |
| state = 95; | |
| return true; | |
| case 90: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 91; | |
| // fallthrough | |
| case 91: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| hr2x_filterParams = new ArrayList <>( hr2x_numParams ); | |
| state = 92; | |
| // fallthrough | |
| case 92: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| if (hr2x_numParams == 0) { | |
| state = 89; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 93; | |
| // fallthrough | |
| case 93: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_param = hr2x_array; | |
| state = 94; | |
| // fallthrough | |
| case 94: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| hr2x_filterParams.add( hr2x_param ); | |
| state = 92; | |
| return true; | |
| case 95: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| if (! hr2x_converterFactory.isEmpty()) { | |
| state = 97; | |
| return true; | |
| } | |
| hr2x_converterParams = null ; | |
| ; | |
| state = 96; | |
| // fallthrough | |
| case 96: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| pos = buf.readerIndex(); | |
| hr2x_bool = org.infinispan.server.hotrod.Intrinsics.bool(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_useRawEvents = hr2x_bool; | |
| state = 86; | |
| return true; | |
| case 97: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 98; | |
| // fallthrough | |
| case 98: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| hr2x_converterParams = new ArrayList <>( hr2x_numParams ); | |
| state = 99; | |
| // fallthrough | |
| case 99: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| if (hr2x_numParams == 0) { | |
| state = 96; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 100; | |
| // fallthrough | |
| case 100: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_param = hr2x_array; | |
| state = 101; | |
| // fallthrough | |
| case 101: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| hr2x_converterParams.add( hr2x_param ); | |
| state = 99; | |
| return true; | |
| case 102: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| if (! hr2x_filterFactory.isEmpty()) { | |
| state = 104; | |
| return true; | |
| } | |
| hr2x_filterParams = null ; | |
| state = 103; | |
| // fallthrough | |
| case 103: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_converterFactory = hr2x_string; | |
| state = 109; | |
| return true; | |
| case 104: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 105; | |
| // fallthrough | |
| case 105: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| hr2x_filterParams = new ArrayList <>( hr2x_numParams ); | |
| state = 106; | |
| // fallthrough | |
| case 106: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| if (hr2x_numParams == 0) { | |
| state = 103; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 107; | |
| // fallthrough | |
| case 107: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_param = hr2x_array; | |
| state = 108; | |
| // fallthrough | |
| case 108: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.filterParams | |
| hr2x_filterParams.add( hr2x_param ); | |
| state = 106; | |
| return true; | |
| case 109: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams | |
| if (! hr2x_converterFactory.isEmpty()) { | |
| state = 110; | |
| return true; | |
| } | |
| hr2x_converterParams = null ; | |
| ; | |
| state = 86; | |
| return true; | |
| case 110: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 111; | |
| // fallthrough | |
| case 111: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| hr2x_converterParams = new ArrayList <>( hr2x_numParams ); | |
| state = 112; | |
| // fallthrough | |
| case 112: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| if (hr2x_numParams == 0) { | |
| state = 86; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 113; | |
| // fallthrough | |
| case 113: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_param = hr2x_array; | |
| state = 114; | |
| // fallthrough | |
| case 114: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerParams/hr2x.converterParams | |
| hr2x_converterParams.add( hr2x_param ); | |
| state = 112; | |
| return true; | |
| case 115: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.addClientListener ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_listenerId , hr2x_includeCurrentState , hr2x_filterFactory , hr2x_filterParams , hr2x_converterFactory , hr2x_converterParams , hr2x_useRawEvents , hr2x_listenerInterests ); | |
| state = 0; | |
| return true; | |
| case 116: | |
| // hr2x.request/hr2x.parameters/hr2x.listenerInterests | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_listenerInterests = hr2x_vInt; | |
| state = 115; | |
| return true; | |
| case 117: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_listenerId = hr2x_array; | |
| state = 118; | |
| // fallthrough | |
| case 118: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.removeClientListener ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_listenerId ); | |
| state = 0; | |
| return true; | |
| case 119: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.size ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 120: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_taskName = hr2x_string; | |
| state = 121; | |
| // fallthrough | |
| case 121: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 123; | |
| return true; | |
| case 122: | |
| // hr2x.request/hr2x.parameters | |
| taskProcessor.exec ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_taskName , hr2x_taskParams ); | |
| state = 0; | |
| return true; | |
| case 123: | |
| // hr2x.request/hr2x.parameters/hr2x.taskParams | |
| hr2x_taskParams = new HashMap <>( hr2x_numParams ); | |
| state = 124; | |
| // fallthrough | |
| case 124: | |
| // hr2x.request/hr2x.parameters/hr2x.taskParams | |
| if (hr2x_numParams == 0) { | |
| state = 122; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 125; | |
| // fallthrough | |
| case 125: | |
| // hr2x.request/hr2x.parameters/hr2x.taskParams | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_taskParam = hr2x_string; | |
| state = 126; | |
| // fallthrough | |
| case 126: | |
| // hr2x.request/hr2x.parameters/hr2x.taskParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_taskParamValue = hr2x_array; | |
| state = 127; | |
| // fallthrough | |
| case 127: | |
| // hr2x.request/hr2x.parameters/hr2x.taskParams | |
| hr2x_taskParams.put( hr2x_taskParam , hr2x_taskParamValue ); | |
| state = 124; | |
| return true; | |
| } | |
| return true; | |
| } | |
| private boolean switch2(ByteBuf buf) throws Exception { | |
| byte b; | |
| int pos; | |
| switch (state) { | |
| case 128: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 130; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 132; | |
| return true; | |
| case 129: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numEntries = hr2x_vInt; | |
| state = 137; | |
| return true; | |
| case 130: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 131; | |
| // fallthrough | |
| case 131: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 129; | |
| return true; | |
| case 132: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 134; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 133; | |
| // fallthrough | |
| case 133: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 135; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 129; | |
| return true; | |
| case 134: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 133; | |
| return true; | |
| case 135: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 129; | |
| return true; | |
| case 136: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.putAll ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_entryMap , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 137: | |
| // hr2x.request/hr2x.parameters/hr2x.entryMap | |
| hr2x_entryMap = new HashMap <>( hr2x_numEntries ); | |
| state = 138; | |
| // fallthrough | |
| case 138: | |
| // hr2x.request/hr2x.parameters/hr2x.entryMap | |
| if (hr2x_numEntries == 0) { | |
| state = 136; | |
| return true; | |
| } | |
| hr2x_numEntries--; | |
| state = 139; | |
| // fallthrough | |
| case 139: | |
| // hr2x.request/hr2x.parameters/hr2x.entryMap | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 140; | |
| // fallthrough | |
| case 140: | |
| // hr2x.request/hr2x.parameters/hr2x.entryMap | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 141; | |
| // fallthrough | |
| case 141: | |
| // hr2x.request/hr2x.parameters/hr2x.entryMap | |
| hr2x_entryMap.put( hr2x_key , hr2x_value ); | |
| state = 138; | |
| return true; | |
| case 142: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numKeys = hr2x_vInt; | |
| state = 144; | |
| return true; | |
| case 143: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.getAll ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_keys ); | |
| state = 0; | |
| return true; | |
| case 144: | |
| // hr2x.request/hr2x.parameters/hr2x.keys | |
| hr2x_keys = new HashSet <>( hr2x_numKeys ); | |
| state = 145; | |
| // fallthrough | |
| case 145: | |
| // hr2x.request/hr2x.parameters/hr2x.keys | |
| if (hr2x_numKeys == 0) { | |
| state = 143; | |
| return true; | |
| } | |
| hr2x_numKeys--; | |
| state = 146; | |
| // fallthrough | |
| case 146: | |
| // hr2x.request/hr2x.parameters/hr2x.keys | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 147; | |
| // fallthrough | |
| case 147: | |
| // hr2x.request/hr2x.parameters/hr2x.keys | |
| hr2x_keys.add( hr2x_key ); | |
| state = 145; | |
| return true; | |
| case 148: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_optionalArray = org.infinispan.server.hotrod.Intrinsics.optionalArray(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_segmentMask = hr2x_optionalArray; | |
| state = 149; | |
| // fallthrough | |
| case 149: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_optionalString = org.infinispan.server.hotrod.Intrinsics.optionalString(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_filterConverterFactory = hr2x_optionalString; | |
| state = 150; | |
| // fallthrough | |
| case 150: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_filterConverterFactory != null ) { | |
| state = 152; | |
| return true; | |
| } | |
| hr2x_filterConverterParams = null ; | |
| state = 151; | |
| // fallthrough | |
| case 151: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_batchSize = hr2x_vInt; | |
| state = 157; | |
| return true; | |
| case 152: | |
| // hr2x.request/hr2x.parameters/hr2x.filterConverterParams | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numParams = hr2x_byte; | |
| state = 153; | |
| // fallthrough | |
| case 153: | |
| // hr2x.request/hr2x.parameters/hr2x.filterConverterParams | |
| hr2x_filterConverterParams = new ArrayList ( hr2x_numParams ); | |
| state = 154; | |
| // fallthrough | |
| case 154: | |
| // hr2x.request/hr2x.parameters/hr2x.filterConverterParams | |
| if (hr2x_numParams == 0) { | |
| state = 151; | |
| return true; | |
| } | |
| hr2x_numParams--; | |
| state = 155; | |
| // fallthrough | |
| case 155: | |
| // hr2x.request/hr2x.parameters/hr2x.filterConverterParams | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_param = hr2x_array; | |
| state = 156; | |
| // fallthrough | |
| case 156: | |
| // hr2x.request/hr2x.parameters/hr2x.filterConverterParams | |
| hr2x_filterConverterParams.add( hr2x_param ); | |
| state = 154; | |
| return true; | |
| case 157: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_bool = org.infinispan.server.hotrod.Intrinsics.bool(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_includeMetadata = hr2x_bool; | |
| state = 158; | |
| // fallthrough | |
| case 158: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.iterationStart ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_segmentMask , hr2x_filterConverterFactory , hr2x_filterConverterParams , hr2x_batchSize , hr2x_includeMetadata ); | |
| state = 0; | |
| return true; | |
| case 159: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_iterationId = hr2x_string; | |
| state = 160; | |
| // fallthrough | |
| case 160: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.iterationNext ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_iterationId ); | |
| state = 0; | |
| return true; | |
| case 161: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_iterationId = hr2x_string; | |
| state = 162; | |
| // fallthrough | |
| case 162: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.iterationEnd ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_iterationId ); | |
| state = 0; | |
| return true; | |
| case 163: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 164; | |
| // fallthrough | |
| case 164: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_offset = hr2x_vInt; | |
| state = 165; | |
| // fallthrough | |
| case 165: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.getWithMetadata ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_offset ); | |
| state = 0; | |
| return true; | |
| case 166: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 167; | |
| // fallthrough | |
| case 167: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 169; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 171; | |
| return true; | |
| case 168: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_entryVersion = hr2x_long; | |
| state = 175; | |
| return true; | |
| case 169: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 170; | |
| // fallthrough | |
| case 170: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 168; | |
| return true; | |
| case 171: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 173; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 172; | |
| // fallthrough | |
| case 172: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 174; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 168; | |
| return true; | |
| case 173: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 172; | |
| return true; | |
| case 174: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 168; | |
| return true; | |
| case 175: | |
| // hr2x.request/hr2x.parameters | |
| hr2x_chunkedValue = cacheProcessor.channel ().alloc().buffer(); | |
| hr2x_chunkLength =1; | |
| state = 177; | |
| return true; | |
| case 176: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.putStream ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_chunkedValue , hr2x_entryVersion , hr2x_expiration ); | |
| state = 0; | |
| return true; | |
| case 177: | |
| // hr2x.request/hr2x.parameters/hr2x.chunkedValue | |
| if (hr2x_chunkLength == 0) { | |
| state = 176; | |
| return true; | |
| } | |
| hr2x_chunkLength--; | |
| state = 178; | |
| // fallthrough | |
| case 178: | |
| // hr2x.request/hr2x.parameters/hr2x.chunkedValue | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_chunkLength = hr2x_vInt; | |
| state = 179; | |
| // fallthrough | |
| case 179: | |
| // hr2x.request/hr2x.parameters/hr2x.chunkedValue/hr2x.chunk | |
| if (hr2x_chunkLength >0) { | |
| state = 181; | |
| return true; | |
| } | |
| hr2x_chunkBytes = cacheProcessor.channel ().alloc().buffer(0); | |
| ; | |
| state = 180; | |
| // fallthrough | |
| case 180: | |
| // hr2x.request/hr2x.parameters/hr2x.chunkedValue/hr2x.chunk | |
| hr2x_chunkedValue.writeBytes( hr2x_chunkBytes , hr2x_chunkBytes.readerIndex()- hr2x_chunkLength , hr2x_chunkLength ); | |
| state = 177; | |
| return true; | |
| case 181: | |
| // hr2x.request/hr2x.parameters/hr2x.chunkedValue/hr2x.chunk/hr2x.chunkBytes | |
| pos = buf.readerIndex(); | |
| hr2x_readable = org.infinispan.server.hotrod.Intrinsics.readable(buf, hr2x_chunkLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_chunkBytes = hr2x_readable; | |
| state = 180; | |
| return true; | |
| case 182: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_signedVInt = org.infinispan.server.hotrod.Intrinsics.signedVInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidFormat = hr2x_signedVInt; | |
| state = 184; | |
| return true; | |
| case 183: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_bool = org.infinispan.server.hotrod.Intrinsics.bool(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_onePhaseCommit = hr2x_bool; | |
| state = 190; | |
| return true; | |
| case 184: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidLength = hr2x_byte; | |
| state = 185; | |
| // fallthrough | |
| case 185: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_xidLength >0) { | |
| state = 187; | |
| return true; | |
| } | |
| hr2x_transactionId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| state = 186; | |
| // fallthrough | |
| case 186: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchLength = hr2x_byte; | |
| state = 188; | |
| return true; | |
| case 187: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.transactionId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_xidLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_transactionId = hr2x_fixedArray; | |
| state = 186; | |
| return true; | |
| case 188: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_branchLength >0) { | |
| state = 189; | |
| return true; | |
| } | |
| hr2x_branchId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 183; | |
| return true; | |
| case 189: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.branchId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_branchLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchId = hr2x_fixedArray; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 183; | |
| return true; | |
| case 190: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_numModifications = hr2x_vInt; | |
| state = 192; | |
| return true; | |
| case 191: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.prepareTransaction ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_xid , hr2x_onePhaseCommit , hr2x_modifications ); | |
| state = 0; | |
| return true; | |
| } | |
| return true; | |
| } | |
| private boolean switch3(ByteBuf buf) throws Exception { | |
| byte b; | |
| int pos; | |
| switch (state) { | |
| case 192: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications | |
| hr2x_modifications = new ArrayList <>( hr2x_numModifications ); | |
| state = 193; | |
| // fallthrough | |
| case 193: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications | |
| if (hr2x_numModifications == 0) { | |
| state = 191; | |
| return true; | |
| } | |
| hr2x_numModifications--; | |
| state = 194; | |
| // fallthrough | |
| case 194: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 196; | |
| return true; | |
| case 195: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications | |
| hr2x_modifications.add( hr2x_modification ); | |
| state = 193; | |
| return true; | |
| case 196: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_controlByte = hr2x_byte; | |
| state = 197; | |
| // fallthrough | |
| case 197: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification | |
| if (! ControlByte.NOT_READ.hasFlag ( hr2x_controlByte )&&! ControlByte.NON_EXISTING.hasFlag ( hr2x_controlByte )) { | |
| state = 199; | |
| return true; | |
| } | |
| hr2x_versionRead = 0L; | |
| state = 198; | |
| // fallthrough | |
| case 198: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification | |
| if (! ControlByte.REMOVE_OP.hasFlag ( hr2x_controlByte )) { | |
| state = 200; | |
| return true; | |
| } | |
| ; | |
| hr2x_modification = new TransactionWrite ( hr2x_key , hr2x_versionRead , hr2x_controlByte , hr2x_value , hr2x_expiration ); | |
| state = 195; | |
| return true; | |
| case 199: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.versionRead | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_entryVersion = hr2x_long; | |
| hr2x_versionRead = hr2x_entryVersion; | |
| state = 198; | |
| return true; | |
| case 200: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 202; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 204; | |
| return true; | |
| case 201: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| hr2x_modification = new TransactionWrite ( hr2x_key , hr2x_versionRead , hr2x_controlByte , hr2x_value , hr2x_expiration ); | |
| state = 195; | |
| return true; | |
| case 202: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 203; | |
| // fallthrough | |
| case 203: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 201; | |
| return true; | |
| case 204: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 206; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 205; | |
| // fallthrough | |
| case 205: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 207; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 201; | |
| return true; | |
| case 206: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 205; | |
| return true; | |
| case 207: | |
| // hr2x.request/hr2x.parameters/hr2x.modifications/hr2x.modification/hr2x.modificationData/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 201; | |
| return true; | |
| case 208: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_signedVInt = org.infinispan.server.hotrod.Intrinsics.signedVInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidFormat = hr2x_signedVInt; | |
| state = 210; | |
| return true; | |
| case 209: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.commitTransaction ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_xid ); | |
| state = 0; | |
| return true; | |
| case 210: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidLength = hr2x_byte; | |
| state = 211; | |
| // fallthrough | |
| case 211: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_xidLength >0) { | |
| state = 213; | |
| return true; | |
| } | |
| hr2x_transactionId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| state = 212; | |
| // fallthrough | |
| case 212: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchLength = hr2x_byte; | |
| state = 214; | |
| return true; | |
| case 213: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.transactionId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_xidLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_transactionId = hr2x_fixedArray; | |
| state = 212; | |
| return true; | |
| case 214: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_branchLength >0) { | |
| state = 215; | |
| return true; | |
| } | |
| hr2x_branchId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 209; | |
| return true; | |
| case 215: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.branchId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_branchLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchId = hr2x_fixedArray; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 209; | |
| return true; | |
| case 216: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_signedVInt = org.infinispan.server.hotrod.Intrinsics.signedVInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidFormat = hr2x_signedVInt; | |
| state = 218; | |
| return true; | |
| case 217: | |
| // hr2x.request/hr2x.parameters | |
| cacheProcessor.rollbackTransaction ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_xid ); | |
| state = 0; | |
| return true; | |
| case 218: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_xidLength = hr2x_byte; | |
| state = 219; | |
| // fallthrough | |
| case 219: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_xidLength >0) { | |
| state = 221; | |
| return true; | |
| } | |
| hr2x_transactionId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| state = 220; | |
| // fallthrough | |
| case 220: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchLength = hr2x_byte; | |
| state = 222; | |
| return true; | |
| case 221: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.transactionId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_xidLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_transactionId = hr2x_fixedArray; | |
| state = 220; | |
| return true; | |
| case 222: | |
| // hr2x.request/hr2x.parameters/hr2x.xid | |
| if (hr2x_branchLength >0) { | |
| state = 223; | |
| return true; | |
| } | |
| hr2x_branchId = org.infinispan.commons.util.Util.EMPTY_BYTE_ARRAY ; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 217; | |
| return true; | |
| case 223: | |
| // hr2x.request/hr2x.parameters/hr2x.xid/hr2x.branchId | |
| pos = buf.readerIndex(); | |
| hr2x_fixedArray = org.infinispan.server.hotrod.Intrinsics.fixedArray(buf, hr2x_branchLength ); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_branchId = hr2x_fixedArray; | |
| hr2x_xid = XidImpl.create ( hr2x_xidFormat , hr2x_transactionId , hr2x_branchId ); | |
| state = 217; | |
| return true; | |
| case 224: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 225; | |
| // fallthrough | |
| case 225: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterFlags = hr2x_byte; | |
| state = 227; | |
| return true; | |
| case 226: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.createCounter ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName , hr2x_counterConfiguration.build()); | |
| state = 0; | |
| return true; | |
| case 227: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration | |
| hr2x_counterConfiguration = CounterConfiguration.builder ( EncodeUtil.decodeType ( hr2x_counterFlags )).storage( EncodeUtil.decodeStorage ( hr2x_counterFlags )); | |
| state = 228; | |
| // fallthrough | |
| case 228: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration | |
| if (( hr2x_counterFlags &1)==1) { | |
| state = 230; | |
| return true; | |
| } | |
| ; | |
| state = 229; | |
| // fallthrough | |
| case 229: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration | |
| if (( hr2x_counterFlags &2)==2) { | |
| state = 233; | |
| return true; | |
| } | |
| ; | |
| state = 232; | |
| return true; | |
| case 230: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration/hr2x.counterConcurrency | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| state = 231; | |
| // fallthrough | |
| case 231: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration/hr2x.counterConcurrency | |
| hr2x_counterConfiguration.concurrencyLevel( hr2x_vInt ); | |
| state = 229; | |
| return true; | |
| case 232: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_initialValue = hr2x_long; | |
| hr2x_counterConfiguration = hr2x_counterConfiguration.initialValue( hr2x_initialValue ); | |
| ; | |
| state = 226; | |
| return true; | |
| case 233: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration/hr2x.counterBounds | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lowerBound = hr2x_long; | |
| state = 234; | |
| // fallthrough | |
| case 234: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration/hr2x.counterBounds | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_upperBound = hr2x_long; | |
| state = 235; | |
| // fallthrough | |
| case 235: | |
| // hr2x.request/hr2x.parameters/hr2x.counterConfiguration/hr2x.counterBounds | |
| hr2x_counterConfiguration.lowerBound( hr2x_lowerBound ).upperBound( hr2x_upperBound ); | |
| state = 232; | |
| return true; | |
| case 236: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 237; | |
| // fallthrough | |
| case 237: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.getCounterConfiguration ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName ); | |
| state = 0; | |
| return true; | |
| case 238: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 239; | |
| // fallthrough | |
| case 239: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.isCounterDefined ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName ); | |
| state = 0; | |
| return true; | |
| case 240: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 241; | |
| // fallthrough | |
| case 241: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_updateValue = hr2x_long; | |
| state = 242; | |
| // fallthrough | |
| case 242: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.counterAddAndGet ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName , hr2x_updateValue ); | |
| state = 0; | |
| return true; | |
| case 243: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 244; | |
| // fallthrough | |
| case 244: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.counterReset ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName ); | |
| state = 0; | |
| return true; | |
| case 245: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 246; | |
| // fallthrough | |
| case 246: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.counterGet ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName ); | |
| state = 0; | |
| return true; | |
| case 247: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 248; | |
| // fallthrough | |
| case 248: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_expectValue = hr2x_long; | |
| state = 249; | |
| // fallthrough | |
| case 249: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_long = org.infinispan.server.hotrod.Intrinsics.long_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_updateValue = hr2x_long; | |
| state = 250; | |
| // fallthrough | |
| case 250: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.counterCompareAndSwap ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName , hr2x_expectValue , hr2x_updateValue ); | |
| state = 0; | |
| return true; | |
| case 251: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 252; | |
| // fallthrough | |
| case 252: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_listenerId = hr2x_array; | |
| state = 253; | |
| // fallthrough | |
| case 253: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.addCounterListener ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName , hr2x_listenerId ); | |
| state = 0; | |
| return true; | |
| case 254: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 255; | |
| // fallthrough | |
| case 255: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_listenerId = hr2x_array; | |
| state = 256; | |
| // fallthrough | |
| } | |
| return true; | |
| } | |
| private boolean switch4(ByteBuf buf) throws Exception { | |
| byte b; | |
| int pos; | |
| switch (state) { | |
| case 256: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.removeCounterListener ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName , hr2x_listenerId ); | |
| state = 0; | |
| return true; | |
| case 257: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_string = org.infinispan.server.hotrod.Intrinsics.string(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_counterName = hr2x_string; | |
| state = 258; | |
| // fallthrough | |
| case 258: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.counterRemove ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_counterName ); | |
| state = 0; | |
| return true; | |
| case 259: | |
| // hr2x.request/hr2x.parameters | |
| counterProcessor.getCounterNames ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 260: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 261; | |
| // fallthrough | |
| case 261: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.get ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 262: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 263; | |
| // fallthrough | |
| case 263: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.getWithMetadata ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 264: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 265; | |
| // fallthrough | |
| case 265: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 267; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 269; | |
| return true; | |
| case 266: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 273; | |
| return true; | |
| case 267: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 268; | |
| // fallthrough | |
| case 268: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 266; | |
| return true; | |
| case 269: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 271; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 270; | |
| // fallthrough | |
| case 270: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 272; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 266; | |
| return true; | |
| case 271: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 270; | |
| return true; | |
| case 272: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 266; | |
| return true; | |
| case 273: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.put ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value ); | |
| state = 0; | |
| return true; | |
| case 274: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 275; | |
| // fallthrough | |
| case 275: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.removeKey ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 276: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 277; | |
| // fallthrough | |
| case 277: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 279; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 281; | |
| return true; | |
| case 278: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 285; | |
| return true; | |
| case 279: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 280; | |
| // fallthrough | |
| case 280: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 278; | |
| return true; | |
| case 281: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 283; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 282; | |
| // fallthrough | |
| case 282: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 284; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 278; | |
| return true; | |
| case 283: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 282; | |
| return true; | |
| case 284: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 278; | |
| return true; | |
| case 285: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.removeEntry ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value ); | |
| state = 0; | |
| return true; | |
| case 286: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.size ( getHeader (), auth.getSubject ( hr2x_operation )); | |
| state = 0; | |
| return true; | |
| case 287: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 288; | |
| // fallthrough | |
| case 288: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 290; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 292; | |
| return true; | |
| case 289: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 296; | |
| return true; | |
| case 290: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 291; | |
| // fallthrough | |
| case 291: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 289; | |
| return true; | |
| case 292: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 294; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 293; | |
| // fallthrough | |
| case 293: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 295; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 289; | |
| return true; | |
| case 294: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 293; | |
| return true; | |
| case 295: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 289; | |
| return true; | |
| case 296: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.containsEntry ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key , hr2x_value ); | |
| state = 0; | |
| return true; | |
| case 297: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_key = hr2x_array; | |
| state = 298; | |
| // fallthrough | |
| case 298: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.containsKey ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_key ); | |
| state = 0; | |
| return true; | |
| case 299: | |
| // hr2x.request/hr2x.parameters | |
| if (hr2x_version < org.infinispan.server.hotrod.HotRodConstants.VERSION_22 ) { | |
| state = 301; | |
| return true; | |
| } | |
| pos = buf.readerIndex(); | |
| hr2x_byte = org.infinispan.server.hotrod.Intrinsics.byte_(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_timeUnits = hr2x_byte; | |
| state = 303; | |
| return true; | |
| case 300: | |
| // hr2x.request/hr2x.parameters | |
| pos = buf.readerIndex(); | |
| hr2x_array = org.infinispan.server.hotrod.Intrinsics.array(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_value = hr2x_array; | |
| state = 307; | |
| return true; | |
| case 301: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanInt = hr2x_vInt; | |
| state = 302; | |
| // fallthrough | |
| case 302: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| pos = buf.readerIndex(); | |
| hr2x_vInt = org.infinispan.server.hotrod.Intrinsics.vInt(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleInt = hr2x_vInt; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , defaultExpiration ( hr2x_lifespanInt , hr2x_flags , ProtocolFlag.DefaultLifespan ), TimeUnitValue.SECONDS , defaultExpiration ( hr2x_maxIdleInt , hr2x_flags , ProtocolFlag.DefaultMaxIdle ), TimeUnitValue.SECONDS ); | |
| state = 300; | |
| return true; | |
| case 303: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0xF0)!=0x70&&( hr2x_timeUnits &0xF0)!=0x80) { | |
| state = 305; | |
| return true; | |
| } | |
| hr2x_lifespanLong = 0L; | |
| state = 304; | |
| // fallthrough | |
| case 304: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration | |
| if (( hr2x_timeUnits &0x0F)!=0x07&&( hr2x_timeUnits &0x0F)!=0x08) { | |
| state = 306; | |
| return true; | |
| } | |
| hr2x_maxIdleLong = 0L; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 300; | |
| return true; | |
| case 305: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.lifespanLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_lifespanLong = hr2x_vLong; | |
| state = 304; | |
| return true; | |
| case 306: | |
| // hr2x.request/hr2x.parameters/hr2x.expiration/hr2x.maxIdleLong | |
| pos = buf.readerIndex(); | |
| hr2x_vLong = org.infinispan.server.hotrod.Intrinsics.vLong(buf); | |
| if (buf.readerIndex() == pos) return false; | |
| hr2x_maxIdleLong = hr2x_vLong; | |
| hr2x_expiration = cp.buildMetadata ( hr2x_header , hr2x_lifespanLong , TimeUnitValue.decode ( BitShift.right ( hr2x_timeUnits ,4)), hr2x_maxIdleLong , TimeUnitValue.decode ( BitShift.mask ( hr2x_timeUnits ,0x0F))); | |
| state = 300; | |
| return true; | |
| case 307: | |
| // hr2x.request/hr2x.parameters | |
| multimapProcessor.containsValue ( getHeader (), auth.getSubject ( hr2x_operation ), hr2x_value ); | |
| state = 0; | |
| return true; | |
| } | |
| return true; | |
| } | |
| private void deadEnd() { | |
| if (! deadEnd ){ | |
| cacheProcessor.writeException ( getHeader (), new RequestParsingException ("Invalid state of parsing", hr2x_version , hr2x_messageId )); | |
| deadEnd = true ; | |
| } | |
| state =0; | |
| } | |
| private void exceptionally(Throwable t) throws Exception { | |
| log.trace ("Parsing error", t ); | |
| cacheProcessor.writeException ( getHeader (), t ); | |
| state =0; | |
| } | |
| private void reset() { | |
| requestBytes = 0; hr2x_bool = false; | |
| hr2x_xidLength = 0; | |
| hr2x_expiration = null; | |
| hr2x_timeUnits = 0; | |
| hr2x_filterParams = null; | |
| hr2x_numEntries = 0; | |
| hr2x_iterationId = null; | |
| hr2x_offset = 0; | |
| hr2x_controlByte = 0; | |
| hr2x_chunkBytes = null; | |
| hr2x_updateValue = 0; | |
| hr2x_fixedArray = null; | |
| hr2x_txMarker = 0; | |
| hr2x_queryBytes = null; | |
| hr2x_counterFlags = 0; | |
| hr2x_useRawEvents = false; | |
| hr2x_chunkLength = 0; | |
| hr2x_expectValue = 0; | |
| hr2x_readable = null; | |
| hr2x_includeCurrentState = false; | |
| hr2x_taskParam = null; | |
| hr2x_taskName = null; | |
| hr2x_lowerBound = 0; | |
| hr2x_taskParamValue = null; | |
| hr2x_cacheName = null; | |
| hr2x_chunkedValue = null; | |
| hr2x_vInt = 0; | |
| hr2x_key = null; | |
| hr2x_initialValue = 0; | |
| hr2x_batchSize = 0; | |
| hr2x_header = null; | |
| hr2x_scope = 0; | |
| hr2x_lifespanLong = 0; | |
| hr2x_numModifications = 0; | |
| hr2x_taskParams = null; | |
| hr2x_param = null; | |
| hr2x_array = null; | |
| hr2x_flags = 0; | |
| hr2x_authMech = null; | |
| hr2x_authResponse = null; | |
| hr2x_listenerId = null; | |
| hr2x_listenerInterests = 0; | |
| hr2x_numParams = 0; | |
| hr2x_segmentMask = null; | |
| hr2x_magic = 0; | |
| hr2x_xidFormat = 0; | |
| hr2x_maxIdleInt = 0; | |
| hr2x_filterFactory = null; | |
| hr2x_maxIdleLong = 0; | |
| hr2x_onePhaseCommit = false; | |
| hr2x_entryVersion = 0; | |
| hr2x_operation = null; | |
| hr2x_includeMetadata = false; | |
| hr2x_upperBound = 0; | |
| hr2x_opCode = 0; | |
| hr2x_entryMap = null; | |
| hr2x_messageId = 0; | |
| hr2x_vLong = 0; | |
| hr2x_filterConverterParams = null; | |
| hr2x_version = 0; | |
| hr2x_converterFactory = null; | |
| hr2x_numKeys = 0; | |
| hr2x_signedVInt = 0; | |
| hr2x_branchId = null; | |
| hr2x_filterConverterFactory = null; | |
| hr2x_string = null; | |
| hr2x_versionRead = 0; | |
| hr2x_byte = 0; | |
| hr2x_transactionId = null; | |
| hr2x_lifespanInt = 0; | |
| hr2x_counterName = null; | |
| hr2x_modification = null; | |
| hr2x_intelligence = 0; | |
| hr2x_long = 0; | |
| hr2x_converterParams = null; | |
| hr2x_counterConfiguration = null; | |
| hr2x_value = null; | |
| hr2x_branchLength = 0; | |
| hr2x_topologyId = 0; | |
| hr2x_keys = null; | |
| hr2x_xid = null; | |
| hr2x_modifications = null; | |
| hr2x_optionalString = null; | |
| hr2x_optionalArray = null; | |
| } | |
| public int requestBytes() { | |
| return requestBytes; | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment