net.intelie.pipes.CompilerContext Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of pipes-api Show documentation
Intelie Pipes' API classes and interfaces
There is a newer version: 0.25.5
package net.intelie.pipes;

import net.intelie.pipes.ast.AstNode;
import net.intelie.pipes.types.ClauseInfo;
import net.intelie.pipes.types.Metadata;
import net.intelie.pipes.util.Preconditions;

import java.util.List;

public interface CompilerContext extends PropertySource {
    FunctionContext functionContext();

    ModuleContext moduleContext();

    FilterContext filterContext();

    HelpCollection help();

    CompilationResult compile(AstNode node) throws PipeException;

    CompilerContext forwarded(CompilerContext newThis);

    CompilerContext optimize() throws PipeException;

    CompilerContext insideModule(ModuleContext module) throws PipeException;

    CompilerContext insideFunction(FunctionContext args) throws PipeException;

    CompilerContext insideFilter(FilterContext context) throws PipeException;

    CompilerContext addModule(Module module) throws PipeException;

    CompilerContext newSource(Metadata metadata) throws PipeException;

    CompilerContext newChildSource(Metadata metadata) throws PipeException;

    CompilerContext getParentSource() throws PipeException;

    abstract class Forwarding implements CompilerContext {
        private final CompilerContext delegate;
        private final CompilerContext original;

        public Forwarding(CompilerContext context) {
            this(context, null);
        }

        public Forwarding(CompilerContext context, CompilerContext forwarding) {
            Preconditions.checkArgument(context != null, "Context must be not null");
            this.original = context;
            this.delegate = context.forwarded(forwarding != null ? forwarding : this);
            Preconditions.checkArgument(this.delegate != null, "Delegated context must be not null");
        }

        public abstract Forwarding wrap(CompilerContext context, CompilerContext forward);

        public CompilerContext delegate() {
            return delegate;
        }

        @Override
        public FunctionContext functionContext() {
            return delegate.functionContext();
        }

        @Override
        public ModuleContext moduleContext() {
            return delegate.moduleContext();
        }

        @Override
        public FilterContext filterContext() {
            return delegate.filterContext();
        }

        @Override
        public HelpCollection help() {
            return delegate.help();
        }

        @Override
        public CompilationResult compile(AstNode node) throws PipeException {
            return delegate.compile(node);
        }

        @Override
        public CompilerContext forwarded(CompilerContext newThis) {
            return wrap(original, newThis);
        }

        @Override
        public Forwarding optimize() throws PipeException {
            return wrap(delegate.optimize(), null);
        }

        @Override
        public Forwarding insideModule(ModuleContext module) throws PipeException {
            return wrap(delegate.insideModule(module), null);
        }

        @Override
        public Forwarding insideFunction(FunctionContext args) throws PipeException {
            return wrap(delegate.insideFunction(args), null);
        }

        @Override
        public Forwarding insideFilter(FilterContext context) throws PipeException {
            return wrap(delegate.insideFilter(context), null);
        }

        @Override
        public Forwarding addModule(Module module) throws PipeException {
            return wrap(delegate.addModule(module), null);
        }

        @Override
        public Forwarding newSource(Metadata metadata) throws PipeException {
            return wrap(delegate.newSource(metadata), null);
        }

        @Override
        public Forwarding newChildSource(Metadata metadata) throws PipeException {
            return wrap(delegate.newChildSource(metadata), null);
        }

        @Override
        public Forwarding getParentSource() throws PipeException {
            return wrap(delegate.getParentSource(), null);
        }

        @Override
        public Property timestamp() throws PipeException {
            return delegate.timestamp();
        }

        @Override
        public Property property() throws PipeException {
            return delegate.property();
        }

        @Override
        public Property property(String name) throws PipeException {
            return delegate.property(name);
        }

        @Override
        public PropertyReplacer makeReplacer(ClauseInfo fields) throws PipeException {
            return delegate.makeReplacer(fields);
        }

        @Override
        public Metadata metadata() {
            return delegate.metadata();
        }

        @Override
        public List defaultProperties() {
            return delegate.defaultProperties();
        }
    }
}