Renders markers as: *marker1,marker2..

@param markers markers to render (may be null)
@return rendered markers or empty string if no markers provided
975890
public static String markers(final List<String> markers) {
        String signs = "";
        if (markers != null && !markers.isEmpty()) {
            signs = "*" + Joiner.on(", ").join(markers);
        }
        return signs;
    }
72266
public static String renderHTML(Collection<Component> components) {
        return renderHTML(components.toArray(new Component[components.size()]));
    }
33977
public function render(array $extendables)
    {
        $result = [];

        foreach ($extendables as $value) {
            if ($value instanceof Coordinate) {
                $result[] = $this->coordinateRenderer->render($value);
            } elseif ($value instanceof Marker) {
                $result[] = $this->markerLocationRenderer->render($value);
            } elseif ($value instanceof Polyline) {
                $result[] = $this->polylineLocationRenderer->render($value);
            } else {
                $result[] = $value;
            }
        }

        return implode('|', $result);
    }
713710
public function render(MarkerCluster $markerCluster, Map $map, $markers)
    {
        $options = $markerCluster->getOptions();

        if (!isset($options['imagePath'])) {
            $options['imagePath'] = 'https://cdn.rawgit.com/googlemaps/js-marker-clusterer/gh-pages/images/m';
        }

        $formatter = $this->getFormatter();
        $jsonBuilder = $this->getJsonBuilder()->setValues($options);

        return $formatter->renderObjectAssignment($markerCluster, $formatter->renderObject('MarkerClusterer', [
            $map->getVariable(),
            $markers,
            $jsonBuilder->build(),
        ], false));
    }
1089218
function (options) {
		var ret,
			series = this.series,
			pointArrayMap = series.pointArrayMap || ['y'],
			valueCount = pointArrayMap.length,
			firstItemType,
			i = 0,
			j = 0;

		if (typeof options === 'number' || options === null) {
			ret = { y: options };

		} else if (isArray(options)) {
			ret = {};
			// with leading x value
			if (options.length > valueCount) {
				firstItemType = typeof options[0];
				if (firstItemType === 'string') {
					ret.name = options[0];
				} else if (firstItemType === 'number') {
					ret.x = options[0];
				}
				i++;
			}
			while (j < valueCount) {
				ret[pointArrayMap[j++]] = options[i++];
			}			
		} else if (typeof options === 'object') {
			ret = options;

			// This is the fastest way to detect if there are individual point dataLabels that need 
			// to be considered in drawDataLabels. These can only occur in object configs.
			if (options.dataLabels) {
				series._hasPointLabels = true;
			}

			// Same approach as above for markers
			if (options.marker) {
				series._hasPointMarkers = true;
			}
		}
		return ret;
	}
220065
public SeriesColorMarkerLineStyle getNextSeriesColorMarkerLineStyle() {

    // 1. Color - cycle through colors one by one
    if (colorCounter >= seriesColorList.length) {
      colorCounter = 0;
      strokeCounter++;
    }
    Color seriesColor = seriesColorList[colorCounter++];

    // 2. Stroke - cycle through strokes one by one but only after a color cycle
    if (strokeCounter >= seriesLineStyleList.length) {
      strokeCounter = 0;
    }
    BasicStroke seriesLineStyle = seriesLineStyleList[strokeCounter];

    // 3. Marker - cycle through markers one by one
    if (markerCounter >= seriesMarkerList.length) {
      markerCounter = 0;
    }
    Marker marker = seriesMarkerList[markerCounter++];

    return new SeriesColorMarkerLineStyle(seriesColor, marker, seriesLineStyle);
  }
419578
private static void initMarkers() {

    if (initialized)
      return;

    Class<?> cExtClass = findExtClass(EXT_CLASS);

    if (cExtClass.isAssignableFrom(String.class)) {
      createDefaultMarkers();
    } else {
      createMultiMarkers(cExtClass);
    }

    if (!initialized)
      LOG.warn("SecureLogging Markers could not be initialized!");
    else
      LOG.debug("SecureLogging Markers created: '{}', ...", markerSecurSuccConfid.getName());
    return;
  }
1327295
public static String render(SimpleHTMLTag tag) {
        List<SimpleHTMLTag> tags = new ArrayList<>();
        tags.add(tag);

        HTMLRenderer renderer = new HTMLRenderer(tags);

        return renderer.render();
    }
1333830
private void expandBoundingBoxMarkers(BoundingBox boundingBox,
                                          List<Marker> markers) {
        for (Marker marker : markers) {
            expandBoundingBox(boundingBox, marker.getPosition());
        }
    }
811927
function render(context, xyPoints, map, canvasFeature) {
    ctx = context;
    
    if( canvasFeature.type === 'Point' ) {
        renderPoint(xyPoints, this.size);
    } else if( canvasFeature.type === 'LineString' ) {
        renderLine(xyPoints);
    } else if( canvasFeature.type === 'Polygon' ) {
        renderPolygon(xyPoints);
    } else if( canvasFeature.type === 'MultiPolygon' ) {
        xyPoints.forEach(renderPolygon);
    }
}
868980
public synchronized Map<String, String> getTags() {
        if (tags == null || tags.isEmpty()) {
            return Collections.emptyMap();
        }

        return Collections.unmodifiableMap(tags);
    }
913344
public static String render(List<Token> tokens, Map<String, Object> arguments) {
    StringBuilder builder = new StringBuilder();
    for (Token token : tokens) {
      builder.append(token.render(arguments));
    }

    return builder.toString();
  }
306896
public void setMarkers(QueryResult queryResult){
        mapWidget.clearMarkers();
        RecordList recordList = queryResult.getRecordList();
        List<RecordList.Record> records = recordList.getRecords();
        List<GenericMarker> markers = new ArrayList<GenericMarker>();
        final MarkerCoordinateSource markerCoordinateSource1 = getMarkerCoordinateSource();
        final MarkerDisplayFilter markerFilter = getMarkerDisplayFilter();
        markerFilter.init();
        for (final RecordList.Record record : records) {
            MapMarkerBuilder markerBuilder = new MapMarkerBuilder();
            final MarkerCoordinateSource.LatitudeLongitude latitudeLongitude = markerCoordinateSource1.process(record);
            double lat = latitudeLongitude.getLatitude();
            double lon = latitudeLongitude.getLongitude();

            if(markerFilter.filter(record)){
                GenericMarker<RecordList.Record> marker = markerBuilder.setMarkerLat(lat).setMarkerLon(lon).setMarkerIconPathBuilder(getMarkerIconPathBuilder()).createMarker(record, mapWidget);
                marker.setupMarkerHoverLabel(getMarkerHoverLabelBuilder());
                marker.setupMarkerClickInfoWindow(getMarkerClickInfoWindow());
                marker.addClickHandler(new GenericMarker.MarkerCallBackEventHandler<GenericMarker>() {
                    @Override
                    public void run(GenericMarker sourceElement) {
                    clientFactory.getEventBus().fireEvent(new MarkerClickEvent(record));
                    }
                });
                markers.add(marker);
            }
        }

        mapWidget.setMarkers(markers);
    }
591218
public function getMarkers($marker = NULL)
	{
		if($marker !== NULL && $this->markers !== NULL)
		{
			$result = [];
			
			foreach($this->markers as $check)
			{
				if($check instanceof $marker)
				{
					$result[] = $check;
				}
			}
			
			return $result;
		}
		
		return (array)$this->markers;
	}
1127843
public static void sortIMarkers(IMarker[] markers) {
        Arrays.sort(markers, new Comparator<IMarker>() {
            @Override
            public int compare(IMarker arg0, IMarker arg1) {
                IResource resource0 = arg0.getResource();
                IResource resource1 = arg1.getResource();
                if (resource0 != null && resource1 != null) {
                    return resource0.getName().compareTo(resource1.getName());
                }
                if (resource0 != null && resource1 == null) {
                    return 1;
                }
                if (resource0 == null && resource1 != null) {
                    return -1;
                }
                return 0;
            }
        });
    }
1019787
public int removeMarker() {
        System.out.println("Remove Marker");
        final int idx = getBox().getChildren().indexOf(this.marker);
        getBox().getChildren().remove(this.marker);
        return idx;
    }
664120
def marker_tags(self, iid):
        """"""
        tags = self._markers[iid]["tags"]
        for tag in tags:
            yield tag