RC9/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java - qpid - Git at Google

 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */
 package org.apache.qpid.gentools;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeMap;

 @SuppressWarnings("serial")
 public class AmqpFieldMap implements VersionConsistencyCheck
 {

     private final TreeMap<String, AmqpField> _map = new TreeMap<String, AmqpField>();

     private final AmqpVersionSet _versionSet = new AmqpVersionSet();

     public void removeVersion(AmqpVersion version)
     {
         String[] fieldNameArray = new String[size()];
         _map.keySet().toArray(fieldNameArray);
         Iterator<Entry<String, AmqpField>> iter = _map.entrySet().iterator();

         while (iter.hasNext())
         {
             Entry<String, AmqpField> entry = iter.next();
             entry.getValue().removeVersion(version);
             iter.remove();
         }
     }

     public int size()
     {
         return _map.size();

     }

     public AmqpFieldMap getFieldMapForOrdinal(int ordinal)
     {
         AmqpFieldMap newMap = new AmqpFieldMap();
         for (AmqpField field : _map.values())
         {

             TreeMap<Integer, AmqpVersionSet> ordinalMap = field.getOrdinalMap();
             AmqpVersionSet ordinalVersions = ordinalMap.get(ordinal);
             if (ordinalVersions != null)
             {
                 newMap.add(field.getName(), field);
             }
         }
         return newMap;
     }

     public void add(String name, AmqpField field)
     {
         _versionSet.addAll(field.getVersionSet());
         _map.put(name, field);
     }

     public AmqpOrdinalFieldMap getMapForVersion(AmqpVersion version, boolean codeTypeFlag,
                                                 LanguageConverter converter)
     {
         // TODO: REVIEW THIS! There may be a bug here that affects C++ generation (only with >1 version)...
         // If version == null (a common scenario) then the version map is built up on the
         // basis of first found item, and ignores other version variations.
         // This should probably be disallowed by throwing an NPE, as AmqpOrdinalFieldMap cannot
         // represent these possibilities.
         // *OR*
         // Change the structure of AmqpOrdianlFieldMap to allow for the various combinations that
         // will result from version variation - but that is what AmqpFieldMap is... :-$
         AmqpOrdinalFieldMap ordinalFieldMap = new AmqpOrdinalFieldMap();
         for (AmqpField field : _map.values())
         {

             if (version == null || field.getVersionSet().contains(version))
             {
                 // 1. Search for domain name in field domain map with version that matches
                 String domain = "";
                 boolean dFound = false;
                 for (String thisDomainName : field.getDomainMap().keySet())
                 {
                     domain = thisDomainName;
                     AmqpVersionSet versionSet = field.getDomainMap().get(domain);
                     if (version == null || versionSet.contains(version))
                     {
                         if (codeTypeFlag)
                         {
                             domain = converter.getGeneratedType(domain, version);
                         }
                         dFound = true;
                     }
                 }

                 // 2. Search for ordinal in field ordianl map with version that matches
                 int ordinal = -1;
                 boolean oFound = false;
                 for (Integer thisOrdinal : field.getOrdinalMap().keySet())
                 {
                     ordinal = thisOrdinal;
                     AmqpVersionSet versionSet = field.getOrdinalMap().get(ordinal);
                     if (version == null || versionSet.contains(version))
                     {
                         oFound = true;
                     }
                 }

                 if (dFound && oFound)
                 {
                     String[] fieldDomainPair = {field.getName(), domain};
                     ordinalFieldMap.put(ordinal, fieldDomainPair);
                 }
             }
         }
         return ordinalFieldMap;
     }

     public boolean isDomainConsistent(Generator generator, AmqpVersionSet versionSet)
             throws AmqpTypeMappingException
     {
         if (size() != 1) // Only one field for this ordinal
         {
             return false;
         }
         return _map.get(_map.firstKey()).isConsistent(generator);
     }

     public int getNumFields(AmqpVersion version)
     {
         int fCntr = 0;
         for (AmqpField field : _map.values())
         {

             if (field.getVersionSet().contains(version))
             {
                 fCntr++;
             }
         }
         return fCntr;
     }

     public String parseFieldMap(CommandGenerateMethod commonGenerateMethod, MangledGenerateMethod mangledGenerateMethod,
                                 int indentSize, int tabSize, LanguageConverter converter)
     {
         String indent = Utils.createSpaces(indentSize);
         String cr = Utils.LINE_SEPARATOR;
         StringBuffer sb = new StringBuffer();

         if (commonGenerateMethod == null)
         {
             // Generate warnings in code if required methods are null.
             sb.append(indent + "/*********************************************************" + cr);
             sb.append(indent + " * WARNING: Generated code could be missing." + cr);
             sb.append(indent + " * In call to parseFieldMap(), generation method was null." + cr);
             sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
             sb.append(indent + " *********************************************************/" + cr);
         }

         Iterator<Entry<String, AmqpField>> itr = _map.entrySet().iterator();
         while (itr.hasNext())
         {
             Entry<String, AmqpField> entry = itr.next();
             String fieldName = entry.getKey();
             AmqpField field = entry.getValue();
             if (field.isCodeTypeConsistent(converter))
             {
                 // All versions identical - Common declaration
                 String domainName = field.getDomainMap().firstKey();
                 AmqpVersionSet versionSet = field.getDomainMap().get(domainName);
                 String codeType = converter.getGeneratedType(domainName, versionSet.first());
                 if (commonGenerateMethod != null)
                 {
                     sb.append(commonGenerateMethod.generate(codeType, field, versionSet,
                                                             indentSize, tabSize, itr.hasNext()));
                 }
             }
             else if (mangledGenerateMethod != null) // Version-mangled
             {
                 sb.append(mangledGenerateMethod.generate(field, indentSize, tabSize,
                                                          itr.hasNext()));
             }
         }
         return sb.toString();
     }

     public String parseFieldMapOrdinally(GenerateMethod generateMethod, BitFieldGenerateMethod bitGenerateMethod,
                                          int indentSize, int tabSize, Generator codeGenerator)
     {
         String indent = Utils.createSpaces(indentSize);
         String cr = Utils.LINE_SEPARATOR;
         StringBuffer sb = new StringBuffer();

         // Generate warnings in code if required methods are null.
         if (generateMethod == null || bitGenerateMethod == null)
         {
             sb.append(indent + "/***********************************************" + cr);
             sb.append(indent + " * WARNING: In call to parseFieldMapOrdinally():" + cr);
             if (generateMethod == null)
             {
                 sb.append(indent + " *  => generateMethod is null." + cr);
             }
             if (bitGenerateMethod == null)
             {
                 sb.append(indent + " *  => bitGenerateMethod is null." + cr);
             }
             sb.append(indent + " * Generated code could be missing." + cr);
             sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
             sb.append(indent + " ***********************************************/" + cr);
         }

         /* We must process elements in ordinal order because adjacent booleans (bits)
            * must be combined into a single byte (in groups of up to 8). Start with shared
            * declarations until an ordinal divergence is found. (For most methods where
            * there is no difference between versions, this will simplify the generated
            * code. */

         ArrayList<String> bitFieldList = new ArrayList<String>();
         boolean ordinalDivergenceFlag = false;
         int ordinal = 0;
         while (ordinal < size() && !ordinalDivergenceFlag)
         {
             /* Since the getFieldMapOrdinal() function may map more than one Field to
                 * an ordinal, the number of ordinals may be less than the total number of
                 * fields in the fieldMap. Check for empty fieldmaps... */
             AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(ordinal);
             if (ordinalFieldMap.size() > 0)
             {
                 if (ordinalFieldMap.isDomainConsistent(codeGenerator, getVersionSet()))
                 {
                     String fieldName = ordinalFieldMap.getFirstFieldName();
                     String domain = ordinalFieldMap._map.get(fieldName).getDomainMap().firstKey();

                     String domainType = codeGenerator.getDomainType(domain,
                                                                     codeGenerator.getVersionSet().first());

                     if (domainType.compareTo("bit") == 0)
                     {
                         bitFieldList.add(fieldName);
                     }
                     else if (bitFieldList.size() > 0)
                     {
                         // End of bit types - handle deferred bit type generation
                         if (bitGenerateMethod != null)
                         {
                             sb.append(bitGenerateMethod.generate(bitFieldList, ordinal,
                                                                  indentSize, tabSize));
                         }
                         bitFieldList.clear();
                     }
                     if (!ordinalDivergenceFlag)
                     {
                         // Defer generation of bit types until all adjacent bits have been
                         // accounted for.
                         if (bitFieldList.size() == 0 && generateMethod != null)
                         {
                             sb.append(generateMethod.generate(domainType, fieldName, ordinal,
                                                               indentSize, tabSize));
                         }
                     }
                     ordinal++;
                 }
                 else
                 {
                     ordinalDivergenceFlag = true;
                 }
             }
         }

         // Check if there is still more to do under a version-specific breakout
         if (ordinalDivergenceFlag && ordinal < size())
         {
             // 1. Cycle through all versions in order, create outer if(version) structure
             AmqpVersion[] versionArray = new AmqpVersion[getVersionSet().size()];
             getVersionSet().toArray(versionArray);
             for (int v = 0; v < versionArray.length; v++)
             {
                 sb.append(indent);
                 if (v > 0)
                 {
                     sb.append("else ");
                 }
                 sb.append("if (major == " + versionArray[v].getMajor() + " && minor == " +
                           versionArray[v].getMinor() + ")" + cr);
                 sb.append(indent + "{" + cr);

                 // 2. Cycle though each ordinal from where we left off in the loop above.
                 ArrayList<String> bitFieldList2 = new ArrayList<String>(bitFieldList);
                 for (int o = ordinal; o < size(); o++)
                 {
                     AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(o);
                     if (ordinalFieldMap.size() > 0)
                     {
                         // 3. Cycle through each of the fields that have this ordinal.
                         Iterator<Map.Entry<String, AmqpField>> i = ordinalFieldMap._map.entrySet().iterator();
                         while (i.hasNext())
                         {

                             Map.Entry<String, AmqpField> entry = i.next();
                             AmqpField field = entry.getValue();
                             String fieldName = entry.getKey();

                             // 4. Some fields may have more than one ordinal - match by both
                             //    ordinal and version.
                             Iterator<Integer> j = field.getOrdinalMap().keySet().iterator();
                             while (j.hasNext())
                             {
                                 int thisOrdinal = j.next();
                                 AmqpVersionSet v1 = field.getOrdinalMap().get(thisOrdinal);
                                 if (thisOrdinal == o && v1.contains(versionArray[v]))
                                 {
                                     // 5. Now get the domain for this version
                                     int domainCntr = 0;
                                     Iterator<String> k = field.getDomainMap().keySet().iterator();
                                     while (k.hasNext())
                                     {
                                         // Mangle domain-divergent field names
                                         String mangledFieldName = fieldName;
                                         if (field.getDomainMap().size() > 1)
                                         {
                                             mangledFieldName += "_" + (domainCntr++);
                                         }
                                         String domainName = k.next();
                                         AmqpVersionSet v2 = field.getDomainMap().get(domainName);
                                         if (v2.contains(versionArray[v]))
                                         {
                                             // 6. (Finally!!) write the declaration
                                             String domainType = codeGenerator.getDomainType(domainName,
                                                                                             versionArray[v]);
                                             if (domainType.compareTo("bit") == 0)
                                             {
                                                 bitFieldList2.add(mangledFieldName);
                                             }
                                             else if (bitFieldList2.size() > 0)
                                             {
                                                 // End of bit types - handle deferred bit type generation
                                                 if (bitGenerateMethod != null)
                                                 {
                                                     sb.append(bitGenerateMethod.generate(
                                                             bitFieldList2, o, indentSize + tabSize,
                                                             tabSize));
                                                 }
                                                 bitFieldList2.clear();
                                             }
                                             // Defer generation of bit types until all adjacent bits have
                                             // been accounted for.
                                             if (bitFieldList2.size() == 0 && generateMethod != null)
                                             {
                                                 sb.append(generateMethod.generate(domainType,
                                                                                   mangledFieldName, o, indentSize + tabSize, tabSize));
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
                 // Check for remaining deferred bits
                 if (bitFieldList2.size() > 0 && bitGenerateMethod != null)
                 {
                     sb.append(bitGenerateMethod.generate(bitFieldList2, size(),
                                                          indentSize + tabSize, tabSize));
                 }
                 sb.append(indent + "}" + cr);
             }
         }
         // Check for remaining deferred bits
         else if (bitFieldList.size() > 0 && bitGenerateMethod != null)
         {
             sb.append(bitGenerateMethod.generate(bitFieldList, size(),
                                                  indentSize, tabSize));
         }
         return sb.toString();
     }

     private String getFirstFieldName()
     {
         return _map.firstKey();
     }

     public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
     {
         for (String thisFieldName : _map.keySet())
         {
             AmqpField field = _map.get(thisFieldName);
             if (!field.isVersionConsistent(globalVersionSet))
             {
                 return false;
             }
         }
         return true;
     }

     public boolean isVersionInterfaceConsistent(AmqpVersionSet globalVersionSet)
     {
         for (String thisFieldName : _map.keySet())
         {
             AmqpField field = _map.get(thisFieldName);
             if (!field.isVersionInterfaceConsistent(globalVersionSet))
             {
                 return false;
             }
         }
         return true;
     }


     public AmqpVersionSet getVersionSet()
     {
         return _versionSet;
     }

     public Collection<AmqpField> values()
     {
         return _map.values();
     }

     public AmqpField get(String fieldName)
     {
         return _map.get(fieldName);
     }

     public void remove(String fieldName)
     {
         _map.remove(fieldName);
     }

     public Set<String> keySet()
     {
         return _map.keySet();
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/
	package org.apache.qpid.gentools;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;
	import java.util.TreeMap;

	@SuppressWarnings("serial")
	public class AmqpFieldMap implements VersionConsistencyCheck
	{

	private final TreeMap<String, AmqpField> _map = new TreeMap<String, AmqpField>();

	private final AmqpVersionSet _versionSet = new AmqpVersionSet();

	public void removeVersion(AmqpVersion version)
	{
	String[] fieldNameArray = new String[size()];
	_map.keySet().toArray(fieldNameArray);
	Iterator<Entry<String, AmqpField>> iter = _map.entrySet().iterator();

	while (iter.hasNext())
	{
	Entry<String, AmqpField> entry = iter.next();
	entry.getValue().removeVersion(version);
	iter.remove();
	}
	}

	public int size()
	{
	return _map.size();

	}

	public AmqpFieldMap getFieldMapForOrdinal(int ordinal)
	{
	AmqpFieldMap newMap = new AmqpFieldMap();
	for (AmqpField field : _map.values())
	{

	TreeMap<Integer, AmqpVersionSet> ordinalMap = field.getOrdinalMap();
	AmqpVersionSet ordinalVersions = ordinalMap.get(ordinal);
	if (ordinalVersions != null)
	{
	newMap.add(field.getName(), field);
	}
	}
	return newMap;
	}

	public void add(String name, AmqpField field)
	{
	_versionSet.addAll(field.getVersionSet());
	_map.put(name, field);
	}

	public AmqpOrdinalFieldMap getMapForVersion(AmqpVersion version, boolean codeTypeFlag,
	LanguageConverter converter)
	{
	// TODO: REVIEW THIS! There may be a bug here that affects C++ generation (only with >1 version)...
	// If version == null (a common scenario) then the version map is built up on the
	// basis of first found item, and ignores other version variations.
	// This should probably be disallowed by throwing an NPE, as AmqpOrdinalFieldMap cannot
	// represent these possibilities.
	// OR
	// Change the structure of AmqpOrdianlFieldMap to allow for the various combinations that
	// will result from version variation - but that is what AmqpFieldMap is... :-$
	AmqpOrdinalFieldMap ordinalFieldMap = new AmqpOrdinalFieldMap();
	for (AmqpField field : _map.values())
	{

	if (version == null \|\| field.getVersionSet().contains(version))
	{
	// 1. Search for domain name in field domain map with version that matches
	String domain = "";
	boolean dFound = false;
	for (String thisDomainName : field.getDomainMap().keySet())
	{
	domain = thisDomainName;
	AmqpVersionSet versionSet = field.getDomainMap().get(domain);
	if (version == null \|\| versionSet.contains(version))
	{
	if (codeTypeFlag)
	{
	domain = converter.getGeneratedType(domain, version);
	}
	dFound = true;
	}
	}

	// 2. Search for ordinal in field ordianl map with version that matches
	int ordinal = -1;
	boolean oFound = false;
	for (Integer thisOrdinal : field.getOrdinalMap().keySet())
	{
	ordinal = thisOrdinal;
	AmqpVersionSet versionSet = field.getOrdinalMap().get(ordinal);
	if (version == null \|\| versionSet.contains(version))
	{
	oFound = true;
	}
	}

	if (dFound && oFound)
	{
	String[] fieldDomainPair = {field.getName(), domain};
	ordinalFieldMap.put(ordinal, fieldDomainPair);
	}
	}
	}
	return ordinalFieldMap;
	}

	public boolean isDomainConsistent(Generator generator, AmqpVersionSet versionSet)
	throws AmqpTypeMappingException
	{
	if (size() != 1) // Only one field for this ordinal
	{
	return false;
	}
	return _map.get(_map.firstKey()).isConsistent(generator);
	}

	public int getNumFields(AmqpVersion version)
	{
	int fCntr = 0;
	for (AmqpField field : _map.values())
	{

	if (field.getVersionSet().contains(version))
	{
	fCntr++;
	}
	}
	return fCntr;
	}

	public String parseFieldMap(CommandGenerateMethod commonGenerateMethod, MangledGenerateMethod mangledGenerateMethod,
	int indentSize, int tabSize, LanguageConverter converter)
	{
	String indent = Utils.createSpaces(indentSize);
	String cr = Utils.LINE_SEPARATOR;
	StringBuffer sb = new StringBuffer();

	if (commonGenerateMethod == null)
	{
	// Generate warnings in code if required methods are null.
	sb.append(indent + "/*********************************************************" + cr);
	sb.append(indent + " * WARNING: Generated code could be missing." + cr);
	sb.append(indent + " * In call to parseFieldMap(), generation method was null." + cr);
	sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
	sb.append(indent + " *********************************************************/" + cr);
	}

	Iterator<Entry<String, AmqpField>> itr = _map.entrySet().iterator();
	while (itr.hasNext())
	{
	Entry<String, AmqpField> entry = itr.next();
	String fieldName = entry.getKey();
	AmqpField field = entry.getValue();
	if (field.isCodeTypeConsistent(converter))
	{
	// All versions identical - Common declaration
	String domainName = field.getDomainMap().firstKey();
	AmqpVersionSet versionSet = field.getDomainMap().get(domainName);
	String codeType = converter.getGeneratedType(domainName, versionSet.first());
	if (commonGenerateMethod != null)
	{
	sb.append(commonGenerateMethod.generate(codeType, field, versionSet,
	indentSize, tabSize, itr.hasNext()));
	}
	}
	else if (mangledGenerateMethod != null) // Version-mangled
	{
	sb.append(mangledGenerateMethod.generate(field, indentSize, tabSize,
	itr.hasNext()));
	}
	}
	return sb.toString();
	}

	public String parseFieldMapOrdinally(GenerateMethod generateMethod, BitFieldGenerateMethod bitGenerateMethod,
	int indentSize, int tabSize, Generator codeGenerator)
	{
	String indent = Utils.createSpaces(indentSize);
	String cr = Utils.LINE_SEPARATOR;
	StringBuffer sb = new StringBuffer();

	// Generate warnings in code if required methods are null.
	if (generateMethod == null \|\| bitGenerateMethod == null)
	{
	sb.append(indent + "/***********************************************" + cr);
	sb.append(indent + " * WARNING: In call to parseFieldMapOrdinally():" + cr);
	if (generateMethod == null)
	{
	sb.append(indent + " * => generateMethod is null." + cr);
	}
	if (bitGenerateMethod == null)
	{
	sb.append(indent + " * => bitGenerateMethod is null." + cr);
	}
	sb.append(indent + " * Generated code could be missing." + cr);
	sb.append(indent + " * Check for NoSuchMethodException on startup." + cr);
	sb.append(indent + " ***********************************************/" + cr);
	}

	/* We must process elements in ordinal order because adjacent booleans (bits)
	* must be combined into a single byte (in groups of up to 8). Start with shared
	* declarations until an ordinal divergence is found. (For most methods where
	* there is no difference between versions, this will simplify the generated
	* code. */

	ArrayList<String> bitFieldList = new ArrayList<String>();
	boolean ordinalDivergenceFlag = false;
	int ordinal = 0;
	while (ordinal < size() && !ordinalDivergenceFlag)
	{
	/* Since the getFieldMapOrdinal() function may map more than one Field to
	* an ordinal, the number of ordinals may be less than the total number of
	* fields in the fieldMap. Check for empty fieldmaps... */
	AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(ordinal);
	if (ordinalFieldMap.size() > 0)
	{
	if (ordinalFieldMap.isDomainConsistent(codeGenerator, getVersionSet()))
	{
	String fieldName = ordinalFieldMap.getFirstFieldName();
	String domain = ordinalFieldMap._map.get(fieldName).getDomainMap().firstKey();

	String domainType = codeGenerator.getDomainType(domain,
	codeGenerator.getVersionSet().first());

	if (domainType.compareTo("bit") == 0)
	{
	bitFieldList.add(fieldName);
	}
	else if (bitFieldList.size() > 0)
	{
	// End of bit types - handle deferred bit type generation
	if (bitGenerateMethod != null)
	{
	sb.append(bitGenerateMethod.generate(bitFieldList, ordinal,
	indentSize, tabSize));
	}
	bitFieldList.clear();
	}
	if (!ordinalDivergenceFlag)
	{
	// Defer generation of bit types until all adjacent bits have been
	// accounted for.
	if (bitFieldList.size() == 0 && generateMethod != null)
	{
	sb.append(generateMethod.generate(domainType, fieldName, ordinal,
	indentSize, tabSize));
	}
	}
	ordinal++;
	}
	else
	{
	ordinalDivergenceFlag = true;
	}
	}
	}

	// Check if there is still more to do under a version-specific breakout
	if (ordinalDivergenceFlag && ordinal < size())
	{
	// 1. Cycle through all versions in order, create outer if(version) structure
	AmqpVersion[] versionArray = new AmqpVersion[getVersionSet().size()];
	getVersionSet().toArray(versionArray);
	for (int v = 0; v < versionArray.length; v++)
	{
	sb.append(indent);
	if (v > 0)
	{
	sb.append("else ");
	}
	sb.append("if (major == " + versionArray[v].getMajor() + " && minor == " +
	versionArray[v].getMinor() + ")" + cr);
	sb.append(indent + "{" + cr);

	// 2. Cycle though each ordinal from where we left off in the loop above.
	ArrayList<String> bitFieldList2 = new ArrayList<String>(bitFieldList);
	for (int o = ordinal; o < size(); o++)
	{
	AmqpFieldMap ordinalFieldMap = getFieldMapForOrdinal(o);
	if (ordinalFieldMap.size() > 0)
	{
	// 3. Cycle through each of the fields that have this ordinal.
	Iterator<Map.Entry<String, AmqpField>> i = ordinalFieldMap._map.entrySet().iterator();
	while (i.hasNext())
	{

	Map.Entry<String, AmqpField> entry = i.next();
	AmqpField field = entry.getValue();
	String fieldName = entry.getKey();

	// 4. Some fields may have more than one ordinal - match by both
	// ordinal and version.
	Iterator<Integer> j = field.getOrdinalMap().keySet().iterator();
	while (j.hasNext())
	{
	int thisOrdinal = j.next();
	AmqpVersionSet v1 = field.getOrdinalMap().get(thisOrdinal);
	if (thisOrdinal == o && v1.contains(versionArray[v]))
	{
	// 5. Now get the domain for this version
	int domainCntr = 0;
	Iterator<String> k = field.getDomainMap().keySet().iterator();
	while (k.hasNext())
	{
	// Mangle domain-divergent field names
	String mangledFieldName = fieldName;
	if (field.getDomainMap().size() > 1)
	{
	mangledFieldName += "_" + (domainCntr++);
	}
	String domainName = k.next();
	AmqpVersionSet v2 = field.getDomainMap().get(domainName);
	if (v2.contains(versionArray[v]))
	{
	// 6. (Finally!!) write the declaration
	String domainType = codeGenerator.getDomainType(domainName,
	versionArray[v]);
	if (domainType.compareTo("bit") == 0)
	{
	bitFieldList2.add(mangledFieldName);
	}
	else if (bitFieldList2.size() > 0)
	{
	// End of bit types - handle deferred bit type generation
	if (bitGenerateMethod != null)
	{
	sb.append(bitGenerateMethod.generate(
	bitFieldList2, o, indentSize + tabSize,
	tabSize));
	}
	bitFieldList2.clear();
	}
	// Defer generation of bit types until all adjacent bits have
	// been accounted for.
	if (bitFieldList2.size() == 0 && generateMethod != null)
	{
	sb.append(generateMethod.generate(domainType,
	mangledFieldName, o, indentSize + tabSize, tabSize));
	}
	}
	}
	}
	}
	}
	}
	}
	// Check for remaining deferred bits
	if (bitFieldList2.size() > 0 && bitGenerateMethod != null)
	{
	sb.append(bitGenerateMethod.generate(bitFieldList2, size(),
	indentSize + tabSize, tabSize));
	}
	sb.append(indent + "}" + cr);
	}
	}
	// Check for remaining deferred bits
	else if (bitFieldList.size() > 0 && bitGenerateMethod != null)
	{
	sb.append(bitGenerateMethod.generate(bitFieldList, size(),
	indentSize, tabSize));
	}
	return sb.toString();
	}

	private String getFirstFieldName()
	{
	return _map.firstKey();
	}

	public boolean isVersionConsistent(AmqpVersionSet globalVersionSet)
	{
	for (String thisFieldName : _map.keySet())
	{
	AmqpField field = _map.get(thisFieldName);
	if (!field.isVersionConsistent(globalVersionSet))
	{
	return false;
	}
	}
	return true;
	}

	public boolean isVersionInterfaceConsistent(AmqpVersionSet globalVersionSet)
	{
	for (String thisFieldName : _map.keySet())
	{
	AmqpField field = _map.get(thisFieldName);
	if (!field.isVersionInterfaceConsistent(globalVersionSet))
	{
	return false;
	}
	}
	return true;
	}


	public AmqpVersionSet getVersionSet()
	{
	return _versionSet;
	}

	public Collection<AmqpField> values()
	{
	return _map.values();
	}

	public AmqpField get(String fieldName)
	{
	return _map.get(fieldName);
	}

	public void remove(String fieldName)
	{
	_map.remove(fieldName);
	}

	public Set<String> keySet()
	{
	return _map.keySet();
	}
	}