* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.protocol.cpp;

/**
 * Marker interface for {@link org.gradle.tooling.model.cpp.CppSharedLibrary}.
 */
public interface InternalCppSharedLibrary {

        logger().trace(message, arg1, arg2, arg3)
        logger().trace((Marker) null, message)
        logger().trace((Marker) null, message, new Exception())
        logger().trace((Marker) null, message, arg1)
        logger().trace((Marker) null, message, arg1, arg2)
        logger().trace((Marker) null, message, arg1, arg2, arg3)

        then:
        0 * context.outputEventListener._

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.plugin.software.internal;

/**
 * Marker interface for objects that can receive conventions of a certain type and apply them appropriately.
 *
 * @since 8.9
 */
public interface ConventionReceiver {

}

func (pr *pkgReader) newReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
	return &reader{
		Decoder: pr.NewDecoder(k, idx, marker),
		p:       pr,
	}
}

func (pr *pkgReader) tempReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
	return &reader{
		Decoder: pr.TempDecoder(k, idx, marker),
		p:       pr,
	}
}

         */
        AGENT_INSTRUMENTATION_MARKER(".gradle-agent-instrumented.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that it is using legacy instrumentation.
         */
        LEGACY_INSTRUMENTATION_MARKER(".gradle-legacy-instrumented.marker"),
        /**
         * A marker file put next to the instrumented entry to indicate that original file doesn't exist so there was no instrumentation.

 * limitations under the License.
 */

package org.gradle.model.internal.manage.instance;

import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.type.ModelType;

/**
 * A marker interface that is implemented by views of managed elements.
 */
public interface ManagedInstance {
    /**
     * Returns the node that this managed instance is backed by.
     */
    MutableModelNode getBackingNode();

        def markerModules = new ArrayList<Module>()

        pluginIds.keySet().each { id ->
            // The marker files for each plugin.
            def marker = ivyRepo.module(id, id + PLUGIN_MARKER_SUFFIX, omr[2])
            marker.dependsOn(module)
            marker.publish()
            markerModules.add(marker)
        }

        publishTo(executer, artifactFile);

)

type codeAssign int

func (c codeAssign) Marker() pkgbits.SyncMarker { return pkgbits.SyncAssign }
func (c codeAssign) Value() int                 { return int(c) }

const (
	assignBlank codeAssign = iota
	assignDef
	assignExpr
)

// A codeDecl distinguishes among declaration encodings.
type codeDecl int

func (c codeDecl) Marker() pkgbits.SyncMarker { return pkgbits.SyncDecl }

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module('org:main:1.0')
            }
        }
    }

    private void createPomFile(boolean marker) {
        if (!marker) {
            mainModule.withoutGradleMetadataRedirection()
        }
        mainModule.publish()
        // and now we manually patch the Gradle metadata so that its dependencies

			dprintf(depth+1, "URL: %q\n", in.URL)
		case *md.Strong:
			dprintf(depth, "Strong(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		case *md.Emph:
			dprintf(depth, "Emph(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		case *md.Del:
			dprintf(depth, "Del(%q):\n", in.Marker)
			dumpInlines(in.Inner, depth+1)
		default:
			fmt.Printf("%*s%#v\n", depth*4, "", in)
		}
	}
}