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_ = [other]{ 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++()
 243         {
 244                 T new_value = get();
 245                 ++new_value;
 246
 247                 set(new_value);
 248
 249                 return *this;
 250         }
 251
 252         binding<T> operator++(int)
 253         {
 254                 binding<T> pre_val(get());
 255                 ++*this;
 256
 257                 return pre_val;
 258         }
 259
 260         binding<T> operator-() const
 261         {
 262                 return transformed([](T self) { return -self; });
 263         }
 264
 265         binding<T> operator-(const binding<T>& other) const
 266         {
 267                 return *this + -other;
 268         }
 269
 270         binding<T> operator-(T other) const
 271         {
 272                 return *this + -other;
 273         }
 274
 275         binding<T>& operator--()
 276         {
 277                 T new_value = get();
 278                 --new_value;
 279
 280                 set(new_value);
 281
 282                 return *this;
 283         }
 284
 285         binding<T> operator--(int)
 286         {
 287                 binding<T> pre_val(get());
 288                 --*this;
 289
 290                 return pre_val;
 291         }
 292
 293         binding<T> operator*(T other) const
 294         {
 295                 return transformed([other](T self) { return self * other; });
 296         }
 297
 298         binding<T> operator*(const binding<T>& other) const
 299         {
 300                 return composed(other, [](T self, T o) { return self * o; });
 301         }
 302
 303         binding<T> operator/(T other) const
 304         {
 305                 return transformed([other](T self) { return self / other; });
 306         }
 307
 308         binding<T> operator/(const binding<T>& other) const
 309         {
 310                 return composed(other, [](T self, T o) { return self / o; });
 311         }
 312
 313         binding<T> operator%(T other) const
 314         {
 315                 return transformed([other](T self) { return self % other; });
 316         }
 317
 318         binding<T> operator%(const binding<T>& other) const
 319         {
 320                 return composed(other, [](T self, T o) { return self % o; });
 321         }
 322
 323         binding<bool> operator==(T other) const
 324         {
 325                 return transformed([other](T self) { return self == other; });
 326         }
 327
 328         binding<bool> operator==(const binding<T>& other) const
 329         {
 330                 return composed(other, [](T self, T o) { return self == o; });
 331         }
 332
 333         binding<bool> operator!=(T other) const
 334         {
 335                 return transformed([other](T self) { return self != other; });
 336         }
 337
 338         binding<bool> operator!=(const binding<T>& other) const
 339         {
 340                 return composed(other, [](T self, T o) { return self != o; });
 341         }
 342
 343         binding<bool> operator<(T other) const
 344         {
 345                 return transformed([other](T self) { return self < other; });
 346         }
 347
 348         binding<bool> operator<(const binding<T>& other) const
 349         {
 350                 return composed(other, [](T self, T o) { return self < o; });
 351         }
 352
 353         binding<bool> operator>(T other) const
 354         {
 355                 return transformed([other](T self) { return self > other; });
 356         }
 357
 358         binding<bool> operator>(const binding<T>& other) const
 359         {
 360                 return composed(other, [](T self, T o) { return self > o; });
 361         }
 362
 363         binding<bool> operator<=(T other) const
 364         {
 365                 return transformed([other](T self) { return self <= other; });
 366         }
 367
 368         binding<bool> operator<=(const binding<T>& other) const
 369         {
 370                 return composed(other, [](T self, T o) { return self <= o; });
 371         }
 372
 373         binding<bool> operator>=(T other) const
 374         {
 375                 return transformed([other](T self) { return self >= other; });
 376         }
 377
 378         binding<bool> operator>=(const binding<T>& other) const
 379         {
 380                 return composed(other, [](T self, T o) { return self >= o; });
 381         }
 382
 383         template<typename T2>
 384         binding<T2> as() const
 385         {
 386                 return transformed([](T val) { return static_cast<T2>(val); });
 387         }
 388
 389         // Func -> R (T self_val)
 390         // Returns binding<R>
 391         template<typename Func>
 392         auto transformed(const Func& func) const -> binding<decltype(func(impl_->value_))>
 393         {
 394                 typedef decltype(func(impl_->value_)) R;
 395                 auto self = impl_;
 396
 397                 return binding<R>(
 398                                 [self, func] { return func(self->get()); },
 399                                 *this);
 400         }
 401
 402         // Func -> R (T self_val, T2 other_val)
 403         // Returns binding<R>
 404         template<typename Func, typename T2>
 405         auto composed(const binding<T2> other, const Func& func) const -> binding<decltype(func(impl_->value_, other.impl_->value_))>
 406         {
 407                 typedef decltype(func(impl_->value_, other.impl_->value_)) R;
 408                 auto self = impl_;
 409                 auto o = other.impl_;
 410
 411                 return binding<R>(
 412                                 [self, o, func] { return func(self->get(), o->get()); },
 413                                 *this,
 414                                 other);
 415         }
 416
 417         void unbind()
 418         {
 419                 impl_->unbind();
 420         }
 421
 422         void on_change(
 423                         const std::weak_ptr<void> dependant,
 424                         const std::function<void ()>& listener) const
 425         {
 426                 impl_->on_change(dependant, listener);
 427         }
 428
 429         std::shared_ptr<void> on_change(
 430                         const std::function<void ()>& listener) const
 431         {
 432                 std::shared_ptr<void> subscription(new char);
 433
 434                 on_change(subscription, listener);
 435
 436                 return subscription;
 437         }
 438 private:
 439         binding(const std::shared_ptr<impl>& self)
 440                 : impl_(self)
 441         {
 442         }
 443 };
 444
 445 static binding<bool> operator||(const binding<bool>& lhs, const binding<bool>& rhs)
 446 {
 447         return lhs.composed(rhs, [](bool lhs, bool rhs) { return lhs || rhs; });
 448 }
 449
 450 static binding<bool> operator&&(const binding<bool>& lhs, const binding<bool>& rhs)
 451 {
 452         return lhs.composed(rhs, [](bool lhs, bool rhs) { return lhs && rhs; });
 453 }
 454
 455 static binding<bool> operator!(const binding<bool>& self)
 456 {
 457         return self.transformed([](bool self) { return !self; });
 458 }
 459
 460 template<typename T>
 461 class ternary_builder
 462 {
 463         binding<bool> condition_;
 464         binding<T> true_result_;
 465 public:
 466         ternary_builder(
 467                         const binding<bool>& condition, const binding<T>& true_result)
 468                 : condition_(condition)
 469                 , true_result_(true_result)
 470         {
 471         }
 472
 473         binding<T> otherwise(const binding<T>& false_result)
 474         {
 475                 auto condition = condition_;
 476                 auto true_result = true_result_;
 477
 478                 binding<T> result([condition, true_result, false_result]()
 479                 {
 480                         return condition.get() ? true_result.get() : false_result.get();
 481                 });
 482
 483                 result.depend_on(condition);
 484                 result.depend_on(true_result);
 485                 result.depend_on(false_result);
 486
 487                 return result;
 488         }
 489
 490         binding<T> otherwise(T false_result)
 491         {
 492                 return otherwise(binding<T>(false_result));
 493         }
 494 };
 495
 496 class when
 497 {
 498         binding<bool> condition_;
 499 public:
 500         when(const binding<bool>& condition)
 501                 : condition_(condition)
 502         {
 503         }
 504
 505         template<typename T>
 506         ternary_builder<T> then(const binding<T>& true_result)
 507         {
 508                 return ternary_builder<T>(condition_, true_result);
 509         }
 510
 511         template<typename T>
 512         ternary_builder<T> then(T true_result)
 513         {
 514                 return then(binding<T>(true_result));
 515         }
 516 };
 517
 518 }}