Refine search
private static org.apache.logging.log4j.Marker convertMarker(final Marker original, final Collection<Marker> visited) { final org.apache.logging.log4j.Marker marker = MarkerManager.getMarker(original.getName()); if (original.hasReferences()) { final Iterator<Marker> it = original.iterator(); while (it.hasNext()) { final Marker next = it.next(); if (visited.contains(next)) { LOGGER.warn("Found a cycle in Marker [{}]. Cycle will be broken.", next.getName()); } else { visited.add(next); marker.addParents(convertMarker(next, visited)); } } } return marker; }
public void add(Marker reference) { if (reference == null) { throw new IllegalArgumentException("A null value cannot be added to a Marker as reference."); } // no point in adding the reference multiple times if (this.contains(reference)) { return; } else if (reference.contains(this)) { // avoid recursion // a potential reference should not hold its future "parent" as a reference return; } else { referenceList.add(reference); } }
public class MarkerDemoActivity extends android.support.v4.app.FragmentActivity implements OnMarkerClickListener { private Marker myMarker; private void setUpMap() { ....... googleMap.setOnMarkerClickListener(this); myMarker = googleMap.addMarker(new MarkerOptions() .position(latLng) .title("My Spot") .snippet("This is my spot!") .icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_AZURE))); ...... } @Override public boolean onMarkerClick(final Marker marker) { if (marker.equals(myMarker)) { //handle click here } } }
// Since we are consuming the event this is necessary to // manage closing opened markers before opening new ones Marker lastOpened = null; mMap.setOnMarkerClickListener(new OnMarkerClickListener() { public boolean onMarkerClick(Marker marker) { // Check if there is an open info window if (lastOpened != null) { // Close the info window lastOpened.hideInfoWindow(); // Is the marker the same marker that was already open if (lastOpened.equals(marker)) { // Nullify the lastOpened object lastOpened = null; // Return so that the info window isn't opened again return true; } } // Open the info window for the marker marker.showInfoWindow(); // Re-assign the last opened such that we can close it later lastOpened = marker; // Event was handled by our code do not launch default behaviour. return true; } });
public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (!(obj instanceof Marker)) return false; final Marker other = (Marker) obj; return name.equals(other.getName()); }
public String toString() { if (!this.hasReferences()) { return this.getName(); } Iterator<Marker> it = this.iterator(); Marker reference; StringBuilder sb = new StringBuilder(this.getName()); sb.append(' ').append(OPEN); while (it.hasNext()) { reference = it.next(); sb.append(reference.getName()); if (it.hasNext()) { sb.append(SEP); } } sb.append(CLOSE); return sb.toString(); } }
public boolean contains(Marker other) { if (other == null) { throw new IllegalArgumentException("Other cannot be null"); } if (this.equals(other)) { return true; } if (hasReferences()) { for (Marker ref : referenceList) { if (ref.contains(other)) { return true; } } } return false; }
static public boolean match(Marker marker, Marker[] markerArray) { if (markerArray == null) { throw new IllegalArgumentException("markerArray should not be null"); } // System.out.println("event marker="+marker); final int size = markerArray.length; for (int i = 0; i < size; i++) { // System.out.println("other:"+markerArray[i]); if (marker.contains(markerArray[i])) { return true; } } return false; }
@Override public void setCurrentRunNumber(int run) { if (m_runMarker != null) { m_threadMarker.remove(m_runMarker); MarkerFactory.getIMarkerFactory().detachMarker( m_runMarker.getName()); } if (run != -1) { m_runMarker = MarkerFactory.getMarker("run-" + run); m_threadMarker.add(m_runMarker); } m_runNumber = run; }
/** * This method is mainly used with Expression Evaluators. */ public boolean contains(String name) { if (name == null) { throw new IllegalArgumentException("Other cannot be null"); } if (this.name.equals(name)) { return true; } if (hasReferences()) { for (Marker ref : referenceList) { if (ref.contains(name)) { return true; } } } return false; }
@Test public void testAddSameMarker() { final String childMarkerName = CHILD_MAKER_NAME + "-ASM"; final String parentMakerName = PARENT_MARKER_NAME + "-ASM"; final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName); final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName); slf4jMarker.add(slf4jParent); slf4jMarker.add(slf4jParent); final Marker log4jParent = MarkerManager.getMarker(parentMakerName); final Marker log4jMarker = MarkerManager.getMarker(childMarkerName); assertTrue(String.format("%s (log4jMarker=%s) is not an instance of %s (log4jParent=%s) in Log4j", childMarkerName, parentMakerName, log4jMarker, log4jParent), log4jMarker.isInstanceOf(log4jParent)); assertTrue(String.format("%s (slf4jMarker=%s) is not an instance of %s (log4jParent=%s) in SLF4J", childMarkerName, parentMakerName, slf4jMarker, slf4jParent), slf4jMarker.contains(slf4jParent)); }
public FilterReply decide(ILoggingEvent event) { if (!isStarted()) { return FilterReply.NEUTRAL; } // make sure the event has a marker Marker eventMarker = event.getMarker(); if (eventMarker == null) { return FilterReply.DENY; } if (eventMarker.hasReferences()) { // check for events with multiple markers for (Marker marker : markersToMatch) { if (eventMarker.contains(marker)) { return acceptAll ? FilterReply.ACCEPT : FilterReply.NEUTRAL; } } } else { // handle simple case of an event with a single marker if (markersToMatch.contains(eventMarker)) { return acceptAll ? FilterReply.ACCEPT : FilterReply.NEUTRAL; } } // no match found for security markers return FilterReply.DENY; }
@Test public void testAddNullMarker() { final String childMarkerName = CHILD_MAKER_NAME + "-ANM"; final String parentMakerName = PARENT_MARKER_NAME + "-ANM"; final org.slf4j.Marker slf4jMarker = org.slf4j.MarkerFactory.getMarker(childMarkerName); final org.slf4j.Marker slf4jParent = org.slf4j.MarkerFactory.getMarker(parentMakerName); slf4jMarker.add(slf4jParent); final Marker log4jParent = MarkerManager.getMarker(parentMakerName); final Marker log4jMarker = MarkerManager.getMarker(childMarkerName); final Log4jMarker log4jSlf4jParent = new Log4jMarker(log4jParent); final Log4jMarker log4jSlf4jMarker = new Log4jMarker(log4jMarker); final org.slf4j.Marker nullMarker = null; try { log4jSlf4jParent.add(nullMarker); fail("Expected " + IllegalArgumentException.class.getName()); } catch (final IllegalArgumentException e) { // expected } try { log4jSlf4jMarker.add(nullMarker); fail("Expected " + IllegalArgumentException.class.getName()); } catch (final IllegalArgumentException e) { // expected } }
@Override public Iterator<Marker> iterator() { return marker.iterator(); }
private void writeLogstashMarkerIfNecessary(JsonGenerator generator, Marker marker) throws IOException { if (marker != null) { if (isLogstashMarker(marker)) { ((LogstashMarker) marker).writeTo(generator); } if (marker.hasReferences()) { for (Iterator<?> i = marker.iterator(); i.hasNext();) { Marker next = (Marker) i.next(); writeLogstashMarkerIfNecessary(generator, next); } } } }
@Override public boolean hasReferences() { return marker.hasReferences(); }