lounge_lizard 0.1.0

data/ext/drafter/ext/snowcrash/src/PayloadParser.h

@@ -0,0 +1,733 @@
+//
+//  PayloadParser.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/7/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_PARSEPAYLOAD_H
+#define SNOWCRASH_PARSEPAYLOAD_H
+
+#include "SectionParser.h"
+#include "RegexMatch.h"
+#include "AssetParser.h"
+#include "HeadersParser.h"
+#include "ParametersParser.h"
+#include "AttributesParser.h"
+
+/** Media type in brackets regex */
+#define MEDIA_TYPE "([[:blank:]]*\\(([^\\)]*)\\))"
+
+namespace snowcrash {
+
+    /** Internal type alias for Collection iterator of Response */
+    typedef Collection<Response>::const_iterator ResponseIterator;
+    typedef Collection<Request>::const_iterator RequestIterator;
+
+    /// Payload signature
+    enum PayloadSignature {
+        NoPayloadSignature = 0,
+        RequestPayloadSignature,    /// < Request payload.
+        ResponsePayloadSignature,   /// < Response payload.
+        ModelPayloadSignature,      /// < Resource Model payload.
+        UndefinedPayloadSignature = -1
+    };
+
+    /** Request matching regex */
+    const char* const RequestRegex = "^[[:blank:]]*[Rr]equest([[:blank:]]" SYMBOL_IDENTIFIER ")?" MEDIA_TYPE "?[[:blank:]]*";
+
+    /** Response matching regex */
+    const char* const ResponseRegex = "^[[:blank:]]*[Rr]esponse([[:blank:][:digit:]]+)?" MEDIA_TYPE "?[[:blank:]]*";
+
+    /** Model matching regex */
+    const char* const  ModelRegex = "^[[:blank:]]*(" SYMBOL_IDENTIFIER "[[:blank:]]+)?[Mm]odel" MEDIA_TYPE "?[[:blank:]]*$";
+
+    /**
+     * Payload Section Processor
+     */
+    template<>
+    struct SectionProcessor<Payload> : public SectionProcessorBase<Payload> {
+
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     const ParseResultRef<Payload>& out) {
+
+            mdp::ByteBuffer signature, remainingContent;
+            signature = GetFirstLine(node->text, remainingContent);
+
+            parseSignature(node, pd, signature, out);
+
+            // WARN: missing status code
+            if (out.node.name.empty() &&
+                (pd.sectionContext() == ResponseSectionType || pd.sectionContext() == ResponseBodySectionType)) {
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning("missing response HTTP status code, assuming 'Response 200'",
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
+                out.node.name = "200";
+            }
+
+            if (!remainingContent.empty()) {
+                if (!isAbbreviated(pd.sectionContext())) {
+                    out.node.description = remainingContent;
+
+                    if (pd.exportSourceMap() && !out.node.description.empty()) {
+                        out.sourceMap.description.sourceMap.append(node->sourceMap);
+                    }
+                } else if (!parseModelReference(node, pd, remainingContent, out)) {
+
+                    // NOTE: NOT THE CORRECT WAY TO DO THIS
+                    // https://github.com/apiaryio/snowcrash/commit/a7c5868e62df0048a85e2f9aeeb42c3b3e0a2f07#commitcomment-7322085
+                    pd.sectionsContext.push_back(BodySectionType);
+                    CodeBlockUtility::signatureContentAsCodeBlock(node, pd, out.report, out.node.body);
+                    TwoNewLines(out.node.body);
+                    pd.sectionsContext.pop_back();
+
+                    if (pd.exportSourceMap() && !out.node.body.empty()) {
+                        out.sourceMap.body.sourceMap.append(node->sourceMap);
+                    }
+                }
+            }
+
+            if (pd.exportSourceMap()) {
+                out.sourceMap.sourceMap = node->sourceMap;
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
+                                                   const MarkdownNodes& siblings,
+                                                   SectionParserData& pd,
+                                                   const ParseResultRef<Payload>& out) {
+
+            mdp::ByteBuffer content;
+
+            if (!out.node.reference.id.empty()) {
+                //WARN: ignoring extraneous content after model reference
+                std::stringstream ss;
+
+                ss << "ignoring extraneous content after model reference";
+                ss << ", expected model reference only e.g. '[" << out.node.reference.id << "][]'";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      IgnoringWarning,
+                                                      sourceMap));
+            } else {
+
+                if (!out.node.body.empty() ||
+                    node->type != mdp::ParagraphMarkdownNodeType ||
+                    !parseModelReference(node, pd, node->text, out)) {
+
+                    // NOTE: NOT THE CORRECT WAY TO DO THIS
+                    // https://github.com/apiaryio/snowcrash/commit/a7c5868e62df0048a85e2f9aeeb42c3b3e0a2f07#commitcomment-7322085
+                    pd.sectionsContext.push_back(BodySectionType);
+                    CodeBlockUtility::contentAsCodeBlock(node, pd, out.report, content);
+                    pd.sectionsContext.pop_back();
+
+                    out.node.body += content;
+
+                    if (pd.exportSourceMap() && !content.empty()) {
+                        out.sourceMap.body.sourceMap.append(node->sourceMap);
+                    }
+                }
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<Payload>& out) {
+
+            switch (pd.sectionContext()) {
+                case HeadersSectionType:
+                {
+                    ParseResultRef<Headers> headers(out.report, out.node.headers, out.sourceMap.headers);
+                    return HeadersParser::parse(node, siblings, pd, headers);
+                }
+
+                case AttributesSectionType:
+                {
+                    ParseResultRef<Attributes> attributes(out.report, out.node.attributes, out.sourceMap.attributes);
+                    return AttributesParser::parse(node, siblings, pd, attributes);
+                }
+
+                case ParametersSectionType:
+                {
+                    if (pd.parentSectionContext() != RequestSectionType) {
+                        // WARN: Only request section can have parameters section
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                        out.report.warnings.push_back(Warning("ignoring parameters section in a non request payload section",
+                                                              IgnoringWarning,
+                                                              sourceMap));
+
+                        return ++MarkdownNodeIterator(node);
+                    }
+
+                    ParseResultRef<Parameters> parameters(out.report, out.node.parameters, out.sourceMap.parameters);
+                    return ParametersParser::parse(node, siblings, pd, parameters);
+                }
+
+                case BodySectionType:
+                {
+                    if (!out.node.body.empty()) {
+                        // WARN: Multiple body section
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                        out.report.warnings.push_back(Warning("ignoring additional 'body' content, it is already defined",
+                                                              RedefinitionWarning,
+                                                              sourceMap));
+                    }
+
+                    ParseResultRef<Asset> asset(out.report, out.node.body, out.sourceMap.body);
+                    return AssetParser::parse(node, siblings, pd, asset);
+                }
+
+                case SchemaSectionType:
+                {
+                    if (!out.node.schema.empty()) {
+                        // WARN: Multiple schema section
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                        out.report.warnings.push_back(Warning("ignoring additional 'schema' content, it is already defined",
+                                                              RedefinitionWarning,
+                                                              sourceMap));
+                    }
+
+                    ParseResultRef<Asset> asset(out.report, out.node.schema, out.sourceMap.schema);
+                    return AssetParser::parse(node, siblings, pd, asset);
+                }
+
+                default:
+                    break;
+            }
+
+            return node;
+        }
+
+        static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
+                                                          const MarkdownNodes& siblings,
+                                                          SectionParserData& pd,
+                                                          SectionType& sectionType,
+                                                          const ParseResultRef<Payload>& out) {
+
+            if ((node->type == mdp::ParagraphMarkdownNodeType ||
+                 node->type == mdp::CodeMarkdownNodeType) &&
+                sectionType == BodySectionType) {
+
+                mdp::ByteBuffer content = CodeBlockUtility::addDanglingAsset(node, pd, sectionType, out.report, out.node.body);
+
+                if (pd.exportSourceMap() && !content.empty()) {
+                    out.sourceMap.body.sourceMap.append(node->sourceMap);
+                }
+
+                return ++MarkdownNodeIterator(node);
+            }
+
+            return SectionProcessorBase<Payload>::processUnexpectedNode(node, siblings, pd, sectionType, out);
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            if (!isAbbreviated(sectionType) &&
+                SectionProcessorBase<Payload>::isDescriptionNode(node, sectionType)) {
+
+                return true;
+            }
+
+            return false;
+        }
+
+        static bool isContentNode(const MarkdownNodeIterator& node,
+                                  SectionType sectionType) {
+
+            if (isAbbreviated(sectionType) &&
+                (SectionKeywordSignature(node) == UndefinedSectionType)) {
+
+                return true;
+            }
+
+            return false;
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                SectionType nestedType = UndefinedSectionType;
+                PayloadSignature signature = payloadSignature(node);
+
+                if (signature == NoPayloadSignature) {
+                    return UndefinedSectionType;
+                }
+
+                for (MarkdownNodeIterator child = node->children().begin();
+                     child != node->children().end();
+                     ++child) {
+
+                    nestedType = nestedSectionType(child);
+
+                    if (nestedType != UndefinedSectionType) {
+                        return getSectionType(signature, nestedType);
+                    }
+                }
+
+                // Return abbreviated signature
+                return getSectionType(signature, nestedType);
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            SectionType nestedType = UndefinedSectionType;
+
+            // Check if headers section
+            nestedType = SectionProcessor<Headers>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            // Check if asset section
+            nestedType = SectionProcessor<Asset>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            // Check if attributes section
+            nestedType = SectionProcessor<Attributes>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            // Check if parameters section
+            nestedType = SectionProcessor<Parameters>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<Payload>& out) {
+
+            SectionType sectionType = pd.sectionContext();
+
+            if (sectionType == RequestSectionType || sectionType == RequestBodySectionType) {
+
+                checkRequest(node, pd, out);
+            }
+            else if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
+
+                checkResponse(node, pd, out);
+            }
+        }
+
+        /** Resolve payload signature */
+        static PayloadSignature payloadSignature(const MarkdownNodeIterator& node) {
+
+            mdp::ByteBuffer subject = node->children().front().text;
+            mdp::ByteBuffer signature;
+            mdp::ByteBuffer remainingContent;
+
+            signature = GetFirstLine(subject, remainingContent);
+            TrimString(signature);
+
+            if (RegexMatch(signature, RequestRegex))
+                return RequestPayloadSignature;
+
+            if (RegexMatch(signature, ResponseRegex))
+                return ResponsePayloadSignature;
+
+            if (RegexMatch(signature, ModelRegex))
+                return ModelPayloadSignature;
+
+            return NoPayloadSignature;
+        }
+
+        /** Get SectionType from PayloadSignature and nestedSectionType */
+        static SectionType getSectionType(PayloadSignature signature,
+                                          SectionType nestedType) {
+
+            switch (signature) {
+                case RequestPayloadSignature:
+                    return (nestedType != UndefinedSectionType) ? RequestSectionType : RequestBodySectionType;
+
+                case ResponsePayloadSignature:
+                    return (nestedType != UndefinedSectionType) ? ResponseSectionType : ResponseBodySectionType;
+
+                case ModelPayloadSignature:
+                    return (nestedType != UndefinedSectionType) ? ModelSectionType : ModelBodySectionType;
+
+                default:
+                    break;
+            }
+
+            return UndefinedSectionType;
+        }
+
+        /** True if abbreviated section type */
+        static bool isAbbreviated(SectionType sectionType) {
+
+            return (sectionType == RequestBodySectionType ||
+                    sectionType == ResponseBodySectionType ||
+                    sectionType == ModelBodySectionType);
+        }
+
+        /** Given the signature, parse it */
+        static bool parseSignature(const MarkdownNodeIterator& node,
+                                   SectionParserData& pd,
+                                   const mdp::ByteBuffer& signature,
+                                   const ParseResultRef<Payload>& out) {
+
+            const char* regex;
+            mdp::ByteBuffer mediaType;
+            CaptureGroups captureGroups;
+
+            switch (pd.sectionContext()) {
+                case RequestSectionType:
+                case RequestBodySectionType:
+                    regex = RequestRegex;
+                    break;
+
+                case ResponseSectionType:
+                case ResponseBodySectionType:
+                    regex = ResponseRegex;
+                    break;
+
+                case ModelSectionType:
+                case ModelBodySectionType:
+                    regex = ModelRegex;
+                    break;
+
+                default:
+                    return true;
+            }
+
+            if (RegexCapture(signature, regex, captureGroups, 5) &&
+                !captureGroups.empty()) {
+
+                mdp::ByteBuffer target = signature;
+                mdp::ByteBuffer::size_type pos = target.find(captureGroups[0]);
+
+                if (pos != mdp::ByteBuffer::npos) {
+                    target.replace(pos, captureGroups[0].length(), mdp::ByteBuffer());
+                }
+
+                TrimString(target);
+
+                if (!target.empty()) {
+                    // WARN: unable to parse payload signature
+                    std::stringstream ss;
+                    ss << "unable to parse " << SectionName(pd.sectionContext()) << " signature, expected ";
+
+                    switch (pd.sectionContext()) {
+                        case RequestSectionType:
+                        case RequestBodySectionType:
+                            ss << "'request [<identifier>] [(<media type>)]'";
+                            break;
+
+                        case ResponseBodySectionType:
+                        case ResponseSectionType:
+                            ss << "'response [<HTTP status code>] [(<media type>)]'";
+                            break;
+
+                        case ModelSectionType:
+                        case ModelBodySectionType:
+                            ss << "'model [(<media type>)]'";
+                            break;
+
+                        default:
+                            return false;
+                    }
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          FormattingWarning,
+                                                          sourceMap));
+
+                    return false;
+                }
+
+                if (pd.sectionContext() == ModelSectionType ||
+                    pd.sectionContext() == ModelBodySectionType) {
+
+                    out.node.name = captureGroups[2];
+                    mediaType = captureGroups[4];
+                } else if (pd.sectionContext() == RequestSectionType ||
+                           pd.sectionContext() == RequestBodySectionType) {
+
+                    out.node.name = captureGroups[1];
+                    mediaType = captureGroups[4];
+                } else {
+                    out.node.name = captureGroups[1];
+                    mediaType = captureGroups[3];
+                }
+
+                TrimString(out.node.name);
+                TrimString(mediaType);
+
+                if (pd.exportSourceMap() && !out.node.name.empty()) {
+                    out.sourceMap.name.sourceMap = node->sourceMap;
+                }
+
+                if (!mediaType.empty()) {
+                    Header header = std::make_pair(HTTPHeaderName::ContentType, mediaType);
+                    out.node.headers.push_back(header);
+
+                    if (pd.exportSourceMap()) {
+                        SourceMap<Header> headerSM;
+                        headerSM.sourceMap = node->sourceMap;
+                        out.sourceMap.headers.collection.push_back(headerSM);
+                    }
+                }
+
+                if (pd.exportSourceMap()) {
+                    out.sourceMap.sourceMap = node->sourceMap;
+                }
+            }
+
+            return true;
+        }
+
+        /** Given the reference id(name), initializes reference of the payload accordingly (if possible resolve it) */
+        static bool parseModelReference(const MarkdownNodeIterator& node,
+                                        SectionParserData& pd,
+                                        mdp::ByteBuffer& source,
+                                        const ParseResultRef<Payload>& out) {
+
+            Identifier symbol;
+
+            TrimString(source);
+
+            if (GetModelReference(source, symbol)) {
+
+                out.node.reference.id = symbol;
+                out.node.reference.meta.node = node;
+                out.node.reference.type = Reference::ModelReference;
+
+                if (pd.exportSourceMap() && !symbol.empty()) {
+                    out.sourceMap.reference.sourceMap = node->sourceMap;
+                }
+
+                // If model has not been defined yet in model table
+                if (pd.modelTable.find(symbol) == pd.modelTable.end()) {
+
+                    out.node.reference.meta.state = Reference::StatePending;
+
+                    return true;
+                }
+
+                out.node.reference.meta.state = Reference::StateResolved;
+
+                assingReferredPayload(pd, out);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         *  \brief  Assigns the reference, referred as reference id(name), into the payload
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void assingReferredPayload(SectionParserData& pd,
+                                          const ParseResultRef<Payload>& out) {
+
+            SourceMap<ResourceModel> modelSM;
+            ResourceModel model = pd.modelTable.find(out.node.reference.id)->second;
+
+
+            out.node.description = model.description;
+            out.node.parameters = model.parameters;
+
+            HeaderIterator modelContentTypeIt = std::find_if(model.headers.begin(),
+                                                             model.headers.end(),
+                                                             std::bind2nd(MatchFirstWith<Header, std::string>(),
+                                                                          HTTPHeaderName::ContentType));
+
+            bool isPayloadContentType = !out.node.headers.empty();
+            bool isModelContentType = modelContentTypeIt != model.headers.end();
+
+            if (isPayloadContentType && isModelContentType) {
+
+                // WARN: Ignoring payload content-type, when referencing a model with headers
+                std::stringstream ss;
+
+                ss << "ignoring additional " << SectionName(pd.sectionContext()) << " header(s), ";
+                ss << "specify this header(s) in the referenced model definition instead";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(out.node.reference.meta.node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      IgnoringWarning,
+                                                      sourceMap));
+            }
+
+            if (isPayloadContentType && !isModelContentType) {
+                out.node.headers.insert(out.node.headers.end(), model.headers.begin(), model.headers.end());
+            } else {
+                out.node.headers = model.headers;
+            }
+
+            out.node.body = model.body;
+            out.node.schema = model.schema;
+
+            if (pd.exportSourceMap()) {
+
+                modelSM = pd.modelSourceMapTable.at(out.node.reference.id);
+
+                out.sourceMap.description = modelSM.description;
+                out.sourceMap.parameters = modelSM.parameters;
+                out.sourceMap.body = modelSM.body;
+                out.sourceMap.schema = modelSM.schema;
+
+                if (isPayloadContentType && !isModelContentType) {
+                    out.sourceMap.headers.collection.insert(out.sourceMap.headers.collection.end(), modelSM.headers.collection.begin(), modelSM.headers.collection.end());
+                } else {
+                    out.sourceMap.headers = modelSM.headers;
+                }
+            }
+        }
+
+        /**
+         *  \brief  Checks request given as out
+         *  \param  node     Markdown node
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void checkRequest(const MarkdownNodeIterator& node,
+                                 SectionParserData& pd,
+                                 const ParseResultRef<Payload>& out) {
+
+            bool warnEmptyBody = false;
+
+            mdp::ByteBuffer contentLength;
+            mdp::ByteBuffer transferEncoding;
+
+            for (HeaderIterator it = out.node.headers.begin();
+                 it != out.node.headers.end();
+                 ++it) {
+
+                if (it->first == HTTPHeaderName::ContentLength) {
+                    contentLength = it->second;
+                }
+
+                if (it->first == HTTPHeaderName::TransferEncoding) {
+                    transferEncoding = it->second;
+                }
+            }
+
+
+            if (out.node.body.empty() && out.node.attributes.empty() &&
+                out.node.reference.meta.state != Reference::StatePending) {
+
+                // Warn when content-length or transfer-encoding is specified or headers, parameters and body are empty
+                if (out.node.headers.empty() && out.node.parameters.empty()) {
+                    warnEmptyBody = true;
+                } else {
+                    warnEmptyBody = !contentLength.empty() || !transferEncoding.empty();
+                }
+
+                if (warnEmptyBody) {
+
+                    // WARN: empty body
+                    std::stringstream ss;
+                    ss << "empty " << SectionName(RequestSectionType) << " " << SectionName(BodySectionType);
+
+                    if (!contentLength.empty()) {
+                        ss << ", expected " << SectionName(BodySectionType) << " for '" << contentLength << "' Content-Length";
+                    } else if (!transferEncoding.empty()) {
+                        ss << ", expected " << SectionName(BodySectionType) << " for '" << transferEncoding << "' Transfer-Encoding";
+                    }
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          EmptyDefinitionWarning,
+                                                          sourceMap));
+                }
+            }
+        }
+
+        /**
+         *  \brief  Checks response given as out
+         *  \param  node     Markdown node
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void checkResponse(const MarkdownNodeIterator& node,
+                                  SectionParserData& pd,
+                                  const ParseResultRef<Payload>& out) {
+
+            HTTPStatusCode code = 200;
+
+            if (!out.node.name.empty()) {
+                std::stringstream(out.node.name) >> code;
+            }
+
+            StatusCodeTraits statusCodeTraits = GetStatusCodeTrait(code);
+
+            if (!statusCodeTraits.allowBody &&
+                !out.node.body.empty() &&
+                out.node.reference.meta.state != Reference::StatePending) {
+
+                // WARN: not empty body
+                std::stringstream ss;
+                ss << "the " << code << " response MUST NOT include a " << SectionName(BodySectionType);
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
+            }
+        }
+
+        /**
+         *  \brief  Find a request within given action.
+         *  \param  transaction  A transaction to check.
+         *  \param  request A request to look for.
+         *  \return Iterator pointing to the matching request within given method requests.
+         */
+        static RequestIterator findRequest(const TransactionExample& example,
+                                           const Request& request) {
+
+            return std::find_if(example.requests.begin(),
+                                example.requests.end(),
+                                std::bind2nd(MatchPayload(), request));
+        }
+
+        /**
+         *  \brief  Find a response within responses of a given action.
+         *  \param  transaction  A transaction to check.
+         *  \param  response A response to look for.
+         *  \return Iterator pointing to the matching response within given method requests.
+         */
+        static ResponseIterator findResponse(const TransactionExample& example,
+                                             const Response& response) {
+
+            return std::find_if(example.responses.begin(),
+                                example.responses.end(),
+                                std::bind2nd(MatchPayload(), response));
+        }
+    };
+
+    /** Payload Section Parser */
+    typedef SectionParser<Payload, ListSectionAdapter> PayloadParser;
+}
+
+#endif