Реализация функций формирований правил -ManadUtils

package bitel.billing.server.ipn.bean;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import ru.bitel.bgbilling.common.DefaultSetup;
import bitel.billing.common.IPUtils;
import bitel.billing.server.util.Utils;
 
	private static StringBuffer processBlock( String ruleText, String replace, String[] objects )
	{
		StringBuffer result = new StringBuffer();
 
		List items = new ArrayList();
		Map letterMaxNumbers = new HashMap();
 
		Pattern pattern = Pattern.compile( "\\{([A-Z]+)(\\d+)\\}" );
		Matcher m = pattern.matcher( ruleText );
 
		while( m.find() )
		{
			String letter = m.group( 1 );
			int number = Utils.parseIntString( m.group( 2 ), 0 );
 
			PatternItem item = new PatternItem();
			item.number = number;
			item.letter = letter;
 
			items.add( item );
 
			Integer maxNumber = letterMaxNumbers.get( letter );
			if( maxNumber == null || maxNumber < number )
			{
				letterMaxNumbers.put( letter, number );
			}
		}
 
		final int size = objects.length;
 
		for( int i = 0; i < size; i++ )
		{
			//String address = IPUtils.convertLongIpToString( Utils.parseLongString( addreses[i], 0 ) );
			String addressRule = new String( ruleText );
 
			for( PatternItem item : items )
			{
				int number = i*(letterMaxNumbers.get( item.letter ) + 1) + item.number;
				addressRule = addressRule.replaceAll( 
						"\\{" + item.letter + item.number + "\\}",
						"{" + item.letter + number + "}" );
			}
 
			result.append( addressRule.replaceAll( replace, objects[i] ) );
		}
		return result;
	}
 
	public static final String generateRule( String ruleText,
												String addressList,
												Map replacements,
												RuleType ruleType )
	{
		List  loops = getAddresLoops( addressList );
		return generateRule( ruleText, replacements, ruleType, loops);  		
	}
 
	/**
	 * строку адреса преобразует в 2 LoopPattern-а : для диапазонов и сетей  
	 * @param addressList
	 * @return
	 */
	public static List getAddresLoops( String addressList )
	{
		String[] parts =  addressList.split( ";" );
		String[] addreses = new String [0];
		if ( parts.length > 0 )
		{		
			addreses = parts[0].split( "\\s*,\\s*" );
			if ( addreses.length > 0)
			{
				for ( int i = 0; i < addreses.length; i++)
				{
					String address = IPUtils.convertLongIpToString( Utils.parseLongString( addreses[i], 0 ) );
					addreses[i] = address; 
				}
			}
		}
 
		String[] nets = new String [0];
		String[] net_masks = new String [0];
		if ( parts.length > 1 )
		{		
			nets = parts[1].split( "\\s*,\\s*" );
			net_masks = new String[nets.length];
			if ( nets.length > 0)
			{
				for ( int i = 0; i < nets.length; i++)
				{
					String[] parts2 = nets[i].split( "/" );
					if ( parts2.length == 2)
					{
						String address = IPUtils.convertLongIpToString( Utils.parseLongString( parts2[0], 0 ) );
						String mask = parts2[1];
						nets[i] = address + "/" + mask;
 
    					//махинация для того чтоб получить 0xFFFFFFFF -в beanshell не 
						//получилось задать такое большое число и модификатор l в конце не работает
    					long ffMask = (0xFFFFFFF);
    					ffMask = (ffMask << 8 ) | 0xFF;
 
						long maskNew = ( ffMask << ( 32 - Utils.parseIntString( mask, 0 ) ) ) & ffMask;
						net_masks[i] = address + "/" + IPUtils.convertLongIpToString( maskNew );
					}
				}
			}
		}
 
		List loops =new ArrayList();
 
		//адреса
		LoopPattern p = new LoopPattern();		
		p.setLoopPatern( "LOOP" );
		p.setReplace( "\\{A\\}" );
		p.setObjects( addreses );		
		loops.add( p );
 
		//сети
		p = new LoopPattern();		
		p.setLoopPatern( "LOOP_NET" );
		p.setReplace( "\\{NET\\}" );
		p.setObjects( nets );		
		loops.add( p );
 
		//сети с маской
		p = new LoopPattern();		
		p.setLoopPatern( "LOOP_NET_MASK" );
		p.setReplace( "\\{NET_MASK\\}" );
		p.setObjects( net_masks );		
		loops.add( p );
 
		return loops;
	}
 
 
	public static final String generateRule( String ruleText,												
												Map replacements,
												RuleType ruleType,
												List loops)
	{
		StringBuffer resultBuf = null; 
		for ( LoopPattern loop : loops)
		{
			resultBuf = new StringBuffer ();
			String loopPattern = "(<LOOP>.*?</LOOP>)?(.*?)<LOOP>(.*?)</LOOP>";
			loopPattern = loopPattern.replaceAll( "LOOP", loop.getLoopPatern() );
			Pattern pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
			Matcher m = pattern.matcher( ruleText );
			boolean find = false;
 
			while( m.find() )
			{
				find = true;
 
				String block = m.group( 3 );
				block = processBlock( block, loop.getReplace(), loop.getObjects() ).toString();
 
				resultBuf.append( m.group( 2 ) );
				resultBuf.append( block );				
			}
 
			if (find)
			{
				//хвост(ищем жадным алгоритмом) или если вообще нет ни одного цикла 
				loopPattern = "(?:<LOOP>(?:.*)</LOOP>)(.*)\\z";
				loopPattern = loopPattern.replaceAll( "LOOP", loop.getLoopPatern() );
 
				pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
				m = pattern.matcher( ruleText );		
 
				if( m.find() )
				{
					resultBuf.append( m.group( 1 ) );
				}
			}
			else
			{
 
				resultBuf  = new StringBuffer( ruleText ); 		
			}	
 
			//пошли по второму и т.п заходу 
			ruleText = resultBuf.toString();
		}
 
		String result = resultBuf.toString(); 
 
		result = result.replaceAll( "<ver 2\\.0/>", "" );
		//убиваем пустые строки
		result = result.replaceAll( "\r", "" );
		result = result.replaceAll( "\n\\s*\n", "\n" );		
		result = result.replaceAll( "(\n){2,}", "\n" );
		result = result.trim();
 
		String ruleData = ruleType.getData();
		ruleData.replaceAll( "\r", "\n" );
		ruleData = ruleData.trim();
 
		DefaultSetup setup = new DefaultSetup( ruleData, "\n");
		//получаем все значения
		Map values = setup.getHashValuesWithPrefix( "" );
 
		if( replacements == null)
		{
			replacements = new HashMap();
		}
 
		for (Map.Entry entry : values.entrySet())
		{
			String key = "\\$\\{" + entry.getKey() + "\\}";
			replacements.put( key, entry.getValue() );
		}
 
		if (replacements != null)
		{
			for (Map.Entry rep : replacements.entrySet())
			{
				//result = result.replaceAll( "\\{CID\\}", String.valueOf( cid ) );	
				result = result.replaceAll( rep.getKey(), rep.getValue() );
			}
		}
 
		return result.toString();
	}
 
	private static class PatternItem
	{
		public String letter;
		public int number;
	}
 
	public static String getRule( GateType gateType, RuleType ruleType )
	{
		String result  = "";
 
		String template = "\\[RULE ID=\"((?:\\d+,*)+)\"\\](.*?)\\[/RULE\\]";		
		Pattern pattern = Pattern.compile( template, Pattern.DOTALL );
 
		Matcher m = pattern.matcher( gateType.getRule() );		
		while( m.find() )
		{
			String idsStr = m.group(1);
			String rule = m.group( 2 );
			int[] ids = parseIds( idsStr );
			for (int i = 0; i < ids.length; i++)
			{
				if (ruleType.getId() == ids [i] )
				{
					return rule;	
				}
			}
		}
 
		//default
		template = "\\[DEFAULT\\](.*)\\[/DEFAULT\\]";		
		pattern = Pattern.compile( template, Pattern.DOTALL );		
		m = pattern.matcher( gateType.getRule() );		
		if( m.find() )
		{			
			String rule = m.group( 1 );
			return rule;
		}
 
		return result;
	}
 
	private static int[] parseIds( String idsStr )
	{
		String [] strs = idsStr.split( "," );
		int[] result  = new int [strs.length];
 
		for (int i = 0; i < strs.length; i++)
		{
			result[i] = Integer.parseInt( strs[i]);
		}
		return result;
	}