if (!pidWritten) {
                            System.out.println("Worker daemon pid is " + ProcessHandle.current().pid());
                            FileObject file = processingEnv.getFiler().createResource(StandardLocation.SOURCE_OUTPUT, "resources", "pid.txt");
                            Writer writer = file.openWriter();
                            writer.write(String.valueOf(ProcessHandle.current().pid()));

                        if (!pidWritten) {
                            System.out.println("Worker daemon pid is " + ProcessHandle.current().pid());
                            FileObject file = processingEnv.getFiler().createResource(StandardLocation.SOURCE_OUTPUT, "resources", "pid.txt");
                            Writer writer = file.openWriter();
                            writer.write(String.valueOf(ProcessHandle.current().pid()));

* If they use link:{javaApi}/javax/annotation/processing/Filer.html#createResource(javax.tools.JavaFileManager.Location,java.lang.CharSequence,java.lang.CharSequence,javax.lang.model.element.Element++...++)[Filer#createResource],

			responsewriters.ErrorNegotiated(err, Codecs, schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}, w, req)
			return nil
		}
		return handlers.CreateResource(storage, requestScope, r.admission)
	case "update":
		return handlers.UpdateResource(storage, requestScope, r.admission)
	case "patch":
		return handlers.PatchResource(storage, requestScope, r.admission, supportedTypes)

	}
}

func restfulCreateResource(r rest.Creater, scope handlers.RequestScope, admit admission.Interface) restful.RouteFunction {
	return func(req *restful.Request, res *restful.Response) {
		handlers.CreateResource(r, &scope, admit)(res.ResponseWriter, req.Request)
	}
}

func restfulDeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope handlers.RequestScope, admit admission.Interface) restful.RouteFunction {

  }

  private static class UrlByteSourceFactory extends FileByteSourceFactory {

    @SuppressWarnings("CheckReturnValue") // only using super.createSource to create a file
    @Override
    public ByteSource createSource(byte[] bytes) throws IOException {
      super.createSource(bytes);
      return Resources.asByteSource(getFile().toURI().toURL());
    }
  }

                                   TFConcreteFunction* create_resource,
                                   TFConcreteFunction* initialize,
                                   TFConcreteFunction* destroy_resource,
                                   ImmediateTensorHandlePtr resource_handle)
    : TensorHandleConvertible(std::move(resource_handle)),
      device_(device),
      create_resource_(create_resource),
      initialize_(initialize),

        String name = decoder.readString();
        byte[] sha1 = decoder.readBinary();
        DefaultMetadataFileSource source = createSource(sha1, group, module, version, name);
        return source;
    }

    private DefaultMetadataFileSource createSource(byte[] sha1, String group, String module, String version, String name) {

 * limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import org.openjdk.jmh.annotations.Level;

import java.io.IOException;

public interface DataAccessor {
    DataSource createSource(String name, byte[] bytes, Level level) throws IOException;
    DataTarget createTarget(String name, Level level);
    DataTargetFactory createTargetFactory(String root, Level level) throws IOException;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class InMemoryDataAccessor implements DataAccessor {
    @Override
    public DataSource createSource(String name, byte[] bytes, Level level) {
        return new Source(name, bytes);
    }

    @Override
    public DataTarget createTarget(String name, Level level) {
        return new Target(name);
    }