class MetaImpl<A, B> implements Meta<A, B> {
    
    private final A model;
    private final B result;
    private final Transform<A, B> transform;
    private final TransformFactory factory;
    private final RenderStack stack;
    private final RenderTree tree;

    private MetaImpl(
            A model, 
            B result, 
            Transform<A, B> transform, 
            TransformFactory factory, 
            RenderStack stack, 
            RenderTree tree) {
        
        this.model     = requireNonNull(model);
        this.result    = requireNonNull(result);
        this.transform = requireNonNull(transform);
        this.factory   = requireNonNull(factory);
        this.stack     = requireNonNull(stack);
        this.tree      = requireNonNull(tree);
    }

    @Override
    public B getResult() {
        return result;
    }

    @Override
    public Transform<A, B> getTransform() {
        return transform;
    }

    @Override
    public TransformFactory getFactory() {
        return factory;
    }
    
    @Override
    public A getModel() {
        return model;
    }

    @Override
    public RenderStack getRenderStack() {
        return stack;
    }
    
    @Override
    public RenderTree getRenderTree() {
        return tree;
    }

    @Override
    public String toString() {<FILL_FUNCTION_BODY>}
   
    public static final class MetaBuilder<A, B> implements Meta.Builder<A, B> {
        
        private A model;
        private B result;
        private Transform<A, B> transform;
        private TransformFactory factory;
        private RenderStack stack;
        private RenderTree tree;
        
        public MetaBuilder(A model, B result) {
            this.model  = requireNonNull(model);
            this.result = requireNonNull(result);
        }
        
        @Override
        public Meta.Builder<A, B> withResult(B result) {
            this.result = requireNonNull(result);
            return this;
        }
        
        @Override
        public Meta.Builder<A, B> withTransform(Transform<A, B> transform) {
            this.transform = requireNonNull(transform);
            return this;
        }
        
        @Override
        public Meta.Builder<A, B> withFactory(TransformFactory factory) {
            this.factory = requireNonNull(factory);
            return this;
        }
        
        @Override
        public Meta.Builder<A, B> withModel(A model) {
            this.model = requireNonNull(model);
            return this;
        }
        
        @Override
        public Meta.Builder<A, B> withRenderStack(RenderStack stack) {
            this.stack = requireNonNull(stack);
            return this;
        }
        
        @Override
        public Meta.Builder<A, B> withRenderTree(RenderTree tree) {
            this.tree = requireNonNull(tree);
            return this;
        }
        
        @Override
        public Meta<A, B> build() {
            return new MetaImpl<>(
                model,
                result,
                transform,
                factory,
                stack,
                tree
            );
        }
    }
}

        return "MetaImpl{" + "model=" + model + ", result=" + result + ", transform=" + transform + ", factory=" + factory + ", stack=" + stack + ", tree=" + tree + '}';
    
<no_super_class>