Creates a tracer for intf
@param <T>
@param intf Implemented interface
@param ob Class instance for given interface or null
@param appendable Output for trace
@return
518911
public static <T> T getTracer(Class<T> intf, T ob, Appendable appendable)
    {
        return getTracer(intf, new InterfaceTracer(ob), ob, appendable);
    }
364666
def tracer(object):
    

    @functools.wraps(object)
    @functools.partial(validate_tracer, object)
    def tracer_wrapper(*args, **kwargs):
        """
        Traces execution.

        :param \*args: Arguments.
        :type \*args: \*
        :param \*\*kwargs: Keywords arguments.
        :type \*\*kwargs: \*\*
        :return: Object.
        :rtype: object
        """

        code = object.func_code
        args_count = code.co_argcount
        args_names = code.co_varnames[:args_count]
        function_defaults = object.func_defaults or list()
        args_defaults = dict(zip(args_names[-len(function_defaults):], function_defaults))

        positional_args = map(format_argument, zip(args_names, args))
        defaulted_args = [format_argument((name, args_defaults[name]))
                          for name in args_names[len(args):] if name not in kwargs]
        nameless_args = map(repr, args[args_count:])
        keyword_args = map(format_argument, kwargs.items())
        sys.stdout.write("{0}({1})\n".format(get_trace_name(object),
                                             ", ".join(itertools.chain(positional_args,
                                                                       defaulted_args,
                                                                       nameless_args,
                                                                       keyword_args))))
        return object(*args, **kwargs)

    return tracer_wrapper
300711
public final static DataWriter createDataWriter(File file, IOType type) {
        if(type == IOType.MAPPED) {
            if(file.length() <= Integer.MAX_VALUE) {
                return new MappedWriter(file);
            } else {
                return new MultiMappedWriter(file);
            }
        } else {
            return new ChannelWriter(file);
        }
    }
392968
public <A extends Appendable> A appendTo(A appendable, Iterable<?> parts) throws IOException {
    return appendTo(appendable, parts.iterator());
  }
1372236
@SuppressWarnings("unchecked")
    public static <T> T createProxyObject(Class<T> interfaceType, Object implementObject) {
        return (T) Proxy.newProxyInstance(
                implementObject.getClass().getClassLoader(),
                implementObject.getClass().getInterfaces(),
                new InvokeInterceptor(implementObject)
        );

    }
163948
public void appendXMLToTable(final XMLUtil util, final Appendable appendable) throws IOException {
        this.appendRowOpenTag(util, appendable);
        int nullFieldCounter = 0;

        final int size = this.cells.usedSize();
        for (int c = 0; c < size; c++) {
            final TableCell cell = this.cells.get(c);
            if (this.hasNoValue(cell)) {
                nullFieldCounter++;
                continue;
            }
            this.appendRepeatedCell(util, appendable, nullFieldCounter);
            nullFieldCounter = 0;
            cell.appendXMLToTableRow(util, appendable);
        }

        appendable.append("</table:table-row>");
    }
632287
public static final SeekableByteChannel traceableChannel(SeekableByteChannel channel, Consumer<ByteBuffer> tracer)
    {
        return new TraceableSeekableByteChannel(channel, tracer);
    }
152246
private void createInterceptors(InterceptorMetaData imd) {
        ivInterceptors = new Object[imd.ivInterceptorClasses.length];

        try {
            imd.createInterceptorInstances(getInjectionEngine(), ivInterceptors, ivEjbManagedObjectContext, this);
        } catch (Throwable t) {
            FFDCFilter.processException(t, CLASS_NAME + ".ManagedBeanOBase", "177", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "interceptor creation failure", t);
            throw ExceptionUtil.EJBException("Interceptor creation failure", t);
        }
    }
533014
public void print(float f) throws IOException
    {      
        if(this._listener!= null &&  !checkIfCalledFromWLonError()){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "non blocking print float , WriteListener enabled: " + this._listener);
            this.print_NonBlocking(Float.toString(f));
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "print float");
            super.print(f);
        }

    }
162529
public <A extends Appendable> A appendTo(A appendable, Multimap<?, ?> map) throws IOException {
		return appendTo(appendable, map.asMap().entrySet());
	}
862276
@Override
	protected void append(ILoggingEvent eventObject)
	{
		Trace<ILoggingEvent> trace = traceManager.getTrace();
		if(trace != null)
		{
			trace.addEvent(eventObject);
		}
	}
937121
public static final ByteChannel traceableChannel(ByteChannel channel, Consumer<ByteBuffer> tracer)
    {
        return new TraceableByteChannel(channel, tracer);
    }
777324
public void println(float f) throws IOException
    {       
        if(this._listener!= null &&  !checkIfCalledFromWLonError()){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "non blocking println float , WriteListener enabled: " + this._listener);
            this.println_NonBlocking(Float.toString(f));
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "println float");
            super.println(f);
        }
    }
381226
public static <T> FlowableTransformer<T,T> doOnCompleteFx(Action onCompleted) {
        return obs -> obs.doOnComplete(() -> runOnFx(onCompleted));
    }
376246
public static final void entry(TraceComponent tc, String methodName, Object obj) {
        if (obj != null && obj instanceof Object[]) {
            com.ibm.websphere.ras.Tr.entry(tc, methodName, (Object[]) obj);
        } else {
            com.ibm.websphere.ras.Tr.entry(tc, methodName, obj);
        }
    }
124712
private static void appendImmutableList(
      IndentedLinesBuilder ilb, String typeParamSnippet, Collection<String> itemSnippets) {
    appendListOrSetHelper(ilb, "ImmutableList." + typeParamSnippet + "of", itemSnippets);
  }
850579
public final void writeObject(java.io.DataOutputStream dataOutputStream)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "writeObject",
                        "dataOutputStream=" + dataOutputStream);

        try {
            dataOutputStream.writeByte(SimpleSerialVersion);
            super.writeObject(dataOutputStream);

            dataOutputStream.writeInt(activeSubListCount);
            for (int i = 0; i < subListTokens.length; i++) {
                subListTokens[i].writeObject(dataOutputStream);
            } // for subLists.

        } catch (java.io.IOException exception) {
            // No FFDC Code Needed.
            ObjectManager.ffdc.processException(this,
                                                cclass,
                                                "writeObject",
                                                exception,
                                                "1:1229:1.26");

            if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
                trace.exit(this, cclass
                           , "writeObject"
                           , "via PermanentIOException"
                                );
            throw new PermanentIOException(this,
                                           exception);
        } // catch (java.io.IOException exception).

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "writeObject");
    }