response.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <ctime>
 
#include <string>
#include <vector>
#include <ostream>
#include <exception>
#include <memory>
 
#include "fundamentals.h"
#include "musictypes.h"
#include "retainer.h"
 
namespace Football {
    class Thingie;
}
namespace Parsnip {
    class Data;
}
 
extern const char *ResponseText (RESPONSE_CODE code);
extern const char *JSONFieldName (RESPONSE_CODE code);
 
namespace JSON {
    namespace Key {
        extern const char *PlayDuration;
        extern const char *PlayPoint;
        extern const char *PlayRemaining;
    }  // namespace Key
}  // namespace JSON
 
std::string format_duration (time_t duration, int minute_places = 1);
 
class Response {
    friend class ResponseCollector;
    friend class ResponseGroup;
    friend class CommandReply;
 
public:
    using List = std::vector<std::string>;
    static constexpr int TransmitUnaltered = 0;        
    static constexpr int TransmitAsDiagnostic = -100;  
 
    static Parsnip::Data NoJsonData;
private:
 
    enum class Type { EMPTY, STRING, LONG, DOUBLE, WORDLIST };  // Additional data types.
    RESPONSE_CODE message = NO_REPLY;                           
    Type type{ Type::EMPTY };                                   
    std::string value;
    long long_value;
    double double_value;
    int double_precision;
    List list;
    std::shared_ptr<Parsnip::Data> json_data;  
    std::string regarding;                     
    Retainer<MusicThingie *> related;          
    mutable const class User *user = nullptr;  
 
public:
    inline bool isStatusChange() const {
        return ::isStatusChange (message);
    }
    inline bool isDataField() const {
        return ::isDataField (message);
    }
    inline bool isSuccess() const {
        return ::isSuccess (message);
    }
    inline bool isCommandError() const {
        return ::isCommandError (message);
    }
    inline bool isServerFailure() const {
        return ::isServerFailure (message);
    }
    inline bool isUserAction() const {
        return ::isUserAction (message);
    }
    inline void bindUser (const class User *u) const {
        user = u;
    };
 
    void transmitLine (Football::Thingie &there, int offset = TransmitUnaltered) const;
    Parsnip::Data serialize() const;
 
    Response() = default;
    Response (const Response &) = default;
    Response (Response &&) = default;
    Response &operator= (const Response &) = default;
    Response &operator= (Response &&) = default;
 
    Response (RESPONSE_CODE msg);
    Response (RESPONSE_CODE msg, const std::string &details);
    Response (RESPONSE_CODE msg, long details);
    Response (RESPONSE_CODE msg, double details, int precision);
    Response (RESPONSE_CODE msg, List &&details, Parsnip::Data &&json_details);
 
    Response (const std::string &regard, RESPONSE_CODE msg);
    Response (const std::string &regard, RESPONSE_CODE msg, const std::string &details);
    Response (const std::string &regard, RESPONSE_CODE msg, long details);
    Response (const std::string &regard, RESPONSE_CODE msg, double details, int precision);
    Response (const std::string &regard, RESPONSE_CODE msg, List &&details, Parsnip::Data &&json_details);
 
    Response (Retainer<MusicThingie *> rel, RESPONSE_CODE msg);
    Response (Retainer<MusicThingie *> rel, RESPONSE_CODE msg, const std::string &details);
    Response (Retainer<MusicThingie *> rel, RESPONSE_CODE msg, long details);
    Response (Retainer<MusicThingie *> rel, RESPONSE_CODE msg, double details, int precision);
    Response (Retainer<MusicThingie *> rel, RESPONSE_CODE msg, List &&details, Parsnip::Data &&json_details);
    
    Response (const CommandError &err);
    Response (const std::string &regard, const CommandError &err);
    Response (Retainer<MusicThingie *> rel, const CommandError &err);
};
 
inline Football::Thingie &operator<< (Football::Thingie &there, const Response &response) {
    response.transmitLine (there);
    return there;
}
 
inline Football::Thingie &operator<< (Football::Thingie *there, const Response &response) {
    response.transmitLine (*there);
    return *there;
}
 
extern PianodConnection &operator<< (PianodConnection &there, const Response &response);
 
inline PianodConnection &operator<< (PianodConnection *there, const Response &response) {
    return (*there << response);
}
 
class ResponseGroup : public std::vector<Response> {
    friend class ResponseCollector;
 
private:
    Parsnip::Data serializeReply() const;
    Parsnip::Data serializeData (const User *) const;
    Parsnip::Data serializeHomogenousData (const User *) const;
    Parsnip::Data serializeEvents (bool, const User *) const;
 
    void transmitLine (class PianodService &) const;
    void transmitJSON (class PianodService &) const;
 
public:
    ResponseGroup() = default;
    ResponseGroup (ResponseGroup &&) = default;
    ResponseGroup &operator= (ResponseGroup &&) = default;
 
    ResponseGroup (Response &&r) {
        push_back (std::move (r));
    }
    template <typename... Parameters>
    inline void operator() (Parameters &&...params) {
        push_back (Response (std::forward<Parameters> (params)...));
    }
 
    void operator() (ResponseGroup &&);
 
    void transmit (class PianodService &) const;
 
    void transmitLine (PianodConnection &, int offset = Response::TransmitUnaltered) const;
    void transmit (class PianodConnection &) const;
};
 
class ResponseCollector {
    friend class PianodConnection &operator<< (class PianodConnection &there, const ResponseCollector &response);
 
private:
    bool close_after_response = false;  
 
    Parsnip::Data serialize (const User *user) const;
    void transmitJSON (PianodConnection &) const;
    void transmitLine (PianodConnection &) const;
 
protected:
    RESPONSE_CODE reason{ S_NOOP };  
 
    ResponseGroup successes;    
    ResponseGroup diagnostics;  
 
    std::vector<ResponseGroup> data_groups;  
    ResponseGroup data_reply;                
 
    // These are not publicly  accessible through ResponseCollector; use DataResponse instead.
    void data (ResponseGroup &&group);
    void data (const ThingieList &item_list);
    void data (const SongList &songs);
    void data (const PlaylistList &playlists);
 
    ResponseGroup user_events;       
    ResponseGroup room_events;       
    ResponseGroup broadcast_events;  
public:
    ResponseGroup information;  
 
    inline void setNoResponse() {
        assert (noop() && reason != S_DATA);
        reason = NO_REPLY;
    }
 
    inline bool allSuccess() const {
        assert (data_reply.empty());
        return diagnostics.empty() && !successes.empty();
    };
    inline bool allFailure() const {
        assert (data_reply.empty());
        return !diagnostics.empty() && successes.empty();
    }
    inline bool anySuccess() const {
        assert (data_reply.empty());
        return !successes.empty();
    };
    inline bool anyFailure() const {
        assert (data_reply.empty());
        return !diagnostics.empty();
    }
    inline bool partial() const {
        assert (data_reply.empty());
        return !diagnostics.empty() && !successes.empty();
    }
    inline bool noop() const {
        return diagnostics.empty() && successes.empty();
    }
    inline bool dataResponse() const {
        return (reason == S_DATA);
    }
    inline bool isNoResponse() const {
        return (reason == NO_REPLY);
    }
    inline void close() {
        close_after_response = true;
    }
 
    void transmit (PianodConnection &, const bool json);
 
    ResponseCollector() = default;
    ResponseCollector (ResponseCollector &&from) = default;
    ResponseCollector &operator =(ResponseCollector &&from) = default;
    
    ResponseCollector (Response &&initial);
    inline ResponseCollector (const RESPONSE_CODE response) : ResponseCollector (Response{ response }){};
    ResponseCollector (MusicThingie *item);
    ResponseCollector (const ThingieList &things);
    ResponseCollector (const SongList &songs);
    ResponseCollector (ResponseGroup &&group);
};
 
class CommandReply : public ResponseCollector {
public:
    enum class Aggregation { PESSIMISTIC, OPTIMISTIC };
 
private:
    RESPONSE_CODE mixed_reason{ E_PARTIAL };  
    void mergeReason (RESPONSE_CODE why);
 
public:
    using ResponseCollector::information;
    using ResponseCollector::user_events;
    using ResponseCollector::room_events;
    using ResponseCollector::broadcast_events;
 
    void fail (Response &&failure);
    template <typename ParamOne, typename ParamTwo, typename... Additional>
    inline void fail (ParamOne &&first, ParamTwo &&second, Additional &&...more) {
        fail (Response (std::forward<ParamOne> (first),
                        std::forward<ParamTwo> (second),
                        std::forward<Additional> (more)...));
    }
 
    void succeed (Response &&success);
    inline void succeed() {
        succeed (S_OK);
    }
    template <typename ParamOne, typename ParamTwo, typename... Additional>
    inline void succeed (ParamOne &&first, ParamTwo &&second, Additional &&...more) {
        succeed (Response (std::forward<ParamOne> (first),
                           std::forward<ParamTwo> (second),
                           std::forward<Additional> (more)...));
    }
 
    void operator() (Response &&r);
    template <typename ParamOne, typename... Parameters>
    inline void operator() (ParamOne &&first, Parameters &&...more) {
        operator() (Response (std::forward<ParamOne> (first), std::forward<Parameters> (more)...));
    }
 
    CommandReply (Aggregation kind = Aggregation::OPTIMISTIC);
    inline CommandReply (Response &&initial) : ResponseCollector (std::move (initial)){};
    CommandReply (const std::exception_ptr except, const char *triggering_command = nullptr);
};
 
class DataResponse : public ResponseCollector {
public:
    using ResponseCollector::data;
    using ResponseCollector::information;
 
    void data (Response &&r);
 
    template <typename ParamOne, typename ParamTwo, typename... Additional>
    inline void data (ParamOne &&first, ParamTwo &&second, Additional &&...more) {
        data (Response (std::forward<ParamOne> (first),
                        std::forward<ParamTwo> (second),
                        std::forward<Additional> (more)...));
    }
 
    template <typename T>
    inline void data (const Retainer<T> &from) {
        ResponseGroup group;
        group (from, I_ATTACHED_THING);
        data_groups.push_back (std::move (group));
    }
 
    inline DataResponse() : ResponseCollector (S_DATA) {
    }
};
 
extern class PianodConnection &operator<< (class PianodConnection &there, const ResponseCollector &response);
 
inline class PianodConnection &operator<< (class PianodConnection *there, const ResponseCollector &response) {
    *there << response;
    return *there;
}
 
// Helper for sending updated ratings.
void sendUpdatedRatings (PianodConnection &conn, const PianodSong *song, CommandReply *reply);