TacFilters;

class TacFilterPass
    : public PassWrapper<TacFilterPass, OperationPass<ModuleOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TacFilterPass)

  TacFilterPass() = default;
  TacFilterPass(const TacFilterPass& other) {
    this->tac_filters_ = other.tac_filters_;
  }
  explicit TacFilterPass(TacFilters* tac_filters) {
    tac_filters_ = tac_filters;
  }

 private:

// parts that they want to use other hardware to accelerate.
message TacFilters {
  // A list of filters/rules to specify the parts that user wants to run on
  // other hardware.
  repeated TacFilter tac_filters = 1;
}

// A filter can be used for an op or function.
message TacFilter {
  oneof filter {
    OpFilter op_filter = 1;
    FunctionFilter function_filter = 2;
  }
}

    bool fold_all_constants);

// Create an instance of TacFilterPass.
std::unique_ptr<OperationPass<ModuleOp>> CreateTacFilterPass(
    ::third_party::tensorflow::compiler::mlir::lite::experimental::tac::
        TacFilters* tac_filters);

}  // namespace tac
}  // namespace TFL
}  // namespace mlir

	return &Builder{builder: b}
}

func (b *Builder) BuildTCP() []*listener.Filter {
	if b == nil || b.builder == nil {
		return nil
	}
	if b.tcpBuilt {
		return b.tcpFilters
	}
	b.tcpBuilt = true
	b.tcpFilters = b.builder.BuildTCP()

	return b.tcpFilters
}

func (b *Builder) BuildHTTP(class networking.ListenerClass) []*hcm.HttpFilter {
	if b == nil || b.builder == nil {
		return nil
	}

        "transforms/fold_constants_to_subgraph.cc",
        "transforms/get_alternative_subgraph.cc",
        "transforms/pick_subgraphs.cc",
        "transforms/raise_target_subgraphs.cc",
        "transforms/tac_filter.cc",
        "transforms/target_annotation.cc",
    ],
    hdrs = [
        "tac_module.h",
        "transforms/passes.h",
        "transforms/tac_pass.h",
    ],
    deps = [
        ":common",

	if res := t.telemetryFilters(proxy, class, networking.ListenerProtocolHTTP, svc); res != nil {
		return res.([]*hcm.HttpFilter)
	}
	return nil
}

// TCPFilters computes the TCPFilters for a given proxy/class
func (t *Telemetries) TCPFilters(proxy *Proxy, class networking.ListenerClass, svc *Service) []*listener.Filter {
	if res := t.telemetryFilters(proxy, class, networking.ListenerProtocolTCP, svc); res != nil {

	}

	return filterstack
}

func buildMetricsNetworkFilters(push *model.PushContext, proxy *model.Proxy, class istionetworking.ListenerClass, svc *model.Service) []*listener.Filter {
	return push.Telemetry.TCPFilters(proxy, class, svc)
}

// setAccessLogAndBuildTCPFilter sets the AccessLog configuration in the given
// TcpProxy instance and builds a TCP filter out of it.