/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.engine.internal;

import java.util.*;
import java.util.Collections;

import org.hibernate.AssertionFailure;
import org.hibernate.MappingException;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.hql.internal.ast.tree.ImpliedFromElement;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.persister.collection.QueryableCollection;
import org.hibernate.persister.entity.AbstractEntityPersister;
import org.hibernate.persister.entity.Joinable;
import org.hibernate.sql.JoinFragment;
import org.hibernate.sql.JoinType;
import org.hibernate.sql.QueryJoinFragment;
import org.hibernate.type.AssociationType;

A sequence of Join delegates to make it "easier" to work with joins. The "easier" part is obviously subjective ;) 
 Additionally JoinSequence is a directed graph of other JoinSequence instances, as represented by the next (setNext(JoinSequence)) pointer. 
Author:
Gavin King, Steve Ebersole
See Also:
JoinFragment/**
 * A sequence of {@link Join} delegates to make it "easier" to work with joins.  The "easier" part is obviously
 * subjective ;)
 * <p/>
 * Additionally JoinSequence is a directed graph of other JoinSequence instances, as represented by the
 * {@link #next} ({@link #setNext(JoinSequence)}) pointer.
 *
 * @author Gavin King
 * @author Steve Ebersole
 *
 * @see JoinFragment
 */
public class JoinSequence {
	private final SessionFactoryImplementor factory;
	private final boolean collectionJoinSubquery;

	private final StringBuilder conditions = new StringBuilder();
	private final List<Join> joins = new ArrayList<Join>();

	private boolean useThetaStyle;
	private String rootAlias;
	private Joinable rootJoinable;
	private Selector selector;
	private JoinSequence next;
	private boolean isFromPart;

	
Constructs a JoinSequence
Params:
factory – The SessionFactory/**
	 * Constructs a JoinSequence
	 *
	 * @param factory The SessionFactory
	 */
	public JoinSequence(SessionFactoryImplementor factory) {
		this.factory = factory;
		this.collectionJoinSubquery = factory.getSessionFactoryOptions().isCollectionJoinSubqueryRewriteEnabled();
	}

	
Retrieve a JoinSequence that represents just the FROM clause parts
Returns:
The JoinSequence that represents just the FROM clause parts/**
	 * Retrieve a JoinSequence that represents just the FROM clause parts
	 *
	 * @return The JoinSequence that represents just the FROM clause parts
	 */
	public JoinSequence getFromPart() {
		final JoinSequence fromPart = new JoinSequence( factory );
		fromPart.joins.addAll( this.joins );
		fromPart.useThetaStyle = this.useThetaStyle;
		fromPart.rootAlias = this.rootAlias;
		fromPart.rootJoinable = this.rootJoinable;
		fromPart.selector = this.selector;
		fromPart.next = this.next == null ? null : this.next.getFromPart();
		fromPart.isFromPart = true;
		return fromPart;
	}

	private Set<String> treatAsDeclarations;

	public void applyTreatAsDeclarations(Set<String> treatAsDeclarations) {
		if ( treatAsDeclarations == null || treatAsDeclarations.isEmpty() ) {
			return;
		}

		if ( this.treatAsDeclarations == null ) {
			this.treatAsDeclarations = new HashSet<String>();
		}

		this.treatAsDeclarations.addAll( treatAsDeclarations );
	}

	protected Set<String> getTreatAsDeclarations() {
		return treatAsDeclarations;
	}


	
Create a full, although shallow, copy.
Returns:
The copy/**
	 * Create a full, although shallow, copy.
	 *
	 * @return The copy
	 */
	public JoinSequence copy() {
		final JoinSequence copy = new JoinSequence( factory );
		copy.joins.addAll( this.joins );
		copy.useThetaStyle = this.useThetaStyle;
		copy.rootAlias = this.rootAlias;
		copy.rootJoinable = this.rootJoinable;
		copy.selector = this.selector;
		copy.next = this.next == null ? null : this.next.copy();
		copy.isFromPart = this.isFromPart;
		copy.conditions.append( this.conditions.toString() );
		return copy;
	}

	
Add a join to this sequence
Params:
associationType – The type of the association representing the join
alias – The RHS alias for the join
joinType – The type of join (INNER, etc)
referencingKey – The LHS columns for the join condition
Throws:
MappingException – Generally indicates a problem resolving the associationType to a Joinable
Returns:
The Join memento/**
	 * Add a join to this sequence
	 *
	 * @param associationType The type of the association representing the join
	 * @param alias The RHS alias for the join
	 * @param joinType The type of join (INNER, etc)
	 * @param referencingKey The LHS columns for the join condition
	 *
	 * @return The Join memento
	 *
	 * @throws MappingException Generally indicates a problem resolving the associationType to a {@link Joinable}
	 */
	public JoinSequence addJoin(
			AssociationType associationType,
			String alias,
			JoinType joinType,
			String[] referencingKey) throws MappingException {
		joins.add( new Join( factory, associationType, alias, joinType, new String[][] { referencingKey } ) );
		return this;
	}

	
Add a join to this sequence
Params:
associationType – The type of the association representing the join
alias – The RHS alias for the join
joinType – The type of join (INNER, etc)
referencingKeys – The LHS columns for the join condition
Throws:
MappingException – Generally indicates a problem resolving the associationType to a Joinable
Returns:
The Join memento/**
	 * Add a join to this sequence
	 *
	 * @param associationType The type of the association representing the join
	 * @param alias The RHS alias for the join
	 * @param joinType The type of join (INNER, etc)
	 * @param referencingKeys The LHS columns for the join condition
	 *
	 * @return The Join memento
	 *
	 * @throws MappingException Generally indicates a problem resolving the associationType to a {@link Joinable}
	 */
	public JoinSequence addJoin(
			AssociationType associationType,
			String alias,
			JoinType joinType,
			String[][] referencingKeys) throws MappingException {
		joins.add( new Join( factory, associationType, alias, joinType, referencingKeys ) );
		return this;
	}

	
Embedds an implied from element into this sequence
Params:
fromElement – The implied from element to embedd
Returns:
The Join memento/**
	 * Embedds an implied from element into this sequence
	 *
	 * @param fromElement The implied from element to embedd
	 * @return The Join memento
	 */
	public JoinSequence addJoin(ImpliedFromElement fromElement) {
		joins.addAll( fromElement.getJoinSequence().joins );
		return this;
	}

	
Generate a JoinFragment
Throws:
MappingException – Indicates a problem access the provided metadata, or incorrect metadata
Returns:
The JoinFragment/**
	 * Generate a JoinFragment
	 *
	 * @return The JoinFragment
	 *
	 * @throws MappingException Indicates a problem access the provided metadata, or incorrect metadata
	 */
	public JoinFragment toJoinFragment() throws MappingException {
		return toJoinFragment( Collections.EMPTY_MAP, true );
	}

	
Generate a JoinFragment
Params:
enabledFilters – The filters associated with the originating session to properly define join conditions
includeAllSubclassJoins – Should all subclass joins be added to the rendered JoinFragment?
Throws:
MappingException – Indicates a problem access the provided metadata, or incorrect metadata
Returns:
The JoinFragment/**
	 * Generate a JoinFragment
	 *
	 * @param enabledFilters The filters associated with the originating session to properly define join conditions
	 * @param includeAllSubclassJoins Should all subclass joins be added to the rendered JoinFragment?
	 *
	 * @return The JoinFragment
	 *
	 * @throws MappingException Indicates a problem access the provided metadata, or incorrect metadata
	 */
	public JoinFragment toJoinFragment(Map enabledFilters, boolean includeAllSubclassJoins) throws MappingException {
		return toJoinFragment( enabledFilters, includeAllSubclassJoins, null );
	}

	
Generate a JoinFragment
Params:
enabledFilters – The filters associated with the originating session to properly define join conditions
includeAllSubclassJoins – Should all subclass joins be added to the rendered JoinFragment?
withClauseFragment – The with clause (which represents additional join restrictions) fragment
Throws:
MappingException – Indicates a problem access the provided metadata, or incorrect metadata
Returns:
The JoinFragment/**
	 * Generate a JoinFragment
	 *
	 * @param enabledFilters The filters associated with the originating session to properly define join conditions
	 * @param includeAllSubclassJoins Should all subclass joins be added to the rendered JoinFragment?
	 * @param withClauseFragment The with clause (which represents additional join restrictions) fragment
	 *
	 * @return The JoinFragment
	 *
	 * @throws MappingException Indicates a problem access the provided metadata, or incorrect metadata
	 */
	public JoinFragment toJoinFragment(
			Map enabledFilters,
			boolean includeAllSubclassJoins,
			String withClauseFragment) throws MappingException {
		return toJoinFragment( enabledFilters, includeAllSubclassJoins, true, withClauseFragment );
	}

	public JoinFragment toJoinFragment(
			Map enabledFilters,
			boolean includeAllSubclassJoins,
			boolean renderSubclassJoins,
			String withClauseFragment) throws MappingException {
		final QueryJoinFragment joinFragment = new QueryJoinFragment( factory.getDialect(), useThetaStyle );
		Iterator<Join> iter;
		Join first;
		Joinable last;
		if ( rootJoinable != null ) {
			joinFragment.addCrossJoin( rootJoinable.getTableName(), rootAlias );
			final String filterCondition = rootJoinable.filterFragment( rootAlias, enabledFilters, treatAsDeclarations );
			// JoinProcessor needs to know if the where clause fragment came from a dynamic filter or not so it
			// can put the where clause fragment in the right place in the SQL AST.   'hasFilterCondition' keeps track
			// of that fact.
			joinFragment.setHasFilterCondition( joinFragment.addCondition( filterCondition ) );
			addSubclassJoins( joinFragment, rootAlias, rootJoinable, true, includeAllSubclassJoins, treatAsDeclarations );

			last = rootJoinable;
		}
		else if ( needsTableGroupJoin( joins, withClauseFragment ) ) {
			iter = joins.iterator();
			first = iter.next();
			final String joinString;
			switch (first.joinType) {
				case INNER_JOIN:
					joinString = " inner join ";
					break;
				case LEFT_OUTER_JOIN:
					joinString = " left outer join ";
					break;
				case RIGHT_OUTER_JOIN:
					joinString = " right outer join ";
					break;
				case FULL_JOIN:
					joinString = " full outer join ";
					break;
				default:
					throw new AssertionFailure("undefined join type");
			}

			joinFragment.addFromFragmentString( joinString );
			joinFragment.addFromFragmentString( " (" );
			joinFragment.addFromFragmentString( first.joinable.getTableName() );
			joinFragment.addFromFragmentString( " " );
			joinFragment.addFromFragmentString( first.getAlias() );

			for ( Join join : joins ) {
				// Skip joining the first join node as it is contained in the subquery
				if ( join != first ) {
					joinFragment.addJoin(
							join.getJoinable().getTableName(),
							join.getAlias(),
							join.getLHSColumns(),
							JoinHelper.getRHSColumnNames( join.getAssociationType(), factory ),
							join.joinType
					);
				}
				addSubclassJoins(
						joinFragment,
						join.getAlias(),
						join.getJoinable(),
						// TODO: Think about if this could be made always true
						join.joinType == JoinType.INNER_JOIN,
						includeAllSubclassJoins,
						// ugh.. this is needed because of how HQL parser (FromElementFactory/SessionFactoryHelper)
						// builds the JoinSequence for HQL joins
						treatAsDeclarations
				);
			}

			joinFragment.addFromFragmentString( ")" );
			joinFragment.addFromFragmentString( " on " );

			final String rhsAlias = first.getAlias();
			final String[][] lhsColumns = first.getLHSColumns();
			final String[] rhsColumns = JoinHelper.getRHSColumnNames( first.getAssociationType(), factory );
			if ( lhsColumns.length > 1 ) {
				joinFragment.addFromFragmentString( "(" );
			}
			for ( int i = 0; i < lhsColumns.length; i++ ) {
				for ( int j = 0; j < lhsColumns[i].length; j++ ) {
					joinFragment.addFromFragmentString( lhsColumns[i][j] );
					joinFragment.addFromFragmentString( "=" );
					joinFragment.addFromFragmentString( rhsAlias );
					joinFragment.addFromFragmentString( "." );
					joinFragment.addFromFragmentString( rhsColumns[j] );
					if ( j < lhsColumns[i].length - 1 ) {
						joinFragment.addFromFragmentString( " and " );
					}
				}
				if ( i < lhsColumns.length - 1 ) {
					joinFragment.addFromFragmentString( " or " );
				}
			}
			if ( lhsColumns.length > 1 ) {
				joinFragment.addFromFragmentString( ")" );
			}

			joinFragment.addFromFragmentString( " and " );
			joinFragment.addFromFragmentString( withClauseFragment );

			return joinFragment;
		}
		else {
			last = null;
		}
		for ( Join join : joins ) {
			// technically the treatAsDeclarations should only apply to rootJoinable or to a single Join,
			// but that is not possible atm given how these JoinSequence and Join objects are built.
			// However, it is generally ok given how the HQL parser builds these JoinSequences (a HQL join
			// results in a JoinSequence with an empty rootJoinable and a single Join).  So we use that here
			// as an assumption
			final String on = join.getAssociationType().getOnCondition( join.getAlias(), factory, enabledFilters, treatAsDeclarations );
			String condition;
			if ( last != null
					&& isManyToManyRoot( last )
					&& ((QueryableCollection) last).getElementType() == join.getAssociationType() ) {
				// the current join represents the join between a many-to-many association table
				// and its "target" table.  Here we need to apply any additional filters
				// defined specifically on the many-to-many
				final String manyToManyFilter = ( (QueryableCollection) last ).getManyToManyFilterFragment(
						join.getAlias(),
						enabledFilters
				);
				condition = "".equals( manyToManyFilter )
						? on
						: "".equals( on ) ? manyToManyFilter : on + " and " + manyToManyFilter;
			}
			else {
				condition = on;
			}

			if ( withClauseFragment != null && !isManyToManyRoot( join.joinable )) {
				condition += " and " + withClauseFragment;
			}

			joinFragment.addJoin(
					join.getJoinable().getTableName(),
					join.getAlias(),
					join.getLHSColumns(),
					JoinHelper.getRHSColumnNames( join.getAssociationType(), factory ),
					join.joinType,
					condition
			);

			if (renderSubclassJoins) {
				addSubclassJoins(
						joinFragment,
						join.getAlias(),
						join.getJoinable(),
						join.joinType == JoinType.INNER_JOIN,
						includeAllSubclassJoins,
						// ugh.. this is needed because of how HQL parser (FromElementFactory/SessionFactoryHelper)
						// builds the JoinSequence for HQL joins
						treatAsDeclarations
				);
			}

			last = join.getJoinable();
		}

		if ( next != null ) {
			joinFragment.addFragment( next.toJoinFragment( enabledFilters, includeAllSubclassJoins ) );
		}

		joinFragment.addCondition( conditions.toString() );

		if ( isFromPart ) {
			joinFragment.clearWherePart();
		}

		return joinFragment;
	}

	private boolean needsTableGroupJoin(List<Join> joins, String withClauseFragment) {
		// If the rewrite is disabled or we don't have a with clause, we don't need a table group join
		if ( !collectionJoinSubquery || StringHelper.isEmpty( withClauseFragment ) ) {
			return false;
		}
		// If we only have one join, a table group join is only necessary if subclass columns are used in the with clause
		if ( joins.size() < 2 ) {
			return isSubclassAliasDereferenced( joins.get( 0 ), withClauseFragment );
		}
		// If more than one table is involved and this is not an inner join, we definitely need a table group join
		// i.e. a left join has to be made for the table group to retain the join semantics
		if ( joins.get( 0 ).getJoinType() != JoinType.INNER_JOIN ) {
			return true;
		}
		// If a subclass columns is used, we need a table group, otherwise we generate wrong SQL by putting the ON condition to the first join
		if ( isSubclassAliasDereferenced( joins.get( 0 ), withClauseFragment ) ) {
			return true;
		}

		// Normally, the ON condition of a HQL join is put on the ON clause of the first SQL join
		// Since the ON condition could refer to columns from subsequently joined tables i.e. joins with index > 0
		// or could refer to columns of subclass tables, the SQL could be wrong
		// To avoid generating wrong SQL, we detect these cases here i.e. a subsequent join alias is used in the ON condition
		// If we find out that this is the case, we return true and generate a table group join

		// Skip the first since that is the driving join
		for ( int i = 1; i < joins.size(); i++ ) {
			Join join = joins.get( i );

			if ( isAliasDereferenced( withClauseFragment, join.getAlias() ) || isSubclassAliasDereferenced( join, withClauseFragment ) ) {
				return true;
			}
		}

		return false;
	}

	private boolean isSubclassAliasDereferenced(Join join, String withClauseFragment) {
		if ( join.getJoinable() instanceof AbstractEntityPersister ) {
			AbstractEntityPersister persister = (AbstractEntityPersister) join.getJoinable();
			int subclassTableSpan = persister.getSubclassTableSpan();
			for ( int j = 1; j < subclassTableSpan; j++ ) {
				String subclassAlias = AbstractEntityPersister.generateTableAlias( join.getAlias(), j );
				if ( isAliasDereferenced( withClauseFragment, subclassAlias ) ) {
					return true;
				}
			}
		}
		return false;
	}

	private boolean isAliasDereferenced(String withClauseFragment, String alias) {
		// See if the with clause contains the join alias
		int index = withClauseFragment.indexOf( alias );
		int dotIndex = index + alias.length();
		if ( index != -1
				// Check that the join alias is not a suffix
				&& ( index == 0 || !Character.isLetterOrDigit( withClauseFragment.charAt( index - 1 ) ) )
				// Check that the join alias gets de-referenced i.e. the next char is a dot
				&& dotIndex < withClauseFragment.length() && withClauseFragment.charAt( dotIndex ) == '.' ) {
			return true;
		}

		return false;
	}

	@SuppressWarnings("SimplifiableIfStatement")
	private boolean isManyToManyRoot(Joinable joinable) {
		if ( joinable != null && joinable.isCollection() ) {
			return ( (QueryableCollection) joinable ).isManyToMany();
		}
		return false;
	}

	private void addSubclassJoins(
			JoinFragment joinFragment,
			String alias,
			Joinable joinable,
			boolean innerJoin,
			boolean includeSubclassJoins,
			Set<String> treatAsDeclarations) {
		final boolean include = includeSubclassJoins && isIncluded( alias );
		joinFragment.addJoins(
				joinable.fromJoinFragment( alias, innerJoin, include, treatAsDeclarations ),
				joinable.whereJoinFragment( alias, innerJoin, include, treatAsDeclarations )
		);
	}

	protected boolean isIncluded(String alias) {
		return selector != null && selector.includeSubclasses( alias );
	}

	
Add a condition to this sequence.
Params:
condition – The condition
Returns:
this, for method chaining/**
	 * Add a condition to this sequence.
	 *
	 * @param condition The condition
	 *
	 * @return {@link this}, for method chaining
	 */
	public JoinSequence addCondition(String condition) {
		if ( condition.trim().length() != 0 ) {
			if ( !condition.startsWith( " and " ) ) {
				conditions.append( " and " );
			}
			conditions.append( condition );
		}
		return this;
	}

	
Add a condition to this sequence.  Typical usage here might be:
    addCondition( "a", {"c1", "c2"}, "?" )

to represent:
    "... a.c1 = ? and a.c2 = ? ..."

Params:
alias – The alias to apply to the columns
columns – The columns to add checks for
condition – The conditions to check against the columns
Returns:
this, for method chaining/**
	 * Add a condition to this sequence.  Typical usage here might be:
	 * <pre>
	 *     addCondition( "a", {"c1", "c2"}, "?" )
	 * </pre>
	 * to represent:
	 * <pre>
	 *     "... a.c1 = ? and a.c2 = ? ..."
	 * </pre>
	 *
	 * @param alias The alias to apply to the columns
	 * @param columns The columns to add checks for
	 * @param condition The conditions to check against the columns
	 *
	 * @return {@link this}, for method chaining
	 */
	public JoinSequence addCondition(String alias, String[] columns, String condition) {
		for ( String column : columns ) {
			conditions.append( " and " )
					.append( alias )
					.append( '.' )
					.append( column )
					.append( condition );
		}
		return this;
	}

	
Set the root of this JoinSequence.  In SQL terms, this would be the driving table.
Params:
joinable – The entity/collection that is the root of this JoinSequence
alias – The alias associated with that joinable.
Returns:
this, for method chaining/**
	 * Set the root of this JoinSequence.  In SQL terms, this would be the driving table.
	 *
	 * @param joinable The entity/collection that is the root of this JoinSequence
	 * @param alias The alias associated with that joinable.
	 *
	 * @return {@link this}, for method chaining
	 */
	public JoinSequence setRoot(Joinable joinable, String alias) {
		this.rootAlias = alias;
		this.rootJoinable = joinable;
		return this;
	}

	
Sets the next join sequence
Params:
next – The next JoinSequence in the directed graph
Returns:
this, for method chaining/**
	 * Sets the next join sequence
	 *
	 * @param next The next JoinSequence in the directed graph
	 *
	 * @return {@code this}, for method chaining
	 */
	public JoinSequence setNext(JoinSequence next) {
		this.next = next;
		return this;
	}

	
Set the Selector to use to determine how subclass joins should be applied.
Params:
selector – The selector to apply
Returns:
this, for method chaining/**
	 * Set the Selector to use to determine how subclass joins should be applied.
	 *
	 * @param selector The selector to apply
	 *
	 * @return {@code this}, for method chaining
	 */
	public JoinSequence setSelector(Selector selector) {
		this.selector = selector;
		return this;
	}

	
Should this JoinSequence use theta-style joining (both a FROM and WHERE component) in the rendered SQL?
Params:
useThetaStyle – true indicates that theta-style joins should be used.
Returns:
this, for method chaining/**
	 * Should this JoinSequence use theta-style joining (both a FROM and WHERE component) in the rendered SQL?
	 *
	 * @param useThetaStyle {@code true} indicates that theta-style joins should be used.
	 *
	 * @return {@code this}, for method chaining
	 */
	public JoinSequence setUseThetaStyle(boolean useThetaStyle) {
		this.useThetaStyle = useThetaStyle;
		return this;
	}

	public boolean isThetaStyle() {
		return useThetaStyle;
	}

	public Join getFirstJoin() {
		return joins.get( 0 );
	}

	
A subclass join selector
/**
	 * A subclass join selector
	 */
	public static interface Selector {
		
Should subclasses be included in the rendered join sequence?
Params:
alias – The alias
Returns:
true if the subclass joins should be included/**
		 * Should subclasses be included in the rendered join sequence?
		 *
		 * @param alias The alias
		 *
		 * @return {@code true} if the subclass joins should be included
		 */
		public boolean includeSubclasses(String alias);
	}

	
Represents a join
/**
	 * Represents a join
	 */
	public static final class Join {
		private final AssociationType associationType;
		private final Joinable joinable;
		private final JoinType joinType;
		private final String alias;
		private final String[][] lhsColumns;

		Join(
				SessionFactoryImplementor factory,
				AssociationType associationType,
				String alias,
				JoinType joinType,
				String[][] lhsColumns) throws MappingException {
			this.associationType = associationType;
			this.joinable = associationType.getAssociatedJoinable( factory );
			this.alias = alias;
			this.joinType = joinType;
			this.lhsColumns = lhsColumns;
		}

		public String getAlias() {
			return alias;
		}

		public AssociationType getAssociationType() {
			return associationType;
		}

		public Joinable getJoinable() {
			return joinable;
		}

		public JoinType getJoinType() {
			return joinType;
		}

		public String[][] getLHSColumns() {
			return lhsColumns;
		}

		@Override
		public String toString() {
			return joinable.toString() + '[' + alias + ']';
		}
	}

	public JoinSequence copyForCollectionProperty() {
		JoinSequence copy = this.copy();
		copy.joins.clear();
		Iterator<Join> joinIterator = this.joins.iterator();
		while ( joinIterator.hasNext() ) {
			Join join = joinIterator.next();
			copy.addJoin(
					join.getAssociationType(),
					join.getAlias(),
					JoinType.INNER_JOIN,
					join.getLHSColumns()
			);
		}
		return copy;
	}

	@Override
	public String toString() {
		final StringBuilder buf = new StringBuilder();
		buf.append( "JoinSequence{" );
		if ( rootJoinable != null ) {
			buf.append( rootJoinable )
					.append( '[' )
					.append( rootAlias )
					.append( ']' );
		}
		for ( Join join : joins ) {
			buf.append( "->" ).append( join );
		}
		return buf.append( '}' ).toString();
	}
}