) : CachedProjectState(path, projectDir, buildFile)


internal
class ProjectWithNoWork(
    path: Path,
    projectDir: File,
    buildFile: File
) : CachedProjectState(path, projectDir, buildFile)


data class BuildToStore(
    val build: VintageGradleBuild,
    // Does this build have work scheduled?
    val hasWork: Boolean,
    // Does this build have a child build with work scheduled?
    val hasChildren: Boolean
) {

		return
	}
	if dc.IsNil() {
		err = dc.ReadNil()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		z.Data = nil
	} else {
		z.Data, err = dc.ReadBytes(z.Data)
		if err != nil {
			err = msgp.WrapError(err, "Data")
			return
		}
	}
	z.NumVersions, err = dc.ReadInt()
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return
	}

        'generic' : 'Generic'
    ]

    private static final def KNOWN_DEFINITIONS = [
        'problems-api:missing-id' : 'Problem id must be specified',
        'problems-api:unsupported-additional-data' : 'Unsupported additional data type',
        'compilation:groovy-dsl:compilation-failed' : 'Groovy DSL script compilation problem',
        'compilation:java:initialization-failed' : 'Java compilation initialization error',

				f := joinFields[idx][len(joinFields[idx])-1]
				db.AddError(f.Set(db.Statement.Context, relValue, values[idx]))
			}
		}

		// release data to pool
		field.NewValuePool.Put(values[idx])
	}
}

// ScanMode scan data mode
type ScanMode uint8

// scan modes
const (
	ScanInitialized         ScanMode = 1 << 0 // 1
	ScanUpdate              ScanMode = 1 << 1 // 2

	if !rb.cfg.EnableIPv6 {
		return rb
	}
	return rb.insertInternal(&rb.rules.rulesv6, command, chain, table, position, params...)
}

func indexOf(element string, data []string) int {
	for k, v := range data {
		if element == v {
			return k
		}
	}
	return -1 // not found.
}

    private
    fun isolate(actions: IsolatedProjectActions, owner: IsolateOwner) =
        IsolatedActionSerializer(owner, owner.serviceOf(), owner.serviceOf())
            .serialize(actions)
}


private
data class IsolatedProjectActions(
    val beforeProject: IsolatedProjectActionList,
    val afterProject: IsolatedProjectActionList
)


private
class IsolatedProjectEvaluationListener(

		{
			configMap: api.ConfigMap{
				ObjectMeta: metav1.ObjectMeta{
					Name:              "configmap3",
					CreationTimestamp: metav1.Time{Time: time.Now().Add(1.9e9)},
				},
				Data: map[string]string{
					"foo": "bar",
				},
				BinaryData: map[string][]byte{
					"bin": []byte("binary data"),
				},
			},
			// Columns: Name, (Num) Data, Age

        return TypeArgumentMapping(typeParameterOwner, mapping)
    }

    private data class TypeArgumentMapping(
        val owner: ClassifierDescriptorWithTypeParameters,
        val mapping: Map<TypeParameterDescriptor, BoundTypeArgument>
    )

    private data class BoundTypeArgument(val type: KotlinType, val variance: Variance)

def ExecutorConvertControlToDataOutputsPass : Pass<"tf-executor-convert-control-to-data-outputs", "ModuleOp"> {
  let summary = "Chain control outputs of while loop body";

  let description = [{
    This pass converts the control outputs of a while loop body function to data
    outputs. Thus, inter iteration control dependencies are transformed to
    data dependencies. Since data dependencies can express which particular

			return
		}
		return
	}

	defer func() {
		var data []byte
		if buf != nil {
			data = buf.Bytes()
		}

		if len(data) == 0 {
			return
		}

		globalCacheConfig.Set(&cache.ObjectInfo{
			Key:          objInfo.Name,
			Bucket:       objInfo.Bucket,
			ETag:         objInfo.ETag,
			ModTime:      objInfo.ModTime,
			Expires:      objInfo.ExpiresStr(),