Conversation.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef CONVERSATION_HPP
#define CONVERSATION_HPP

#include <memory>
#include <duds/hardware/interface/ConversationVector.hpp>
#include <duds/hardware/interface/ConversationExternal.hpp>

namespace duds { namespace hardware { namespace interface {

class ConversationExtractor;

typedef boost::error_info<struct Info_ConversationPartIndex, int>
    ConversationPartIndex;

class Conversation {
public:
    typedef std::vector< std::unique_ptr<ConversationPart> >  PartVector;
protected:
    PartVector parts;  // the clonus horror
public:
    //struct CopyAll { };
    //struct CopyExtractible { };
    //struct MoveExtractible { };
    Conversation() = default;
    //Conversation(const Conversation &msg);
    //Conversation(const Conversation &msg, CopyAll) : Conversation(msg) { }
    /*
     * Creates a copy of the given Conversation that only includes the
     * ConversationPart objects flagged as extractible.
     * @sa ConversationPart::MpfExtract
     * @param msg  The source of the copy.
     */
    //Conversation(const Conversation &msg, CopyExtractible);
    /*
     * Creates a new Conversation that only includes ConversationPart objects
     * flagged as extractible. The parts are moved from the original. They
     * are replaced in @a msg by new ConversationVector objects with identical
     * flags and lengths. This can be used to extract data on one thread while
     * reusing the original Conversation to gather more data.
     * @sa ConversationPart::MpfExtract
     * @param msg  The source of the copy.
     */
    //Conversation(Conversation &msg, MoveExtractible);
    PartVector::iterator begin() {
        return parts.begin();
    }
    PartVector::iterator end() {
        return parts.end();
    }
    PartVector::const_iterator cbegin() const {
        return parts.cbegin();
    }
    PartVector::const_iterator cend() const {
        return parts.cend();
    }
    std::size_t size() const {
        return parts.size();
    }
    bool empty() const {
        return parts.empty();
    }
    void clear() {
        parts.clear();
    }
    template <class CP>
    void add(std::unique_ptr<CP> &cp) {
        parts.emplace_back(std::move(cp));
    }
    template <class CP>
    CP &add(const CP &cp) {
        CP *np = new CP(cp);
        parts.emplace_back(np);
        return *np;
    }
    ConversationVector &addOutputVector();
    ConversationVector &addInputVector(std::size_t len);
    template <class LengthType>
    ConversationVector &addInputVector(std::size_t len, LengthType lt) {
        ConversationVector *cv = new ConversationVector(len, lt);
        parts.emplace_back(cv);
        return *cv;
    }
    ConversationExternal &addOutputBuffer(const char *a, std::size_t len);
    template <typename T, std::size_t N>
    ConversationExternal &addOutputBuffer(const T (&a)[N]) {
        ConversationExternal *ce = new ConversationExternal(a);
        parts.emplace_back(ce);
        return *ce;
    }
    ConversationExternal &addInputBuffer(char *a, std::size_t len);
    template <typename T, std::size_t N>
    ConversationExternal &addInputBuffer(T (&a)[N]) {
        ConversationExternal *ce = new ConversationExternal(a);
        parts.emplace_back(ce);
        return *ce;
    }
    ConversationExtractor extract() const;
};

} } }

#endif        //  #ifndef CONVERSATION_HPP