* limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

import javax.annotation.Nullable;

/**
 * A dependency onto a library published by a project.
 */
@Incubating
public interface ProjectDependencySpec extends DependencySpec {

    /**
     * Returns the project path of the project this dependency refers to.
     *

	// The carp will be allowed to use secrets referenced by the ServiceAccount
	ServiceAccountName string

	// NodeName is a request to schedule this carp onto a specific node.  If it is non-empty,
	// the scheduler simply schedules this carp onto that node, assuming that it fits resource
	// requirements.
	// +optional
	NodeName string
	// Specifies the hostname of the Carp.

# Code in this directory is intended to form the glue between the C API and the internal C++
# implementation by
# 1. mapping C API calls onto correponding methods of C++ objects
# 2. mapping opaque C types onto C++ classes

# Note(bmzhao): The *.cc files in this directory form the direct implementation of the
# C API functions exposed in tf/c/experimental/saved_model/public/.

limitations under the License.
*/

package schema

// All objects that are serialized from a Scheme encode their type information. This interface is used
// by serialization to set type information from the Scheme onto the serialized version of an object.
// For objects that cannot be serialized or have unique requirements, this interface may be a no-op.
type ObjectKind interface {

 *
 * It is important that the cleanup only occurs when nobody uses the classloader anymore, which means when no consumer retains a strong reference onto a {@link CachedClassLoader}. If we directly put
 * the cached classloader as a value of the map, then it cannot be reclaimed, and will never be cleaned up. If we just use a SoftReference to the cached class loader, then the reference will be

	// The pod will be allowed to use secrets referenced by the ServiceAccount
	ServiceAccountName string

	// NodeName is a request to schedule this pod onto a specific node.  If it is non-empty,
	// the scheduler simply schedules this pod onto that node, assuming that it fits resource
	// requirements.
	// +optional
	NodeName string
	// Specifies the hostname of the Pod.

                                          RankedTensorType* elem_type,
                                          int64_t* count) {
  auto lengths_const =
      llvm::dyn_cast_or_null<TF::ConstOp>(split.getLengths().getDefiningOp());
  if (!lengths_const) return split.emitOpError("non-constant split lengths");
  *count = lengths_const.getValue().getNumElements();

    // We can only clone the constant op or const->dequantize combo. The latter
    // case is useful for float16 quantization. Since all ops have been
    // legalized to tflite ops, so we only care about ConstOp or QConstOp or
    // mlir constant op.
    Operation* input_op = operand.getDefiningOp();
    if (input_op == nullptr) return failure();

    Attribute attr;
    if (matchPattern(input_op, m_Constant(&attr))) {

// Checks if the data format is "NDHWC".
def IsDataFormatNDHWC : ConstantAttr<TF_ConvnetDataFormatAttr, "\"NDHWC\"">;

// Checks if the op is constant op.
def IsConstTensor :  Constraint<CPred<"dyn_cast_or_null<TF::ConstOp>($0.getDefiningOp())">>;

// Checks if the element value has a float type.
def IsFloatElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<ElementsAttr>() && "

}

TEST_F(LegalizationOpConfigTest, ChecksDynamicPadderOps) {
  EXPECT_TRUE(
      IsDynamicPadderOp(TypeID::get<TF::XlaSetDynamicDimensionSizeOp>()));
  EXPECT_FALSE(IsDynamicPadderOp(TypeID::get<TF::ConstOp>()));
}

// This test is kind of odd. We go through all the Tensorflow types and check
// whether they are legalized with MLIR, TF2XLA, or both. Ideally the sets are