/**
 * Described model element.
 *
 * @since 1.0-milestone-5
 */
public interface Element extends Model {

    /**
     * Returns the name of the element. Note that the name is not a unique identifier.
     *
     * @return The name of the element.
     * @since 1.0-milestone-5
     */
    String getName();

    /**
     * Returns the description of the element, or {@code null} if it has no description.

 * limitations under the License.
 */

package org.gradle.nativeplatform.fixtures.app;

import org.gradle.integtests.fixtures.SourceFile;

public class Element {
    protected SourceFile sourceFile(String path, String name, String content) {
        return new SourceFile(path, name, content);
    }

	list *List

	// The value stored with this element.
	Value any
}

// Next returns the next list element or nil.
func (e *Element) Next() *Element {
	if p := e.next; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

// Prev returns the previous list element or nil.
func (e *Element) Prev() *Element {
	if p := e.prev; e.list != nil && p != &e.list.root {
		return p
	}

                prefixes.put(element, getParent(prefixElement));
                return true;
            }
            return false;
        }

        private void renameTo(T element, String newName) {
            elementsByName.remove(getCurrentlyAssignedName(element), element);
            elementsByName.put(newName, element);
            newNames.put(element, newName);
        }

        this.parent = parent
    }

    protected Element createNode(Object name) {
        Element element = document.createElement(name as String)
        if (getCurrent() == null) {
            elements << element
            parent?.appendChild(element)
        }
        return element
    }

    protected Element createNode(Object name, Map attributes) {
        Element element = createNode(name)
        attributes.each {key, value ->

// and returns r and 0.
func (r *Element) SqrtRatio(u, v *Element) (R *Element, wasSquare int) {
	t0 := new(Element)

	// r = (u * v3) * (u * v7)^((p-5)/8)
	v2 := new(Element).Square(v)
	uv3 := new(Element).Multiply(u, t0.Multiply(v2, v))
	uv7 := new(Element).Multiply(uv3, t0.Square(v2))
	rr := new(Element).Multiply(uv3, t0.Pow22523(uv7))

	check := new(Element).Multiply(v, t0.Square(rr)) // check = v * r^2

    }

    def "handles calculated name matches existing element name"() {
        given:
        element("root") {
            element("root-foo-bar") {}
            element("foo-bar") {}
            element("foo") {
                element("bar") {}
            }
            element("baz") {
                element("bar") {}
            }
        }

        when:
        deduplicateNames()

        spec.isSatisfiedBy(element("a/c/d.java"))
        spec.isSatisfiedBy(element("c/a/b/d.java"))
        spec.isSatisfiedBy(element("a/c/d/d.groovy"))

        !spec.isSatisfiedBy(element("a/b/c.groovy"))
        !spec.isSatisfiedBy(element("1/c/d/e.java"))

        // Default excludes
        !spec.isSatisfiedBy(element("/.git/refs"))
    }

    FileTreeElement element(String path) {

class STSElement(object):
    """STS aware XML parsing class. Wraps a root element name and
    cElementTree.Element instance. Provides STS namespace aware parsing
    functions.

    """

    def __init__(self, root_name, element):
        self.root_name = root_name
        self.element = element

    @classmethod
    def fromstring(cls, root_name, data):

            }
            assertThat(domainObject, sameInstance(element))
        }

        container.apply {
            // regular syntax
            val domainObject by getting
            assertThat(domainObject, sameInstance(element))
        }
    }

    @Test
    fun `can configure named element by getting`() {

        val element = DomainObject()