int set_field_just(FIELD *f, int just) { if (just != NO_JUSTIFICATION && just != JUSTIFY_LEFT && just != JUSTIFY_CENTER &&just != JUSTIFY_RIGHT) return (E_BAD_ARGUMENT); f = Field(f); if (Just(f) != just) { Just(f) = just; return (_sync_attrs(f)); } return (E_OK); }
AngelTargetProviderBaseT<ProviderT, ObjectT, TargetT, AntiT>::AngelTargetProviderBaseT(Handler<Heap> const& heap, std::string const& provname, Handler<Heaven> const& heaven) :AngelTargetProvider(heap, provname, heaven) { this->registerReactiveNativeClosure("attatchServant", [this](AngelTargetObject* target, ServantObject* servant) { AntiT anti; AngelTargetSideEffect& side = anti; side.op = AngelTargetSideEffect::DetatchServant; side.detatchedServant = servant->servant(); target->angelTarget()->attatchServant(servant->servant()); return std::make_tuple(servant, Just(anti)); }); this->registerReactiveNativeClosure("detatchServant", [this](AngelTargetObject* target, ServantObject* servant) { AntiT anti; AngelTargetSideEffect& side = anti; side.op = AngelTargetSideEffect::AttatchServant; side.attatchedServant = servant->servant(); return std::make_tuple(servant, Just(anti)); }); }
AngelProviderBaseT<ProviderT, ObjectT, AngelT, AntiT>::AngelProviderBaseT(Handler<Heap> const& heap, std::string const& provname, Handler<Heaven> const& heaven) :AngelProvider(heap, provname, heaven) { this->registerPureNativeClosure("newElementTarget", [this](ObjectT* obj, std::string elementId){ return obj->angel()->newElementTarget(elementId)->donutObject(this->heap().lock()); }); this->registerPureNativeClosure("newWidgetTarget", [this](ObjectT* obj, std::string elementId, std::string widgetGuide){ return obj->angel()->newWidgetTarget(elementId, widgetGuide)->donutObject(this->heap().lock()); }); this->registerPureNativeClosure("findElementTarget", [this](ObjectT* obj, std::string elementId){ return obj->angel()->findElementTarget(elementId)->donutObject(this->heap().lock()); }); this->registerPureNativeClosure("findElementById", [this](ObjectT* obj, std::string elementId){ return obj->angel()->findElementById(elementId); }); this->registerPureNativeClosure("findWidgetTarget", [this](ObjectT* obj, std::string elementId, std::string widgetGuide){ return obj->angel()->findWidgetTarget(elementId, widgetGuide)->donutObject(this->heap().lock()); }); this->registerReactiveNativeClosure("attatchTarget", [this](ObjectT* dangel, AngelTargetObject* dtarget) { Handler<AngelT> angel(dangel->angel()); Handler<AngelTarget> target(dtarget->angelTarget()); angel->attatchTarget(target); AntiT side_; AngelSideEffect& side = side_; side.op = AngelSideEffect::DetatchTarget; side.detatchedTarget_ = target; return std::make_tuple(dtarget, Just(side_)); }); this->registerReactiveNativeClosure("detatchTarget", [this](ObjectT* dangel, AngelTargetObject* dtarget) { Handler<AngelT> angel(dangel->angel()); Handler<AngelTarget> target(dtarget->angelTarget()); angel->detatchTarget(target); AntiT side_; AngelSideEffect& side = side_; side.op = AngelSideEffect::AttatchTarget; side.attatchedTarget_ = target; return std::make_tuple(dtarget, Just(side_)); }); }
/** * @brief Returns symbolic names for the given parameter from the given map. */ Maybe<IntStringMap> getSymbolicNamesForParamFromMap(const std::string &funcName, unsigned paramPos, const FuncParamsMap &map) { // Try to find the function. auto funcIter = map.find(funcName); if (funcIter == map.end()) { return Nothing<IntStringMap>(); } // Try to find the parameter by its position. auto paramIter = funcIter->second.find(paramPos); return paramIter != funcIter->second.end() ? Just(paramIter->second) : Nothing<IntStringMap>(); }
ElementServantProvider::ElementServantProvider(const Handler<Heap>& heap, const Handler<Heaven>& heaven) :Super(heap, "ElementServant", heaven) { this->registerPureNativeClosure("element", [this](ElementServantObject* servant){ return servant->servant()->element()->donutObject(); }); this->registerReactiveNativeClosure("enableAnimation", [this](ElementServantObject* servant_){ auto servant = servant_->servant(); bool enabled = servant->animEnabled(); servant->animEnabled(true); AntiSideEffect anti; anti.op = enabled ? AntiSideEffect::None : AntiSideEffect::DisableAnimation; return std::tuple<bool,Maybe<AntiSideEffect> >(enabled, Just(anti)); }); this->registerReactiveNativeClosure("disableAnimation", [this](ElementServantObject* servant_){ auto servant = servant_->servant(); bool enabled = servant->animEnabled(); servant->animEnabled(false); AntiSideEffect anti; anti.op = !enabled ? AntiSideEffect::None : AntiSideEffect::EnableAnimation; return std::tuple<bool,Maybe<AntiSideEffect> >(enabled, Just(anti)); }); }
inline typename AngelObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::ResultType AngelObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::execAntiSideEffect(const Handler<Heap>& heap, const AntiSideEffect& val) { AntiT newAnti; AngelSideEffect& side = newAnti; AngelSideEffect const& old = val; switch(old.op){ case AngelSideEffect::AttatchTarget: this->angel()->attatchTarget(old.attatchedTarget_); side.op = AngelSideEffect::DetatchTarget; side.detatchedTarget_ = old.attatchedTarget_; break; case AngelSideEffect::DetatchTarget: this->angel()->detatchTarget(old.detatchedTarget_); side.op = AngelSideEffect::AttatchTarget; side.attatchedTarget_ = old.detatchedTarget_; break; } return Just(newAnti); }
inline typename ServantObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::ResultType ServantObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::execAntiSideEffect(const Handler<Heap>& heap, const AntiSideEffect& val) { AntiT newAnti; return Just(newAnti); }
int field_just(FIELD *f) { return (Just(Field(f))); }
std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> > WorldObject::popElement() { Handler<World> const world = this->world(); WorldSideEffect anti; anti.op = AntiSideEffect::PushElement; anti.elm = world->rootElement(); world->popElement(); return std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> >(anti.elm->donutObject(), Just(anti)); }
std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> > WorldObject::pushElement(std::string const& elementId) { Handler<World> const world = this->world(); WorldSideEffect anti; anti.op = AntiSideEffect::PopElement; world->pushElement(elementId); return std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> >(world->rootElement()->donutObject(), Just(anti)); }