Exemple #1
0
void ShellSurface::setFullscreen()
{
    m_nextType = Type::Toplevel;
    m_toplevel.fullscreen = true;
    m_toplevel.maximized = false;

    Output *output = selectOutput();

    QRect rect = output->geometry();
    Debug::debug("Fullscrening surface '{}' on output '{}' with rect {}", surface(), output, rect);
    sendConfigure(rect.width(), rect.height());
}
Exemple #2
0
void CmfSaver::_writeFloatInRange (Output &output, float v, float min, float range)
{
   if (range > EPSILON)
   {
      float v2 = (((v - min) / range) * 65535 + 0.5f);
      if (v2 < 0 || v2 > 65536)
         throw Error("Internal error: Value %f is outsize of [%f, %f]", v, min, min + range);
      output.writeBinaryWord((word)v2);
   }
   else
      output.writeBinaryWord(0);
}
Exemple #3
0
void print_method(Output& out, const Func* func) {
  auto const finfo = find_func_info(func);
  out.fmtln(".method{} {}({}) {{",
    opt_attrs(AttrContext::Func, func->attrs()),
    func->name()->data(),
    func_param_list(finfo));
  indented(out, [&] {
    print_func_directives(out, func);
    print_func_body(out, finfo);
  });
  out.fmtln("}}");
}
  // -----------------------------------------
  // tests
  // -----------------------------------------
  TEST(ExtendedKalmanFilterTest, initialization)
  {
    ExtendedKalmanFilter ekf;

    // check setting required params
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "STM missing"
    ekf.setStateTransitionModel(f);
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "Jacobian of STM missing"
    ekf.setJacobianOfStateTransitionModel(df);
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "OM missing"
    ekf.setObservationModel(h);
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "Jacobian of OM missing"
    ekf.setJacobianOfObservationModel(dh);
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "PNC missing"
    MatrixXd Q(1,1); Q << 0.1;
    ekf.setProcessNoiseCovariance(Q);
    EXPECT_THROW(ekf.validate(), IEstimator::estimator_error);	// "MNC missing"
    MatrixXd R(1,1); R << 10;
    ekf.setMeasurementNoiseCovariance(R);
    EXPECT_NO_THROW(ekf.validate());			// all required params given

    // check setting optional params  
    // optional params doesn't set new sizes
    MatrixXd P0_f(2,2); P0_f << 1, 0, 0, 1;
    ekf.setInitialErrorCovariance(P0_f);
    EXPECT_NO_THROW(ekf.validate());
    EXPECT_EQ(ekf.getState().size(), 1);

    VectorXd x_f(2); x_f << 0,1;
    ekf.setInitialState(x_f);
    EXPECT_NO_THROW(ekf.validate());
    EXPECT_NE(ekf.getState().size(), 2);

    // required param Q sets new size of x and out
    MatrixXd Q2(2,2); Q2 << 0.1, 0, 0, 0.1;
    ekf.setProcessNoiseCovariance(Q2);   
    EXPECT_NO_THROW(ekf.validate());
    EXPECT_EQ(ekf.getState().size(), 2);
    EXPECT_EQ(ekf.getLastEstimate().size(), 2);

    // check initialization of output
    Output out = ekf.getLastEstimate();
    OutputValue defaultOutVal;
    EXPECT_GT(out.size(), 0);
    EXPECT_DOUBLE_EQ(out.getValue(), defaultOutVal.getValue());

    // check setting the control input
    InputValue ctrl(0);
    Input in_ctrl(ctrl);
    EXPECT_THROW(ekf.setControlInput(in_ctrl), length_error);
    ekf.setControlInputSize(1);
    EXPECT_NO_THROW(ekf.setControlInput(in_ctrl));
  }
Exemple #5
0
bool PositionAttitudeTransform_writeLocalData(const Object& obj, Output& fw)
{
    const PositionAttitudeTransform& transform = static_cast<const PositionAttitudeTransform&>(obj);

    fw.indent()<<"position "<<transform.getPosition()<<std::endl;
    fw.indent()<<"attitude "<<transform.getAttitude()<<std::endl;
    fw.indent()<<"scale "<<transform.getScale()<<std::endl;
    fw.indent()<<"pivotPoint "<<transform.getPivotPoint()<<std::endl;


    return true;
}
Exemple #6
0
void print_cls_inheritance_list(Output& out, const PreClass* cls) {
  if (!cls->parent()->empty()) {
    out.fmt(" extends {}", cls->parent());
  }
  if (!cls->interfaces().empty()) {
    out.fmt(" implements (");
    for (auto i = uint32_t{}; i < cls->interfaces().size(); ++i) {
      out.fmt("{}{}", i != 0 ? " " : "", cls->interfaces()[i].get());
    }
    out.fmt(")");
  }
}
Exemple #7
0
bool TexGenNode_writeLocalData(const Object& obj, Output& fw)
{
    const TexGenNode& texGenNode = static_cast<const TexGenNode&>(obj);

    fw.indent()<<"TextureUnit "<<texGenNode.getTextureUnit()<<std::endl;

    if (texGenNode.getTexGen())
    {
        fw.writeObject(*texGenNode.getTexGen());
    }

    return true;
}
Exemple #8
0
bool FrontFace_writeLocalData(const Object &obj, Output &fw)
{
    const FrontFace &frontface = static_cast<const FrontFace&>(obj);

    switch (frontface.getMode())
    {
    case (FrontFace::CLOCKWISE):         fw.indent() << "mode CLOCKWISE" << std::endl; break;

    case (FrontFace::COUNTER_CLOCKWISE): fw.indent() << "mode COUNTER_CLOCKWISE" << std::endl; break;
    }

    return true;
}
bool VisibilityGroup_writeLocalData(const Object& obj, Output& fw)
{
    const VisibilityGroup& vg = static_cast<const VisibilityGroup&>(obj);

    fw.indent()<<"volumeIntersectionMask 0x"<<std::hex<<vg.getVolumeIntersectionMask()<<std::dec<<std::endl;
    fw.indent()<<"segmentLength "<<vg.getSegmentLength()<<std::endl;
    fw.indent()<<"visibilityVolume" <<std::endl;
    fw.moveIn();
    fw.writeObject(*vg.getVisibilityVolume());
    fw.moveOut();

    return true;
}
Exemple #10
0
/* Set an output's next value to the value of the sensor */
void action_set_output(int pin, int value, void *arg) 
{
  Output *out = (Output *)arg;

  out->setValue(value);
  DEBUG3_PRINT("set_output: pin-");
  DEBUG3_PRINT(pin);
  DEBUG3_PRINT(" value-");
  DEBUG3_PRINT(value);
  DEBUG3_PRINT(" outpin-");
  DEBUG3_PRINT(out->_value);
  DEBUG3_PRINT("\n");
}
Exemple #11
0
bool Geode_writeLocalData(const osg::Object& obj, Output& fw)
{
    const Geode& geode = static_cast<const Geode&>(obj);

    fw.indent() << "num_drawables " << geode.getNumDrawables() << std::endl;

    for(unsigned int i=0;i<geode.getNumDrawables();++i)
    {
        fw.writeObject(*geode.getDrawable(i));
    }

    return true;
}
Exemple #12
0
void print_cls_used_traits(Output& out, const PreClass* cls) {
  auto& traits = cls->usedTraits();
  if (traits.empty()) return;

  out.indent();
  out.fmt(".use");

  for (auto i = uint32_t{0}; i < traits.size(); ++i) {
    out.fmt(" {}", traits[i].get());
  }

  auto& precRules  = cls->traitPrecRules();
  auto& aliasRules = cls->traitAliasRules();
  if (precRules.empty() && aliasRules.empty()) {
    out.fmt(";");
    out.nl();
    return;
  }

  out.fmt(" {{");
  out.nl();
  indented(out, [&] {
    for (auto& prec : precRules) {
      out.fmtln("{}::{} insteadof{};",
        prec.selectedTraitName()->data(),
        prec.methodName()->data(),
        [&]() -> std::string {
          auto ret = std::string{};
          for (auto& name : prec.otherTraitNames()) {
            ret += folly::format(" {}", name.get()).str();
          }
          return ret;
        }()
      );
    }

    for (auto& alias : aliasRules) {
      out.fmtln("{}{} as{}{};",
        alias.traitName()->empty()
          ? std::string{}
          : folly::format("{}::", alias.traitName()).str(),
        alias.origMethodName()->data(),
        opt_attrs(AttrContext::TraitImport, alias.modifiers()),
        alias.newMethodName() != alias.origMethodName()
          ? std::string(" ") + alias.newMethodName()->data()
          : std::string{}
      );
    }
  });
  out.fmtln("}}");
}
Exemple #13
0
RefTargetHandle Output::Clone(RemapDir &remap) {
	Output *mnew = new Output();
	*((MtlBase*)mnew) = *((MtlBase*)this);  // copy superclass stuff
	mnew->ReplaceReference(1,remap.CloneRef(texout));
	mnew->ivalid.SetEmpty();	
	for (int i = 0; i<NSUBTEX; i++) {
		mnew->subTex[i] = NULL;
		if (subTex[i])
			mnew->ReplaceReference(i,remap.CloneRef(subTex[i]));
		mnew->mapOn[i] = mapOn[i];
		}
	BaseClone(this, mnew, remap);
	return (RefTargetHandle)mnew;
	}
Exemple #14
0
void Dashboard::toggle(Seat *seat)
{
    if (seat->pointer()->isGrabActive()) {
        return;
    }

    m_visible = !m_visible;

    Output *output = m_shell->selectPrimaryOutput();
    View *wsv = workspaceViewForOutput(this, output);
    Transform tr;
    tr.translate(m_visible ? 0 : -output->width(), m_visible ? 0 : output->height());
    wsv->setTransform(tr, true);
}
Exemple #15
0
void ProfilingSystem::_printCounterData (const Record::Data &data, Output &output)
{
   if (data.count == 0)
   {
      output.printf("-\t0\t\t\t"); 
      return;
   }
   float avg_value = (float)data.value / data.count;

   // To avoid platform-specific code qwords were casted to doubles
   double sigma_sq = data.square_sum / data.count - avg_value * avg_value;
   output.printf("%0.0lf\t%0.0lf\t%0.1f\t%0.1lf\t%0.0lf",
      (double)data.value, (double)data.count, avg_value, sqrt(sigma_sq), (double)data.max_value); 
}
Exemple #16
0
bool AnimationManagerBase_writeLocalData(const osgAnimation::AnimationManagerBase &manager, Output &fw)
{
    const osgAnimation::AnimationList &animList = manager.getAnimationList();

    fw.indent() << "num_animations " << animList.size() << std::endl;

    for (osgAnimation::AnimationList::const_iterator it = animList.begin(); it != animList.end(); ++it)
    {
        if (!fw.writeObject(**it))
            osg::notify(osg::WARN) << "Warning: can't write an animation object" << std::endl;
    }

    return true;
}
int
main(int argc, char *argv[])
{
  Fraction rate(1, 10);

  SharedPtr<System> system = new System("Simulation Time System");
  Group* group = new Group("Simulation Time Group");
  group->setSampleTime(rate);
  system->setNode(group);
  
  SimulationTime* simulationTime = new SimulationTime("Simulation Time");
  group->addChild(simulationTime);

  Output* output = new Output("Simulation Time Output");
  group->addChild(output);
  SharedPtr<CollectOutputCallback> simTimeCallback = new CollectOutputCallback;
  output->setCallback(simTimeCallback);
  if (!group->connect(simulationTime->getPort("output"), output->getPort("input"))) {
    std::cout << "Could not connect ports" << std::endl;
    return EXIT_FAILURE;
  }
  
  if (!system->init()) {
    std::cout << "Could not initialize the system" << std::endl;
    return EXIT_FAILURE;
  }

  system->simulate(10);

  Vector errors(simTimeCallback->values.size());
  for (unsigned i = 0; i < simTimeCallback->values.size(); ++i) {
    errors(i) = simTimeCallback->values[i] - i*rate.getRealValue();
  }

  real_type expectedRoundoff;
  expectedRoundoff = Limits<real_type>::epsilon()/rate.getRealValue();
  real_type error = normInf(errors);
  if (expectedRoundoff < error) {
    std::cerr << "Maximum simulation time error " << error
              << " exceeds limit of expected roundoff "
              << expectedRoundoff << std::endl;
    return EXIT_FAILURE;
  }

  std::cout << "Maximum simulation time error " << error
            << " passes limit of expected roundoff "
            << expectedRoundoff << std::endl;

  return EXIT_SUCCESS;
}
Exemple #18
0
	//output of one character with return code true/false for success/failure
	bool print( char ch)
	{
		if ((unsigned char)ch > 127)
		{
			if (!output.print( ch)) return false;
		}
		else switch (mode)
		{
			case Ident:	if (!output.print( ch)) return false; break;
			case Uppercase: if (!output.print( toupper(ch))) return false; break;
			case Lowercase: if (!output.print( tolower(ch))) return false; break;
		}
		return true;
	}
Exemple #19
0
void print_method(Output& out, const Func* func) {
  auto const finfo = find_func_info(func);
  out.fmtln(".method{} {}{}({}){}{{",
    opt_attrs(AttrContext::Func, func->attrs(), &func->userAttributes()),
    opt_type_info(func->returnUserType(), func->returnTypeConstraint()),
    func->name(),
    func_param_list(finfo),
    func_flag_list(finfo));
  indented(out, [&] {
    print_func_directives(out, finfo);
    print_func_body(out, finfo);
  });
  out.fmtln("}}");
}
Exemple #20
0
void print_func_directives(Output& out, const FuncInfo& finfo) {
  const Func* func = finfo.func;
  if (auto const niters = func->numIterators()) {
    out.fmtln(".numiters {};", niters);
  }
  if (func->numNamedLocals() > func->numParams()) {
    std::vector<std::string> locals;
    for (int i = func->numParams(); i < func->numNamedLocals(); i++) {
      locals.push_back(loc_name(finfo, i));
    }
    out.fmtln(".declvars {};", folly::join(" ", locals));
  }

}
  // -----------------------------------------
  // tests
  // -----------------------------------------
  TEST(KalmanFilterTest, initializationAndValidation)
  {
    KalmanFilter kf;

    // check setting required params
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "STM missing"
    MatrixXd A_f(2,1); A_f << 1, 0;
    kf.setStateTransitionModel(A_f);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "OM missing"
    MatrixXd H(1,2); H << 1,0;
    kf.setObservationModel(H);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "PNC missing"
    MatrixXd Q(2,2); Q << 0.1,0,0,0.1;
    kf.setProcessNoiseCovariance(Q);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "MNC missing"
    MatrixXd R(1,1); R << 10;
    kf.setMeasurementNoiseCovariance(R);

    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "STM invalid size"
    MatrixXd A(2,2); A << 1,0,0,1;
    kf.setStateTransitionModel(A);
    EXPECT_NO_THROW(kf.validate());			// all required params given

    MatrixXd R_f(2,1); R_f << 10,1;
    kf.setMeasurementNoiseCovariance(R_f);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "MNC invalid size"
    kf.setMeasurementNoiseCovariance(R);
    MatrixXd H_f(3,1); H_f << 1,0,2;
    kf.setObservationModel(H_f);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "OM invalid size"
    kf.setObservationModel(H);

    // check setting optional params
    MatrixXd B_f(1,1); B_f << 0;
    kf.setControlInputModel(B_f);
    EXPECT_THROW(kf.validate(), IEstimator::estimator_error);	// "CIM invalid size"
    MatrixXd B(2,1); B << 0,0;
    kf.setControlInputModel(B);
    EXPECT_NO_THROW(kf.validate());
    
    VectorXd x(2); x << 0,1;
    kf.setInitialState(x);
    EXPECT_NO_THROW(kf.validate());
  
    // check initialization of output
    Output out = kf.getLastEstimate();
    OutputValue defaultOutVal;
    EXPECT_GT(out.size(), 0);
    EXPECT_DOUBLE_EQ(out.getValue(), defaultOutVal.getValue());
  }
bool EllipsoidModel_writeLocalData(const Object& obj, Output& fw)
{
    const EllipsoidModel& em = static_cast<const EllipsoidModel&>(obj);

    int prec = fw.precision();
    fw.precision(15);

    fw.indent()<<"RadiusEquator "<<em.getRadiusEquator()<<std::endl;
    fw.indent()<<"RadiusPolar "<<em.getRadiusPolar()<<std::endl;

    fw.precision(prec);

    return true;
}
Exemple #23
0
bool Object_writeLocalData(const Object& obj, Output& fw)
{
    switch(obj.getDataVariance())
    {
        case(osg::Object::STATIC):      fw.indent() << "DataVariance STATIC" << std::endl;break;
        case(osg::Object::DYNAMIC):     fw.indent() << "DataVariance DYNAMIC" << std::endl;break;
        case(osg::Object::UNSPECIFIED): break; // fw.indent() << "DataVariance UNSPECIFIED" << std::endl;break;
    }

    if (!obj.getName().empty()) fw.indent() << "name "<<fw.wrapString(obj.getName())<< std::endl;

    if (obj.getUserData())
    {
        const Object* object = dynamic_cast<const Object*>(obj.getUserData());
        if (object)
        {
            fw.indent() << "UserData {"<< std::endl;
            fw.moveIn();
            fw.writeObject(*object);
            fw.moveOut();
            fw.indent() << "}"<< std::endl;
        }
    }

    return true;
}
bool AutoTransform_writeLocalData(const Object& obj, Output& fw)
{
    const AutoTransform& transform = static_cast<const AutoTransform&>(obj);

    fw.indent()<<"position "<<transform.getPosition()<<std::endl;
    fw.indent()<<"rotation "<<transform.getRotation()<<std::endl;
    fw.indent()<<"scale "<<transform.getScale()<<std::endl;

    if (transform.getMinimumScale()>0.0) fw.indent()<<"minimumScale "<<transform.getMinimumScale()<<std::endl;
    if (transform.getMaximumScale()<FLT_MAX) fw.indent()<<"maximumScale "<<transform.getMaximumScale()<<std::endl;
    
    
    fw.indent()<<"pivotPoint "<<transform.getPivotPoint()<<std::endl;
    fw.indent()<<"autoUpdateEyeMovementTolerance "<<transform.getAutoUpdateEyeMovementTolerance()<<std::endl;
    fw.indent()<<"autoRotateMode ";
    switch(transform.getAutoRotateMode())
    {
      case(osg::AutoTransform::ROTATE_TO_SCREEN): fw<<"ROTATE_TO_SCREEN"<<std::endl; break;
      case(osg::AutoTransform::ROTATE_TO_CAMERA): fw<<"ROTATE_TO_CAMERA"<<std::endl; break;
      case(osg::AutoTransform::NO_ROTATION):
      default: fw<<"NO_ROTATION"<<std::endl; break;
    }

    fw.indent()<<"autoScaleToScreen "<<(transform.getAutoScaleToScreen()?"TRUE":"FALSE")<<std::endl;
    
    if (transform.getAutoScaleTransitionWidthRatio()!=0.25) 
    {
            fw.indent()<<"autoScaleTransitionWidthRatio "<<transform.getAutoScaleTransitionWidthRatio()<<std::endl;
    }
    
    return true;
}
    virtual bool set_path(Output& output, const char* path, bert::Value* val) {
      if(val->string_p()) {
        output.ok("value");
        if(shared_.config.import(path, val->string())) {
          output.e().write_atom("ok");
        } else {
          output.e().write_atom("unknown_key");
        }
      } else {
        output.error("format");
      }

      return true;
    }
Exemple #26
0
bool Group_writeLocalData(const Object &obj, Output &fw)
{
    const Group &group = static_cast<const Group&>(obj);

    if (group.getNumChildren() != 0)
        fw.indent() << "num_children " << group.getNumChildren() << std::endl;

    for (unsigned int i = 0; i < group.getNumChildren(); ++i)
    {
        fw.writeObject(*group.getChild(i));
    }

    return true;
}
void difference_output(std::string const& caseid, G1 const& g1, G2 const& g2, Output const& output)
{
    boost::ignore_unused(caseid, g1, g2, output);

#if defined(TEST_WITH_SVG)
    {
        typedef typename bg::coordinate_type<G1>::type coordinate_type;
        typedef typename bg::point_type<G1>::type point_type;

        bool const ccw =
            bg::point_order<G1>::value == bg::counterclockwise
            || bg::point_order<G2>::value == bg::counterclockwise;
        bool const open =
            bg::closure<G1>::value == bg::open
            || bg::closure<G2>::value == bg::open;

        std::ostringstream filename;
        filename << "difference_"
            << caseid << "_"
            << string_from_type<coordinate_type>::name()
            << (ccw ? "_ccw" : "")
            << (open ? "_open" : "")
#if defined(BOOST_GEOMETRY_NO_SELF_TURNS)
           << "_no_self"
#endif
#if defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
            << "_no_rob"
#endif
            << ".svg";

        std::ofstream svg(filename.str().c_str());

        bg::svg_mapper<point_type> mapper(svg, 500, 500);

        mapper.add(g1);
        mapper.add(g2);

        mapper.map(g1, "fill-opacity:0.3;fill:rgb(51,51,153);stroke:rgb(51,51,153);stroke-width:3");
        mapper.map(g2, "fill-opacity:0.5;fill:rgb(153,204,0);stroke:rgb(153,204,0);stroke-width:3");


        for (typename Output::const_iterator it = output.begin(); it != output.end(); ++it)
        {
            mapper.map(*it,
                //sym ? "fill-opacity:0.2;stroke-opacity:0.4;fill:rgb(255,255,0);stroke:rgb(255,0,255);stroke-width:8" :
                "fill-opacity:0.2;stroke-opacity:0.4;fill:rgb(255,0,0);stroke:rgb(255,0,255);stroke-width:8");
        }
    }
#endif
}
Exemple #28
0
void GammaControlManager::getGammaControl(wl_client *client, wl_resource *res, uint32_t id, wl_resource *outputRes)
{
    Output *output = Output::fromResource(outputRes);

    class GammaControl
    {
    public:
        GammaControl(Output *o)
            : output(o)
        {
        }
        void destroy(wl_client *c, wl_resource *r)
        {
            wl_resource_destroy(r);
        }
        void setGamma(wl_client *c, wl_resource *res, wl_array *red, wl_array *green, wl_array *blue)
        {
            if (red->size != green->size || red->size != blue->size) {
                wl_resource_post_error(res, GAMMA_CONTROL_ERROR_INVALID_GAMMA, "The gamma ramps don't have the same size");
                return;
            }

            uint16_t *r = (uint16_t *)red->data;
            uint16_t *g = (uint16_t *)green->data;
            uint16_t *b = (uint16_t *)blue->data;
            output->setGamma(red->size / sizeof(uint16_t), r, g, b);
        }
        void resetGamma(wl_client *c, wl_resource *res)
        {

        }

        Output *output;
    };

    static const struct gamma_control_interface implementation = {
        wrapExtInterface(&GammaControl::destroy),
        wrapExtInterface(&GammaControl::setGamma),
        wrapExtInterface(&GammaControl::resetGamma)
    };
    GammaControl *gc = new GammaControl(output);

    wl_resource *resource = wl_resource_create(client, &gamma_control_interface, wl_resource_get_version(res), id);
    wl_resource_set_implementation(resource, &implementation, gc, [](wl_resource *r) {
        delete static_cast<GammaControl *>(wl_resource_get_user_data(r));
    });

    gamma_control_send_gamma_size(resource, output->gammaSize());
}
RippleCalc::Output RippleCalc::rippleCalculate (
    PaymentSandbox& view,

    // Compute paths using this ledger entry set.  Up to caller to actually
    // apply to ledger.

    // Issuer:
    //      XRP: xrpAccount()
    //  non-XRP: uSrcAccountID (for any issuer) or another account with
    //           trust node.
    STAmount const& saMaxAmountReq,             // --> -1 = no limit.

    // Issuer:
    //      XRP: xrpAccount()
    //  non-XRP: uDstAccountID (for any issuer) or another account with
    //           trust node.
    STAmount const& saDstAmountReq,

    AccountID const& uDstAccountID,
    AccountID const& uSrcAccountID,

    // A set of paths that are included in the transaction that we'll
    // explore for liquidity.
    STPathSet const& spsPaths,
    Logs& l,
    Input const* const pInputs)
{
    RippleCalc rc (
        view,
        saMaxAmountReq,
        saDstAmountReq,
        uDstAccountID,
        uSrcAccountID,
        spsPaths,
        l);
    if (pInputs != nullptr)
    {
        rc.inputFlags = *pInputs;
    }

    auto result = rc.rippleCalculate ();
    Output output;
    output.setResult (result);
    output.actualAmountIn = rc.actualAmountIn_;
    output.actualAmountOut = rc.actualAmountOut_;
    output.pathStateList = rc.pathStateList_;

    return output;
}
    virtual void set(Output& output, bert::Value* val) {
      GlobalLock::LockGuard guard(state_->global_lock());

      if(val->string_p()) {
        output.ok("value");
        String* path = String::create(state_, val->string());
        if(RTEST(System::vm_dump_heap(state_, path))) {
          output.e().write_atom("ok");
        } else {
          output.e().write_atom("error");
        }
      } else {
        output.error("format");
      }
    }