This method will dump all registered transform descriptors. It includes className, methodName and description
@param writer
542161
private void transformDescriptorIntrospectors(PrintWriter writer) {
		
    	
    	Map<String, RequestProbeTransformDescriptor> registeredTransformDescriptors =  RequestProbeBCIManagerImpl.getRequestProbeTransformDescriptors();
        List<String> transformDescriptorRefs = new ArrayList<String>() {{add("Transform Descriptor");  add("");}};
        List<String> tdDetails = new ArrayList<String>() {{add("ClassName.MethodName(Description)");  add("");}};
        List<Integer> indentationLength = new ArrayList<Integer>();
        int maxSpaceRequired = 0;
       
        for(Entry<String, RequestProbeTransformDescriptor> transformDescriptor : registeredTransformDescriptors.entrySet()) {
        	
        	transformDescriptorRefs.add(transformDescriptor.getValue().toString());
        	if(transformDescriptor.getValue().getMethodDesc().equals("all"))
        		 tdDetails.add(transformDescriptor.getValue().getClassName() + "." + transformDescriptor.getValue().getMethodName() + "("+ transformDescriptor.getValue().getMethodDesc() + ")" );
        	else
        		 tdDetails.add(transformDescriptor.getValue().getClassName() + "." + transformDescriptor.getValue().getMethodName() +  transformDescriptor.getValue().getMethodDesc() );
        }
        
        for(String transformDescriptorRef : transformDescriptorRefs) {
        	if(transformDescriptorRef.length() > maxSpaceRequired) {
        		maxSpaceRequired = transformDescriptorRef.length();
        	}
        }
        indentationLength.add(maxSpaceRequired+ EXTRA_SPACE_REQUIRED);

        writer.println();
        writer.println("------------------------------------------------------------------------------");
        writer.println("              Registered Transform Descriptors ");
        writer.println("------------------------------------------------------------------------------");
        
        for(int i = 0 ; i < transformDescriptorRefs.size(); i ++) {
        	writer.println(String.format("%-" + indentationLength.get(0) + "s%s",transformDescriptorRefs.get(i) ,tdDetails.get(i)));
        }
        
        if(registeredTransformDescriptors.size() ==  0) {
          	 writer.println("----- No transform descriptors are registered ----- ");
           }

	}
855990
public void setOutputWriter(Writer writer) {
        if (writer instanceof PrintWriter) {
            this.out = (PrintWriter) writer;
        } else if (writer == null) {
            this.out = null;
        } else {
            this.out = new PrintWriter(writer);
        }
    }
622365
@Override
    public void toWriter(boolean wholeDocument, Writer writer, Properties outputProperties)
    {
        try {
            super.toWriter(wholeDocument, writer, outputProperties);
        } catch (TransformerException e) {
            throw wrapExceptionAsRuntimeException(e);
        }
    }
192567
public static <T> void registerWriter(Class<?> cls, JsonWriterI<T> writer) {
		defaultWriter.registerWriter(writer, cls);
	}
1176135
@Override
    public void marshalWriter(Object graph, Writer writer, DataHolder dataHolder) throws XmlMappingException,
            IOException {
        if (graph instanceof Document) {
            OutputFormat outputFormat = OutputFormat.createCompactFormat();
            outputFormat.setSuppressDeclaration(suppressXmlDeclaration);

            XMLWriter xmlWriter = new XMLWriter(writer, outputFormat);
            try {
                xmlWriter.write((Document)graph);
            } finally {
                try {
                    xmlWriter.flush();
                } catch (Exception ex) {
                    logger.debug("Could not flush XMLWriter", ex);
                }
            }
        } else {
            if (!suppressXmlDeclaration) {
                writer.write(XML_DECLARATION);
            }

            HierarchicalStreamWriter streamWriter = new EscapingCompactWriter(writer);
            try {
                getXStream().marshal(graph, streamWriter, dataHolder);
            } catch (Exception ex) {
                throw convertXStreamException(ex, true);
            } finally {
                try {
                    streamWriter.flush();
                } catch (Exception ex) {
                    logger.debug("Could not flush HierarchicalStreamWriter", ex);
                }
            }
        }
    }
1024099
public final void dumpTo(StringBuilder builder) {
      StringWriter stringWriter = new StringWriter();
      globalContainer.dumpTo(new PrintWriter(stringWriter));
      builder.append(stringWriter.getBuffer());
   }
87521
public void write(PrintWriter writer) {
        this.output = writer;
        dispatch(base, false);
        writer.flush();
    }
1280640
public void render(final Writer writer) throws GitChangelogRepositoryException {
    final MustacheFactory mf = new DefaultMustacheFactory();
    final String templateContent = checkNotNull(getTemplateContent(), "No template!");
    final StringReader reader = new StringReader(templateContent);
    final Mustache mustache = mf.compile(reader, this.settings.getTemplatePath());
    try {
      final boolean useIntegrationIfConfigured = shouldUseIntegrationIfConfigured(templateContent);
      final Changelog changelog = this.getChangelog(useIntegrationIfConfigured);
      mustache
          .execute(
              writer, //
              new Object[] {changelog, this.settings.getExtendedVariables()} //
              )
          .flush();
    } catch (final IOException e) {
      // Should be impossible!
      throw new GitChangelogRepositoryException("", e);
    }
  }
851783
protected void render(final PrintWriter writer, final int level) throws IOException {

		beginTag(writer, tag, empty, attrs, level, indent);

		if (!empty) {

			if (text != null) {
				writer.print(text);
			}

			if (newline) {
				writer.println();
			}

			for (Tag child : children) {
				child.render(writer, level + 1);
			}

			endTag(writer, tag, newline, level, indent);
		}
	}
500981
public void write(PrintWriter writer, Janitor janitor) {
        write(writer,janitor,warnings,"warning");
        write(writer,janitor,errors,"error");
    }
651230
public static void toWriter(Node node, Writer writer, Map<String, String> outputProperties) throws TransformerException {
		try {
			Transformer transformer = TransformerFactory.newInstance().newTransformer();
			for (Map.Entry<String, String> property : outputProperties.entrySet()) {
				try {
					transformer.setOutputProperty(property.getKey(), property.getValue());
				} catch (IllegalArgumentException e) {
					//ignore invalid output properties
				}
			}

			DOMSource source = new DOMSource(node);
			StreamResult result = new StreamResult(writer);
			transformer.transform(source, result);
		} catch (TransformerConfigurationException e) {
			//no complex configurations
		} catch (TransformerFactoryConfigurationError e) {
			//no complex configurations
		}
	}
1199513
public void write(Writer writer) throws IOException {					
		GFF3Writer.writeVersionPragma(writer);
		GFF3Writer.writeRegionPragma(writer, entry.getPrimaryAccession(), 
				windowBeginPosition, windowEndPosition);		
		int ID = 0;
		if (show.contains(SHOW_GENE)) {
			locusTagGeneMap = new HashMap<String, GFF3Gene>();
			geneNameGeneMap = new HashMap<String, GFF3Gene>();
		}
		for (Feature feature : entry.getFeatures()) {
			Long minPosition = feature.getLocations().getMinPosition();
			Long maxPosition = feature.getLocations().getMaxPosition();
			// Remove global complement.
			feature.getLocations().removeGlobalComplement();			
		    String geneName = feature.getSingleQualifierValue(Qualifier.GENE_QUALIFIER_NAME);
		    String locusTag = feature.getSingleQualifierValue(Qualifier.LOCUS_TAG_QUALIFIER_NAME);
		    if (show.contains(SHOW_GENE)) {
		    	addGeneSegment(geneName, locusTag, minPosition, maxPosition);		    	
		    }
		    if (show.contains(SHOW_FEATURE)) {
				++ID;		    	
		    	writeFeature(writer, feature, geneName, locusTag, ID, minPosition, maxPosition);
		    	for (Location location : feature.getLocations().getLocations()) {
		    		int parentID = ID;
		    		++ID;
		    		writeFeatureSegment(writer, feature, geneName, locusTag, location, parentID, ID);
		    	}
		    }
		}
		if (show.contains(SHOW_GENE)) {
			for (GFF3Gene gene : locusTagGeneMap.values()) {
				++ID;
				writeGene(writer, gene, ID);			
			}
			for (GFF3Gene gene : geneNameGeneMap.values()) {
				++ID;
				writeGene(writer, gene, ID);			
			}
		}
		if (show.contains(SHOW_CONTIG)) {
			Long contigPosition = 1L;			
			for (Location location : entry.getSequence().getContigs()) {
				++ID;
				contigPosition = writeContig(writer, location, ID, contigPosition);
			}		
		}
		if (show.contains(SHOW_ASSEMBLY)) {
			for (Assembly assembly : entry.getAssemblies()) {
				++ID;
				writeAssembly(writer, assembly, ID);
			}			
		}
	}
996675
public static void serialize(SerializationStreamWriter streamWriter, CmsUUID instance)
    throws SerializationException {

        streamWriter.writeString(instance.toString());
    }
194200
public static void write(final HighScoringPair hsp, final PrintWriter writer) {
        checkNotNull(hsp);
        checkNotNull(writer);
        writer.println(hsp.toString());
    }
1366227
public void write(final ComponentDocumentationWrapper componentWrapper, final OutputStream outputStream)
            throws IOException {

        final Map<String, Object> data = new HashMap<>();

        try {
            data.put("breadcrumbs", _breadcrumbs);
            data.put("component", componentWrapper);

            {
                final Set<ConfiguredPropertyDescriptor> configuredProperties =
                        componentWrapper.getComponentDescriptor().getConfiguredProperties();
                final List<ConfiguredPropertyDescriptor> properties = new ArrayList<>(configuredProperties);
                final List<ConfiguredPropertyDocumentationWrapper> propertyList = new ArrayList<>();
                for (final ConfiguredPropertyDescriptor property : properties) {
                    final HiddenProperty hiddenProperty = property.getAnnotation(HiddenProperty.class);
                    final Deprecated deprecatedProperty = property.getAnnotation(Deprecated.class);

                    // we do not show hidden or deprecated properties in docs
                    if ((hiddenProperty == null || hiddenProperty.hiddenForLocalAccess() == false)
                            && deprecatedProperty == null) {
                        final ConfiguredPropertyDocumentationWrapper wrapper =
                                new ConfiguredPropertyDocumentationWrapper(property);
                        propertyList.add(wrapper);
                    }
                }

                data.put("properties", propertyList);
            }

            /* Write data to a file */
            final Writer out = new OutputStreamWriter(outputStream);
            _template.process(data, out);
            out.flush();
            out.close();
        } catch (final TemplateException e) {
            throw new IllegalStateException("Unexpected templare exception", e);
        }
    }
1030084
public void write(XMLStreamWriter writer, AttributeDefinition<?> def, String name) throws XMLStreamException {
      Attribute<?> attribute = attribute(def);
      attribute.write(writer, name);
   }
1218659
public static <T> Writer<Params<T>> writer(final Writer<? super T> writer) {
		return elem(
			"params",
			attr("name").map(Params::getName),
			elems("param", writer)
		);
	}