diff options
Diffstat (limited to 'trunk/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java')
| -rw-r--r-- | trunk/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java | 452 |
1 files changed, 0 insertions, 452 deletions
diff --git a/trunk/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java b/trunk/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java deleted file mode 100644 index 0bb5e03a61..0000000000 --- a/trunk/qpid/gentools/src/org/apache/qpid/gentools/AmqpFieldMap.java +++ /dev/null @@ -1,452 +0,0 @@ -/* - * - * 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(); - } -} |