Registration( const char* optionName, bool byDefault = !T::isRewriter );<--- Class 'Registration < AutoMem >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < AutoMem >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < BadStatics >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < BadStatics >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < BlockBlock >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < BlockBlock >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < BufferAdd >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < BufferAdd >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < BuriedAssign >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < BuriedAssign >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CastToVoid >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CastToVoid >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ChangeToolsGen >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ChangeToolsGen >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CharRightShift >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CharRightShift >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CheckConfigMacros >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CheckConfigMacros >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CheckUnusedParams >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CheckUnusedParams >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ClassMemAccess >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ClassMemAccess >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CollapseIf >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CollapseIf >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CommaOperator >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CommaOperator >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ComparisonWithConstant >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ComparisonWithConstant >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConditionalString >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConditionalString >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstantParam >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstantParam >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstFields >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstFields >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstFieldsRewrite >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstFieldsRewrite >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstMethod >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstMethod >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstParams >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstParams >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstStringVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstStringVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstToBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstToBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConstVars >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConstVars >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ConvertLong >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ConvertLong >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CountUsersOfDefaultParams >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CountUsersOfDefaultParams >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CppunitAssertEquals >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CppunitAssertEquals >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < CStyleCast >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < CStyleCast >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < Data >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < Data >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DataMemberShadow >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DataMemberShadow >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DbgUnhandledException >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DbgUnhandledException >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DerefNullPtr >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DerefNullPtr >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DllPrivate >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DllPrivate >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DodgySwitch >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DodgySwitch >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DoubleConvert >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DoubleConvert >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DuplicateDefines >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DuplicateDefines >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DynCastVisibility >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DynCastVisibility >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < DynExcSpec >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < DynExcSpec >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ElideStringVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ElideStringVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < Empty >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < Empty >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < EmptyIf >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < EmptyIf >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ExpandableMethods >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ExpandableMethods >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ExpressionAlwaysZero >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ExpressionAlwaysZero >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < External >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < External >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ExternAndNotDefined >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ExternAndNotDefined >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ExternVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ExternVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < FailedDynCast >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < FailedDynCast >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < FakeBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < FakeBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < FinalClasses >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < FinalClasses >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < FinalProtected >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < FinalProtected >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < Flatten >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < Flatten >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < FragileDestructor >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < FragileDestructor >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < GetImplementationName >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < GetImplementationName >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < GetStr >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < GetStr >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ImplicitBoolConversion >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ImplicitBoolConversion >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < IncludeForm >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < IncludeForm >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < Indentation >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < Indentation >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < InlineFields >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < InlineFields >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < InlineSimpleMemberFunctions >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < InlineSimpleMemberFunctions >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < InlineVisible >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < InlineVisible >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < IntVsFloat >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < IntVsFloat >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < LiteralToBoolConversion >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < LiteralToBoolConversion >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < LogExceptionNicely >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < LogExceptionNicely >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < LoopVarTooSmall >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < LoopVarTooSmall >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < MakeShared >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < MakeShared >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < MapIndex >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < MapIndex >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < MemoryVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < MemoryVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < MergeClasses >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < MergeClasses >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < MethodCycles >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < MethodCycles >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < NamespaceIndentation >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < NamespaceIndentation >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < NestedUnnamed >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < NestedUnnamed >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration' has a constructor with 1 argument that is not explicit. [+]Class 'Registration' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < Nullptr >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < Nullptr >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < OnceVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < OnceVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < OslEndian >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < OslEndian >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < OverrideParam >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < OverrideParam >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < OverrideVirtual >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < OverrideVirtual >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < PassParamsByRef >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < PassParamsByRef >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < PassStuffByRef >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < PassStuffByRef >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration' has a constructor with 1 argument that is not explicit. [+]Class 'Registration' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration' has a constructor with 1 argument that is not explicit. [+]Class 'Registration' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < PointerBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < PointerBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < PrivateBase >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < PrivateBase >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < PtrVector >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < PtrVector >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RangedForCopy >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RangedForCopy >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RedundantPreprocessor >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RedundantPreprocessor >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RedundantCast >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RedundantCast >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RedundantFCast >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RedundantFCast >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RedundantInline >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RedundantInline >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RedundantPointerOps >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RedundantPointerOps >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RefCounting >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RefCounting >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ReferenceCasting >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ReferenceCasting >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < RenderContext >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < RenderContext >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ReservedId >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ReservedId >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ReturnConstant >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ReturnConstant >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ReturnConstVal >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ReturnConstVal >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SalCall >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SalCall >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SalLogAreas >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SalLogAreas >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SalUnicodeLiteral >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SalUnicodeLiteral >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SelfInit >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SelfInit >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SequenceLoop >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SequenceLoop >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SequentialAssign >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SequentialAssign >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SfxPoolItem >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SfxPoolItem >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < ShouldReturnBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < ShouldReturnBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SimplifyBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SimplifyBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SimplifyConstruct >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SimplifyConstruct >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SimplifyDynamicCast >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SimplifyDynamicCast >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SimplifyPointerToBool >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SimplifyPointerToBool >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SingleValFields >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SingleValFields >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StaticAccess >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StaticAccess >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StaticAnonymous >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StaticAnonymous >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StaticConstField >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StaticConstField >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StaticMethods >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StaticMethods >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StaticVar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StaticVar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StdFunction >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StdFunction >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringAdd >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringAdd >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringBuffer >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringBuffer >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringConcatAuto >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringConcatAuto >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringConcatLiterals >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringConcatLiterals >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringConstant >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringConstant >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringLoop >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringLoop >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < StringStatic >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < StringStatic >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < SubtleZeroInit >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < SubtleZeroInit >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < TypedefParam >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < TypedefParam >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnicodeToChar >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnicodeToChar >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnnecessaryCatchThrow >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnnecessaryCatchThrow >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnnecessaryOverride >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnnecessaryOverride >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnnecessaryParen >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnnecessaryParen >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnnecessaryVirtual >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnnecessaryVirtual >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnoAny >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnoAny >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnoQuery >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnoQuery >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnrefFun >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnrefFun >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnsignedCompare >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnsignedCompare >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedEnumConstants >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedEnumConstants >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedFields >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedFields >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedFieldsRemove >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedFieldsRemove >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedIndex >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedIndex >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedMember >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedMember >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedMethods >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedMethods >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedMethodsRemove >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedMethodsRemove >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedVariableCheck >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedVariableCheck >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedVariableMore >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedVariableMore >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UnusedVariablePlus >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UnusedVariablePlus >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < UseUniquePtr >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < UseUniquePtr >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < VCLWidgets >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < VCLWidgets >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < VirtualDead >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < VirtualDead >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < VirtualDown >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < VirtualDown >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < WeakBase >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < WeakBase >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < WeakObject >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < WeakObject >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < WriteOnlyVars >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < WriteOnlyVars >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'Registration < XmlImport >' has a constructor with 1 argument that is not explicit. [+]Class 'Registration < XmlImport >' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.