/*** This file is part of snapcast Copyright (C) 2014-2021 Johannes Pohl This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. ***/ #ifndef MESSAGE_FACTORY_HPP #define MESSAGE_FACTORY_HPP #include "client_info.hpp" #include "codec_header.hpp" #include "hello.hpp" #include "pcm_chunk.hpp" #include "server_settings.hpp" // #include "stream_tags.hpp" #include "time.hpp" #include "common/str_compat.hpp" #include "common/utils.hpp" #include "json_message.hpp" #include <string> namespace msg { template <typename ToType> static std::unique_ptr<ToType> message_cast(std::unique_ptr<msg::BaseMessage> message) { ToType* tmp = dynamic_cast<ToType*>(message.get()); std::unique_ptr<ToType> result; if (tmp != nullptr) { message.release(); result.reset(tmp); return result; } return nullptr; } namespace factory { template <typename T> static std::unique_ptr<T> createMessage(const BaseMessage& base_message, char* buffer) { std::unique_ptr<T> result = std::make_unique<T>(); if (!result) return nullptr; result->deserialize(base_message, buffer); return result; } static std::unique_ptr<BaseMessage> createMessage(const BaseMessage& base_message, char* buffer) { std::unique_ptr<BaseMessage> result; switch (base_message.type) { case message_type::kCodecHeader: return createMessage<CodecHeader>(base_message, buffer); case message_type::kHello: return createMessage<Hello>(base_message, buffer); case message_type::kServerSettings: return createMessage<ServerSettings>(base_message, buffer); // case message_type::kStreamTags: // return createMessage<StreamTags>(base_message, buffer); case message_type::kTime: return createMessage<Time>(base_message, buffer); case message_type::kWireChunk: // this is kind of cheated to safe the convertion from WireChunk to PcmChunk // the user of the factory must be aware that a PcmChunk will be created return createMessage<PcmChunk>(base_message, buffer); case message_type::kClientInfo: return createMessage<ClientInfo>(base_message, buffer); default: return nullptr; } } } // namespace factory } // namespace msg #endif