
 

// This file is autogenerated. DO NOT EDIT

#pragma once
#include <robotpy_build.h>


#include <../src/include/frc2/command/ProfiledPIDCommand.h>

#include <frc2/command/Command.h>
#include <frc2/command/Subsystem.h>



#include <rpygen/frc2__CommandBase.hpp>

namespace rpygen {

using namespace frc2;


template <typename CfgBase>
using PyTrampolineCfgBase_frc2__ProfiledPIDCommand =
    PyTrampolineCfg_frc2__CommandBase<
CfgBase
>;

template <typename Distance, typename CfgBase = EmptyTrampolineCfg>
struct PyTrampolineCfg_frc2__ProfiledPIDCommand :
    PyTrampolineCfgBase_frc2__ProfiledPIDCommand< CfgBase>
{
    using Base = frc2::ProfiledPIDCommand<Distance>;

    using override_base_Initialize_v = frc2::ProfiledPIDCommand<Distance>;
    using override_base_Execute_v = frc2::ProfiledPIDCommand<Distance>;
    using override_base_End_b = frc2::ProfiledPIDCommand<Distance>;
};


template <typename PyTrampolineBase, typename PyTrampolineCfg>
using PyTrampolineBase_frc2__ProfiledPIDCommand =
    PyTrampoline_frc2__CommandBase<
        PyTrampolineBase
        
        , PyTrampolineCfg
    >
;

template <typename PyTrampolineBase, typename Distance, typename PyTrampolineCfg>
struct PyTrampoline_frc2__ProfiledPIDCommand : PyTrampolineBase_frc2__ProfiledPIDCommand<PyTrampolineBase, PyTrampolineCfg> {
    using PyTrampolineBase_frc2__ProfiledPIDCommand<PyTrampolineBase, PyTrampolineCfg>::PyTrampolineBase_frc2__ProfiledPIDCommand;


using Distance_t = units::unit_t<Distance>;using State = typename frc::TrapezoidProfile<Distance>::State;
#ifndef RPYGEN_DISABLE_Initialize_v
    void Initialize() override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_Initialize_v;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(void), LookupBase,
            "initialize", );
        return CxxCallBase::Initialize();
    }
#endif

#ifndef RPYGEN_DISABLE_Execute_v
    void Execute() override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_Execute_v;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(void), LookupBase,
            "execute", );
        return CxxCallBase::Execute();
    }
#endif

#ifndef RPYGEN_DISABLE_End_b
    void End(bool interrupted) override {
        using LookupBase = typename PyTrampolineCfg::Base;
        using CxxCallBase = typename PyTrampolineCfg::override_base_End_b;
        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(void), LookupBase,
            "end", interrupted);
        return CxxCallBase::End(interrupted);
    }
#endif



    using frc2::ProfiledPIDCommand<Distance>::m_controller;

    using frc2::ProfiledPIDCommand<Distance>::m_measurement;
using frc2::ProfiledPIDCommand<Distance>::m_goal;
using frc2::ProfiledPIDCommand<Distance>::m_useOutput;

};

}; // namespace rpygen


namespace rpygen {

using namespace frc2;


template <typename Distance>
struct bind_frc2__ProfiledPIDCommand {

          using Distance_t = units::unit_t<Distance>;
      using State = typename frc::TrapezoidProfile<Distance>::State;


      using ProfiledPIDCommand_Trampoline = rpygen::PyTrampoline_frc2__ProfiledPIDCommand<typename frc2::ProfiledPIDCommand<Distance>, Distance, typename rpygen::PyTrampolineCfg_frc2__ProfiledPIDCommand<Distance>>;
py::class_<typename frc2::ProfiledPIDCommand<Distance>, ProfiledPIDCommand_Trampoline, CommandBase> cls_ProfiledPIDCommand;




    py::module &m;
    std::string clsName;

bind_frc2__ProfiledPIDCommand(py::module &m, const char * clsName) :
    cls_ProfiledPIDCommand(m, clsName),



    m(m),
    clsName(clsName)
{
    
}

void finish(const char * set_doc = NULL, const char * add_doc = NULL) {

    cls_ProfiledPIDCommand.doc() =
    "A command that controls an output with a ProfiledPIDController.  Runs forever\n"
"by default - to add exit conditions and/or other behavior, subclass this\n"
"class. The controller calculation and output are performed synchronously in\n"
"the command's execute() method.\n"
"\n"
"@see ProfiledPIDController<Distance>";

  cls_ProfiledPIDCommand
      .def(py::init<frc::ProfiledPIDController<Distance >, std::function<Distance_t ( )>, std::function<State ( )>, std::function<void ( double, State )>, wpi::span<std::shared_ptr<Subsystem> >>(),
      py::arg("controller"), py::arg("measurementSource"), py::arg("goalSource"), py::arg("useOutput"), py::arg("requirements")=wpi::span<std::shared_ptr<Subsystem> >{}, release_gil(), py::doc(
    "Creates a new PIDCommand, which controls the given output with a\n"
"ProfiledPIDController.\n"
"\n"
":param controller:        the controller that controls the output.\n"
":param measurementSource: the measurement of the process variable\n"
":param goalSource:        the controller's goal\n"
":param useOutput:         the controller's output\n"
":param requirements:      the subsystems required by this command")
  )
    
      .def(py::init<frc::ProfiledPIDController<Distance >, std::function<Distance_t ( )>, std::function<Distance_t ( )>, std::function<void ( double, State )>, wpi::span<std::shared_ptr<Subsystem> >>(),
      py::arg("controller"), py::arg("measurementSource"), py::arg("goalSource"), py::arg("useOutput"), py::arg("requirements")=wpi::span<std::shared_ptr<Subsystem> >{}, release_gil(), py::doc(
    "Creates a new PIDCommand, which controls the given output with a\n"
"ProfiledPIDController.\n"
"\n"
":param controller:        the controller that controls the output.\n"
":param measurementSource: the measurement of the process variable\n"
":param goalSource:        the controller's goal\n"
":param useOutput:         the controller's output\n"
":param requirements:      the subsystems required by this command")
  )
    
      .def(py::init<frc::ProfiledPIDController<Distance >, std::function<Distance_t ( )>, typename frc::TrapezoidProfile<Distance >::State, std::function<void ( double, State )>, wpi::span<std::shared_ptr<Subsystem> >>(),
      py::arg("controller"), py::arg("measurementSource"), py::arg("goal"), py::arg("useOutput"), py::arg("requirements")=wpi::span<std::shared_ptr<Subsystem> >{}, release_gil(), py::doc(
    "Creates a new PIDCommand, which controls the given output with a\n"
"ProfiledPIDController with a constant goal.\n"
"\n"
":param controller:        the controller that controls the output.\n"
":param measurementSource: the measurement of the process variable\n"
":param goal:              the controller's goal\n"
":param useOutput:         the controller's output\n"
":param requirements:      the subsystems required by this command")
  )
    
      .def(py::init<frc::ProfiledPIDController<Distance >, std::function<Distance_t ( )>, units::unit_t<Distance >, std::function<void ( double, State )>, wpi::span<std::shared_ptr<Subsystem> >>(),
      py::arg("controller"), py::arg("measurementSource"), py::arg("goal"), py::arg("useOutput"), py::arg("requirements")=wpi::span<std::shared_ptr<Subsystem> >{}, release_gil(), py::doc(
    "Creates a new PIDCommand, which controls the given output with a\n"
"ProfiledPIDController with a constant goal.\n"
"\n"
":param controller:        the controller that controls the output.\n"
":param measurementSource: the measurement of the process variable\n"
":param goal:              the controller's goal\n"
":param useOutput:         the controller's output\n"
":param requirements:      the subsystems required by this command")
  )
    
      .def("initialize", &frc2::ProfiledPIDCommand<Distance>::Initialize, release_gil()
  )
    
      .def("execute", &frc2::ProfiledPIDCommand<Distance>::Execute, release_gil()
  )
    
      .def("end", &frc2::ProfiledPIDCommand<Distance>::End,
      py::arg("interrupted"), release_gil()
  )
    
      .def("getController", &frc2::ProfiledPIDCommand<Distance>::GetController, release_gil(), py::doc(
    "Returns the ProfiledPIDController used by the command.\n"
"\n"
":returns: The ProfiledPIDController")
  )
    
    .def_readonly("_controller", &ProfiledPIDCommand_Trampoline::m_controller);

  

    if (set_doc) {
        cls_ProfiledPIDCommand.doc() = set_doc;
    }
    if (add_doc) {
        cls_ProfiledPIDCommand.doc() = py::cast<std::string>(cls_ProfiledPIDCommand.doc()) + add_doc;
    }

    cls_ProfiledPIDCommand
  .def_readwrite("_measurement", &ProfiledPIDCommand_Trampoline::m_measurement)
  .def_readwrite("_goal", &ProfiledPIDCommand_Trampoline::m_goal)
  .def_readwrite("_useOutput", &ProfiledPIDCommand_Trampoline::m_useOutput)
;

}

}; // struct bind_frc2__ProfiledPIDCommand

}; // namespace rpygen