Changed CALL params to vector of strings

diff --git a/core/producer/frame_producer.cpp b/core/producer/frame_producer.cpp
index 4ccdb593b5ec06cf0e85beb2620e0354076dfe48..4469a53f33e49b6a27e537955dc8f23624d1f53f 100644 (file)
--- a/core/producer/frame_producer.cpp
+++ b/core/producer/frame_producer.cpp
@@ -115,7 +115,7 @@ draw_frame frame_producer_base::last_frame()
        return impl_->last_frame();
 }
 
-boost::unique_future<std::wstring> frame_producer_base::call(const std::wstring&) 
+boost::unique_future<std::wstring> frame_producer_base::call(const std::vector<std::wstring>&) 
 {
        CASPAR_THROW_EXCEPTION(not_supported());
 }
@@ -144,7 +144,7 @@ const spl::shared_ptr<frame_producer>& frame_producer::empty()
                void unsubscribe(const monitor::observable::observer_ptr& o) override{} 
                std::wstring name() const override {return L"empty";}
                uint32_t frame_number() const override {return 0;}
-               boost::unique_future<std::wstring> call(const std::wstring& params) override{CASPAR_THROW_EXCEPTION(not_supported());}
+               boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) override{CASPAR_THROW_EXCEPTION(not_supported());}
                draw_frame last_frame() {return draw_frame::empty();}
                constraints& pixel_constraints() override { static constraints c; return c; }
        
@@ -213,7 +213,7 @@ public:
        std::wstring                                                                            name() const override                                                                                                                   {return producer_->name();}
        uint32_t                                                                                        frame_number() const override                                                                                                   {return producer_->frame_number();}
        boost::property_tree::wptree                                            info() const override                                                                                                                   {return producer_->info();}
-       boost::unique_future<std::wstring>                                      call(const std::wstring& str) override                                                                                  {return producer_->call(str);}
+       boost::unique_future<std::wstring>                                      call(const std::vector<std::wstring>& params) override                                                  {return producer_->call(params);}
        void                                                                                            leading_producer(const spl::shared_ptr<frame_producer>& producer) override              {return producer_->leading_producer(producer);}
        uint32_t                                                                                        nb_frames() const override                                                                                                              {return producer_->nb_frames();}
        class draw_frame                                                                        last_frame()                                                                                                                                    {return producer_->last_frame();}

diff --git a/core/producer/frame_producer.h b/core/producer/frame_producer.h
index 177c9e680c3083cab1fb4eb7654f97a17649ecea..85b7d77c8e8617b20f62df97827185f16ad03f42 100644 (file)
--- a/core/producer/frame_producer.h
+++ b/core/producer/frame_producer.h
@@ -72,7 +72,7 @@ public:
        // Methods      
 
        virtual class draw_frame                                        receive() = 0;
-       virtual boost::unique_future<std::wstring>      call(const std::wstring& params) = 0;
+       virtual boost::unique_future<std::wstring>      call(const std::vector<std::wstring>& params) = 0;
        
        // monitor::observable
 
@@ -105,7 +105,7 @@ public:
 
        // Methods      
 
-       virtual boost::unique_future<std::wstring>      call(const std::wstring& params);
+       virtual boost::unique_future<std::wstring>      call(const std::vector<std::wstring>& params);
        
        // monitor::observable
        

diff --git a/core/producer/scene/scene_producer.cpp b/core/producer/scene/scene_producer.cpp
index f31d3304a60f98a81b4e9a9d2b2c09084ae3cb55..45ca4858a98b7aa6ad5ae3415ef1eefa0072413a 100644 (file)
--- a/core/producer/scene/scene_producer.cpp
+++ b/core/producer/scene/scene_producer.cpp
@@ -165,14 +165,11 @@ struct scene_producer::impl
                return boost::optional<interaction_target>();
        }
 
-       boost::unique_future<std::wstring> call(const std::wstring& params) 
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) 
        {
                std::wstring result;
                
-               std::vector<std::wstring> words;
-               boost::split(words, params, [](wchar_t c) { return c == L' '; }, boost::token_compress_on);
-
-               if(words.size() >= 2)
+               if(params.size() >= 2)
                {
                        struct layer_comparer
                        {
@@ -181,9 +178,13 @@ struct scene_producer::impl
                                bool operator()(const layer& val) { return boost::iequals(val.name.get(), str); }
                        };
 
-                       auto it = std::find_if(layers_.begin(), layers_.end(), layer_comparer(words[0]));
+                       auto it = std::find_if(layers_.begin(), layers_.end(), layer_comparer(params[0]));
                        if(it != layers_.end())
-                               (*it).producer.get()->call(words[1]);
+                       {
+                               auto params2 = params;
+                               params2.erase(params2.cbegin());
+                               (*it).producer.get()->call(params2);
+                       }
                }
 
                return async(launch::deferred, [=]{return result;});
@@ -279,7 +280,7 @@ boost::property_tree::wptree scene_producer::info() const
        return impl_->info();
 }
 
-boost::unique_future<std::wstring> scene_producer::call(const std::wstring& params) 
+boost::unique_future<std::wstring> scene_producer::call(const std::vector<std::wstring>& params) 
 {
        return impl_->call(params);
 }

diff --git a/core/producer/scene/scene_producer.h b/core/producer/scene/scene_producer.h
index cfb7ccc78b9661feae8ce86cd99a9c86bad91c8c..d8ffd3ef1691a7901a094266f3ffff4dfda3aa9c 100644 (file)
--- a/core/producer/scene/scene_producer.h
+++ b/core/producer/scene/scene_producer.h
@@ -65,7 +65,7 @@ public:
        bool collides(double x, double y) const override;
        std::wstring print() const override;
        std::wstring name() const override;
-       boost::unique_future<std::wstring>      call(const std::wstring& params) override;
+       boost::unique_future<std::wstring>      call(const std::vector<std::wstring>& params) override;
        boost::property_tree::wptree info() const override;
        void subscribe(const monitor::observable::observer_ptr& o) override;
        void unsubscribe(const monitor::observable::observer_ptr& o) override;

diff --git a/core/producer/separated/separated_producer.cpp b/core/producer/separated/separated_producer.cpp
index 561be3bb1602f45db661bc880c6205a5fc0c42aa..44b6e5fbf225bdc6dd3bfcd8b772fddb77356949 100644 (file)
--- a/core/producer/separated/separated_producer.cpp
+++ b/core/producer/separated/separated_producer.cpp
@@ -104,10 +104,10 @@ public:
                return L"separated[fill:" + fill_producer_->print() + L"|key[" + key_producer_->print() + L"]]";
        }       
 
-       boost::unique_future<std::wstring> call(const std::wstring& str) override
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) override
        {
-               key_producer_->call(str);
-               return fill_producer_->call(str);
+               key_producer_->call(params);
+               return fill_producer_->call(params);
        }
 
        std::wstring name() const override

diff --git a/core/producer/stage.cpp b/core/producer/stage.cpp
index 4ed35fc4955e7b6ef4a36ff8720f83a776d443dd..6175ba030174e5830b1bb7b62a839fb15d4ff0ad 100644 (file)
--- a/core/producer/stage.cpp
+++ b/core/producer/stage.cpp
@@ -332,7 +332,7 @@ public:
                }, task_priority::high_priority);
        }               
        
-       boost::unique_future<std::wstring> call(int index, const std::wstring& params)
+       boost::unique_future<std::wstring> call(int index, const std::vector<std::wstring>& params)
        {
                return flatten(executor_.begin_invoke([=]
                {
@@ -370,7 +370,7 @@ public:
 };
 
 stage::stage(spl::shared_ptr<diagnostics::graph> graph) : impl_(new impl(std::move(graph))){}
-boost::unique_future<std::wstring> stage::call(int index, const std::wstring& params){return impl_->call(index, params);}
+boost::unique_future<std::wstring> stage::call(int index, const std::vector<std::wstring>& params){return impl_->call(index, params);}
 boost::unique_future<void> stage::apply_transforms(const std::vector<stage::transform_tuple_t>& transforms){return impl_->apply_transforms(transforms);}
 boost::unique_future<void> stage::apply_transform(int index, const std::function<core::frame_transform(core::frame_transform)>& transform, unsigned int mix_duration, const tweener& tween){return impl_->apply_transform(index, transform, mix_duration, tween);}
 boost::unique_future<void> stage::clear_transforms(int index){return impl_->clear_transforms(index);}

diff --git a/core/producer/stage.h b/core/producer/stage.h
index ad9c4cd1768c2be4d0493f6bb49182726ec313dc..70a5f8ad92b92883eca1aae376f75a134413dffe 100644 (file)
--- a/core/producer/stage.h
+++ b/core/producer/stage.h
@@ -72,7 +72,7 @@ public:
        boost::unique_future<void>                      pause(int index);
        boost::unique_future<void>                      play(int index);
        boost::unique_future<void>                      stop(int index);
-       boost::unique_future<std::wstring>      call(int index, const std::wstring& params);
+       boost::unique_future<std::wstring>      call(int index, const std::vector<std::wstring>& params);
        boost::unique_future<void>                      clear(int index);
        boost::unique_future<void>                      clear();        
        boost::unique_future<void>                      swap_layers(stage& other);

diff --git a/core/producer/text/text_producer.cpp b/core/producer/text/text_producer.cpp
index 7aaac08f65288e9156cd330c0f07fb3ea096fa5d..1b59733d0326d51fa66165991477627a008c43cd 100644 (file)
--- a/core/producer/text/text_producer.cpp
+++ b/core/producer/text/text_producer.cpp
@@ -122,10 +122,10 @@ public:
                return frame_;
        }
 
-       boost::unique_future<std::wstring> call(const std::wstring& param)
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& param)
        {
                std::wstring result;
-               generate_frame(param);
+               generate_frame(param.empty() ? L"" : param[0]);
 
                return async(launch::deferred, [=]{return result;});
        }
@@ -159,7 +159,7 @@ text_producer::text_producer(const spl::shared_ptr<frame_factory>& frame_factory
 {}
 
 draw_frame text_producer::receive_impl() { return impl_->receive_impl(); }
-boost::unique_future<std::wstring> text_producer::call(const std::wstring& param) { return impl_->call(param); }
+boost::unique_future<std::wstring> text_producer::call(const std::vector<std::wstring>& param) { return impl_->call(param); }
 text::string_metrics text_producer::measure_string(const std::wstring& str) { return impl_->measure_string(str); }
 
 constraints& text_producer::pixel_constraints() { return impl_->pixel_constraints(); }

diff --git a/core/producer/text/text_producer.h b/core/producer/text/text_producer.h
index a5242fb799303b7ddc08dcf57871ffbc2e45de63..6f7dfec459b2c3f87779f13e555d74e282212605 100644 (file)
--- a/core/producer/text/text_producer.h
+++ b/core/producer/text/text_producer.h
@@ -48,7 +48,7 @@ class text_producer : public frame_producer_base
 public:
        text_producer(const spl::shared_ptr<frame_factory>& frame_factory, int x, int y, const std::wstring& str, const text::text_info& text_info, long parent_width, long parent_height);
        draw_frame receive_impl() override;
-       boost::unique_future<std::wstring> call(const std::wstring& param) override;
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& param) override;
 
        text::string_metrics measure_string(const std::wstring& str);
 

diff --git a/core/producer/transition/transition_producer.cpp b/core/producer/transition/transition_producer.cpp
index 6778e1fd0b162083108bb1db2c6aff33fe12ff24..cc9fd328405d35ce435dfd8d5518969f24ace9a7 100644 (file)
--- a/core/producer/transition/transition_producer.cpp
+++ b/core/producer/transition/transition_producer.cpp
@@ -143,9 +143,9 @@ public:
                return dest_producer_->info();
        }
        
-       boost::unique_future<std::wstring> call(const std::wstring& str) override
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) override
        {
-               return dest_producer_->call(str);
+               return dest_producer_->call(params);
        }
 
        // transition_producer

diff --git a/modules/ffmpeg/producer/ffmpeg_producer.cpp b/modules/ffmpeg/producer/ffmpeg_producer.cpp
index 725c3f01a7a90bf15eeadea75bea5c5d4d9b434a..27c2f0f334fe68d702d69b0ac794c975fdcb413d 100644 (file)
--- a/modules/ffmpeg/producer/ffmpeg_producer.cpp
+++ b/modules/ffmpeg/producer/ffmpeg_producer.cpp
@@ -222,12 +222,14 @@ public:
                return video_decoder_ ? video_decoder_->file_frame_number() : 0;
        }
                
-       boost::unique_future<std::wstring> call(const std::wstring& param) override
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) override
        {
                static const boost::wregex loop_exp(L"LOOP\\s*(?<VALUE>\\d?)?", boost::regex::icase);
                static const boost::wregex seek_exp(L"SEEK\\s+(?<VALUE>\\d+)", boost::regex::icase);
                static const boost::wregex length_exp(L"LENGTH\\s+(?<VALUE>\\d+)?", boost::regex::icase);
                static const boost::wregex start_exp(L"START\\s+(?<VALUE>\\d+)?", boost::regex::icase);
+
+               auto param = boost::algorithm::join(params, L" ");
                
                std::wstring result;
                        

diff --git a/modules/flash/producer/cg_proxy.cpp b/modules/flash/producer/cg_proxy.cpp
index 151308921d25f9413050babc74e0205aa7737a3d..4e91263932c9052c8f9bfbd2b15d57e52b184a46 100644 (file)
--- a/modules/flash/producer/cg_proxy.cpp
+++ b/modules/flash/producer/cg_proxy.cpp
@@ -54,65 +54,82 @@ public:
                        filename += L".ft";
                
                auto str = (boost::wformat(L"<invoke name=\"Add\" returntype=\"xml\"><arguments><number>%1%</number><string>%2%</string>%3%<string>%4%</string><string><![CDATA[%5%]]></string></arguments></invoke>") % layer % filename % (play_on_load?L"<true/>":L"<false/>") % label % data).str();
-
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking add-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> remove(int layer)
        {
                auto str = (boost::wformat(L"<invoke name=\"Delete\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking remove-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> play(int layer)
        {
                auto str = (boost::wformat(L"<invoke name=\"Play\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking play-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> stop(int layer, unsigned int)
        {
                auto str = (boost::wformat(L"<invoke name=\"Stop\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><number>0</number></arguments></invoke>") % layer).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking stop-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> next(int layer)
        {
                auto str = (boost::wformat(L"<invoke name=\"Next\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking next-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> update(int layer, const std::wstring& data)
        {
                auto str = (boost::wformat(L"<invoke name=\"SetData\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><string><![CDATA[%2%]]></string></arguments></invoke>") % layer % data).str();
                CASPAR_LOG(info) << flash_producer_->print() <<" Invoking update-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> invoke(int layer, const std::wstring& label)
        {
                auto str = (boost::wformat(L"<invoke name=\"Invoke\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><string>%2%</string></arguments></invoke>") % layer % label).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking invoke-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> description(int layer)
        {
                auto str = (boost::wformat(L"<invoke name=\"GetDescription\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking description-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
 
        boost::unique_future<std::wstring> template_host_info()
        {
                auto str = (boost::wformat(L"<invoke name=\"GetInfo\" returntype=\"xml\"><arguments></arguments></invoke>")).str();
                CASPAR_LOG(info) << flash_producer_->print() << " Invoking info-command: " << str;
-               return flash_producer_->call(str);
+               std::vector<std::wstring> params;
+               params.push_back(std::move(str));
+               return flash_producer_->call(std::move(params));
        }
                
        std::wstring timed_invoke(int layer, const std::wstring& label)

diff --git a/modules/flash/producer/flash_producer.cpp b/modules/flash/producer/flash_producer.cpp
index 8b734933f8650039f2673f6ecb68a69e5f5b8c61..be58dce0484745a5b0ea672121f522a19f8823fe 100644 (file)
--- a/modules/flash/producer/flash_producer.cpp
+++ b/modules/flash/producer/flash_producer.cpp
@@ -401,8 +401,10 @@ public:
                return constraints_;
        }
                
-       boost::unique_future<std::wstring> call(const std::wstring& param) override
-       {       
+       boost::unique_future<std::wstring> call(const std::vector<std::wstring>& params) override
+       {
+               auto param = boost::algorithm::join(params, L" ");
+
                return executor_.begin_invoke([this, param]() -> std::wstring
                {                       
                        try

diff --git a/protocol/amcp/AMCPCommandsImpl.cpp b/protocol/amcp/AMCPCommandsImpl.cpp
index de9f01008a0275c6a5b2eccfcb3c4e87057a206d..ece322bbe6b05e90d5cb8d57fd3f83ba501c4f80 100644 (file)
--- a/protocol/amcp/AMCPCommandsImpl.cpp
+++ b/protocol/amcp/AMCPCommandsImpl.cpp
@@ -358,12 +358,7 @@ bool CallCommand::DoExecute()
        try
        {
                auto what = _parameters.at(0);
-                               
-               std::wstring param;
-               for(auto it = std::begin(_parameters2); it != std::end(_parameters2); ++it, param += L" ")
-                       param += *it;
-
-               auto result = GetChannel()->stage().call(GetLayerIndex(), boost::trim_copy(param));
+               auto result = GetChannel()->stage().call(GetLayerIndex(), _parameters2);
                
                if(!result.timed_wait(boost::posix_time::seconds(2)))
                        CASPAR_THROW_EXCEPTION(timed_out());

diff --git a/protocol/cii/CIIProtocolStrategy.cpp b/protocol/cii/CIIProtocolStrategy.cpp
index 70ca31b98e96a97b365bc18fa838971f09191408..6ed2cef98413ee89defdce14f7debc90e22e9909 100644 (file)
--- a/protocol/cii/CIIProtocolStrategy.cpp
+++ b/protocol/cii/CIIProtocolStrategy.cpp
@@ -188,7 +188,9 @@ void CIIProtocolStrategy::WriteTemplateData(const std::wstring& templateName, co
 
        std::wstringstream flashParam;
        flashParam << TEXT("<invoke name=\"Add\" returntype=\"xml\"><arguments><number>1</number><string>") << currentProfile_ << '/' <<  templateName << TEXT("</string><number>0</number><true/><string> </string><string><![CDATA[ ") << xmlData << TEXT(" ]]></string></arguments></invoke>");
-       producer->call(flashParam.str());
+       std::vector<std::wstring> params;
+       params.push_back(flashParam.str());
+       producer->call(std::move(params));
 
        CASPAR_LOG(info) << "Saved an instance of " << templateName << TEXT(" as ") << titleName ;