<!--
  ~ Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License").
  ~ You may not use this file except in compliance with the License.
  ~ A copy of the License is located at
  ~
  ~  http://aws.amazon.com/apache2.0
  ~
  ~ or in the "license" file accompanying this file. This file is distributed
  ~ on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  ~ express or implied. See the License for the specific language governing
  ~ permissions and limitations under the License.
  -->

<MessageCollection>
    <Detector class="software.amazon.awssdk.buildtools.findbugs.DisallowMethodCall" >
        <Details>This detector checks for method calls that are not allowed for use.</Details>
    </Detector>
    <Detector class="software.amazon.awssdk.buildtools.findbugs.ToBuilderIsCorrect" >
        <Details>This detector checks for correct CopyableBuilder definition.</Details>
    </Detector>

    <BugPattern type="SDK_BAD_METHOD_CALL">
        <ShortDescription>Bad method call</ShortDescription>

        <LongDescription>
            <![CDATA[
                {1} uses a method that is prohibited.
                The headers() and rawQueryParameters() methods create a deep copy of the data, which can result in
                significant memory pressure. Instead of retrieving a copy of the headers to look at it, use methods like
                hasHeaders(), firstMatchingHeader(...) or forEachHeader(..) which may be optimized in the type to avoid
                copying the data.
            ]]>
        </LongDescription>

        <Details>
            <![CDATA[
                The headers() and rawQueryParameters() methods create a deep copy of the data, which can result in
                significant memory pressure. Instead of retrieving a copy of the headers to look at it, use methods like
                hasHeaders(), firstMatchingHeader(...) or forEachHeader(..) which may be optimized in the type to avoid
                copying the data.
            ]]>
        </Details>
    </BugPattern>
    <BugCode abbrev="BM">Bad method call</BugCode>

    <BugPattern type="BAD_TO_BUILDER">
        <ShortDescription>Bad toBuilder implementation</ShortDescription>
        <LongDescription>Bad toBuilder implementation. See the SpotBugs logs for problem details.</LongDescription>
        <Details>Bad toBuilder implementation. See the SpotBugs logs for problem details.</Details>
    </BugPattern>
    <BugCode abbrev="BTB">Bad toBuilder implementation</BugCode>
</MessageCollection>
