--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/apicompatanamdw/compatanalysercmd/headeranalyser/src/Issues.cpp Tue Jan 12 14:52:39 2010 +0530
@@ -0,0 +1,2757 @@
+/*
+* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <sstream>
+#include "Issues.h"
+#include "XMLStringConst.h"
+
+const char* KIgnoreInfoNone = "None";
+
+// Textual descriptions for the severity levels
+// Can be seen in the result xml
+const char* KSeverityNULL = "None";
+const char* KSeverityBBCBreak = "BBC Break";
+const char* KSeverityPossibleBBCBreak = "Possible BBC Break";
+const char* KSeverityFCBreak = "FC Break";
+const char* KSeverityPossibleFCBreak = "Possible FC Break";
+const char* KSeverityInformative = "Informative";
+
+// Table of severity descriptions levels for binary compatibility
+const char* KSeverityDesc[ESeverityCount] =
+{
+ KSeverityNULL,
+ KSeverityBBCBreak,
+ KSeverityPossibleBBCBreak,
+ KSeverityInformative,
+ KSeverityFCBreak,
+ KSeverityPossibleFCBreak
+};
+
+// Textual descriptions for the severity levels
+// Can be seen in the result xml
+const char* KSeveritySCNULL = "None";
+const char* KSeveritySCBreak = "SC Break";
+const char* KSeverityPossibleSCBreak = "Possible SC Break";
+const char* KSeveritySCInformative = "Informative";
+
+// Table of severity descriptions levels for source compatibility
+const char* KSeveritySCDesc[ESeveritySCCount] =
+{
+ KSeveritySCNULL,
+ KSeveritySCBreak,
+ KSeverityPossibleSCBreak,
+ KSeveritySCInformative
+};
+
+
+// Textual descriptions for the identities
+// Can be seen in the result xml
+const char* KIdentityClass = "Class";
+const char* KIdentityEnumeration = "Enumeration";
+const char* KIdentityExportedFunction = "Exported function";
+const char* KIdentityVirtualFunction = "Virtual function";
+const char* KIdentityStruct = "Struct";
+const char* KIdentityUnion = "Union";
+const char* KIdentityEnumerationValue = "Enumeration value";
+const char* KIdentityTypedef = "Typedef";
+const char* KIdentityVariable = "Constant";
+const char* KIdentityField = "Field";
+const char* KIdentityFieldInaccessible = "Field";
+const char* KIdentityFile = "File";
+const char* KIdentityMacro = "Macro";
+const char* KIdentityInlineFunction = "Inline function";
+const char* KIdentityVirtualTable= "Virtual table";
+const char* KIdentitySubobject = "Subobject";
+const char* KIdentityVirtualTablePointer = "Virtual table pointer";
+const char* KIdentityExportedInlineFunction = "Exported inline function";
+const char* KIdentityExportedVirtualFunction = "Exported virtual function";
+const char* KIdentityVirtualInlineFunction = "Virtual inline function";
+const char* KIdentityExportedVirtualInlineFunction = "Exported virtual inline function";
+const char* KIdentityStructMember = "Strcut member";
+
+
+// Table of the issue description
+const char* KIssueIdentityDesc[EIssueIdentityCount] =
+{
+ KIdentityClass,
+ KIdentityExportedFunction,
+ KIdentityInlineFunction,
+ KIdentityVirtualFunction,
+ KIdentityEnumeration,
+ KIdentityStruct,
+ KIdentityUnion,
+ KIdentityEnumerationValue,
+ KIdentityTypedef,
+ KIdentityVariable,
+ KIdentityField,
+ KIdentityFieldInaccessible,
+ KIdentityMacro,
+ KIdentityFile,
+ KIdentityVirtualTable,
+ KIdentitySubobject,
+ KIdentityVirtualTablePointer,
+ KIdentityExportedInlineFunction,
+ KIdentityExportedVirtualFunction,
+ KIdentityVirtualInlineFunction,
+ KIdentityExportedVirtualInlineFunction,
+ KIdentityStructMember
+};
+
+// Textual descriptions for the issue types
+// Can be seen in the result xml
+const char* KIssueTypeRemoval = "has been removed";
+const char* KIssueTypeAddition = "has been added";
+const char* KIssueTypeChange = "has been changed";
+const char* KIssueTypeSize = "has changed size";
+const char* KIssueTypeBaseSize = "has changed base size";
+const char* KIssueTypeAlign = "has changed alignment";
+const char* KIssueTypeParam = "has changed one of its parameters";
+const char* KIssueTypeParamConst = "has changed one of its parameters or funtion type";
+const char* KIssueTypeParamConst2 = "has changed one of its parameters or funtion type";
+const char* KIssueTypeReturn = "has changed its return value";
+const char* KIssueTypeReturnConst = "has changed its return value";
+const char* KIssueTypeReturnConst2 = "has changed its return value";
+const char* KIssueTypeAccess = "has more restricted access level";
+const char* KIssueTypeInheritance = "has changes in inheritance";
+const char* KIssueTypeOffset = "has changed its offset";
+const char* KIssueTypeOrderChange = "order has changed";
+const char* KIssueTypeCompilationError = "has compilation errors";
+const char* KIssueTypeNotAnalysed = "could not be analysed";
+const char* KIssueTypeUnderConstruction = "analysis under construction";
+const char* KIssueTypeVirtualBases = "has virtual bases";
+const char* KIssueTypeChangeInType = "has changed its type";
+const char* KIssueTypeChangeInInitialisation = "has changed its initialisation value";
+const char* KIssueTypeNewOverride = "overridden in derivable class";
+//const char* KIssueTypeRemovedOverride = "removed override in derivable class";
+const char* KIssueTypeEmpty = "contains nothing to be analysed";
+
+// Table of the issue type descriptions
+const char* KIssueTypeDesc[EIssueTypeCount] =
+{
+ KIssueTypeRemoval,
+ KIssueTypeAddition,
+ KIssueTypeChange,
+ KIssueTypeSize,
+ KIssueTypeAlign,
+ KIssueTypeParam,
+ KIssueTypeReturn,
+ KIssueTypeAccess,
+ KIssueTypeInheritance,
+ KIssueTypeOffset,
+ KIssueTypeOrderChange,
+ KIssueTypeChangeInType,
+ KIssueTypeChangeInInitialisation,
+ KIssueTypeCompilationError,
+ KIssueTypeNotAnalysed,
+ KIssueTypeVirtualBases,
+ KIssueTypeNewOverride,
+// KIssueTypeRemovedOverride,
+ KIssueTypeEmpty,
+ KIssueTypeBaseSize,
+ KIssueTypeUnderConstruction,
+ KIssueTypeParamConst,
+ KIssueTypeParamConst2,
+ KIssueTypeReturnConst,
+ KIssueTypeReturnConst2
+};
+
+template <typename T>
+string GetIgnoreInfoFromAttribute(const HANodeIterator& node, const T* attribute)
+{
+ string ignoreinfo="";
+
+ const XMLCh* idx = node.GetAttribute(attribute);
+ if (idx)
+ {
+ ignoreinfo = toString(idx);
+ }
+ return ignoreinfo;
+}
+
+/**
+* In the following the severities and ignore information of issues are defined through template mechanism.
+* This allows linking time checking that we have not forgot to define meaningful information for new issues.
+* In order to modify severity information or ignore information first determine the TIssueIdentity and TIssueType
+* of the issue and then find the correct function (BCseverityAccessible<TIssueIdentity,TIssueType>,
+* SCseverityAccessible<TIssueIdentity,TIssueType> and ignoreInfo<TIssueIdentity,TIssueType>) and modify the function
+* definition to match with the severity and ignore information.
+
+* The BCseverityAccessible function includes parameter [accessible] that defines if the element is directly accessible
+* or only through some inline method.
+*/
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+//Size,
+//ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return GetIgnoreInfoFromAttribute(current,KXMLSizeString);
+}
+
+//Align,
+//ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* align = current.GetAttribute(KXMLAlignString);
+ if (align)
+ {
+ ignoreinfo = toString(align);
+ }
+ return ignoreinfo;
+}
+
+//Access,
+//ESeverityInformative,
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+//Inheritance,
+//ESeverityPossibleBBCBreak,
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeInheritance>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ DOMNodeList* childs = current.GetElementsByTagName(KXMLBaseString);
+
+ XMLSize_t childcount = childs->getLength();
+
+ for (unsigned int i = 0; i < childcount; ++i)
+ {
+ HANodeIterator baselineit(current);
+ baselineit.current = childs->item(i);
+
+ ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLAccessString);
+ ignoreinfo += " ";
+
+ if (baselineit.CheckForBooleanAttribute(KXMLVirtualString) )
+ {
+ ignoreinfo += "virtual ";
+ }
+
+ ignoreinfo += GetTypeName(baselineit);
+ ignoreinfo += ";";
+ }
+
+ return ignoreinfo;
+}
+
+//KIssueNotAnalysed
+//ESeverityInformative,
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeNotAnalysed>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+//EIssueTypeVirtualBases
+//Informative
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeVirtualBases>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+//EIssueTypeBaseSize
+//ESeverityBBCBreak
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityClass,EIssueTypeBaseSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const NodeIndex::dtable_t& datafields = ClassGenerateDataMemberTable(current);
+ int basesize = ClassBaseSize(current,datafields);
+
+ ostringstream stream;
+ stream << basesize << flush;
+ ignoreinfo = stream.str();
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityEnumeration,
+// Removal,
+// {ESeverityPossibleFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityPossibleFCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+//Change,
+//SeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityPossibleFCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeChange>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ DOMNodeList* baselinechilds = current.GetElementsByTagName(KXMLEnumValueString);
+ XMLSize_t baselinechildcount = baselinechilds->getLength();
+ unsigned int i = 0;
+ for (i = 0; i < baselinechildcount; ++i)
+ {
+ HANodeIterator baselineit(current);
+ baselineit.current = baselinechilds->item(i);
+ ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLNameString);
+ ignoreinfo += "=";
+ ignoreinfo += GetIgnoreInfoFromAttribute(baselineit,KXMLInitString);
+ ignoreinfo += ";";
+ }
+
+ return ignoreinfo;
+}
+
+//Size,
+//ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh* size = current.GetAttribute(KXMLSizeString);
+ if (size)
+ {
+ ignoreinfo = toString(size);
+ }
+ return ignoreinfo;
+}
+
+//Align,
+//ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh* align = current.GetAttribute(KXMLAlignString);
+ if (align)
+ {
+ ignoreinfo = toString(align);
+ }
+ return ignoreinfo;
+}
+
+//Access,
+//ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityEnumeration,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityExportedFunction,
+// Removal,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// Param,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParam>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ DOMElement * element = static_cast<DOMElement*>(current.current);
+ DOMNodeList* childs = element->getChildNodes();
+
+ XMLSize_t childcount = childs->getLength();
+
+ unsigned int i = 0;
+ for (i = 0; i < childcount; ++i)
+ {
+ DOMNode* child = childs->item(i);
+ HANodeIterator childit(current);
+ childit.current = child;
+
+ short nodetype = childit->getNodeType();
+ if (nodetype == DOMNode::ELEMENT_NODE)
+ {
+ const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);
+ if ( defaultval )
+ {
+ ignoreinfo += toString(defaultval);
+ }
+ else
+ {
+ }
+ ignoreinfo += ";";
+ }
+
+ }
+ return ignoreinfo;
+}
+
+// Param non-const to const,
+// ESeverityNULL,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityNULL;
+ }
+ return ESeverityNULL;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ //ignoreinfo = GenerateFunctionSignature(*this);
+ DOMElement * element = static_cast<DOMElement*>(current.current);
+ DOMNodeList* childs = element->getChildNodes();
+
+ XMLSize_t childcount = childs->getLength();
+
+ unsigned int i = 0;
+ for (i = 0; i < childcount; ++i)
+ {
+ DOMNode* child = childs->item(i);
+ HANodeIterator childit(current);
+ childit.current = child;
+
+ short nodetype = childit->getNodeType();
+ if (nodetype == DOMNode::ELEMENT_NODE)
+ {
+ const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);
+ if ( defaultval )
+ {
+ ignoreinfo += toString(defaultval);
+ }
+ else
+ {
+ }
+ ignoreinfo += ";";
+ }
+
+ }
+ return ignoreinfo;
+}
+
+// Param const to non-const,
+// ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ //ignoreinfo = GenerateFunctionSignature(*this);
+ DOMElement * element = static_cast<DOMElement*>(current.current);
+ DOMNodeList* childs = element->getChildNodes();
+
+ XMLSize_t childcount = childs->getLength();
+
+ unsigned int i = 0;
+ for (i = 0; i < childcount; ++i)
+ {
+ DOMNode* child = childs->item(i);
+ HANodeIterator childit(current);
+ childit.current = child;
+
+ short nodetype = childit->getNodeType();
+ if (nodetype == DOMNode::ELEMENT_NODE)
+ {
+ const XMLCh * defaultval = childit.GetAttribute(KXMLDefaultString);
+ if ( defaultval )
+ {
+ ignoreinfo += toString(defaultval);
+ }
+ else
+ {
+ }
+ ignoreinfo += ";";
+ }
+
+ }
+ return ignoreinfo;
+}
+
+// Return,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturn>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);
+ if (baselineid)
+ {
+ HANodeIterator newbaseline(current);
+ bool ret1=newbaseline.FindNodeById(baselineid);
+ if (ret1)
+ {
+ ignoreinfo += GetTypeName(newbaseline);
+ }
+ }
+
+ return ignoreinfo;
+}
+
+// Return const to non-const,
+// ESeverityNULL,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityNULL;
+ }
+ return ESeverityNULL;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);
+ if (baselineid)
+ {
+ HANodeIterator newbaseline(current);
+ bool ret1=newbaseline.FindNodeById(baselineid);
+ if (ret1)
+ {
+ ignoreinfo += GetTypeName(newbaseline);
+ }
+ }
+
+ return ignoreinfo;
+}
+
+// Return non-const to const,
+// ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh * baselineid = current.GetAttribute(KXMLReturnsString);
+ if (baselineid)
+ {
+ HANodeIterator newbaseline(current);
+ bool ret1=newbaseline.FindNodeById(baselineid);
+ if (ret1)
+ {
+ ignoreinfo += GetTypeName(newbaseline);
+ }
+ }
+
+ return ignoreinfo;
+}
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityInlineFunction,
+// Removal,
+// {ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeRemoval>(baseline,current);
+}
+
+// Param,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParam>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParam>(baseline,current);
+}
+
+// Param non-const to const,
+// ESeverityNULL,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityNULL;
+ }
+ return ESeverityNULL;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParamConst>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst>(baseline,current);
+}
+
+// Param const to non-const,
+// ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeParamConst2>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(baseline,current);
+}
+
+// Return,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturn>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturn>(baseline,current);
+}
+
+// Return const to non-const,
+// ESeverityNULL,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityNULL;
+ }
+ return ESeverityNULL;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturnConst>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(baseline,current);
+}
+
+// Return non-const to const,
+// ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeReturnConst2>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(baseline,current);
+}
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityInlineFunction,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeAccess>(baseline,current);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityExportedVirtualFunction,
+// Removal,
+// {ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityExportedVirtualFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityExportedVirtualFunction,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualFunction,
+// Removal,
+// {ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// Addition,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeAddition>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// Param,
+// ESeverityBBCBreak,
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeParam>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeParam>(baseline,current);
+}
+
+// Return,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeReturn>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ return ignoreInfo<EIssueIdentityExportedFunction,EIssueTypeReturn>(baseline,current);
+}
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;}
+
+// OrderChange,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeOrderChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeOrderChange>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ const XMLCh* idx = current.GetAttribute(KXMLBBCVirtualFunctionIndex);
+ if (idx)
+ {
+ ignoreinfo = toString(idx);
+ }
+ return ignoreinfo;
+}
+
+
+// KIssueTypeNewOverride,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeNewOverride>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualFunction,EIssueTypeNewOverride>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ return ignoreinfo;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityStruct,
+// Removal,
+// {ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeRemoval>(baseline,current);
+}
+
+// BaseSize,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeBaseSize>(bool accessible)
+{
+ return BCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(accessible);
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeBaseSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeBaseSize>(baseline,current);
+}
+
+// EIssueTypeNotAnalysed
+// ESeverityInformative
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeNotAnalysed>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeNotAnalysed>(baseline,current);
+}
+
+
+// Size,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeSize>(baseline,current);
+}
+// Align,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeAlign>(baseline,current);
+}
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeAccess>(baseline,current);
+}
+// Inheritance,
+// ESeverityPossibleBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeInheritance>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeInheritance>(baseline,current);
+}
+
+//EIssueTypeVirtualBases
+//Informative
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityStruct,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityStruct,EIssueTypeVirtualBases>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityUnion,
+// Removal,
+// {ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeInheritance>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+// Size,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return GetIgnoreInfoFromAttribute(current,KXMLSizeString);
+}
+
+// BaseSize,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeBaseSize>(bool accessible)
+{
+ return BCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(accessible);
+}
+
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeBaseSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityClass,EIssueTypeBaseSize>(baseline,current);
+}
+
+
+// Align,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeAlign>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return GetIgnoreInfoFromAttribute(current,KXMLAlignString);
+/* string ignoreinfo=KIgnoreInfoNone;
+ ignoreinfo = toString(current.GetAttribute(KXMLAlignString));
+ return ignoreinfo;
+ */
+}
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+// KIssueNotAnalysed
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeNotAnalysed>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+//EIssueTypeVirtualBases
+//Informative
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityUnion,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityUnion,EIssueTypeVirtualBases>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityEnumerationValue,
+// Removal,
+// {ESeverityFCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityPossibleFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityEnumerationValue,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+// ChangeInInitialisation, ,
+// ESeverityFCBreak, ,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeChangeInInitialisation>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityPossibleFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityEnumerationValue,EIssueTypeChangeInInitialisation>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return GetIgnoreInfoFromAttribute(current,KXMLInitString);
+}
+
+//Access,
+//ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityEnumerationValue,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityTypedef,
+// Removal,
+// {ESeverityPossibleBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityTypedef,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityTypedef,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// Change,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityTypedef,EIssueTypeChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityTypedef,EIssueTypeChange>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh * nodetypeid = current.GetAttribute(KXMLTypeString);
+ if (nodetypeid)
+ {
+ HANodeIterator typenode(current);
+ bool ret1=typenode.FindNodeById(nodetypeid);
+ if (ret1)
+ {
+ ignoreinfo = GetTypeName(typenode);
+ }
+ }
+ return ignoreinfo;
+}
+//Access,
+//ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityTypedef,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityTypedef,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVariable,
+// Removal,
+// {ESeverityPossibleBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVariable,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVariable,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// ChangeInType,
+// ESeverityBBCBreak,
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVariable,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityPossibleBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVariable,EIssueTypeChangeInType>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh * nodetypeid = current.GetAttribute(KXMLTypeString);
+ if (nodetypeid)
+ {
+ HANodeIterator typenode(current);
+ bool ret1=typenode.FindNodeById(nodetypeid);
+ if (ret1)
+ {
+ ignoreinfo = GetTypeName(typenode);
+ }
+ }
+
+ return ignoreinfo;
+}
+
+// ChangeInInitialisation, ,
+// ESeverityFCBreak, ,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVariable,EIssueTypeChangeInInitialisation>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleFCBreak;
+ }
+ return ESeverityPossibleFCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVariable,EIssueTypeChangeInInitialisation>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ::GetIgnoreInfoFromAttribute(current,KXMLInitString);
+}
+
+//Access,
+//ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVariable,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityVariable,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityField,
+// Removal,
+// {ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+// Addition,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeAddition>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ ignoreinfo += toString(current.GetAttribute(KXMLContextString));
+ ignoreinfo += ";";
+ const XMLCh * nodetypeid = current.GetAttribute(KXMLTypeString);
+ if (nodetypeid)
+ {
+ HANodeIterator typenode(current);
+ bool ret1=typenode.FindNodeById(nodetypeid);
+ if (ret1)
+ {
+ ignoreinfo += GetTypeName(typenode);
+ }
+ }
+ return ignoreinfo;
+}
+
+// Size,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh * size = GetSize(current);
+ if (size)
+ {
+ ignoreinfo += toString( size );
+ }
+
+ return ignoreinfo;
+}
+
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+ const XMLCh* access = current.GetAttribute(KXMLAccessString);
+ if (access)
+ {
+ ignoreinfo = toString(access);
+ }
+ return ignoreinfo;
+}
+
+// Offset,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeOffset>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeOffset>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ::GetIgnoreInfoFromAttribute(current,KXMLContextString);
+}
+
+
+// ChangeInType,
+// ESeverityBBCBreak,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityField,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityField,EIssueTypeChangeInType>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo="";
+
+ const XMLCh * nodetypeid = current.GetAttribute(KXMLTypeString);
+ if (nodetypeid)
+ {
+ HANodeIterator typenode(current);
+ bool ret1=typenode.FindNodeById(nodetypeid);
+ if (ret1)
+ {
+ ignoreinfo += GetTypeName(typenode);
+ }
+ }
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityFieldInaccessible,
+// Removal,
+// {ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeRemoval>(baseline, current);
+}
+
+// Addition,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeAddition>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeAddition>(baseline, current);
+}
+
+
+// Size,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeSize>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeSize>(baseline, current);
+}
+
+// Access,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeAccess>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeAccess>(baseline, current);
+}
+
+// Offset,
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeOffset>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeOffset>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeOffset>(baseline, current);
+}
+
+// ChangeInType,
+// ESeverityInformative, ,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFieldInaccessible,EIssueTypeChangeInType>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ return ignoreInfo<EIssueIdentityField,EIssueTypeChangeInType>(baseline, current);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityFile,
+// KIssueNotAnalysed
+// ESeverityInformative,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFile,EIssueTypeEmpty>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityInformative;
+ }
+ return ESeverityInformative;
+}
+template <> string ignoreInfo<EIssueIdentityFile,EIssueTypeEmpty>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityFile,EIssueTypeUnderConstruction>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeverityPossibleBBCBreak;
+ }
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityFile,EIssueTypeUnderConstruction>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualTable,
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualTable,EIssueTypeChange>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualTable,EIssueTypeChange>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//KIdentitySubobject
+//Offset
+//ESeverityBBCBreak
+template <> TBCSeverity BCseverityAccessible<EIssueIdentitySubobject,EIssueTypeOffset>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentitySubobject,EIssueTypeOffset>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+//Removal
+//ESeverityBBCBreak
+template <> TBCSeverity BCseverityAccessible<EIssueIdentitySubobject,EIssueTypeRemoval>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentitySubobject,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualTablePointer
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeAddition>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualTablePointer,EIssueTypeAddition>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeRemoval>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+
+template <> string ignoreInfo<EIssueIdentityVirtualTablePointer,EIssueTypeRemoval>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+template <> TBCSeverity BCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeOffset>(bool accessible)
+{
+ return ESeverityBBCBreak;
+}
+template <> string ignoreInfo<EIssueIdentityVirtualTablePointer,EIssueTypeOffset>(const HANodeIterator& baseline,const HANodeIterator& current)
+{
+ string ignoreinfo=KIgnoreInfoNone;
+
+ return ignoreinfo;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityClass
+//Removal
+//ESeveritySCBreak
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//Size,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Align,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Access,
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//Inheritance,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//KIssueNotAnalysed
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//EIssueTypeVirtualBases
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//EIssueTypeBaseSize
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityEnumeration,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//Change,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Size,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Align,
+//ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Access,
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumeration,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityExportedFunction,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param non-const to const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param const to non-const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeParamConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return const to non-const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return non-const to const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeReturnConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityInlineFunction,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param,
+// ESeverityInformative,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param non-const to const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Param const to non-const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeParamConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return const to non-const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return non-const to const,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeReturnConst2>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityInlineFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityExportedVirtualFunction,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityExportedVirtualFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualFunction,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Addition,
+// ESeveritySCBNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Param,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeParam>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Return,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeReturn>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// OrderChange,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeOrderChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// KIssueTypeNewOverride,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualFunction,EIssueTypeNewOverride>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityStruct,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// BaseSize,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeBaseSize>(bool accessible)
+{
+ return SCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(accessible);
+}
+
+//EIssueTypeNotAnalysed
+//ESeveritySCBreak
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Size,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Align,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Inheritance,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//EIssueTypeVirtualBases
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityStruct,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityUnion,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Inheritance,
+// {ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeInheritance>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Size,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// BaseSize,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeBaseSize>(bool accessible)
+{
+ return SCseverityAccessible<EIssueIdentityClass,EIssueTypeBaseSize>(accessible);
+}
+
+// Align,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeAlign>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// KIssueNotAnalysed
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeNotAnalysed>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//EIssueTypeVirtualBases
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityUnion,EIssueTypeVirtualBases>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityEnumerationValue,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// ChangeInInitialisation, ,
+// ESeveritySCNULL, ,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeChangeInInitialisation>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Access,
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityEnumerationValue,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityTypedef,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityTypedef,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Change,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityTypedef,EIssueTypeChange>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+//Access,
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityTypedef,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVariable,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVariable,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// ChangeInType,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVariable,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// ChangeInInitialisation, ,
+// ESeveritySCNULL, ,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVariable,EIssueTypeChangeInInitialisation>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+//Access,
+//ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVariable,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityField,
+// Removal,
+// {ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Addition,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Size,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Access,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+// Offset,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeOffset>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// ChangeInType,
+// ESeveritySCBreak,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityField,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityFieldInaccessible,
+// Removal,
+// {ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeRemoval>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Addition,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeAddition>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Size,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeSize>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Access,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeAccess>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// Offset,
+// ESeveritySCNULL,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeOffset>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+// ChangeInType,
+// ESeveritySCNULL, ,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFieldInaccessible,EIssueTypeChangeInType>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityFile,
+// KIssueNotAnalysed
+// ESeveritySCInformative,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFile,EIssueTypeEmpty>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCInformative;
+}
+
+// EIssueTypeUnderConstruction
+// ESeveritySCInformative
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityFile,EIssueTypeUnderConstruction>(bool accessible)
+{
+ if ( !accessible )
+ {
+ return ESeveritySCNULL;
+ }
+ return ESeveritySCInformative;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualTable,
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualTable,EIssueTypeChange>(bool accessible)
+{
+ return ESeveritySCNULL;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//KIdentitySubobject
+//Offset
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentitySubobject,EIssueTypeOffset>(bool accessible)
+{
+ return ESeveritySCNULL;
+}
+
+//Removal
+//ESeveritySCBreak
+template <> TSCSeverity SCseverityAccessible<EIssueIdentitySubobject,EIssueTypeRemoval>(bool accessible)
+{
+ return ESeveritySCBreak;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EIssueIdentityVirtualTablePointer
+//Addition
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeAddition>(bool accessible)
+{
+ return ESeveritySCNULL;
+}
+
+//Removal
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeRemoval>(bool accessible)
+{
+ return ESeveritySCNULL;
+}
+
+//Offset
+//ESeveritySCNULL
+template <> TSCSeverity SCseverityAccessible<EIssueIdentityVirtualTablePointer,EIssueTypeOffset>(bool accessible)
+{
+ return ESeveritySCNULL;
+}
+
+