/*******************************************************************************
 * GenRGenS v.1.0, Generation of Random Genomic Sequences                      *
 * Copyright (C) 2001  Alain Denise/Yann Ponty                                 *
 *                                                                             *
 * This program is free software; you can redistribute it and/or               *
 * modify it under the terms of the GNU General Public License                 *
 * as published by the Free Software Foundation; either version 2              *
 * of the License, or (at your option) any later version.                      *
 *                                                                             *
 * This program is distributed in the hope that it will be useful,             *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 * GNU General Public License for more details.                                *
 *                                                                             *
 * You should have received a copy of the GNU General Public License           *
 * along with this program; if not, write to the Free Software                 *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. *
 *******************************************************************************/

package GenRGenS.grammar;

/*****************************************************************************
*              NormalContextFreeGrammarProductionProduct         
*
******************************************************************************/

/** 
 * A class for the context-free grammar productions that are binary products
 * @author Fr&eacute;d&eacute;ric Sarron
 * @version 1.0
 */

public class NormalContextFreeGrammarProductionProduct
		extends NormalContextFreeGrammarProduction
{
		/** 
		 * numeros des auxiliaires en produit
		 * (ces numeros doivent etre positifs)
		 * auxiliaire1 est le non-terminal
		 * dont la derivation sera prefixe du mot derive par la source
		 * auxiliaire2 = suffixe 
		 */
		protected int auxiliaire1,auxiliaire2;

		/**
		 * Construit une instance de <code>NormalContextFreeGrammarProductionUnion</code>, classe
		 * modelisant les règles des la grammaire de type Produit (N -> N1.N2).
		 * @param source L'index du non-terminal partie gauche de la règle.
		 * @param nt1 L'index du non-terminal préfixe
		 * @param nt2 L'index du non-terminal suffixe
		 */
		NormalContextFreeGrammarProductionProduct(int source, int nt1, int nt2)
		{	
				super(source);
				setRHS(nt1, nt2);
		};

		/**
		 * Renvoie le non-terminal préfixe (nt1) de la règle.
		 * @return Le non-terminal préfixe (nt1) de la règle.
		 */
		public int getNT1()
		{	return(auxiliaire1); };

		/**
		 * Renvoie le non-terminal suffixe (nt2) de la règle.
		 * @return Le non-terminal suffixe (nt2) de la règle.
		 */
		public int getNT2()
		{ return(auxiliaire2); };

		/**
		 * Affecte à la règle un nouvel ensemble de non-terminaux en partie droite
		 * @param nt1 L'index du nouveau préfixe de la règle.
		 * @param nt2 L'index du nouveau suffixe de la règle.
		 * @throws IllegalArgumentException Quand l'index d'un terminal est trouvé dans le tableau.
		 */
		public void setRHS(int nt1, int nt2)
		{
				if (nt1>=0 && nt2>=0)
						{ auxiliaire1=nt1; auxiliaire2=nt2; }
				else
					throw(new IllegalArgumentException("NormalContextFreeGrammarProductionProduct : setRHS(int, int) need positive integers"));
		};

		/**
		 * Cette methode a pour but de rereferencer les nonTerminaux
		 * dans les LHS et RHS, suite a suppression de certains
		 * auxiliaires dans des algorithmes au niveau grammaire.
		 * @param assignement Ce tableau d'entier fait correspondre
		 * a chaque auxiliaire un nouvel index auquel il faut le substituer 
		 */
		void modifyReferences(int[] assignement)
		{
				int assign;
				if ((assign=assignement[lhs])>=0)
						lhs = assignement[lhs];
				if ((assign=assignement[auxiliaire1])>=0)
						auxiliaire1 = assign;
				if ((assign=assignement[auxiliaire2])>=0)
						auxiliaire2 = assign;
		};

		/**
		 * Cette règle ne dérive-t-elle que le mot epsilon ?
		 * @return true si la règle ne dérive qu'epsilon, false sinon.
		 */
		public boolean isEpsilonProduction()
		{ return(false); };
		
		/**
		 * Renvoie une représentation littérale de cette instance de classe en mode "debug".
		 * @param ncfg La grammaire dans laquelle seront cherchées les représentations littérales 
		 * des symboles.
		 * @return Renvoie une instance de <code>String</code> décrivant cette règle.
		 */
		public String toString(NormalContextFreeGrammar ncfg)
		{
				return(
							 ncfg.CFGsymbolName(lhs)+" -> "+
							 ncfg.CFGsymbolName(auxiliaire1)+" "+
							 ncfg.CFGsymbolName(auxiliaire2));
		};

		/**
		 * Renvoie une représentation littérale de cette instance de classe en mode "debug".
		 */
		public String toStringDebug()
		{
				return(lhs+" -> "+auxiliaire1+" "+auxiliaire2);
		};

}
