git.sesse.net Git - casparcg/blob - core/producer/binding.h

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Helge Norberg, helge.norberg@svt.se
  20 */
  21
  22 #pragma once
  23
  24 #include <functional>
  25 #include <memory>
  26 #include <vector>
  27 #include <map>
  28 #include <algorithm>
  29
  30 namespace caspar { namespace core {
  31
  32 namespace detail {
  33
  34 struct impl_base : std::enable_shared_from_this<impl_base>
  35 {
  36         std::vector<std::shared_ptr<impl_base>> dependencies_;
  37         mutable std::vector<std::pair<
  38                         std::weak_ptr<void>,
  39                         std::function<void ()>>> on_change_;
  40
  41         virtual ~impl_base()
  42         {
  43         }
  44
  45         virtual void evaluate() = 0;
  46
  47         void depend_on(const std::shared_ptr<impl_base>& dependency)
  48         {
  49                 dependency->on_change(shared_from_this(), [=] { evaluate(); });
  50                 dependencies_.push_back(dependency);
  51         }
  52
  53         void on_change(
  54                         const std::weak_ptr<void>& dependant,
  55                         const std::function<void ()>& listener) const
  56         {
  57                 on_change_.push_back(std::make_pair(dependant, listener));
  58         }
  59 };
  60
  61 }
  62
  63 template <typename T>
  64 class binding
  65 {
  66 private:
  67
  68         struct impl : public detail::impl_base
  69         {
  70                 T value_;
  71                 std::function<T ()> expression_;
  72
  73                 impl()
  74                         : value_()
  75                 {
  76                 }
  77
  78                 impl(T value)
  79                         : value_(value)
  80                 {
  81                 }
  82
  83                 template<typename Expr>
  84                 impl(const Expr& expression)
  85                         : expression_(expression)
  86                 {
  87                 }
  88
  89                 T get() const
  90                 {
  91                         return value_;
  92                 }
  93
  94                 bool bound() const
  95                 {
  96                         return static_cast<bool>(expression_);
  97                 }
  98
  99                 void set(T value)
 100                 {
 101                         if (bound())
 102                         {
 103                                 throw std::exception("Bound value cannot be set");
 104                         }
 105
 106                         if (value == value_)
 107                                 return;
 108
 109                         value_ = value;
 110
 111                         on_change();
 112                 }
 113
 114                 void evaluate() override
 115                 {
 116                         if (expression_)
 117                         {
 118                                 auto new_value = expression_();
 119
 120                                 if (new_value != value_)
 121                                 {
 122                                         value_ = new_value;
 123                                         on_change();
 124                                 }
 125                         }
 126                 }
 127
 128                 using impl_base::on_change;
 129                 void on_change()
 130                 {
 131                         auto copy = on_change_;
 132
 133                         for (int i = static_cast<int>(copy.size()) - 1; i >= 0; --i)
 134                         {
 135                                 auto strong = copy[i].first.lock();
 136
 137                                 if (strong)
 138                                         copy[i].second();
 139                                 else
 140                                         on_change_.erase(on_change_.begin() + i);
 141                         }
 142                 }
 143
 144                 void bind(const std::shared_ptr<impl>& other)
 145                 {
 146                         unbind();
 147                         depend_on(other);
 148                         expression_ = [&]{ return other.get(); }
 149                         evaluate();
 150                 }
 151
 152                 void unbind()
 153                 {
 154                         if (expression_)
 155                         {
 156                                 expression_ = std::function<T ()>();
 157                                 dependencies_.clear();
 158                         }
 159                 }
 160         };
 161
 162         template<typename> friend class binding;
 163
 164         std::shared_ptr<impl> impl_;
 165 public:
 166         binding()
 167                 : impl_(new impl)
 168         {
 169         }
 170
 171         explicit binding(T value)
 172                 : impl_(new impl(value))
 173         {
 174         }
 175
 176         // Expr -> T ()
 177         template<typename Expr>
 178         explicit binding(const Expr& expression)
 179                 : impl_(new impl(expression))
 180         {
 181                 impl_->evaluate();
 182         }
 183
 184         // Expr -> T ()
 185         template<typename Expr, typename T2>
 186         binding(const Expr& expression, const binding<T2>& dep)
 187                 : impl_(new impl(expression))
 188         {
 189                 depend_on(dep);
 190                 impl_->evaluate();
 191         }
 192
 193         // Expr -> T ()
 194         template<typename Expr, typename T2, typename T3>
 195         binding(
 196                         const Expr& expression,
 197                         const binding<T2>& dep1,
 198                         const binding<T3>& dep2)
 199                 : impl_(new impl(expression))
 200         {
 201                 depend_on(dep1);
 202                 depend_on(dep2);
 203                 impl_->evaluate();
 204         }
 205
 206         T get() const
 207         {
 208                 return impl_->get();
 209         }
 210
 211         void set(T value)
 212         {
 213                 impl_->set(value);
 214         }
 215
 216         void bind(const binding<T>& other)
 217         {
 218                 impl_->bind(other.impl_);
 219         }
 220
 221         bool bound() const
 222         {
 223                 return impl_->bound();
 224         }
 225
 226         template<typename T2>
 227         void depend_on(const binding<T2>& other)
 228         {
 229                 impl_->depend_on(other.impl_);
 230         }
 231
 232         binding<T> operator+(T other) const
 233         {
 234                 return transformed([other](T self) { return self + other; });
 235         }
 236
 237         binding<T> operator+(const binding<T>& other) const
 238         {
 239                 return composed(other, [](T self, T o) { return self + o; });
 240         }
 241
 242         binding<T> operator-() const
 243         {
 244                 return transformed([](T self) { return -self; });
 245         }
 246
 247         binding<T> operator-(const binding<T>& other) const
 248         {
 249                 return *this + -other;
 250         }
 251
 252         binding<T> operator-(T other) const
 253         {
 254                 return *this + -other;
 255         }
 256
 257         binding<T> operator*(T other) const
 258         {
 259                 return transformed([other](T self) { return self * other; });
 260         }
 261
 262         binding<T> operator*(const binding<T>& other) const
 263         {
 264                 return composed(other, [](T self, T o) { return self * o; });
 265         }
 266
 267         binding<T> operator/(T other) const
 268         {
 269                 return transformed([other](T self) { return self / other; });
 270         }
 271
 272         binding<T> operator/(const binding<T>& other) const
 273         {
 274                 return composed(other, [](T self, T o) { return self / o; });
 275         }
 276
 277         binding<T> operator%(T other) const
 278         {
 279                 return transformed([other](T self) { return self % other; });
 280         }
 281
 282         binding<T> operator%(const binding<T>& other) const
 283         {
 284                 return composed(other, [](T self, T o) { return self % o; });
 285         }
 286
 287         binding<bool> operator==(T other) const
 288         {
 289                 return transformed([other](T self) { return self == other; });
 290         }
 291
 292         binding<bool> operator==(const binding<T>& other) const
 293         {
 294                 return composed(other, [](T self, T o) { return self == o; });
 295         }
 296
 297         binding<bool> operator!=(T other) const
 298         {
 299                 return transformed([other](T self) { return self != other; });
 300         }
 301
 302         binding<bool> operator!=(const binding<T>& other) const
 303         {
 304                 return composed(other, [](T self, T o) { return self != o; });
 305         }
 306
 307         binding<bool> operator<(T other) const
 308         {
 309                 return transformed([other](T self) { return self < other; });
 310         }
 311
 312         binding<bool> operator<(const binding<T>& other) const
 313         {
 314                 return composed(other, [](T self, T o) { return self < o; });
 315         }
 316
 317         binding<bool> operator>(T other) const
 318         {
 319                 return transformed([other](T self) { return self > other; });
 320         }
 321
 322         binding<bool> operator>(const binding<T>& other) const
 323         {
 324                 return composed(other, [](T self, T o) { return self > o; });
 325         }
 326
 327         binding<bool> operator<=(T other) const
 328         {
 329                 return transformed([other](T self) { return self <= other; });
 330         }
 331
 332         binding<bool> operator<=(const binding<T>& other) const
 333         {
 334                 return composed(other, [](T self, T o) { return self <= o; });
 335         }
 336
 337         binding<bool> operator>=(T other) const
 338         {
 339                 return transformed([other](T self) { return self >= other; });
 340         }
 341
 342         binding<bool> operator>=(const binding<T>& other) const
 343         {
 344                 return composed(other, [](T self, T o) { return self >= o; });
 345         }
 346
 347         template<typename T2>
 348         binding<T2> as() const
 349         {
 350                 return transformed([](T val) { return static_cast<T2>(val); });
 351         }
 352
 353         // Func -> R (T self_val)
 354         // Returns binding<R>
 355         template<typename Func>
 356         auto transformed(const Func& func) const -> binding<decltype(func(impl_->value_))>
 357         {
 358                 typedef decltype(func(impl_->value_)) R;
 359                 auto self = impl_;
 360
 361                 return binding<R>(
 362                                 [self, func] { return func(self->get()); },
 363                                 *this);
 364         }
 365
 366         // Func -> R (T self_val, T2 other_val)
 367         // Returns binding<R>
 368         template<typename Func, typename T2>
 369         auto composed(const binding<T2> other, const Func& func) const -> binding<decltype(func(impl_->value_, other.impl_->value_))>
 370         {
 371                 typedef decltype(func(impl_->value_, other.impl_->value_)) R;
 372                 auto self = impl_;
 373                 auto o = other.impl_;
 374
 375                 return binding<R>(
 376                                 [self, o, func] { return func(self->get(), o->get()); },
 377                                 *this,
 378                                 other);
 379         }
 380
 381         void unbind()
 382         {
 383                 impl_->unbind();
 384         }
 385
 386         void on_change(
 387                         const std::weak_ptr<void> dependant,
 388                         const std::function<void ()>& listener) const
 389         {
 390                 impl_->on_change(dependant, listener);
 391         }
 392
 393         std::shared_ptr<void> on_change(
 394                         const std::function<void ()>& listener) const
 395         {
 396                 std::shared_ptr<void> subscription(new char);
 397
 398                 on_change(subscription, listener);
 399
 400                 return subscription;
 401         }
 402 private:
 403         binding(const std::shared_ptr<impl>& self)
 404                 : impl_(self)
 405         {
 406         }
 407 };
 408
 409 static binding<bool> operator||(const binding<bool>& lhs, const binding<bool>& rhs)
 410 {
 411         return lhs.composed(rhs, [](bool lhs, bool rhs) { return lhs || rhs; });
 412 }
 413
 414 static binding<bool> operator&&(const binding<bool>& lhs, const binding<bool>& rhs)
 415 {
 416         return lhs.composed(rhs, [](bool lhs, bool rhs) { return lhs && rhs; });
 417 }
 418
 419 static binding<bool> operator!(const binding<bool>& self)
 420 {
 421         return self.transformed([](bool self) { return !self; });
 422 }
 423
 424 template<typename T>
 425 class ternary_builder
 426 {
 427         binding<bool> condition_;
 428         binding<T> true_result_;
 429 public:
 430         ternary_builder(
 431                         const binding<bool>& condition, const binding<T>& true_result)
 432                 : condition_(condition)
 433                 , true_result_(true_result)
 434         {
 435         }
 436
 437         binding<T> otherwise(const binding<T>& false_result)
 438         {
 439                 auto condition = condition_;
 440                 auto true_result = true_result_;
 441
 442                 binding<T> result([condition, true_result, false_result]()
 443                 {
 444                         return condition.get() ? true_result.get() : false_result.get();
 445                 });
 446
 447                 result.depend_on(condition);
 448                 result.depend_on(true_result);
 449                 result.depend_on(false_result);
 450
 451                 return result;
 452         }
 453
 454         binding<T> otherwise(T false_result)
 455         {
 456                 return otherwise(binding<T>(false_result))
 457         }
 458 };
 459
 460 class when
 461 {
 462         binding<bool> condition_;
 463 public:
 464         when(const binding<bool>& condition)
 465                 : condition_(condition)
 466         {
 467         }
 468
 469         template<typename T>
 470         ternary_builder<T> then(const binding<T>& true_result)
 471         {
 472                 return ternary_builder<T>(condition_, true_result);
 473         }
 474
 475         template<typename T>
 476         ternary_builder<T> then(T true_result)
 477         {
 478                 return then(binding<T>(true_result));
 479         }
 480 };
 481
 482 }}