func (listener *httpListener) Close() (err error) {
	listener.ctxCanceler()

	for i := range listener.listeners {
		listener.listeners[i].Close()
	}

	return nil
}

// Addr - net.Listener interface compatible method returns net.Addr.  In case of multiple TCP listeners, it returns '0.0.0.0' as IP address.
func (listener *httpListener) Addr() (addr net.Addr) {
	addr = listener.listeners[0].Addr()

		if l.Listener != nil {
			listenerTyped := &listener.Listener{}
			// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
			l.Listener.TypeUrl = v3.ListenerType
			err = l.Listener.UnmarshalTo(listenerTyped)
			if err != nil {
				return nil, fmt.Errorf("unmarshal listener: %v", err)
			}
			listeners = append(listeners, listenerTyped)
		}
	}
	if len(listeners) == 0 {

  }

  /** @since 13.0 */
  @Override
  public final void addListener(Listener listener, Executor executor) {
    listeners.addListener(listener, executor);
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + " [" + state() + "]";
  }

  /**
   * Attempts to execute all the listeners in {@link #listeners} while not holding the {@link
   * #monitor}.
   */

		return "", ""
	}
	return fmt.Sprintf("%s.%s", parts[2], parts[1]), parts[3]
}

// Print prints the AuthorizationPolicy in the listener.
func Print(writer io.Writer, listeners []*listener.Listener) {
	parsedListeners := parse(listeners)
	if parsedListeners == nil {
		return
	}

	actionToPolicy := map[rbacpb.RBAC_Action]map[string]struct{}{}
	policyToRule := map[string]map[string]struct{}{}

	}
	diff := difflib.UnifiedDiff{
		FromFile: "Istiod Listeners",
		A:        difflib.SplitLines(istiodBytes.String()),
		ToFile:   "Envoy Listeners",
		B:        difflib.SplitLines(envoyBytes.String()),
		Context:  c.context,
	}
	text, err := difflib.GetUnifiedDiffString(diff)
	if err != nil {
		return err
	}
	if text != "" {
		fmt.Fprintln(c.w, "Listeners Don't Match")
		fmt.Fprintln(c.w, text)
	} else {

        return updateScope;
    }

    private void fireEvent(int event, List<ResolutionListener> listeners, ResolutionNode node) {
        fireEvent(event, listeners, node, null);
    }

    private void fireEvent(int event, List<ResolutionListener> listeners, ResolutionNode node, Artifact replacement) {
        fireEvent(event, listeners, node, replacement, null);
    }

    private void fireEvent(
            int event,

        for (ProjectExecutionListener listener : listeners) {
            listener.afterProjectExecutionFailure(event);
        }
    }

    public void addProjectExecutionListener(ProjectExecutionListener listener) {
        this.listeners.add(listener);
    }

    public void removeProjectExecutionListener(ProjectExecutionListener listener) {
        this.listeners.remove(listener);
    }

    private final Collection<MojoExecutionListener> listeners;

    CompoundMojoExecutionListener(Collection<MojoExecutionListener> listeners) {
        this.listeners = listeners; // NB this is live injected collection
    }

    public void beforeMojoExecution(MojoExecutionEvent event) throws MojoExecutionException {
        for (MojoExecutionListener listener : listeners) {
            listener.beforeMojoExecution(event);
        }
    }

   * MoreExecutors#directExecutor}. Otherwise, avoid it: See the warnings on the docs for {@code
   * directExecutor}.
   *
   * <p>This is the most general listener interface. For common operations performed using
   * listeners, see {@link Futures}. For a simplified but general listener interface, see {@link
   * Futures#addCallback addCallback()}.
   *

        for (MojoExecutionListener listener : listeners) {
            listener.afterMojoExecutionSuccess(event);
        }
    }

    public void afterExecutionFailure(MojoExecutionEvent event) {
        for (MojoExecutionListener listener : listeners) {
            listener.afterExecutionFailure(event);
        }
    }

    public void addMojoExecutionListener(MojoExecutionListener listener) {
        this.listeners.add(listener);