nus-yam/ex-repair huggingface dataset:
Program: 55192
Project: 55192
Buggy source:
private <V>V addView0(Class<V> viewType,V view){
  if (view instanceof KeyedView)   keyedAsset=((KeyedView)view).keyedView();
  Object o=viewMap.putIfAbsent(viewType,view);
  return view;
}

Fixed version (ground truth):
private <V>V addView0(Class<V> viewType,V view){
  if (view instanceof KeyedView)   keyedAsset=((KeyedView)view).keyedView();
  Object o=viewMap.putIfAbsent(viewType,view);
  TopologySubscription topologySubscription=this.root().findView(TopologySubscription.class);
  if (topologySubscription != null) {
    String parentName=parent == null ? "String_Node_Str" : parent.fullName();
    if (o == null) {
      topologySubscription.notifyEvent(AddedAssetEvent.of(parentName,name,viewTypes()));
    }
 else {
      topologySubscription.notifyEvent(ExistingAssetEvent.of(parentName,name,viewTypes()));
    }
  }
  return view;
}
Program: 55193
Project: 55193
Buggy source:
void bootstrapTree(@NotNull Asset asset,@NotNull Subscriber<TopologicalEvent> subscriber) throws InvalidSubscriberException {
  asset.forEachChild(c -> {
    subscriber.onMessage(ExistingAssetEvent.of(asset.fullName(),c));
    bootstrapTree(c,subscriber);
  }
);
}

Fixed version (ground truth):
void bootstrapTree(@NotNull Asset asset,@NotNull Subscriber<TopologicalEvent> subscriber) throws InvalidSubscriberException {
  asset.forEachChild(c -> {
    subscriber.onMessage(ExistingAssetEvent.of(asset.fullName(),c.name(),c.viewTypes()));
    bootstrapTree(c,subscriber);
  }
);
}
Program: 55194
Project: 55194
Buggy source:
@Override public void registerSubscriber(@NotNull RequestContext rc,@NotNull Subscriber<TopologicalEvent> subscriber,@NotNull Filter<TopologicalEvent> filter){
  try {
    if (rc.bootstrap() != Boolean.FALSE) {
      Asset parent=asset.parent();
      String assetName=parent == null ? null : parent.fullName();
      subscriber.onMessage(ExistingAssetEvent.of(assetName,asset));
      bootstrapTree(asset,subscriber);
    }
    subscribers.add(subscriber);
  }
 catch (  InvalidSubscriberException e) {
    Jvm.debug().on(getClass(),"String_Node_Str" + subscriber,e);
  }
}

Fixed version (ground truth):
@Override public void registerSubscriber(@NotNull RequestContext rc,@NotNull Subscriber<TopologicalEvent> subscriber,@NotNull Filter<TopologicalEvent> filter){
  try {
    if (rc.bootstrap() != Boolean.FALSE) {
      Asset parent=asset.parent();
      String assetName=parent == null ? null : parent.fullName();
      subscriber.onMessage(ExistingAssetEvent.of(assetName,asset.name(),asset.viewTypes()));
      bootstrapTree(asset,subscriber);
    }
    subscribers.add(subscriber);
  }
 catch (  InvalidSubscriberException e) {
    Jvm.debug().on(getClass(),"String_Node_Str" + subscriber,e);
  }
}
Program: 55196
Project: 55196
Buggy source:
public TypographyTest(Boolean isRemote) throws Exception {
  if (isRemote) {
    VanillaAssetTree assetTree0=new VanillaAssetTree().forTesting();
    String hostPortDescription="String_Node_Str" + methodName;
    TCPRegistry.createServerSocketChannelFor(hostPortDescription);
    serverEndpoint=new ServerEndpoint(hostPortDescription,assetTree0);
    final VanillaAssetTree client=new VanillaAssetTree();
    assetTree=client.forRemoteAccess(hostPortDescription,WireType.BINARY);
  }
 else {
    assetTree=(new VanillaAssetTree(1)).forTesting();
    serverEndpoint=null;
  }
}

Fixed version (ground truth):
public TypographyTest(Boolean isRemote) throws Exception {
  if (isRemote) {
    VanillaAssetTree assetTree0=new VanillaAssetTree().forTesting();
    String hostPortDescription="String_Node_Str" + methodName;
    TCPRegistry.createServerSocketChannelFor(hostPortDescription);
    serverEndpoint=new ServerEndpoint(hostPortDescription,assetTree0);
    final VanillaAssetTree client=new VanillaAssetTree();
    assetTree=client.forRemoteAccess(hostPortDescription,WireType.BINARY);
    Executors.newScheduledThreadPool(1).schedule((Runnable)() -> {
      assetTree0.acquireMap(ADD_MAP_LATER,String.class,String.class).size();
    }
,500,TimeUnit.MILLISECONDS);
  }
 else {
    assetTree=(new VanillaAssetTree(1)).forTesting();
    assetTree.acquireMap(ADD_MAP_LATER,String.class,String.class).size();
    serverEndpoint=null;
  }
}
Program: 55197
Project: 55197
Buggy source:
@Parameterized.Parameters public static Collection<Object[]> data(){
  return Arrays.asList(new Boolean[][]{{true},{true}});
}

Fixed version (ground truth):
@Parameterized.Parameters public static Collection<Object[]> data(){
  return Arrays.asList(new Boolean[][]{{false},{true}});
}
Program: 55199
Project: 55199
Buggy source:
@NotNull @Override public <V>V acquireView(@NotNull Class<V> viewType,@NotNull RequestContext rc) throws AssetNotFoundException {
}

Fixed version (ground truth):
@NotNull @Override public <V>V acquireView(@NotNull Class<V> viewType,@NotNull RequestContext rc) throws AssetNotFoundException {
  if (!fullName().equals(rc.fullName())) {
    Asset asset=this.root().acquireAsset(rc.fullName());
    return asset.acquireView(rc);
  }
synchronized (viewMap) {
    V view=getView(viewType);
    if (view != null) {
      return view;
    }
    return Threads.withThreadGroup(findView(ThreadGroup.class),() -> {
      V leafView=createLeafView(viewType,rc,this);
      if (leafView instanceof MapView && viewType == QueueView.class)       addView(MapView.class,(MapView)leafView);
      if (leafView != null)       return addView(viewType,leafView);
      V wrappingView=createWrappingView(viewType,rc,this,null);
      if (wrappingView == null)       throw new AssetNotFoundException("String_Node_Str" + viewType.getName() + "String_Node_Str"+ rc);
      return addView(viewType,wrappingView);
    }
);
  }
}
Program: 55200
Project: 55200
Buggy source:
@NotNull @Override public Asset acquireAsset(@NotNull String childName){
  if (keyedAsset != Boolean.TRUE) {
    int pos=childName.indexOf('/');
    if (pos == 0) {
      childName=childName.substring(1);
      pos=childName.indexOf('/');
    }
    if (pos > 0) {
      String name1=childName.substring(0,pos);
      String name2=childName.substring(pos + 1);
      return getAssetOrANFE(name1).acquireAsset(name2);
    }
  }
  return getAssetOrANFE(childName);
}

Fixed version (ground truth):
@NotNull @Override public Asset acquireAsset(@NotNull String childName){
  if ("String_Node_Str".contentEquals(childName))   return root();
  if (keyedAsset != Boolean.TRUE) {
    int pos=childName.indexOf('/');
    if (pos == 0) {
      childName=childName.substring(1);
      pos=childName.indexOf('/');
    }
    if (pos > 0) {
      String name1=childName.substring(0,pos);
      String name2=childName.substring(pos + 1);
      return getAssetOrANFE(name1).acquireAsset(name2);
    }
  }
  return getAssetOrANFE(childName);
}
Program: 55201
Project: 55201
Buggy source:
public TypographyTest(Boolean isRemote) throws Exception {
  if (isRemote) {
    VanillaAssetTree assetTree0=new VanillaAssetTree().forTesting();
    assetTree0.acquireMap("String_Node_Str",String.class,String.class);
    assetTree0.acquireMap("String_Node_Str",String.class,String.class);
    String hostPortDescription="String_Node_Str" + methodName;
    TCPRegistry.createServerSocketChannelFor(hostPortDescription);
    serverEndpoint=new ServerEndpoint(hostPortDescription,assetTree0);
    final VanillaAssetTree client=new VanillaAssetTree();
    assetTree=client.forRemoteAccess(hostPortDescription,WireType.BINARY);
  }
 else {
    assetTree=(new VanillaAssetTree(1)).forTesting();
    serverEndpoint=null;
  }
}

Fixed version (ground truth):
public TypographyTest(Boolean isRemote) throws Exception {
  if (isRemote) {
    VanillaAssetTree assetTree0=new VanillaAssetTree().forTesting();
    String hostPortDescription="String_Node_Str" + methodName;
    TCPRegistry.createServerSocketChannelFor(hostPortDescription);
    serverEndpoint=new ServerEndpoint(hostPortDescription,assetTree0);
    final VanillaAssetTree client=new VanillaAssetTree();
    assetTree=client.forRemoteAccess(hostPortDescription,WireType.BINARY);
  }
 else {
    assetTree=(new VanillaAssetTree(1)).forTesting();
    serverEndpoint=null;
  }
}
Program: 55203
Project: 55203
Buggy source:
private QueueView acquireQV(){
  if (qv != null)   return qv;
  String path="String_Node_Str" + localIdentifier;
  RequestContext requestContext=requestContext(path).elementType(NetworkStats.class).cluster(clusterName());
  qv=asset.root().acquireAsset(requestContext.fullName()).acquireView(QueueView.class,requestContext);
  return qv;
}

Fixed version (ground truth):
private QueueView acquireQV(){
  if (qv != null)   return qv;
  String path="String_Node_Str" + localIdentifier;
  RequestContext requestContext=requestContext(path).elementType(NetworkStats.class);
  if (ChronicleQueueView.isQueueReplicationAvailable())   requestContext.cluster(clusterName());
  qv=asset.root().acquireAsset(requestContext.fullName()).acquireView(QueueView.class,requestContext);
  return qv;
}
Program: 55204
Project: 55204
Buggy source:
/** 
 * Add an implementation of a view to the asset.. This can be used instead of, or in addition to adding rules.
 * @param viewType to associate this implementation with.
 * @param view
 * @return the view provided.
 */
<V>V addView(Class<V> viewType,V view);

Fixed version (ground truth):
default <V>V addView(V view){
  return addView((Class<V>)view.getClass(),view);
}
Program: 55205
Project: 55205
Buggy source:
@Override public ClustersCfg install(String path,AssetTree assetTree) throws Exception {
  assetTree.root().addView(Clusters.class,clusters);
  return this;
}

Fixed version (ground truth):
@Override public ClustersCfg install(String path,AssetTree assetTree) throws Exception {
  assetTree.root().addView(Clusters.class,clusters);
  clusters.install(assetTree);
  return this;
}
Program: 55206
Project: 55206
Buggy source:
private void readMarshallable(String path,WireIn wire){
  StringBuilder name=new StringBuilder();
  while (wire.hasMore()) {
    ValueIn in=wire.read(name);
    long pos=wire.bytes().readPosition();
    String path2=path + "String_Node_Str" + name;
    if (wire.getValueIn().isTyped()) {
      wire.bytes().readPosition(pos);
      Object o=in.typedMarshallable();
      installableMap.put(path2,(Installable)o);
    }
 else {
      in.marshallable(w -> this.readMarshallable(path2,w));
    }
  }
}

Fixed version (ground truth):
private void readMarshallable(String path,WireIn wire){
  StringBuilder name=new StringBuilder();
  while (!wire.isEmpty()) {
    ValueIn in=wire.read(name);
    long pos=wire.bytes().readPosition();
    String path2=path + "String_Node_Str" + name;
    if (wire.getValueIn().isTyped()) {
      wire.bytes().readPosition(pos);
      Object o=in.typedMarshallable();
      installableMap.put(path2,(Installable)o);
    }
 else {
      in.marshallable(w -> this.readMarshallable(path2,w));
    }
  }
}
Program: 55207
Project: 55207
Buggy source:
@Override public Void install(String path,AssetTree assetTree) throws IOException {
  String uri=path + "String_Node_Str" + putReturnsNull+ "String_Node_Str"+ removeReturnsNull;
  MapView mapView=assetTree.acquireMap(uri,keyType,valueType);
  if (importFile != null) {
    Wire wire=Wire.fromFile(importFile);
    StringBuilder keyStr=new StringBuilder();
    while (wire.hasMore()) {
      Object value=wire.readEventName(keyStr).object(valueType);
      Object key=ObjectUtils.convertTo(keyType,keyStr);
      mapView.put(key,value);
    }
  }
  LOGGER.info("String_Node_Str" + path + "String_Node_Str"+ mapView.size());
  return null;
}

Fixed version (ground truth):
@Override public Void install(String path,AssetTree assetTree) throws IOException {
  String uri=path + "String_Node_Str" + putReturnsNull+ "String_Node_Str"+ removeReturnsNull;
  MapView mapView=assetTree.acquireMap(uri,keyType,valueType);
  if (importFile != null) {
    Wire wire=Wire.fromFile(importFile);
    StringBuilder keyStr=new StringBuilder();
    while (!wire.isEmpty()) {
      Object value=wire.readEventName(keyStr).object(valueType);
      Object key=ObjectUtils.convertTo(keyType,keyStr);
      mapView.put(key,value);
    }
  }
  LOGGER.info("String_Node_Str" + path + "String_Node_Str"+ mapView.size());
  return null;
}
Program: 55208
Project: 55208
Buggy source:
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  wire.read(() -> "String_Node_Str").typeLiteral(this,(o,c) -> o.keyType=c).read(() -> "String_Node_Str").typeLiteral(this,(o,c) -> o.valueType=c).read(() -> "String_Node_Str").text(this,(o,c) -> o.compression=c).read(() -> "String_Node_Str").bool(this,(o,e) -> o.putReturnsNull=e).read(() -> "String_Node_Str").bool(this,(o,e) -> o.removeReturnsNull=e);
  if (wire.hasMore())   wire.read(() -> "String_Node_Str").text(this,(o,s) -> o.importFile=s);
}

Fixed version (ground truth):
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  wire.read(() -> "String_Node_Str").typeLiteral(this,(o,c) -> o.keyType=c).read(() -> "String_Node_Str").typeLiteral(this,(o,c) -> o.valueType=c).read(() -> "String_Node_Str").text(this,(o,c) -> o.compression=c).read(() -> "String_Node_Str").bool(this,(o,e) -> o.putReturnsNull=e).read(() -> "String_Node_Str").bool(this,(o,e) -> o.removeReturnsNull=e);
  while (!wire.isEmpty())   wire.read(() -> "String_Node_Str").text(this,(o,s) -> o.importFile=s);
}
Program: 55209
Project: 55209
Buggy source:
public Clusters(Map<String,EngineCluster> clusterMap){
  this.clusterMap=clusterMap;
}

Fixed version (ground truth):
public Clusters(Map<String,EngineCluster> clusterMap){
  this.clusterMap.putAll(clusterMap);
}
Program: 55210
Project: 55210
Buggy source:
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  StringBuilder clusterName=Wires.acquireStringBuilder();
  while (wire.hasMore()) {
    wire.readEventName(clusterName).marshallable(host -> {
      EngineCluster engineCluster=clusterMap.computeIfAbsent(clusterName.toString(),EngineCluster::new);
      engineCluster.readMarshallable(host);
    }
);
  }
}

Fixed version (ground truth):
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  StringBuilder clusterName=Wires.acquireStringBuilder();
  while (!wire.isEmpty()) {
    wire.readEventName(clusterName).marshallable(host -> {
      EngineCluster engineCluster=clusterMap.computeIfAbsent(clusterName.toString(),EngineCluster::new);
      engineCluster.readMarshallable(host);
    }
);
  }
}
Program: 55211
Project: 55211
Buggy source:
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  StringBuilder mountDesc=new StringBuilder();
  while (wire.hasMore()) {
    MountPoint mp=wire.readEventName(mountDesc).typedMarshallable();
    mounts.put(mountDesc.toString(),mp);
  }
}

Fixed version (ground truth):
@Override public void readMarshallable(@NotNull WireIn wire) throws IllegalStateException {
  StringBuilder mountDesc=new StringBuilder();
  while (!wire.isEmpty()) {
    MountPoint mp=wire.readEventName(mountDesc).typedMarshallable();
    mounts.put(mountDesc.toString(),mp);
  }
}
Program: 55212
Project: 55212
Buggy source:
@Override public void onRead(@NotNull WireIn inWire,@NotNull WireOut outWire){
  if (!inWire.hasMore())   return;
  inWire.read(() -> "String_Node_Str").text();
}

Fixed version (ground truth):
@Override public void onRead(@NotNull WireIn inWire,@NotNull WireOut outWire){
  if (inWire.isEmpty())   return;
  inWire.read(() -> "String_Node_Str").text();
}
Program: 55214
Project: 55214
Buggy source:
@Override public void onNetworkStats(long writeBps,long readBps,long socketPollCountPerSecond,@NotNull EngineWireNetworkContext nc,boolean isConnected){
  final WireNetworkStats wireNetworkStats=this.wireNetworkStats.get();
  wireNetworkStats.writeBps(writeBps);
  wireNetworkStats.readBps(readBps);
  wireNetworkStats.socketPollCountPerSecond(socketPollCountPerSecond);
  wireNetworkStats.timestamp(System.currentTimeMillis());
  wireNetworkStats.isConnected(isConnected);
  final SessionDetailsProvider sessionDetailsProvider=nc.sessionDetails();
  if (sessionDetailsProvider != null) {
    wireNetworkStats.clientId(sessionDetailsProvider.clientId());
    wireNetworkStats.userId(sessionDetailsProvider.userId());
  }
  acquireQV().publishAndIndex("String_Node_Str",wireNetworkStats);
}

Fixed version (ground truth):
@Override public void onNetworkStats(long writeBps,long readBps,long socketPollCountPerSecond,@NotNull EngineWireNetworkContext nc,boolean isConnected){
  wireNetworkStats.writeBps(writeBps);
  wireNetworkStats.readBps(readBps);
  wireNetworkStats.socketPollCountPerSecond(socketPollCountPerSecond);
  wireNetworkStats.timestamp(System.currentTimeMillis());
  wireNetworkStats.isConnected(isConnected);
  if (nc.handler() instanceof AbstractSubHandler) {
    final int remoteIdentifier=((AbstractSubHandler)nc.handler()).remoteIdentifier();
    wireNetworkStats.remoteIdentifier(remoteIdentifier);
  }
 else   if (nc.handler() instanceof UberHandler) {
    final UberHandler handler=(UberHandler)nc.handler();
    wireNetworkStats.remoteIdentifier(handler.remoteIdentifier());
    wireNetworkStats.wireType(handler.wireType());
  }
  final SessionDetailsProvider sessionDetailsProvider=nc.sessionDetails();
  if (sessionDetailsProvider != null) {
    wireNetworkStats.clientId(sessionDetailsProvider.clientId());
    wireNetworkStats.userId(sessionDetailsProvider.userId());
    wireNetworkStats.wireType(sessionDetailsProvider.wireType());
  }
  wireNetworkStats.localIdentifier(localIdentifier);
  acquireQV().publishAndIndex("String_Node_Str",wireNetworkStats);
}
Program: 55215
Project: 55215
Buggy source:
@Override public void onHostPort(String hostName,int port){
  final WireNetworkStats wireNetworkStats=this.wireNetworkStats.get();
  wireNetworkStats.host(hostName);
  wireNetworkStats.port(port);
}

Fixed version (ground truth):
@Override public void onHostPort(String hostName,int port){
  wireNetworkStats.remoteHostName(hostName);
  wireNetworkStats.remotePort(port);
}
Program: 55216
Project: 55216
Buggy source:
public EngineNetworkStatsListener(Asset asset,int localIdentifier){
  this.localIdentifier=localIdentifier;
  wireNetworkStats=ThreadLocal.withInitial(() -> new WireNetworkStats(localIdentifier));
  this.asset=asset;
}

Fixed version (ground truth):
public EngineNetworkStatsListener(Asset asset,int localIdentifier){
  this.localIdentifier=localIdentifier;
  this.asset=asset;
}
Program: 55218
Project: 55218
Buggy source:
public ArrayList<String> columnNames();

Fixed version (ground truth):
ArrayList<String> columnNames();
Program: 55219
Project: 55219
Buggy source:
@Override public Row next(){
  final Map.Entry e=core.next();
  final Row row=new Row(columnNames());
  if (!(Marshallable.class.isAssignableFrom(keyType())))   row.add("String_Node_Str",e.getKey());
 else   throw new UnsupportedOperationException("String_Node_Str");
  if (!(Marshallable.class.isAssignableFrom(valueType())))   row.add("String_Node_Str",e.getValue());
 else {
    final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      if (!columnNames.contains(declaredFields.getName()))       continue;
      try {
        declaredFields.setAccessible(true);
        row.add(declaredFields.getName(),declaredFields.get(value));
      }
 catch (      Exception e1) {
        Jvm.warn().on(VanillaMapView.class,e1);
      }
    }
  }
  return row;
}

Fixed version (ground truth):
@Override public Row next(){
  final Map.Entry e=core.next();
  final Row row=new Row(columnNames());
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   row.add("String_Node_Str",e.getKey());
 else   throw new UnsupportedOperationException("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   row.add("String_Node_Str",e.getValue());
 else {
    final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      if (!columnNames.contains(declaredFields.getName()))       continue;
      try {
        declaredFields.setAccessible(true);
        row.add(declaredFields.getName(),declaredFields.get(value));
      }
 catch (      Exception e1) {
        Jvm.warn().on(VanillaMapView.class,e1);
      }
    }
  }
  return row;
}
Program: 55220
Project: 55220
Buggy source:
@Override public List<Column> columns(){
  List<Column> result=new ArrayList<>();
  if (!(Marshallable.class.isAssignableFrom(keyType())))   result.add(new Column("String_Node_Str",false,false,false,true,"String_Node_Str",String.class));
  if (!(Marshallable.class.isAssignableFrom(valueType())))   result.add(new Column("String_Node_Str",false,false,false,false,"String_Node_Str",String.class));
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(new Column(declaredFields.getName(),false,false,false,false,"String_Node_Str",declaredFields.getType()));
    }
  }
  return result;
}

Fixed version (ground truth):
@Override public List<Column> columns(){
  List<Column> result=new ArrayList<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add(new Column("String_Node_Str",false,false,false,true,"String_Node_Str",keyType()));
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add(new Column("String_Node_Str",false,false,false,false,"String_Node_Str",valueType()));
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(new Column(declaredFields.getName(),false,false,false,false,"String_Node_Str",declaredFields.getType()));
    }
  }
  return result;
}
Program: 55221
Project: 55221
Buggy source:
@Override public void onCellChanged(String columnName,K key,K oldKey,Object value,Object oldValue){
  if (!(Marshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,kvStore.getAndRemove(oldKey));
    return;
  }
  if (!(Marshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,(V)value);
    return;
  }
  throw new UnsupportedOperationException("String_Node_Str" + columnName);
}

Fixed version (ground truth):
@Override public void onCellChanged(String columnName,K key,K oldKey,Object value,Object oldValue){
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,kvStore.getAndRemove(oldKey));
    return;
  }
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,(V)value);
    return;
  }
  throw new UnsupportedOperationException("String_Node_Str" + columnName);
}
Program: 55222
Project: 55222
Buggy source:
@Override public Iterator<Row> iterator(ColumnView.Query<K> query){
  final Iterator<Map.Entry<K,V>> core=entrySet().stream().filter(query::filter).sorted(query.sorted()).iterator();
  Iterator<Row> result=new Iterator<Row>(){
    @Override public boolean hasNext(){
      return core.hasNext();
    }
    @Override public Row next(){
      final Map.Entry e=core.next();
      final Row row=new Row(columnNames());
      if (!(Marshallable.class.isAssignableFrom(keyType())))       row.add("String_Node_Str",e.getKey());
 else       throw new UnsupportedOperationException("String_Node_Str");
      if (!(Marshallable.class.isAssignableFrom(valueType())))       row.add("String_Node_Str",e.getValue());
 else {
        final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
        for (        final Field declaredFields : valueType().getDeclaredFields()) {
          if (!columnNames.contains(declaredFields.getName()))           continue;
          try {
            declaredFields.setAccessible(true);
            row.add(declaredFields.getName(),declaredFields.get(value));
          }
 catch (          Exception e1) {
            Jvm.warn().on(VanillaMapView.class,e1);
          }
        }
      }
      return row;
    }
  }
;
  long x=0;
  while (x++ < query.fromIndex && result.hasNext()) {
    result.next();
  }
  return result;
}

Fixed version (ground truth):
@Override public Iterator<Row> iterator(final ColumnView.Query<K> query){
  final Iterator<Map.Entry<K,V>> core=entrySet().stream().filter(query::filter).sorted(sort(query.marshableOrderBy)).iterator();
  Iterator<Row> result=new Iterator<Row>(){
    @Override public boolean hasNext(){
      return core.hasNext();
    }
    @Override public Row next(){
      final Map.Entry e=core.next();
      final Row row=new Row(columnNames());
      if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))       row.add("String_Node_Str",e.getKey());
 else       throw new UnsupportedOperationException("String_Node_Str");
      if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))       row.add("String_Node_Str",e.getValue());
 else {
        final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
        for (        final Field declaredFields : valueType().getDeclaredFields()) {
          if (!columnNames.contains(declaredFields.getName()))           continue;
          try {
            declaredFields.setAccessible(true);
            row.add(declaredFields.getName(),declaredFields.get(value));
          }
 catch (          Exception e1) {
            Jvm.warn().on(VanillaMapView.class,e1);
          }
        }
      }
      return row;
    }
  }
;
  long x=0;
  while (x++ < query.fromIndex && result.hasNext()) {
    result.next();
  }
  return result;
}
Program: 55223
Project: 55223
Buggy source:
@Override public ArrayList<String> columnNames(){
  if (columnNames != null)   return columnNames;
  LinkedHashSet<String> result=new LinkedHashSet<>();
  if (!(Marshallable.class.isAssignableFrom(keyType())))   result.add("String_Node_Str");
  if (!(Marshallable.class.isAssignableFrom(valueType())))   result.add("String_Node_Str");
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(declaredFields.getName());
    }
  }
  columnNames=new ArrayList<>(result);
  return columnNames;
}

Fixed version (ground truth):
@Override public ArrayList<String> columnNames(){
  if (columnNames != null)   return columnNames;
  LinkedHashSet<String> result=new LinkedHashSet<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add("String_Node_Str");
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(declaredFields.getName());
    }
  }
  columnNames=new ArrayList<>(result);
  return columnNames;
}
Program: 55224
Project: 55224
Buggy source:
/** 
 * called when ever the user modify the cells and the data changes
 * @param columnName the column name of the cell
 * @param key        the rowID of the cell
 * @param oldKey     the old rowID of the cell
 * @param value      the new value of the cell
 * @param oldValue   the old value of the cell
 */
void onRowChanged(String columnName,K key,K oldKey,Object value,Object oldValue);

Fixed version (ground truth):
/** 
 * called when ever the user modify the cells and the data changes
 * @param columnName the column name of the cell
 * @param key        the rowID of the cell
 * @param oldKey     the old rowID of the cell
 * @param value      the new value of the cell
 * @param oldValue   the old value of the cell
 */
void onRowChanged(String columnName,Object key,Object oldKey,Object value,Object oldValue);
Program: 55225
Project: 55225
Buggy source:
int rowCount(Query query);

Fixed version (ground truth):
int rowCount(@Nullable Query query);
Program: 55226
Project: 55226
Buggy source:
/** 
 * @param columnNames all the column names that make up this row
 */
public Row(@NotNull List<String> columnNames){
  this.columnNames=columnNames;
}

Fixed version (ground truth):
/** 
 * @param columns all the column names that make up this row
 */
public Row(@NotNull List<Column> columns){
  columnNames=columns.stream().map(c -> c.name).collect(Collectors.toList());
}
Program: 55227
Project: 55227
Buggy source:
@Override public Row next(){
  final Map.Entry e=core.next();
  final Row row=new Row(columnNames());
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   row.set("String_Node_Str",e.getKey());
 else   throw new UnsupportedOperationException("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   row.set("String_Node_Str",e.getValue());
 else {
    final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      if (!columnNames.contains(declaredFields.getName()))       continue;
      try {
        declaredFields.setAccessible(true);
        row.set(declaredFields.getName(),declaredFields.get(value));
      }
 catch (      Exception e1) {
        Jvm.warn().on(VanillaMapView.class,e1);
      }
    }
  }
  return row;
}

Fixed version (ground truth):
@Override public Row next(){
  final Map.Entry e=core.next();
  final Row row=new Row(columns());
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   row.set("String_Node_Str",e.getKey());
 else   throw new UnsupportedOperationException("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   row.set("String_Node_Str",e.getValue());
 else {
    final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      if (!columnNames().contains(declaredFields.getName()))       continue;
      try {
        declaredFields.setAccessible(true);
        row.set(declaredFields.getName(),declaredFields.get(value));
      }
 catch (      Exception e1) {
        Jvm.warn().on(VanillaMapView.class,e1);
      }
    }
  }
  return row;
}
Program: 55228
Project: 55228
Buggy source:
@Override public Iterator<Row> iterator(final ColumnView.Query query){
  final Iterator<Map.Entry<K,V>> core=entrySet().stream().filter(filter(query)).sorted(sort(query.marshableOrderBy)).iterator();
  final Iterator<Row> result=new Iterator<Row>(){
    @Override public boolean hasNext(){
      return core.hasNext();
    }
    @Override public Row next(){
      final Map.Entry e=core.next();
      final Row row=new Row(columnNames());
      if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))       row.set("String_Node_Str",e.getKey());
 else       throw new UnsupportedOperationException("String_Node_Str");
      if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))       row.set("String_Node_Str",e.getValue());
 else {
        final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
        for (        final Field declaredFields : valueType().getDeclaredFields()) {
          if (!columnNames.contains(declaredFields.getName()))           continue;
          try {
            declaredFields.setAccessible(true);
            row.set(declaredFields.getName(),declaredFields.get(value));
          }
 catch (          Exception e1) {
            Jvm.warn().on(VanillaMapView.class,e1);
          }
        }
      }
      return row;
    }
  }
;
  long x=0;
  while (x++ < query.fromIndex && result.hasNext()) {
    result.next();
  }
  return result;
}

Fixed version (ground truth):
@Override public Iterator<Row> iterator(final ColumnView.Query query){
  final Iterator<Map.Entry<K,V>> core=entrySet().stream().filter(filter(query)).sorted(sort(query.marshableOrderBy)).iterator();
  final Iterator<Row> result=new Iterator<Row>(){
    @Override public boolean hasNext(){
      return core.hasNext();
    }
    @Override public Row next(){
      final Map.Entry e=core.next();
      final Row row=new Row(columns());
      if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))       row.set("String_Node_Str",e.getKey());
 else       throw new UnsupportedOperationException("String_Node_Str");
      if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))       row.set("String_Node_Str",e.getValue());
 else {
        final AbstractMarshallable value=(AbstractMarshallable)e.getValue();
        for (        final Field declaredFields : valueType().getDeclaredFields()) {
          if (!columnNames().contains(declaredFields.getName()))           continue;
          try {
            declaredFields.setAccessible(true);
            row.set(declaredFields.getName(),declaredFields.get(value));
          }
 catch (          Exception e1) {
            Jvm.warn().on(VanillaMapView.class,e1);
          }
        }
      }
      return row;
    }
  }
;
  long x=0;
  while (x++ < query.fromIndex && result.hasNext()) {
    result.next();
  }
  return result;
}
Program: 55229
Project: 55229
Buggy source:
@Override public void onRowChanged(String columnName,K key,K oldKey,Object value,Object oldValue){
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,kvStore.getAndRemove(oldKey));
    return;
  }
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put(key,(V)value);
    return;
  }
  final V v=kvStore.get(key);
  if (!(v instanceof AbstractMarshallable))   throw new UnsupportedOperationException("String_Node_Str" + "String_Node_Str");
  final Field field;
  try {
    field=v.getClass().getDeclaredField(columnName);
    field.setAccessible(true);
    field.set(v,value);
    kvStore.put(key,v);
  }
 catch (  Exception e) {
    Jvm.warn().on(VanillaMapView.class,e);
  }
}

Fixed version (ground truth):
@Override public void onRowChanged(String columnName,Object key,Object oldKey,Object value,Object oldValue){
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put((K)key,kvStore.getAndRemove((K)oldKey));
    return;
  }
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())) && "String_Node_Str".equals(columnName)) {
    kvStore.put((K)key,(V)value);
    return;
  }
  final V v=kvStore.get((K)key);
  if (!(v instanceof AbstractMarshallable))   throw new UnsupportedOperationException("String_Node_Str" + "String_Node_Str");
  final Field field;
  try {
    field=v.getClass().getDeclaredField(columnName);
    field.setAccessible(true);
    field.set(v,value);
    kvStore.put((K)key,v);
  }
 catch (  Exception e) {
    Jvm.warn().on(VanillaMapView.class,e);
  }
}
Program: 55230
Project: 55230
Buggy source:
@Override public ArrayList<String> columnNames(){
  if (columnNames != null)   return columnNames;
  LinkedHashSet<String> result=new LinkedHashSet<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add("String_Node_Str");
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(declaredFields.getName());
    }
  }
  columnNames=new ArrayList<>(result);
  return columnNames;
}

Fixed version (ground truth):
private ArrayList<String> columnNames(){
  if (columnNames != null)   return columnNames;
  LinkedHashSet<String> result=new LinkedHashSet<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add("String_Node_Str");
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add("String_Node_Str");
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(declaredFields.getName());
    }
  }
  columnNames=new ArrayList<>(result);
  return columnNames;
}
Program: 55231
Project: 55231
Buggy source:
@Override public int rowCount(ColumnView.Query query){
  return (int)entrySet().stream().filter(filter(query)).count();
}

Fixed version (ground truth):
/** 
 * @param query if {@code query} == null all the total number of rows is returned
 * @return the number of rows the matches this query
 */
@Override public int rowCount(@Nullable ColumnView.Query query){
  if (query == null)   return (int)longSize();
  return (int)entrySet().stream().filter(filter(query)).count();
}
Program: 55232
Project: 55232
Buggy source:
public QueueWrappingColumnView(RequestContext requestContext,Asset asset,QueueView<String,V> queueView){
  this.queueView=queueView;
  final QueueView.Excerpt<String,V> excerpt=queueView.getExcerpt(0);
  messageClass=excerpt.message().getClass();
}

Fixed version (ground truth):
public QueueWrappingColumnView(RequestContext requestContext,Asset asset,QueueView<String,V> queueView){
  this.queueView=queueView;
  final QueueView.Excerpt<String,V> excerpt=queueView.getExcerpt(0);
  if (excerpt != null)   messageClass=excerpt.message().getClass();
 else   messageClass=Object.class;
}
Program: 55233
Project: 55233
Buggy source:
@Nullable public Predicate<QueueView.Excerpt<String,V>> filter(@NotNull List<MarshableFilter> filters){
  return excerpt -> {
    if (filters.isEmpty())     return true;
    try {
      for (      @NotNull MarshableFilter f : filters) {
        Object item;
        final Class messageClass=excerpt.message().getClass();
        if (AbstractMarshallable.class.isAssignableFrom(messageClass)) {
          try {
            final Field field=messageClass.getDeclaredField(f.columnName);
            field.setAccessible(true);
            final Object o=field.get(excerpt.message());
            if (o == null)             return false;
            if (o instanceof Number) {
              if (toRange((Number)o,f.filter.trim()))               continue;
              return false;
            }
            item=o;
          }
 catch (          Exception e) {
            return false;
          }
        }
 else {
          throw new UnsupportedOperationException();
        }
        if (item instanceof CharSequence) {
          if (!item.toString().toLowerCase().contains(f.filter.toLowerCase()))           return false;
        }
 else         if (item instanceof Number) {
          if (!toRange((Number)item,f.filter.trim()))           return false;
        }
 else {
          if (!item.equals(convertTo(item.getClass(),f.filter.trim())))           return false;
        }
      }
      return true;
    }
 catch (    NumberFormatException e) {
      return false;
    }
  }
;
}

Fixed version (ground truth):
@Nullable public Predicate<QueueView.Excerpt<String,V>> filter(@Nullable List<MarshableFilter> filters){
  return excerpt -> {
    if (filters == null || filters.isEmpty())     return true;
    try {
      for (      @NotNull MarshableFilter f : filters) {
        Object item;
        final Class messageClass=excerpt.message().getClass();
        if (AbstractMarshallable.class.isAssignableFrom(messageClass)) {
          try {
            final Field field=messageClass.getDeclaredField(f.columnName);
            field.setAccessible(true);
            final Object o=field.get(excerpt.message());
            if (o == null)             return false;
            if (o instanceof Number) {
              if (toRange((Number)o,f.filter.trim()))               continue;
              return false;
            }
            item=o;
          }
 catch (          Exception e) {
            return false;
          }
        }
 else {
          throw new UnsupportedOperationException();
        }
        if (item instanceof CharSequence) {
          if (!item.toString().toLowerCase().contains(f.filter.toLowerCase()))           return false;
        }
 else         if (item instanceof Number) {
          if (!toRange((Number)item,f.filter.trim()))           return false;
        }
 else {
          if (!item.equals(convertTo(item.getClass(),f.filter.trim())))           return false;
        }
      }
      return true;
    }
 catch (    NumberFormatException e) {
      return false;
    }
  }
;
}
Program: 55235
Project: 55235
Buggy source:
/** 
 * @param sortedFilter if {@code sortedFilter} == null or empty all the total number of rows isreturned
 * @return the number of rows the matches this query
 */
@Override public int rowCount(@Nullable List<MarshableFilter> sortedFilter){
  final QueueView.Excerpt<String,V> e=queueView.getExcerpt(0);
  if (e == null)   return 0;
  int count=1;
  while (queueView.getExcerpt("String_Node_Str") != null) {
    count++;
  }
  return count;
}

Fixed version (ground truth):
/** 
 * @param sortedFilter if {@code sortedFilter} == null or empty all the total number of rows isreturned
 * @return the number of rows the matches this query
 */
@Override public int rowCount(@Nullable List<MarshableFilter> sortedFilter){
  final Iterator<Row> iterator=iterator(sortedFilter,0);
  int count=0;
  while (iterator.hasNext()) {
    iterator.next();
    count++;
  }
  return count;
}
Program: 55237
Project: 55237
Buggy source:
public Column(String propertyId,boolean readOnly,boolean allowReadOnlyChange,boolean nullable,boolean primaryKey,Object value,Class<?> type,boolean isHidden){
  this.name=propertyId;
  this.readOnly=readOnly;
  this.allowReadOnlyChange=allowReadOnlyChange;
  this.nullable=nullable;
  this.primaryKey=primaryKey;
  this.value=value;
  this.type=type;
  this.isHidden=isHidden;
}

Fixed version (ground truth):
public Column(String name,boolean readOnly,boolean primaryKey,Object value,Class<?> type){
  this.name=name;
  this.readOnly=readOnly;
  this.primaryKey=primaryKey;
  this.value=value;
  this.type=type;
}
Program: 55238
Project: 55238
Buggy source:
@Override public List<Column> columns(){
  List<Column> result=new ArrayList<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add(new Column("String_Node_Str",false,false,false,true,"String_Node_Str",keyType(),false));
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add(new Column("String_Node_Str",false,false,false,false,"String_Node_Str",valueType(),false));
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(new Column(declaredFields.getName(),false,false,false,false,"String_Node_Str",declaredFields.getType(),false));
    }
  }
  return result;
}

Fixed version (ground truth):
@Override public List<Column> columns(){
  List<Column> result=new ArrayList<>();
  if (!(AbstractMarshallable.class.isAssignableFrom(keyType())))   result.add(new Column("String_Node_Str",false,true,"String_Node_Str",keyType()));
  if (!(AbstractMarshallable.class.isAssignableFrom(valueType())))   result.add(new Column("String_Node_Str",false,false,"String_Node_Str",valueType()));
 else {
    for (    final Field declaredFields : valueType().getDeclaredFields()) {
      result.add(new Column(declaredFields.getName(),false,false,"String_Node_Str",declaredFields.getType()));
    }
  }
  return result;
}
Program: 55239
Project: 55239
Buggy source:
/** 
 * Enable JMX management of this Asset Tree
 * @param port to enable a simple web service on
 */
@NotNull default AssetTree enableManagement(int port){
  ManagementTools.enableManagement(this,port);
  return this;
}

Fixed version (ground truth):
/** 
 * Enable JMX management of this Asset Tree
 * @param port to enable a simple web service on
 */
@NotNull default AssetTree enableManagement(int port){
  ManagementTools.enableManagement(this);
  return this;
}
Program: 55240
Project: 55240
Buggy source:
private void dumpThreads(){
  for (  Map.Entry<Thread,StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
    Thread thread=entry.getKey();
    if (thread.getThreadGroup().getName().equals("String_Node_Str"))     continue;
    StringBuilder sb=new StringBuilder();
    sb.append(thread).append("String_Node_Str").append(thread.getState());
    Jvm.trimStackTrace(sb,entry.getValue());
    sb.append("String_Node_Str");
    Jvm.warn().on(getClass(),"String_Node_Str",sb);
  }
}

Fixed version (ground truth):
private void dumpThreads(){
  for (  Map.Entry<Thread,StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
    Thread thread=entry.getKey();
    if (thread.getThreadGroup().getName().equals("String_Node_Str"))     continue;
    StringBuilder sb=new StringBuilder();
    sb.append(thread).append("String_Node_Str").append(thread.getState());
    Jvm.trimStackTrace(sb,entry.getValue());
    sb.append("String_Node_Str");
    Jvm.warn().on(getClass(),"String_Node_Str" + sb.toString());
  }
}
Program: 55241
Project: 55241
Buggy source:
@NotNull public VanillaAssetTree forRemoteAccess(String hostPortDescription){
  return forRemoteAccess(hostPortDescription,WireType.BINARY);
}

Fixed version (ground truth):
public VanillaAssetTree forRemoteAccess(String serverAddress,WireType wireType,Consumer<Throwable> t){
  return forRemoteAccess(serverAddress,wireType);
}
Program: 55242
Project: 55242
Buggy source:
@Override public void writeMarshallable(@NotNull WireOut wire){
  wire.write("String_Node_Str").int64_0x(index);
  wire.write("String_Node_Str").typedMarshallable(v);
}

Fixed version (ground truth):
@Override public void writeMarshallable(@NotNull WireOut wire){
  wire.write("String_Node_Str").int64_0x(index);
  wire.write("String_Node_Str").typedMarshallable(v);
  wire.write("String_Node_Str").int64(timePublished);
  wire.write("String_Node_Str").int64(maxIndex);
}
Program: 55243
Project: 55243
Buggy source:
@Nullable private IndexedValue<V> value(@NotNull IndexQuery<V> vanillaIndexQuery,@NotNull ExcerptTailer tailer,@NotNull Iterator<IndexedValue<V>> iterator,final long from){
  if (iterator.hasNext()) {
    IndexedValue<V> indexedValue=iterator.next();
    indexedValue.timePublished(System.currentTimeMillis());
    indexedValue.maxIndex(lastIndexRead);
    return indexedValue;
  }
  final String eventName=vanillaIndexQuery.eventName();
  final Predicate<V> filter=vanillaIndexQuery.filter();
  if (isClosed.get())   throw Jvm.rethrow(new InvalidEventHandlerException("String_Node_Str"));
  try (DocumentContext dc=tailer.readingDocument()){
    if (!dc.isPresent())     return null;
    if (LOG.isDebugEnabled())     LOG.debug("String_Node_Str",Wires.fromSizePrefixedBlobs(dc));
    if (from > dc.index())     return null;
    final StringBuilder sb=Wires.acquireStringBuilder();
    final ValueIn valueIn=dc.wire().read(sb);
    if (!eventName.contentEquals(sb))     return null;
    final Function<Class,ReadMarshallable> objectCache=objectCacheThreadLocal.get();
    final V v=valueIn.typedMarshallable(objectCache);
    if (!filter.test(v))     return null;
    final IndexedValue<V> indexedValue=this.indexedValue.get();
    indexedValue.index(dc.index());
    indexedValue.v(v);
    indexedValue.timePublished(System.currentTimeMillis());
    indexedValue.maxIndex(lastIndexRead);
    return indexedValue;
  }
 }

Fixed version (ground truth):
@Nullable private IndexedValue<V> value(@NotNull IndexQuery<V> vanillaIndexQuery,@NotNull ExcerptTailer tailer,@NotNull Iterator<IndexedValue<V>> iterator,final long from){
  if (iterator.hasNext()) {
    IndexedValue<V> indexedValue=iterator.next();
    indexedValue.timePublished(System.currentTimeMillis());
    indexedValue.maxIndex(lastIndexRead);
    return indexedValue;
  }
  final String eventName=vanillaIndexQuery.eventName();
  final Predicate<V> filter=vanillaIndexQuery.filter();
  if (isClosed.get())   throw Jvm.rethrow(new InvalidEventHandlerException("String_Node_Str"));
  try (DocumentContext dc=tailer.readingDocument()){
    if (!dc.isPresent())     return null;
    if (LOG.isDebugEnabled())     LOG.debug("String_Node_Str",Wires.fromSizePrefixedBlobs(dc));
    if (from > dc.index())     return null;
    final StringBuilder sb=Wires.acquireStringBuilder();
    final ValueIn valueIn=dc.wire().read(sb);
    if (!eventName.contentEquals(sb))     return null;
    final Function<Class,ReadMarshallable> objectCache=objectCacheThreadLocal.get();
    final V v=valueIn.typedMarshallable(objectCache);
    if (!filter.test(v))     return null;
    final IndexedValue<V> indexedValue=this.indexedValue.get();
    long index=dc.index();
    indexedValue.index(index);
    indexedValue.v(v);
    indexedValue.timePublished(System.currentTimeMillis());
    indexedValue.maxIndex(lastIndexRead);
    return indexedValue;
  }
 }