Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replaced ::std with std for readability/consistency.

Browse Source 
Change-Id: I65f9673c237d3513f99827e28963eb22ae9df0c2
This commit is contained in:
James Kuszmaul
2015-07-29 16:48:04 -04:00
parent f74ca87e26
commit 4b575e3e7e
127 changed files with 404 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
hal/include/HAL/cpp/Resource.hpp
View File

@@ -37,7 +37,7 @@ public:
void Free(uint32_t index);
private:
::std::vector<bool> m_isAllocated;
std::vector<bool> m_isAllocated;
priority_recursive_mutex m_allocateLock;
static priority_recursive_mutex m_createLock;

4
hal/include/HAL/cpp/priority_mutex.h
View File

@@ -6,8 +6,8 @@
#ifdef FRC_SIMULATOR
// We do not want to use pthreads if in the simulator; however, in the
// simulator, we do not care about priority inversion.
typedef ::std::mutex priority_mutex;
typedef ::std::recursive_mutex priority_recursive_mutex;
typedef std::mutex priority_mutex;
typedef std::recursive_mutex priority_recursive_mutex;
#else // Covers rest of file.
#include <pthread.h>

2
networktables/cpp/include/networktables/NetworkTableKeyListenerAdapter.h
View File

@@ -28,7 +28,7 @@ public:
NetworkTableKeyListenerAdapter(std::string relativeKey, std::string fullKey, NetworkTable* targetSource, ITableListener* targetListener);
virtual ~NetworkTableKeyListenerAdapter();
void ValueChanged(ITable* source, const std::string& key, EntryValue value, bool isNew);
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
ValueChanged(source.get(), key, value, isNew);
}

2
networktables/cpp/include/networktables/NetworkTableListenerAdapter.h
View File

@@ -26,7 +26,7 @@ class NetworkTableListenerAdapter : public ITableListener {
virtual ~NetworkTableListenerAdapter();
void ValueChanged(ITable* source, const std::string& key, EntryValue value,
bool isNew);
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
ValueChanged(source.get(), key, value, isNew);
}

2
networktables/cpp/include/networktables/NetworkTableSubListenerAdapter.h
View File

@@ -29,7 +29,7 @@ public:
NetworkTableSubListenerAdapter(std::string& prefix, NetworkTable* targetSource, ITableListener* targetListener);
virtual ~NetworkTableSubListenerAdapter();
void ValueChanged(ITable* source, const std::string& key, EntryValue value, bool isNew);
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
ValueChanged(source.get(), key, value, isNew);
}

4
networktables/cpp/include/tables/ITableListener.h
View File

@@ -33,11 +33,11 @@ class ITableListener {
* @param value the new value
* @param isNew true if the key did not previously exist in the table, otherwise it is false
*/
virtual void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value, bool isNew) = 0;
virtual void ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value, bool isNew) = 0;
virtual void ValueChanged(ITable* source, const std::string& key,
EntryValue value, bool isNew) {
ValueChanged(::std::shared_ptr<ITable>(source, NullDeleter<ITable>()), key, value, isNew);
ValueChanged(std::shared_ptr<ITable>(source, NullDeleter<ITable>()), key, value, isNew);
}
private:

4
wpilibc/wpilibC++/include/Buttons/NetworkButton.h
View File

@@ -15,13 +15,13 @@
class NetworkButton : public Button {
public:
NetworkButton(const std::string &tableName, const std::string &field);
NetworkButton(::std::shared_ptr<ITable> table, const std::string &field);
NetworkButton(std::shared_ptr<ITable> table, const std::string &field);
virtual ~NetworkButton() = default;
virtual bool Get();
private:
::std::shared_ptr<ITable> m_netTable;
std::shared_ptr<ITable> m_netTable;
std::string m_field;
};

6
wpilibc/wpilibC++/include/Buttons/Trigger.h
View File

@@ -42,12 +42,12 @@ class Trigger : public Sendable {
void CancelWhenActive(Command *command);
void ToggleWhenActive(Command *command);
virtual void InitTable(::std::shared_ptr<ITable> table);
virtual ::std::shared_ptr<ITable> GetTable() const;
virtual void InitTable(std::shared_ptr<ITable> table);
virtual std::shared_ptr<ITable> GetTable() const;
virtual std::string GetSmartDashboardType() const;
protected:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};
#endif

8
wpilibc/wpilibC++/include/Commands/Command.h
View File

@@ -176,14 +176,14 @@ class Command : public ErrorBase, public NamedSendable, public ITableListener {
public:
virtual std::string GetName() const;
virtual void InitTable(::std::shared_ptr<ITable> table);
virtual ::std::shared_ptr<ITable> GetTable() const;
virtual void InitTable(std::shared_ptr<ITable> table);
virtual std::shared_ptr<ITable> GetTable() const;
virtual std::string GetSmartDashboardType() const;
virtual void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
virtual void ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew);
protected:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};
#endif

2
wpilibc/wpilibC++/include/Commands/PIDCommand.h
View File

@@ -51,7 +51,7 @@ class PIDCommand : public Command, public PIDOutput, public PIDSource {
std::unique_ptr<PIDController> m_controller;
public:
virtual void InitTable(::std::shared_ptr<ITable> table);
virtual void InitTable(std::shared_ptr<ITable> table);
virtual std::string GetSmartDashboardType() const;
};

2
wpilibc/wpilibC++/include/Commands/PIDSubsystem.h
View File

@@ -68,7 +68,7 @@ class PIDSubsystem : public Subsystem, public PIDOutput, public PIDSource {
std::unique_ptr<PIDController> m_controller;
public:
virtual void InitTable(::std::shared_ptr<ITable> table);
virtual void InitTable(std::shared_ptr<ITable> table);
virtual std::string GetSmartDashboardType() const;
};

6
wpilibc/wpilibC++/include/Commands/Scheduler.h
View File

@@ -40,8 +40,8 @@ class Scheduler : public ErrorBase, public NamedSendable {
void UpdateTable();
std::string GetSmartDashboardType() const;
void InitTable(::std::shared_ptr<ITable> subTable);
::std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
std::string GetName() const;
std::string GetType() const;
@@ -65,7 +65,7 @@ class Scheduler : public ErrorBase, public NamedSendable {
StringArray *commands = nullptr;
NumberArray *ids = nullptr;
NumberArray *toCancel = nullptr;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
bool m_runningCommandsChanged = false;
};
#endif

6
wpilibc/wpilibC++/include/Commands/Subsystem.h
View File

@@ -39,12 +39,12 @@ class Subsystem : public ErrorBase, public NamedSendable {
public:
virtual std::string GetName() const;
virtual void InitTable(::std::shared_ptr<ITable> table);
virtual ::std::shared_ptr<ITable> GetTable() const;
virtual void InitTable(std::shared_ptr<ITable> table);
virtual std::shared_ptr<ITable> GetTable() const;
virtual std::string GetSmartDashboardType() const;
protected:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};
#endif

12
wpilibc/wpilibC++/include/LiveWindow/LiveWindow.h
View File

@@ -38,14 +38,14 @@ class LiveWindow {
void AddSensor(const std::string &subsystem, const std::string &name,
LiveWindowSendable *component);
void AddSensor(const std::string &subsystem, const std::string &name,
::std::shared_ptr<LiveWindowSendable> component);
std::shared_ptr<LiveWindowSendable> component);
[[deprecated(
"Raw pointers are deprecated; pass the component using shared_ptr "
"instead.")]]
void AddActuator(const std::string &subsystem, const std::string &name,
LiveWindowSendable *component);
void AddActuator(const std::string &subsystem, const std::string &name,
::std::shared_ptr<LiveWindowSendable> component);
std::shared_ptr<LiveWindowSendable> component);
void AddSensor(std::string type, int channel, LiveWindowSendable *component);
void AddActuator(std::string type, int channel,
LiveWindowSendable *component);
@@ -64,11 +64,11 @@ class LiveWindow {
void Initialize();
void InitializeLiveWindowComponents();
std::vector<::std::shared_ptr<LiveWindowSendable>> m_sensors;
std::map<::std::shared_ptr<LiveWindowSendable>, LiveWindowComponent> m_components;
std::vector<std::shared_ptr<LiveWindowSendable>> m_sensors;
std::map<std::shared_ptr<LiveWindowSendable>, LiveWindowComponent> m_components;
::std::shared_ptr<ITable> m_liveWindowTable;
::std::shared_ptr<ITable> m_statusTable;
std::shared_ptr<ITable> m_liveWindowTable;
std::shared_ptr<ITable> m_statusTable;
Scheduler &m_scheduler;

2
wpilibc/wpilibC++/include/LiveWindow/LiveWindowStatusListener.h
View File

@@ -6,7 +6,7 @@
class LiveWindowStatusListener : public ITableListener {
public:
virtual void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
virtual void ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew);
};

4
wpilibc/wpilibC++/include/Notifier.h
View File

@@ -49,8 +49,8 @@ class Notifier : public ErrorBase {
// handler call is in progress
#ifdef FRC_SIMULATOR
static ::std::thread m_task;
static ::std::atomic<bool> m_stopped;
static std::thread m_task;
static std::atomic<bool> m_stopped;
#endif
static void Run();
};

8
wpilibc/wpilibC++/include/PIDController.h
View File

@@ -65,7 +65,7 @@ class PIDController : public LiveWindowSendable,
virtual void Reset() override;
virtual void InitTable(::std::shared_ptr<ITable> table) override;
virtual void InitTable(std::shared_ptr<ITable> table) override;
private:
float m_P; // factor for "proportional" control
@@ -104,15 +104,15 @@ class PIDController : public LiveWindowSendable,
PIDOutput *output, float period = 0.05);
static void CallCalculate(void *controller);
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
virtual std::string GetSmartDashboardType() const override;
virtual void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
virtual void ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) override;
virtual void UpdateTable() override;
virtual void StartLiveWindowMode() override;
virtual void StopLiveWindowMode() override;
protected:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
virtual void Calculate();
};

2
wpilibc/wpilibC++/include/Resource.h
View File

@@ -29,7 +29,7 @@ class Resource : public ErrorBase {
Resource(const Resource&) = delete;
Resource& operator=(const Resource&) = delete;
static void CreateResourceObject(::std::unique_ptr<Resource>& r, uint32_t elements);
static void CreateResourceObject(std::unique_ptr<Resource>& r, uint32_t elements);
explicit Resource(uint32_t size);
uint32_t Allocate(const std::string &resourceDesc);
uint32_t Allocate(uint32_t index, const std::string &resourceDesc);

4
wpilibc/wpilibC++/include/RobotState.h
View File

@@ -19,11 +19,11 @@ class RobotStateInterface {
class RobotState {
private:
static ::std::shared_ptr<RobotStateInterface> impl;
static std::shared_ptr<RobotStateInterface> impl;
public:
static void SetImplementation(RobotStateInterface& i);
static void SetImplementation(::std::shared_ptr<RobotStateInterface> i);
static void SetImplementation(std::shared_ptr<RobotStateInterface> i);
static bool IsDisabled();
static bool IsEnabled();
static bool IsOperatorControl();

4
wpilibc/wpilibC++/include/SmartDashboard/Sendable.h
View File

@@ -18,12 +18,12 @@ class Sendable {
* Initializes a table for this sendable object.
* @param subtable The table to put the values in.
*/
virtual void InitTable(::std::shared_ptr<ITable> subtable) = 0;
virtual void InitTable(std::shared_ptr<ITable> subtable) = 0;
/**
* @return the table that is currently associated with the sendable
*/
virtual ::std::shared_ptr<ITable> GetTable() const = 0;
virtual std::shared_ptr<ITable> GetTable() const = 0;
/**
* @return the string representation of the named data type that will be used

6
wpilibc/wpilibC++/include/SmartDashboard/SendableChooser.h
View File

@@ -39,14 +39,14 @@ class SendableChooser : public Sendable {
void AddDefault(const std::string &name, void *object);
void *GetSelected();
virtual void InitTable(::std::shared_ptr<ITable> subtable);
virtual ::std::shared_ptr<ITable> GetTable() const;
virtual void InitTable(std::shared_ptr<ITable> subtable);
virtual std::shared_ptr<ITable> GetTable() const;
virtual std::string GetSmartDashboardType() const;
private:
std::string m_defaultChoice;
std::map<std::string, void *> m_choices;
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
};
#endif

4
wpilibc/wpilibC++/include/SmartDashboard/SmartDashboard.h
View File

@@ -43,14 +43,14 @@ class SmartDashboard : public SensorBase {
virtual ~SmartDashboard() = default;
/** The {@link NetworkTable} used by {@link SmartDashboard} */
static ::std::shared_ptr<ITable> m_table;
static std::shared_ptr<ITable> m_table;
/**
* A map linking tables in the SmartDashboard to the {@link
* SmartDashboardData} objects
* they came from.
*/
static std::map<::std::shared_ptr<ITable> , Sendable *> m_tablesToData;
static std::map<std::shared_ptr<ITable> , Sendable *> m_tablesToData;
};
#endif

2
wpilibc/wpilibC++/src/Buttons/NetworkButton.cpp
View File

@@ -13,7 +13,7 @@ NetworkButton::NetworkButton(const std::string &tableName, const std::string &fi
m_netTable(NetworkTable::GetTable(tableName)),
m_field(field) {}
NetworkButton::NetworkButton(::std::shared_ptr<ITable> table, const std::string &field)
NetworkButton::NetworkButton(std::shared_ptr<ITable> table, const std::string &field)
: m_netTable(table), m_field(field) {}
bool NetworkButton::Get() {

4
wpilibc/wpilibC++/src/Buttons/Trigger.cpp
View File

@@ -52,11 +52,11 @@ void Trigger::ToggleWhenActive(Command *command) {
std::string Trigger::GetSmartDashboardType() const { return "Button"; }
void Trigger::InitTable(::std::shared_ptr<ITable> table) {
void Trigger::InitTable(std::shared_ptr<ITable> table) {
m_table = table;
if (m_table != nullptr) {
m_table->PutBoolean("pressed", Get());
}
}
::std::shared_ptr<ITable> Trigger::GetTable() const { return m_table; }
std::shared_ptr<ITable> Trigger::GetTable() const { return m_table; }

6
wpilibc/wpilibC++/src/Commands/Command.cpp
View File

@@ -370,7 +370,7 @@ std::string Command::GetName() const {
std::string Command::GetSmartDashboardType() const { return "Command"; }
void Command::InitTable(::std::shared_ptr<ITable> table) {
void Command::InitTable(std::shared_ptr<ITable> table) {
if (m_table != nullptr) m_table->RemoveTableListener(this);
m_table = table;
if (m_table != nullptr) {
@@ -381,9 +381,9 @@ void Command::InitTable(::std::shared_ptr<ITable> table) {
}
}
::std::shared_ptr<ITable> Command::GetTable() const { return m_table; }
std::shared_ptr<ITable> Command::GetTable() const { return m_table; }
void Command::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void Command::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
if (value.b) {
if (!IsRunning()) Start();

2
wpilibc/wpilibC++/src/Commands/PIDCommand.cpp
View File

@@ -63,7 +63,7 @@ double PIDCommand::GetSetpoint() const { return m_controller->GetSetpoint(); }
double PIDCommand::GetPosition() const { return ReturnPIDInput(); }
std::string PIDCommand::GetSmartDashboardType() const { return "PIDCommand"; }
void PIDCommand::InitTable(::std::shared_ptr<ITable> table) {
void PIDCommand::InitTable(std::shared_ptr<ITable> table) {
m_controller->InitTable(table);
Command::InitTable(table);
}

2
wpilibc/wpilibC++/src/Commands/PIDSubsystem.cpp
View File

@@ -211,7 +211,7 @@ void PIDSubsystem::PIDWrite(float output) { UsePIDOutput(output); }
double PIDSubsystem::PIDGet() const { return ReturnPIDInput(); }
std::string PIDSubsystem::GetSmartDashboardType() const { return "PIDCommand"; }
void PIDSubsystem::InitTable(::std::shared_ptr<ITable> table) {
void PIDSubsystem::InitTable(std::shared_ptr<ITable> table) {
m_controller->InitTable(table);
Subsystem::InitTable(table);
}

4
wpilibc/wpilibC++/src/Commands/Scheduler.cpp
View File

@@ -258,7 +258,7 @@ std::string Scheduler::GetType() const { return "Scheduler"; }
std::string Scheduler::GetSmartDashboardType() const { return "Scheduler"; }
void Scheduler::InitTable(::std::shared_ptr<ITable> subTable) {
void Scheduler::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
commands = new StringArray();
ids = new NumberArray();
@@ -269,4 +269,4 @@ void Scheduler::InitTable(::std::shared_ptr<ITable> subTable) {
m_table->PutValue("Cancel", *toCancel);
}
::std::shared_ptr<ITable> Scheduler::GetTable() const { return m_table; }
std::shared_ptr<ITable> Scheduler::GetTable() const { return m_table; }

4
wpilibc/wpilibC++/src/Commands/Subsystem.cpp
View File

@@ -126,7 +126,7 @@ std::string Subsystem::GetName() const { return m_name; }
std::string Subsystem::GetSmartDashboardType() const { return "Subsystem"; }
void Subsystem::InitTable(::std::shared_ptr<ITable> table) {
void Subsystem::InitTable(std::shared_ptr<ITable> table) {
m_table = table;
if (m_table != nullptr) {
if (m_defaultCommand != nullptr) {
@@ -144,4 +144,4 @@ void Subsystem::InitTable(::std::shared_ptr<ITable> table) {
}
}
::std::shared_ptr<ITable> Subsystem::GetTable() const { return m_table; }
std::shared_ptr<ITable> Subsystem::GetTable() const { return m_table; }

18
wpilibc/wpilibC++/src/LiveWindow/LiveWindow.cpp
View File

@@ -57,7 +57,7 @@ void LiveWindow::SetEnabled(bool enabled) {
* @param component A LiveWindowSendable component that represents a sensor.
*/
void LiveWindow::AddSensor(const std::string &subsystem, const std::string &name,
::std::shared_ptr<LiveWindowSendable> component) {
std::shared_ptr<LiveWindowSendable> component) {
m_components[component].subsystem = subsystem;
m_components[component].name = name;
m_components[component].isSensor = true;
@@ -67,7 +67,7 @@ void LiveWindow::AddSensor(const std::string &subsystem, const std::string &name
"Raw pointers are deprecated; pass the component using shared_ptr "
"instead.")]]
void LiveWindow::AddSensor(const std::string &subsystem, const std::string &name, LiveWindowSendable *component) {
AddSensor(subsystem, name, ::std::shared_ptr<LiveWindowSendable>(
AddSensor(subsystem, name, std::shared_ptr<LiveWindowSendable>(
component, NullDeleter<LiveWindowSendable>()));
}
@@ -79,7 +79,7 @@ void LiveWindow::AddSensor(const std::string &subsystem, const std::string &name
* @param component A LiveWindowSendable component that represents a actuator.
*/
void LiveWindow::AddActuator(const std::string &subsystem, const std::string &name,
::std::shared_ptr<LiveWindowSendable> component) {
std::shared_ptr<LiveWindowSendable> component) {
m_components[component].subsystem = subsystem;
m_components[component].name = name;
m_components[component].isSensor = false;
@@ -91,7 +91,7 @@ void LiveWindow::AddActuator(const std::string &subsystem, const std::string &na
void LiveWindow::AddActuator(const std::string &subsystem, const std::string &name,
LiveWindowSendable *component) {
AddActuator(subsystem, name,
::std::shared_ptr<LiveWindowSendable>(
std::shared_ptr<LiveWindowSendable>(
component, NullDeleter<LiveWindowSendable>()));
}
@@ -108,7 +108,7 @@ void LiveWindow::AddSensor(std::string type, int channel,
types.copy(cc, types.size());
cc[types.size()] = '\0';
AddSensor("Ungrouped", cc, component);
::std::shared_ptr<LiveWindowSendable> component_stl(
std::shared_ptr<LiveWindowSendable> component_stl(
component, NullDeleter<LiveWindowSendable>());
if (std::find(m_sensors.begin(), m_sensors.end(), component_stl) ==
m_sensors.end())
@@ -126,7 +126,7 @@ void LiveWindow::AddActuator(std::string type, int channel,
auto cc = new char[types.size() + 1];
types.copy(cc, types.size());
cc[types.size()] = '\0';
AddActuator("Ungrouped", cc, ::std::shared_ptr<LiveWindowSendable>(
AddActuator("Ungrouped", cc, std::shared_ptr<LiveWindowSendable>(
component, [](LiveWindowSendable *) {}));
}
@@ -141,7 +141,7 @@ void LiveWindow::AddActuator(std::string type, int module, int channel,
auto cc = new char[types.size() + 1];
types.copy(cc, types.size());
cc[types.size()] = '\0';
AddActuator("Ungrouped", cc, ::std::shared_ptr<LiveWindowSendable>(
AddActuator("Ungrouped", cc, std::shared_ptr<LiveWindowSendable>(
component, [](LiveWindowSendable *) {}));
}
@@ -175,13 +175,13 @@ void LiveWindow::Run() {
*/
void LiveWindow::InitializeLiveWindowComponents() {
for (auto& elem : m_components) {
::std::shared_ptr<LiveWindowSendable> component = elem.first;
std::shared_ptr<LiveWindowSendable> component = elem.first;
LiveWindowComponent c = elem.second;
std::string subsystem = c.subsystem;
std::string name = c.name;
m_liveWindowTable->GetSubTable(subsystem)
->PutString("~TYPE~", "LW Subsystem");
::std::shared_ptr<ITable> table(
std::shared_ptr<ITable> table(
m_liveWindowTable->GetSubTable(subsystem)->GetSubTable(name));
table->PutString("~TYPE~", component->GetSmartDashboardType());
table->PutString("Name", name);

2
wpilibc/wpilibC++/src/LiveWindow/LiveWindowStatusListener.cpp
View File

@@ -1,6 +1,6 @@
#include "LiveWindow/LiveWindowStatusListener.h"
#include "Commands/Scheduler.h"
void LiveWindowStatusListener::ValueChanged(::std::shared_ptr<ITable> source,
void LiveWindowStatusListener::ValueChanged(std::shared_ptr<ITable> source,
const std::string& key,
EntryValue value, bool isNew) {}

4
wpilibc/wpilibC++/src/Resource.cpp
View File

@@ -20,7 +20,7 @@ priority_recursive_mutex Resource::m_createLock;
*/
Resource::Resource(uint32_t elements) {
std::unique_lock<priority_recursive_mutex> sync(m_createLock);
m_isAllocated = ::std::vector<bool>(elements, false);
m_isAllocated = std::vector<bool>(elements, false);
}
/**
@@ -33,7 +33,7 @@ Resource::Resource(uint32_t elements) {
* track, that is, it will allocate resource numbers in the range
* [0 .. elements - 1].
*/
/*static*/ void Resource::CreateResourceObject(::std::unique_ptr<Resource>& r,
/*static*/ void Resource::CreateResourceObject(std::unique_ptr<Resource>& r,
uint32_t elements) {
std::unique_lock<priority_recursive_mutex> sync(m_createLock);
if (!r) {

6
wpilibc/wpilibC++/src/RobotState.cpp
View File

@@ -2,15 +2,15 @@
#include "Base.h"
::std::shared_ptr<RobotStateInterface> RobotState::impl = nullptr;
std::shared_ptr<RobotStateInterface> RobotState::impl = nullptr;
void RobotState::SetImplementation(RobotStateInterface& i) {
impl = ::std::shared_ptr<RobotStateInterface>(
impl = std::shared_ptr<RobotStateInterface>(
&i, NullDeleter<RobotStateInterface>());
}
void RobotState::SetImplementation(
::std::shared_ptr<RobotStateInterface> i) {
std::shared_ptr<RobotStateInterface> i) {
impl = i;
}

4
wpilibc/wpilibC++/src/SmartDashboard/SendableChooser.cpp
View File

@@ -53,7 +53,7 @@ void *SendableChooser::GetSelected() {
return m_choices[selected];
}
void SendableChooser::InitTable(::std::shared_ptr<ITable> subtable) {
void SendableChooser::InitTable(std::shared_ptr<ITable> subtable) {
StringArray keys;
m_table = subtable;
if (m_table != nullptr) {
@@ -66,7 +66,7 @@ void SendableChooser::InitTable(::std::shared_ptr<ITable> subtable) {
}
}
::std::shared_ptr<ITable> SendableChooser::GetTable() const { return m_table; }
std::shared_ptr<ITable> SendableChooser::GetTable() const { return m_table; }
std::string SendableChooser::GetSmartDashboardType() const {
return "String Chooser";

8
wpilibc/wpilibC++/src/SmartDashboard/SmartDashboard.cpp
View File

@@ -13,8 +13,8 @@
#include "networktables/NetworkTable.h"
#include "HLUsageReporting.h"
::std::shared_ptr<ITable> SmartDashboard::m_table = nullptr;
std::map<::std::shared_ptr<ITable> , Sendable *> SmartDashboard::m_tablesToData;
std::shared_ptr<ITable> SmartDashboard::m_table = nullptr;
std::map<std::shared_ptr<ITable> , Sendable *> SmartDashboard::m_tablesToData;
void SmartDashboard::init() {
m_table.reset(NetworkTable::GetTable("SmartDashboard"));
@@ -35,7 +35,7 @@ void SmartDashboard::PutData(std::string key, Sendable *data) {
wpi_setGlobalWPIErrorWithContext(NullParameter, "value");
return;
}
::std::shared_ptr<ITable> dataTable(m_table->GetSubTable(key));
std::shared_ptr<ITable> dataTable(m_table->GetSubTable(key));
dataTable->PutString("~TYPE~", data->GetSmartDashboardType());
data->InitTable(dataTable);
m_tablesToData[dataTable] = data;
@@ -63,7 +63,7 @@ void SmartDashboard::PutData(NamedSendable *value) {
* @return the value
*/
Sendable *SmartDashboard::GetData(std::string key) {
::std::shared_ptr<ITable> subtable(m_table->GetSubTable(key));
std::shared_ptr<ITable> subtable(m_table->GetSubTable(key));
Sendable *data = m_tablesToData[subtable];
if (data == nullptr) {
wpi_setGlobalWPIErrorWithContext(SmartDashboardMissingKey, key.c_str());

6
wpilibc/wpilibC++Devices/include/ADXL345_I2C.h
View File

@@ -67,12 +67,12 @@ class ADXL345_I2C : public Accelerometer,
virtual AllAxes GetAccelerations();
virtual std::string GetSmartDashboardType() const override;
virtual void InitTable(::std::shared_ptr<ITable> subtable) override;
virtual void InitTable(std::shared_ptr<ITable> subtable) override;
virtual void UpdateTable() override;
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
virtual void StartLiveWindowMode() override {}
virtual void StopLiveWindowMode() override {}
private:
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
};

6
wpilibc/wpilibC++Devices/include/ADXL345_SPI.h
View File

@@ -71,9 +71,9 @@ class ADXL345_SPI : public Accelerometer,
virtual AllAxes GetAccelerations();
virtual std::string GetSmartDashboardType() const override;
virtual void InitTable(::std::shared_ptr<ITable> subtable) override;
virtual void InitTable(std::shared_ptr<ITable> subtable) override;
virtual void UpdateTable() override;
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
virtual void StartLiveWindowMode() override {}
virtual void StopLiveWindowMode() override {}
@@ -84,5 +84,5 @@ class ADXL345_SPI : public Accelerometer,
SPI::Port m_port;
private:
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
};

10
wpilibc/wpilibC++Devices/include/AnalogAccelerometer.h
View File

@@ -32,7 +32,7 @@ class AnalogAccelerometer : public SensorBase,
"AnalogAccelerometer(int channel). If you want to keep your own copy of "
"the AnalogInput, use std::shared_ptr.")]]
explicit AnalogAccelerometer(AnalogInput *channel);
explicit AnalogAccelerometer(::std::shared_ptr<AnalogInput> channel);
explicit AnalogAccelerometer(std::shared_ptr<AnalogInput> channel);
virtual ~AnalogAccelerometer() = default;
float GetAcceleration() const;
@@ -44,16 +44,16 @@ class AnalogAccelerometer : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
void InitAccelerometer();
::std::shared_ptr<AnalogInput> m_analogInput;
std::shared_ptr<AnalogInput> m_analogInput;
float m_voltsPerG = 1.0;
float m_zeroGVoltage = 2.5;
bool m_allocatedChannel;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

6
wpilibc/wpilibC++Devices/include/AnalogInput.h
View File

@@ -73,8 +73,8 @@ class AnalogInput : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
uint32_t m_channel;
@@ -82,5 +82,5 @@ class AnalogInput : public SensorBase,
void *m_port;
int64_t m_accumulatorOffset;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

6
wpilibc/wpilibC++Devices/include/AnalogOutput.h
View File

@@ -27,12 +27,12 @@ class AnalogOutput : public SensorBase, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
protected:
uint32_t m_channel;
void *m_port;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

10
wpilibc/wpilibC++Devices/include/AnalogPotentiometer.h
View File

@@ -44,7 +44,7 @@ class AnalogPotentiometer : public Potentiometer, public LiveWindowSendable {
explicit AnalogPotentiometer(AnalogInput *input, double fullRange = 1.0,
double offset = 0.0);
explicit AnalogPotentiometer(::std::shared_ptr<AnalogInput> input,
explicit AnalogPotentiometer(std::shared_ptr<AnalogInput> input,
double fullRange = 1.0, double offset = 0.0);
virtual ~AnalogPotentiometer() = default;
@@ -67,9 +67,9 @@ class AnalogPotentiometer : public Potentiometer, public LiveWindowSendable {
* Live Window code, only does anything if live window is activated.
*/
virtual std::string GetSmartDashboardType() const override;
virtual void InitTable(::std::shared_ptr<ITable> subtable) override;
virtual void InitTable(std::shared_ptr<ITable> subtable) override;
virtual void UpdateTable() override;
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
/**
* AnalogPotentiometers don't have to do anything special when entering the
@@ -84,8 +84,8 @@ class AnalogPotentiometer : public Potentiometer, public LiveWindowSendable {
virtual void StopLiveWindowMode() override {}
private:
::std::shared_ptr<AnalogInput> m_analog_input;
std::shared_ptr<AnalogInput> m_analog_input;
double m_fullRange, m_offset;
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
bool m_init_analog_input;
};

2
wpilibc/wpilibC++Devices/include/AnalogTrigger.h
View File

@@ -27,7 +27,7 @@ class AnalogTrigger : public SensorBase {
uint32_t GetIndex() const;
bool GetInWindow();
bool GetTriggerState();
::std::shared_ptr<AnalogTriggerOutput> CreateOutput(AnalogTriggerType type) const;
std::shared_ptr<AnalogTriggerOutput> CreateOutput(AnalogTriggerType type) const;
private:
uint8_t m_index;

6
wpilibc/wpilibC++Devices/include/BuiltInAccelerometer.h
View File

@@ -30,12 +30,12 @@ class BuiltInAccelerometer : public Accelerometer,
virtual double GetZ() override;
virtual std::string GetSmartDashboardType() const override;
virtual void InitTable(::std::shared_ptr<ITable> subtable) override;
virtual void InitTable(std::shared_ptr<ITable> subtable) override;
virtual void UpdateTable() override;
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
virtual void StartLiveWindowMode() override {}
virtual void StopLiveWindowMode() override {}
private:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

8
wpilibc/wpilibC++Devices/include/CANJaguar.h
View File

@@ -232,16 +232,16 @@ class CANJaguar : public MotorSafety,
std::unique_ptr<MotorSafetyHelper> m_safetyHelper;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
private:
void InitCANJaguar();

8
wpilibc/wpilibC++Devices/include/CANTalon.h
View File

@@ -156,14 +156,14 @@ class CANTalon : public MotorSafety,
double GetSetpoint() const override;
// LiveWindow stuff.
void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
// SpeedController overrides
virtual void SetInverted(bool isInverted) override;
@@ -202,6 +202,6 @@ class CANTalon : public MotorSafety,
void ApplyControlMode(CANSpeedController::ControlMode mode);
// LiveWindow stuff.
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
bool m_isInverted;
};

8
wpilibc/wpilibC++Devices/include/Compressor.h
View File

@@ -48,9 +48,9 @@ class Compressor : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void ValueChanged(std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
bool isNew) override;
protected:
@@ -59,7 +59,7 @@ class Compressor : public SensorBase,
private:
void SetCompressor(bool on);
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};
#endif /* Compressor_H_ */

24
wpilibc/wpilibC++Devices/include/Counter.h
View File

@@ -37,7 +37,7 @@ class Counter : public SensorBase,
"want to keep your own copy of the DigitalSource, use "
"std::shared_ptr.")]]
explicit Counter(DigitalSource *source);
explicit Counter(::std::shared_ptr<DigitalSource> source);
explicit Counter(std::shared_ptr<DigitalSource> source);
[[deprecated(
"Raw pointers are deprecated. Use pass-by-reference instead.")]]
explicit Counter(AnalogTrigger *trigger);
@@ -46,8 +46,8 @@ class Counter : public SensorBase,
"Raw pointers are deprecated; prefer to use shared_ptr instead.")]]
Counter(EncodingType encodingType, DigitalSource *upSource,
DigitalSource *downSource, bool inverted);
Counter(EncodingType encodingType, ::std::shared_ptr<DigitalSource> upSource,
::std::shared_ptr<DigitalSource> downSource, bool inverted);
Counter(EncodingType encodingType, std::shared_ptr<DigitalSource> upSource,
std::shared_ptr<DigitalSource> downSource, bool inverted);
virtual ~Counter();
void SetUpSource(int32_t channel);
@@ -55,11 +55,11 @@ class Counter : public SensorBase,
"Raw pointers are deprecated; prefer to call either SetUpSource(int) or "
"SetUpSource(shared_ptr).")]]
void SetUpSource(AnalogTrigger *analogTrigger, AnalogTriggerType triggerType);
void SetUpSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
void SetUpSource(std::shared_ptr<AnalogTrigger> analogTrigger,
AnalogTriggerType triggerType);
[[deprecated("Raw pointers are deprecated. Use std::shared_ptr instead.")]]
void SetUpSource(DigitalSource *source);
void SetUpSource(::std::shared_ptr<DigitalSource> source);
void SetUpSource(std::shared_ptr<DigitalSource> source);
[[deprecated("References are deprecated. Use std::shared_ptr instead.")]]
void SetUpSource(DigitalSource &source);
void SetUpSourceEdge(bool risingEdge, bool fallingEdge);
@@ -71,11 +71,11 @@ class Counter : public SensorBase,
"or SetDownSource(shared_ptr).")]]
void SetDownSource(AnalogTrigger *analogTrigger,
AnalogTriggerType triggerType);
void SetDownSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
void SetDownSource(std::shared_ptr<AnalogTrigger> analogTrigger,
AnalogTriggerType triggerType);
[[deprecated("Raw pointers are deprecated. Use std::shared_ptr instead.")]]
void SetDownSource(DigitalSource *source);
void SetDownSource(::std::shared_ptr<DigitalSource> source);
void SetDownSource(std::shared_ptr<DigitalSource> source);
[[deprecated("References are deprecated. Use std::shared_ptr instead.")]]
void SetDownSource(DigitalSource &source);
void SetDownSourceEdge(bool risingEdge, bool fallingEdge);
@@ -105,18 +105,18 @@ class Counter : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
virtual std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
protected:
// Makes the counter count up.
::std::shared_ptr<DigitalSource> m_upSource;
std::shared_ptr<DigitalSource> m_upSource;
// Makes the counter count down.
::std::shared_ptr<DigitalSource> m_downSource;
std::shared_ptr<DigitalSource> m_downSource;
// The FPGA counter object
void *m_counter = nullptr; ///< The FPGA counter object.
private:
uint32_t m_index = 0; ///< The index of this counter.
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

6
wpilibc/wpilibC++Devices/include/DigitalInput.h
View File

@@ -37,11 +37,11 @@ class DigitalInput : public DigitalSource, public LiveWindowSendable {
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(::std::shared_ptr<ITable> subTable);
::std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
private:
uint32_t m_channel;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

8
wpilibc/wpilibC++Devices/include/DigitalOutput.h
View File

@@ -38,18 +38,18 @@ class DigitalOutput : public DigitalSource,
virtual uint32_t GetModuleForRouting() const;
virtual bool GetAnalogTriggerForRouting() const;
virtual void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
virtual void ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew);
void UpdateTable();
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(::std::shared_ptr<ITable> subTable);
::std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
private:
uint32_t m_channel;
void *m_pwmGenerator;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

8
wpilibc/wpilibC++Devices/include/DoubleSolenoid.h
View File

@@ -34,14 +34,14 @@ class DoubleSolenoid : public SolenoidBase,
bool IsFwdSolenoidBlackListed() const;
bool IsRevSolenoidBlackListed() const;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
bool isNew);
void UpdateTable();
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(::std::shared_ptr<ITable> subTable);
::std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
private:
uint32_t m_forwardChannel; ///< The forward channel on the module to control.
@@ -49,5 +49,5 @@ class DoubleSolenoid : public SolenoidBase,
uint8_t m_forwardMask; ///< The mask for the forward channel.
uint8_t m_reverseMask; ///< The mask for the reverse channel.
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

16
wpilibc/wpilibC++Devices/include/Encoder.h
View File

@@ -49,8 +49,8 @@ class Encoder : public SensorBase,
Encoder(uint32_t aChannel, uint32_t bChannel, bool reverseDirection = false,
EncodingType encodingType = k4X);
Encoder(::std::shared_ptr<DigitalSource> aSource,
::std::shared_ptr<DigitalSource> bSource,
Encoder(std::shared_ptr<DigitalSource> aSource,
std::shared_ptr<DigitalSource> bSource,
bool reverseDirection = false, EncodingType encodingType = k4X);
[[deprecated(
"Raw pointers are deprecated; if you wish to construct your own copy of "
@@ -97,8 +97,8 @@ class Encoder : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
int32_t GetFPGAIndex() const { return m_index; }
@@ -106,17 +106,17 @@ class Encoder : public SensorBase,
void InitEncoder(bool _reverseDirection, EncodingType encodingType);
double DecodingScaleFactor() const;
::std::shared_ptr<DigitalSource> m_aSource; // the A phase of the quad encoder
::std::shared_ptr<DigitalSource> m_bSource; // the B phase of the quad encoder
std::shared_ptr<DigitalSource> m_aSource; // the A phase of the quad encoder
std::shared_ptr<DigitalSource> m_bSource; // the B phase of the quad encoder
void *m_encoder = nullptr;
int32_t m_index = 0; // The encoder's FPGA index.
double m_distancePerPulse = 1.0; // distance of travel for each encoder tick
::std::unique_ptr<Counter> m_counter =
std::unique_ptr<Counter> m_counter =
nullptr; // Counter object for 1x and 2x encoding
EncodingType m_encodingType; // Encoding type
int32_t m_encodingScale; // 1x, 2x, or 4x, per the encodingType
PIDSourceParameter
m_pidSource = kDistance; // Encoder parameter that sources a PID controller
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

2
wpilibc/wpilibC++Devices/include/GearTooth.h
View File

@@ -23,7 +23,7 @@ class GearTooth : public Counter {
static constexpr double kGearToothThreshold = 55e-6;
GearTooth(uint32_t channel, bool directionSensitive = false);
GearTooth(DigitalSource *source, bool directionSensitive = false);
GearTooth(::std::shared_ptr<DigitalSource> source,
GearTooth(std::shared_ptr<DigitalSource> source,
bool directionSensitive = false);
virtual ~GearTooth() = default;
void EnableDirectionSensing(bool directionSensitive);

10
wpilibc/wpilibC++Devices/include/Gyro.h
View File

@@ -43,7 +43,7 @@ class Gyro : public SensorBase, public PIDSource, public LiveWindowSendable {
"Raw pointers are deprecated; consider calling the Gyro constructor with "
"a channel number or passing a shared_ptr instead.")]]
explicit Gyro(AnalogInput *channel);
explicit Gyro(::std::shared_ptr<AnalogInput> channel);
explicit Gyro(std::shared_ptr<AnalogInput> channel);
virtual ~Gyro() = default;
virtual float GetAngle() const;
virtual double GetRate() const;
@@ -60,11 +60,11 @@ class Gyro : public SensorBase, public PIDSource, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
protected:
::std::shared_ptr<AnalogInput> m_analog;
std::shared_ptr<AnalogInput> m_analog;
private:
float m_voltsPerDegreePerSecond;
@@ -72,5 +72,5 @@ class Gyro : public SensorBase, public PIDSource, public LiveWindowSendable {
uint32_t m_center;
PIDSourceParameter m_pidSource;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

2
wpilibc/wpilibC++Devices/include/InterruptableSensorBase.h
View File

@@ -48,5 +48,5 @@ class InterruptableSensorBase : public SensorBase {
uint32_t m_interruptIndex;
void AllocateInterrupts(bool watcher);
static ::std::unique_ptr<Resource> m_interrupts;
static std::unique_ptr<Resource> m_interrupts;
};

4
wpilibc/wpilibC++Devices/include/Joystick.h
View File

@@ -108,8 +108,8 @@ class Joystick : public GenericHID, public ErrorBase {
private:
DriverStation &m_ds;
uint32_t m_port;
::std::vector<uint32_t> m_axes;
::std::vector<uint32_t> m_buttons;
std::vector<uint32_t> m_axes;
std::vector<uint32_t> m_buttons;
uint32_t m_outputs = 0;
uint16_t m_leftRumble = 0;
uint16_t m_rightRumble = 0;

2
wpilibc/wpilibC++Devices/include/MotorSafetyHelper.h
View File

@@ -34,7 +34,7 @@ class MotorSafetyHelper : public ErrorBase {
m_syncMutex; // protect accesses to the state for this object
MotorSafety *m_safeObject; // the object that is using the helper
// List of all existing MotorSafetyHelper objects.
static ::std::set<MotorSafetyHelper*> m_helperList;
static std::set<MotorSafetyHelper*> m_helperList;
static priority_recursive_mutex
m_listMutex; // protect accesses to the list of helpers
};

8
wpilibc/wpilibC++Devices/include/PWM.h
View File

@@ -99,16 +99,16 @@ class PWM : public SensorBase,
int32_t m_deadbandMinPwm;
int32_t m_minPwm;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
private:
uint32_t m_channel;

6
wpilibc/wpilibC++Devices/include/PowerDistributionPanel.h
View File

@@ -38,11 +38,11 @@ class PowerDistributionPanel : public SensorBase, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
uint8_t m_module;
};

2
wpilibc/wpilibC++Devices/include/Preferences.h
View File

@@ -59,7 +59,7 @@ class Preferences : public ErrorBase, public ITableListener {
bool ContainsKey(const char *key);
void Remove(const char *key);
void ValueChanged(::std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string &key, EntryValue value,
bool isNew) override;
protected:

8
wpilibc/wpilibC++Devices/include/Relay.h
View File

@@ -40,16 +40,16 @@ class Relay : public SensorBase,
void Set(Value value);
Value Get() const;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
private:
uint32_t m_channel;

20
wpilibc/wpilibC++Devices/include/RobotDrive.h
View File

@@ -48,18 +48,18 @@ class RobotDrive : public MotorSafety, public ErrorBase {
RobotDrive(SpeedController *leftMotor, SpeedController *rightMotor);
[[deprecated("References are deprecated; use shared_ptr instead.")]]
RobotDrive(SpeedController &leftMotor, SpeedController &rightMotor);
RobotDrive(::std::shared_ptr<SpeedController> leftMotor,
::std::shared_ptr<SpeedController> rightMotor);
RobotDrive(std::shared_ptr<SpeedController> leftMotor,
std::shared_ptr<SpeedController> rightMotor);
[[deprecated("Raw pointers are deprecated; use shared_ptr instead.")]]
RobotDrive(SpeedController *frontLeftMotor, SpeedController *rearLeftMotor,
SpeedController *frontRightMotor, SpeedController *rearRightMotor);
[[deprecated("References are deprecated; use shared_ptr instead.")]]
RobotDrive(SpeedController &frontLeftMotor, SpeedController &rearLeftMotor,
SpeedController &frontRightMotor, SpeedController &rearRightMotor);
RobotDrive(::std::shared_ptr<SpeedController> frontLeftMotor,
::std::shared_ptr<SpeedController> rearLeftMotor,
::std::shared_ptr<SpeedController> frontRightMotor,
::std::shared_ptr<SpeedController> rearRightMotor);
RobotDrive(std::shared_ptr<SpeedController> frontLeftMotor,
std::shared_ptr<SpeedController> rearLeftMotor,
std::shared_ptr<SpeedController> frontRightMotor,
std::shared_ptr<SpeedController> rearRightMotor);
virtual ~RobotDrive() = default;
RobotDrive(const RobotDrive&) = delete;
@@ -114,10 +114,10 @@ class RobotDrive : public MotorSafety, public ErrorBase {
static const int32_t kMaxNumberOfMotors = 4;
float m_sensitivity = 0.5;
double m_maxOutput = 1.0;
::std::shared_ptr<SpeedController> m_frontLeftMotor = nullptr;
::std::shared_ptr<SpeedController> m_frontRightMotor = nullptr;
::std::shared_ptr<SpeedController> m_rearLeftMotor = nullptr;
::std::shared_ptr<SpeedController> m_rearRightMotor = nullptr;
std::shared_ptr<SpeedController> m_frontLeftMotor = nullptr;
std::shared_ptr<SpeedController> m_frontRightMotor = nullptr;
std::shared_ptr<SpeedController> m_rearLeftMotor = nullptr;
std::shared_ptr<SpeedController> m_rearRightMotor = nullptr;
std::unique_ptr<MotorSafetyHelper> m_safetyHelper;
uint8_t m_syncGroup = 0;

8
wpilibc/wpilibC++Devices/include/Servo.h
View File

@@ -30,16 +30,16 @@ class Servo : public SafePWM {
static float GetMaxAngle() { return kMaxServoAngle; }
static float GetMinAngle() { return kMinServoAngle; }
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
private:
float GetServoAngleRange() const { return kMaxServoAngle - kMinServoAngle; }

8
wpilibc/wpilibC++Devices/include/Solenoid.h
View File

@@ -30,16 +30,16 @@ class Solenoid : public SolenoidBase,
virtual bool Get() const;
bool IsBlackListed() const;
void ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
void ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
bool isNew);
void UpdateTable();
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(::std::shared_ptr<ITable> subTable);
::std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
private:
uint32_t m_channel; ///< The channel on the module to control.
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

2
wpilibc/wpilibC++Devices/include/SolenoidBase.h
View File

@@ -35,5 +35,5 @@ class SolenoidBase : public SensorBase {
static void* m_ports[m_maxModules][m_maxPorts];
uint32_t m_moduleNumber; ///< Slot number where the module is plugged into
///the chassis.
static ::std::unique_ptr<Resource> m_allocated;
static std::unique_ptr<Resource> m_allocated;
};

14
wpilibc/wpilibC++Devices/include/Ultrasonic.h
View File

@@ -54,8 +54,8 @@ class Ultrasonic : public SensorBase,
Ultrasonic(DigitalOutput &pingChannel, DigitalInput &echoChannel,
DistanceUnit units = kInches);
Ultrasonic(::std::shared_ptr<DigitalOutput> pingChannel,
::std::shared_ptr<DigitalInput> echoChannel,
Ultrasonic(std::shared_ptr<DigitalOutput> pingChannel,
std::shared_ptr<DigitalInput> echoChannel,
DistanceUnit units = kInches);
Ultrasonic(uint32_t pingChannel, uint32_t echoChannel,
DistanceUnit units = kInches);
@@ -77,8 +77,8 @@ class Ultrasonic : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
void Initialize();
@@ -98,13 +98,13 @@ class Ultrasonic : public SensorBase,
static std::atomic<bool> m_automaticEnabled; // automatic round robin mode
static priority_mutex m_mutex; // synchronize access to the list of sensors
::std::shared_ptr<DigitalOutput> m_pingChannel;
::std::shared_ptr<DigitalInput> m_echoChannel;
std::shared_ptr<DigitalOutput> m_pingChannel;
std::shared_ptr<DigitalInput> m_echoChannel;
bool m_allocatedChannels;
bool m_enabled;
Counter m_counter;
Ultrasonic *m_nextSensor;
DistanceUnit m_units;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

4
wpilibc/wpilibC++Devices/src/ADXL345_I2C.cpp
View File

@@ -88,7 +88,7 @@ std::string ADXL345_I2C::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void ADXL345_I2C::InitTable(::std::shared_ptr<ITable> subtable) {
void ADXL345_I2C::InitTable(std::shared_ptr<ITable> subtable) {
m_table = subtable;
UpdateTable();
}
@@ -99,4 +99,4 @@ void ADXL345_I2C::UpdateTable() {
m_table->PutNumber("Z", GetZ());
}
::std::shared_ptr<ITable> ADXL345_I2C::GetTable() const { return m_table; }
std::shared_ptr<ITable> ADXL345_I2C::GetTable() const { return m_table; }

4
wpilibc/wpilibC++Devices/src/ADXL345_SPI.cpp
View File

@@ -122,7 +122,7 @@ std::string ADXL345_SPI::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void ADXL345_SPI::InitTable(::std::shared_ptr<ITable> subtable) {
void ADXL345_SPI::InitTable(std::shared_ptr<ITable> subtable) {
m_table = subtable;
UpdateTable();
}
@@ -135,4 +135,4 @@ void ADXL345_SPI::UpdateTable() {
}
}
::std::shared_ptr<ITable> ADXL345_SPI::GetTable() const { return m_table; }
std::shared_ptr<ITable> ADXL345_SPI::GetTable() const { return m_table; }

8
wpilibc/wpilibC++Devices/src/AnalogAccelerometer.cpp
View File

@@ -27,7 +27,7 @@ void AnalogAccelerometer::InitAccelerometer() {
* connected to
*/
AnalogAccelerometer::AnalogAccelerometer(int32_t channel) {
m_analogInput = ::std::make_shared<AnalogInput>(channel);
m_analogInput = std::make_shared<AnalogInput>(channel);
InitAccelerometer();
}
@@ -61,7 +61,7 @@ AnalogAccelerometer::AnalogAccelerometer(AnalogInput *channel)
* @param channel The existing AnalogInput object for the analog input the
* accelerometer is connected to
*/
AnalogAccelerometer::AnalogAccelerometer(::std::shared_ptr<AnalogInput> channel)
AnalogAccelerometer::AnalogAccelerometer(std::shared_ptr<AnalogInput> channel)
: m_analogInput(channel) {
if (channel == nullptr) {
wpi_setWPIError(NullParameter);
@@ -126,9 +126,9 @@ std::string AnalogAccelerometer::GetSmartDashboardType() const {
return "Accelerometer";
}
void AnalogAccelerometer::InitTable(::std::shared_ptr<ITable> subTable) {
void AnalogAccelerometer::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> AnalogAccelerometer::GetTable() const { return m_table; }
std::shared_ptr<ITable> AnalogAccelerometer::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/AnalogInput.cpp
View File

@@ -13,7 +13,7 @@
#include <sstream>
static ::std::unique_ptr<Resource> inputs;
static std::unique_ptr<Resource> inputs;
const uint8_t AnalogInput::kAccumulatorModuleNumber;
const uint32_t AnalogInput::kAccumulatorNumChannels;
@@ -413,9 +413,9 @@ std::string AnalogInput::GetSmartDashboardType() const {
return "Analog Input";
}
void AnalogInput::InitTable(::std::shared_ptr<ITable> subTable) {
void AnalogInput::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> AnalogInput::GetTable() const { return m_table; }
std::shared_ptr<ITable> AnalogInput::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/AnalogOutput.cpp
View File

@@ -12,7 +12,7 @@
#include <sstream>
static ::std::unique_ptr<Resource> outputs;
static std::unique_ptr<Resource> outputs;
/**
* Construct an analog output on the given channel.
@@ -91,9 +91,9 @@ std::string AnalogOutput::GetSmartDashboardType() const {
return "Analog Output";
}
void AnalogOutput::InitTable(::std::shared_ptr<ITable> subTable) {
void AnalogOutput::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> AnalogOutput::GetTable() const { return m_table; }
std::shared_ptr<ITable> AnalogOutput::GetTable() const { return m_table; }

8
wpilibc/wpilibC++Devices/src/AnalogPotentiometer.cpp
View File

@@ -12,7 +12,7 @@
*/
AnalogPotentiometer::AnalogPotentiometer(int channel, double fullRange,
double offset)
: m_analog_input(::std::make_unique<AnalogInput>(channel)),
: m_analog_input(std::make_unique<AnalogInput>(channel)),
m_fullRange(fullRange),
m_offset(offset) {}
@@ -45,7 +45,7 @@ AnalogPotentiometer::AnalogPotentiometer(AnalogInput *input, double fullRange,
* @param offset The angular value (in desired units) representing the angular
* output at 0V.
*/
AnalogPotentiometer::AnalogPotentiometer(::std::shared_ptr<AnalogInput> input,
AnalogPotentiometer::AnalogPotentiometer(std::shared_ptr<AnalogInput> input,
double fullRange, double offset)
: m_analog_input(input), m_fullRange(fullRange), m_offset(offset) {}
@@ -78,7 +78,7 @@ std::string AnalogPotentiometer::GetSmartDashboardType() const {
/**
* Live Window code, only does anything if live window is activated.
*/
void AnalogPotentiometer::InitTable(::std::shared_ptr<ITable> subtable) {
void AnalogPotentiometer::InitTable(std::shared_ptr<ITable> subtable) {
m_table = subtable;
UpdateTable();
}
@@ -89,4 +89,4 @@ void AnalogPotentiometer::UpdateTable() {
}
}
::std::shared_ptr<ITable> AnalogPotentiometer::GetTable() const { return m_table; }
std::shared_ptr<ITable> AnalogPotentiometer::GetTable() const { return m_table; }

4
wpilibc/wpilibC++Devices/src/AnalogTrigger.cpp
View File

@@ -151,9 +151,9 @@ bool AnalogTrigger::GetTriggerState() {
* @param type An enum of the type of output object to create.
* @return A pointer to a new AnalogTriggerOutput object.
*/
::std::shared_ptr<AnalogTriggerOutput> AnalogTrigger::CreateOutput(
std::shared_ptr<AnalogTriggerOutput> AnalogTrigger::CreateOutput(
AnalogTriggerType type) const {
if (StatusIsFatal()) return nullptr;
return ::std::shared_ptr<AnalogTriggerOutput>(
return std::shared_ptr<AnalogTriggerOutput>(
new AnalogTriggerOutput(*this, type), NullDeleter<AnalogTriggerOutput>());
}

4
wpilibc/wpilibC++Devices/src/BuiltInAccelerometer.cpp
View File

@@ -52,7 +52,7 @@ std::string BuiltInAccelerometer::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void BuiltInAccelerometer::InitTable(::std::shared_ptr<ITable> subtable) {
void BuiltInAccelerometer::InitTable(std::shared_ptr<ITable> subtable) {
m_table = subtable;
UpdateTable();
}
@@ -65,4 +65,4 @@ void BuiltInAccelerometer::UpdateTable() {
}
}
::std::shared_ptr<ITable> BuiltInAccelerometer::GetTable() const { return m_table; }
std::shared_ptr<ITable> BuiltInAccelerometer::GetTable() const { return m_table; }

8
wpilibc/wpilibC++Devices/src/CANJaguar.cpp
View File

@@ -31,7 +31,7 @@ static const uint32_t kFullMessageIDMask =
static const int32_t kReceiveStatusAttempts = 50;
static ::std::unique_ptr<Resource> allocated;
static std::unique_ptr<Resource> allocated;
static int32_t sendMessageHelper(uint32_t messageID, const uint8_t *data,
uint8_t dataSize, int32_t period) {
@@ -1935,7 +1935,7 @@ uint8_t CANJaguar::GetDeviceID() const { return m_deviceNumber; }
*/
void CANJaguar::StopMotor() { DisableControl(); }
void CANJaguar::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void CANJaguar::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
Set(value.f);
}
@@ -1977,9 +1977,9 @@ std::string CANJaguar::GetSmartDashboardType() const {
return "Speed Controller";
}
void CANJaguar::InitTable(::std::shared_ptr<ITable> subTable) {
void CANJaguar::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> CANJaguar::GetTable() const { return m_table; }
std::shared_ptr<ITable> CANJaguar::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/CANTalon.cpp
View File

@@ -1270,7 +1270,7 @@ bool CANTalon::GetInverted() const { return m_isInverted; }
*/
void CANTalon::StopMotor() { Disable(); }
void CANTalon::ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void CANTalon::ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
Set(value.f);
}
@@ -1297,9 +1297,9 @@ std::string CANTalon::GetSmartDashboardType() const {
return "Speed Controller";
}
void CANTalon::InitTable(::std::shared_ptr<ITable> subTable) {
void CANTalon::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> CANTalon::GetTable() const { return m_table; }
std::shared_ptr<ITable> CANTalon::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/Compressor.cpp
View File

@@ -260,14 +260,14 @@ void Compressor::StopLiveWindowMode() {}
std::string Compressor::GetSmartDashboardType() const { return "Compressor"; }
void Compressor::InitTable(::std::shared_ptr<ITable> subTable) {
void Compressor::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Compressor::GetTable() const { return m_table; }
std::shared_ptr<ITable> Compressor::GetTable() const { return m_table; }
void Compressor::ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void Compressor::ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
if (value.b)
Start();

38
wpilibc/wpilibC++Devices/src/Counter.cpp
View File

@@ -67,7 +67,7 @@ Counter::Counter(DigitalSource *source) : Counter() {
* @param source A pointer to the existing DigitalSource object. It will be
* set as the Up Source.
*/
Counter::Counter(::std::shared_ptr<DigitalSource> source) : Counter() {
Counter::Counter(std::shared_ptr<DigitalSource> source) : Counter() {
SetUpSource(source);
ClearDownSource();
}
@@ -126,9 +126,9 @@ Counter::Counter(const AnalogTrigger &trigger) : Counter() {
Counter::Counter(EncodingType encodingType, DigitalSource *upSource,
DigitalSource *downSource, bool inverted)
: Counter(encodingType,
::std::shared_ptr<DigitalSource>(upSource,
std::shared_ptr<DigitalSource>(upSource,
NullDeleter<DigitalSource>()),
::std::shared_ptr<DigitalSource>(downSource,
std::shared_ptr<DigitalSource>(downSource,
NullDeleter<DigitalSource>()),
inverted) {}
@@ -141,8 +141,8 @@ Counter::Counter(EncodingType encodingType, DigitalSource *upSource,
* @param inverted True to invert the output (reverse the direction)
*/
Counter::Counter(EncodingType encodingType,
::std::shared_ptr<DigitalSource> upSource,
::std::shared_ptr<DigitalSource> downSource, bool inverted)
std::shared_ptr<DigitalSource> upSource,
std::shared_ptr<DigitalSource> downSource, bool inverted)
: Counter(kExternalDirection) {
if (encodingType != k1X && encodingType != k2X) {
wpi_setWPIErrorWithContext(
@@ -185,7 +185,7 @@ Counter::~Counter() {
*/
void Counter::SetUpSource(int32_t channel) {
if (StatusIsFatal()) return;
SetUpSource(::std::make_shared<DigitalInput>(channel));
SetUpSource(std::make_shared<DigitalInput>(channel));
}
/**
@@ -198,7 +198,7 @@ void Counter::SetUpSource(int32_t channel) {
"SetUpSource(shared_ptr).")]]
void Counter::SetUpSource(AnalogTrigger *analogTrigger,
AnalogTriggerType triggerType) {
SetUpSource(::std::shared_ptr<AnalogTrigger>(analogTrigger,
SetUpSource(std::shared_ptr<AnalogTrigger>(analogTrigger,
NullDeleter<AnalogTrigger>()),
triggerType);
}
@@ -208,7 +208,7 @@ void Counter::SetUpSource(AnalogTrigger *analogTrigger,
* @param analogTrigger The analog trigger object that is used for the Up Source
* @param triggerType The analog trigger output that will trigger the counter.
*/
void Counter::SetUpSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
void Counter::SetUpSource(std::shared_ptr<AnalogTrigger> analogTrigger,
AnalogTriggerType triggerType) {
if (StatusIsFatal()) return;
SetUpSource(analogTrigger->CreateOutput(triggerType));
@@ -219,7 +219,7 @@ void Counter::SetUpSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
* Set the up counting DigitalSource.
* @param source Pointer to the DigitalSource object to set as the up source
*/
void Counter::SetUpSource(::std::shared_ptr<DigitalSource> source) {
void Counter::SetUpSource(std::shared_ptr<DigitalSource> source) {
if (StatusIsFatal()) return;
m_upSource = source;
if (m_upSource->StatusIsFatal()) {
@@ -235,7 +235,7 @@ void Counter::SetUpSource(::std::shared_ptr<DigitalSource> source) {
[[deprecated("Raw pointers are deprecated. Use std::shared_ptr instead.")]]
void Counter::SetUpSource(DigitalSource *source) {
SetUpSource(
::std::shared_ptr<DigitalSource>(source, NullDeleter<DigitalSource>()));
std::shared_ptr<DigitalSource>(source, NullDeleter<DigitalSource>()));
}
/**
@@ -246,7 +246,7 @@ void Counter::SetUpSource(DigitalSource *source) {
[[deprecated("References are deprecated. Use std::shared_ptr instead.")]]
void Counter::SetUpSource(DigitalSource &source) {
SetUpSource(
::std::shared_ptr<DigitalSource>(&source, NullDeleter<DigitalSource>()));
std::shared_ptr<DigitalSource>(&source, NullDeleter<DigitalSource>()));
}
/**
@@ -285,7 +285,7 @@ void Counter::ClearUpSource() {
*/
void Counter::SetDownSource(int32_t channel) {
if (StatusIsFatal()) return;
SetDownSource(::std::make_shared<DigitalInput>(channel));
SetDownSource(std::make_shared<DigitalInput>(channel));
}
/**
@@ -299,7 +299,7 @@ void Counter::SetDownSource(int32_t channel) {
"SetUpSource(shared_ptr).")]]
void Counter::SetDownSource(AnalogTrigger *analogTrigger,
AnalogTriggerType triggerType) {
SetDownSource(::std::shared_ptr<AnalogTrigger>(analogTrigger, NullDeleter<AnalogTrigger>()), triggerType);
SetDownSource(std::shared_ptr<AnalogTrigger>(analogTrigger, NullDeleter<AnalogTrigger>()), triggerType);
}
/**
@@ -308,7 +308,7 @@ void Counter::SetDownSource(AnalogTrigger *analogTrigger,
* Source
* @param triggerType The analog trigger output that will trigger the counter.
*/
void Counter::SetDownSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
void Counter::SetDownSource(std::shared_ptr<AnalogTrigger> analogTrigger,
AnalogTriggerType triggerType) {
if (StatusIsFatal()) return;
SetDownSource(analogTrigger->CreateOutput(triggerType));
@@ -319,7 +319,7 @@ void Counter::SetDownSource(::std::shared_ptr<AnalogTrigger> analogTrigger,
* Set the down counting DigitalSource.
* @param source Pointer to the DigitalSource object to set as the down source
*/
void Counter::SetDownSource(::std::shared_ptr<DigitalSource> source) {
void Counter::SetDownSource(std::shared_ptr<DigitalSource> source) {
if (StatusIsFatal()) return;
m_downSource = source;
if (m_downSource->StatusIsFatal()) {
@@ -334,7 +334,7 @@ void Counter::SetDownSource(::std::shared_ptr<DigitalSource> source) {
[[deprecated("Raw pointers are deprecated. Use std::shared_ptr instead.")]]
void Counter::SetDownSource(DigitalSource *source) {
SetDownSource(::std::shared_ptr<DigitalSource>(source, NullDeleter<DigitalSource>()));
SetDownSource(std::shared_ptr<DigitalSource>(source, NullDeleter<DigitalSource>()));
}
/**
@@ -344,7 +344,7 @@ void Counter::SetDownSource(DigitalSource *source) {
*/
[[deprecated("References are deprecated. Use std::shared_ptr instead.")]]
void Counter::SetDownSource(DigitalSource &source) {
SetDownSource(::std::shared_ptr<DigitalSource>(&source, NullDeleter<DigitalSource>()));
SetDownSource(std::shared_ptr<DigitalSource>(&source, NullDeleter<DigitalSource>()));
}
/**
@@ -600,9 +600,9 @@ void Counter::StopLiveWindowMode() {}
std::string Counter::GetSmartDashboardType() const { return "Counter"; }
void Counter::InitTable(::std::shared_ptr<ITable> subTable) {
void Counter::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Counter::GetTable() const { return m_table; }
std::shared_ptr<ITable> Counter::GetTable() const { return m_table; }

4
wpilibc/wpilibC++Devices/src/DigitalInput.cpp
View File

@@ -100,9 +100,9 @@ std::string DigitalInput::GetSmartDashboardType() const {
return "DigitalInput";
}
void DigitalInput::InitTable(::std::shared_ptr<ITable> subTable) {
void DigitalInput::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> DigitalInput::GetTable() const { return m_table; }
std::shared_ptr<ITable> DigitalInput::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/DigitalOutput.cpp
View File

@@ -196,7 +196,7 @@ uint32_t DigitalOutput::GetModuleForRouting() const { return 0; }
*/
bool DigitalOutput::GetAnalogTriggerForRouting() const { return false; }
void DigitalOutput::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void DigitalOutput::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
Set(value.b);
}
@@ -219,9 +219,9 @@ std::string DigitalOutput::GetSmartDashboardType() const {
return "Digital Output";
}
void DigitalOutput::InitTable(::std::shared_ptr<ITable> subTable) {
void DigitalOutput::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> DigitalOutput::GetTable() const { return m_table; }
std::shared_ptr<ITable> DigitalOutput::GetTable() const { return m_table; }

10
wpilibc/wpilibC++Devices/src/DoubleSolenoid.cpp
View File

@@ -11,8 +11,8 @@
#include <sstream>
::std::unique_ptr<Resource> SolenoidBase::m_allocated =
::std::make_unique<Resource>(solenoid_kNumDO7_0Elements *
std::unique_ptr<Resource> SolenoidBase::m_allocated =
std::make_unique<Resource>(solenoid_kNumDO7_0Elements *
kSolenoidChannels);
/**
@@ -155,7 +155,7 @@ bool DoubleSolenoid::IsRevSolenoidBlackListed() const {
return (blackList & m_reverseMask) ? 1 : 0;
}
void DoubleSolenoid::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void DoubleSolenoid::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
Value lvalue = kOff;
std::string *val = (std::string *)value.ptr;
@@ -192,9 +192,9 @@ std::string DoubleSolenoid::GetSmartDashboardType() const {
return "Double Solenoid";
}
void DoubleSolenoid::InitTable(::std::shared_ptr<ITable> subTable) {
void DoubleSolenoid::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> DoubleSolenoid::GetTable() const { return m_table; }
std::shared_ptr<ITable> DoubleSolenoid::GetTable() const { return m_table; }

14
wpilibc/wpilibC++Devices/src/Encoder.cpp
View File

@@ -58,7 +58,7 @@ void Encoder::InitEncoder(bool reverseDirection, EncodingType encodingType) {
case k1X:
case k2X: {
m_encodingScale = encodingType == k1X ? 1 : 2;
m_counter = ::std::make_unique<Counter>(m_encodingType, m_aSource,
m_counter = std::make_unique<Counter>(m_encodingType, m_aSource,
m_bSource, reverseDirection);
m_index = m_counter->GetFPGAIndex();
break;
@@ -98,8 +98,8 @@ void Encoder::InitEncoder(bool reverseDirection, EncodingType encodingType) {
*/
Encoder::Encoder(uint32_t aChannel, uint32_t bChannel, bool reverseDirection,
EncodingType encodingType) {
m_aSource = ::std::make_shared<DigitalInput>(aChannel);
m_bSource = ::std::make_shared<DigitalInput>(bChannel);
m_aSource = std::make_shared<DigitalInput>(aChannel);
m_bSource = std::make_shared<DigitalInput>(bChannel);
InitEncoder(reverseDirection, encodingType);
}
@@ -139,8 +139,8 @@ Encoder::Encoder(DigitalSource *aSource, DigitalSource *bSource,
InitEncoder(reverseDirection, encodingType);
}
Encoder::Encoder(::std::shared_ptr<DigitalSource> aSource,
::std::shared_ptr<DigitalSource> bSource,
Encoder::Encoder(std::shared_ptr<DigitalSource> aSource,
std::shared_ptr<DigitalSource> bSource,
bool reverseDirection, EncodingType encodingType)
: m_aSource(aSource), m_bSource(bSource) {
if (m_aSource == nullptr || m_bSource == nullptr)
@@ -573,9 +573,9 @@ std::string Encoder::GetSmartDashboardType() const {
return "Encoder";
}
void Encoder::InitTable(::std::shared_ptr<ITable> subTable) {
void Encoder::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Encoder::GetTable() const { return m_table; }
std::shared_ptr<ITable> Encoder::GetTable() const { return m_table; }

2
wpilibc/wpilibC++Devices/src/GearTooth.cpp
View File

@@ -56,7 +56,7 @@ GearTooth::GearTooth(DigitalSource *source, bool directionSensitive)
* @param directionSensitive True to enable the pulse length decoding in
* hardware to specify count direction.
*/
GearTooth::GearTooth(::std::shared_ptr<DigitalSource> source, bool directionSensitive)
GearTooth::GearTooth(std::shared_ptr<DigitalSource> source, bool directionSensitive)
: Counter(source) {
EnableDirectionSensing(directionSensitive);
}

10
wpilibc/wpilibC++Devices/src/Gyro.cpp
View File

@@ -75,7 +75,7 @@ void Gyro::InitGyro() {
can only be used on on-board Analog Inputs 0-1.
*/
Gyro::Gyro(int32_t channel) {
m_analog = ::std::make_shared<AnalogInput>(channel);
m_analog = std::make_shared<AnalogInput>(channel);
InitGyro();
}
@@ -92,7 +92,7 @@ Gyro::Gyro(int32_t channel) {
"Raw pointers are deprecated; consider calling the Gyro constructor with "
"a channel number or passing a shared_ptr instead.")]]
Gyro::Gyro(AnalogInput *channel)
: Gyro(::std::shared_ptr<AnalogInput>(channel,
: Gyro(std::shared_ptr<AnalogInput>(channel,
NullDeleter<AnalogInput>())) {}
/**
@@ -103,7 +103,7 @@ Gyro::Gyro(AnalogInput *channel)
* @param channel A pointer to the AnalogInput object that the gyro is
* connected to.
*/
Gyro::Gyro(::std::shared_ptr<AnalogInput> channel) : m_analog(channel) {
Gyro::Gyro(std::shared_ptr<AnalogInput> channel) : m_analog(channel) {
if (channel == nullptr) {
wpi_setWPIError(NullParameter);
} else {
@@ -228,9 +228,9 @@ void Gyro::StopLiveWindowMode() {}
std::string Gyro::GetSmartDashboardType() const { return "Gyro"; }
void Gyro::InitTable(::std::shared_ptr<ITable> subTable) {
void Gyro::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Gyro::GetTable() const { return m_table; }
std::shared_ptr<ITable> Gyro::GetTable() const { return m_table; }

4
wpilibc/wpilibC++Devices/src/InterruptableSensorBase.cpp
View File

@@ -9,8 +9,8 @@
#include "Utility.h"
#include "WPIErrors.h"
::std::unique_ptr<Resource> InterruptableSensorBase::m_interrupts =
::std::make_unique<Resource>(interrupt_kNumSystems);
std::unique_ptr<Resource> InterruptableSensorBase::m_interrupts =
std::make_unique<Resource>(interrupt_kNumSystems);
InterruptableSensorBase::InterruptableSensorBase() {
}

2
wpilibc/wpilibC++Devices/src/MotorSafetyHelper.cpp
View File

@@ -15,7 +15,7 @@
#include <stdio.h>
#include <sstream>
::std::set<MotorSafetyHelper*> MotorSafetyHelper::m_helperList;
std::set<MotorSafetyHelper*> MotorSafetyHelper::m_helperList;
priority_recursive_mutex MotorSafetyHelper::m_listMutex;
/**

6
wpilibc/wpilibC++Devices/src/PIDController.cpp
View File

@@ -456,7 +456,7 @@ std::string PIDController::GetSmartDashboardType() const {
return "PIDController";
}
void PIDController::InitTable(::std::shared_ptr<ITable> table) {
void PIDController::InitTable(std::shared_ptr<ITable> table) {
if (m_table != nullptr) m_table->RemoveTableListener(this);
m_table = table;
if (m_table != nullptr) {
@@ -470,9 +470,9 @@ void PIDController::InitTable(::std::shared_ptr<ITable> table) {
}
}
::std::shared_ptr<ITable> PIDController::GetTable() const { return m_table; }
std::shared_ptr<ITable> PIDController::GetTable() const { return m_table; }
void PIDController::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void PIDController::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
if (key == kP || key == kI || key == kD || key == kF) {
if (m_P != m_table->GetNumber(kP) || m_I != m_table->GetNumber(kI) ||

6
wpilibc/wpilibC++Devices/src/PWM.cpp
View File

@@ -337,7 +337,7 @@ void PWM::SetZeroLatch() {
wpi_setErrorWithContext(status, getHALErrorMessage(status));
}
void PWM::ValueChanged(::std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
void PWM::ValueChanged(std::shared_ptr<ITable> source, const std::string& key, EntryValue value,
bool isNew) {
SetSpeed(value.f);
}
@@ -364,9 +364,9 @@ void PWM::StopLiveWindowMode() {
std::string PWM::GetSmartDashboardType() const { return "Speed Controller"; }
void PWM::InitTable(::std::shared_ptr<ITable> subTable) {
void PWM::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> PWM::GetTable() const { return m_table; }
std::shared_ptr<ITable> PWM::GetTable() const { return m_table; }

4
wpilibc/wpilibC++Devices/src/PowerDistributionPanel.cpp
View File

@@ -182,9 +182,9 @@ std::string PowerDistributionPanel::GetSmartDashboardType() const {
return "PowerDistributionPanel";
}
void PowerDistributionPanel::InitTable(::std::shared_ptr<ITable> subTable) {
void PowerDistributionPanel::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> PowerDistributionPanel::GetTable() const { return m_table; }
std::shared_ptr<ITable> PowerDistributionPanel::GetTable() const { return m_table; }

2
wpilibc/wpilibC++Devices/src/Preferences.cpp
View File

@@ -513,7 +513,7 @@ static bool isKeyAcceptable(const std::string &value) {
return true;
}
void Preferences::ValueChanged(::std::shared_ptr<ITable> table, const std::string &key,
void Preferences::ValueChanged(std::shared_ptr<ITable> table, const std::string &key,
EntryValue value, bool isNew) {
if (key == kSaveField) {
if (table->GetBoolean(kSaveField, false)) Save();

8
wpilibc/wpilibC++Devices/src/Relay.cpp
View File

@@ -17,7 +17,7 @@
#include <sstream>
// Allocate each direction separately.
static ::std::unique_ptr<Resource> relayChannels;
static std::unique_ptr<Resource> relayChannels;
/**
* Relay constructor given a channel.
@@ -189,7 +189,7 @@ Relay::Value Relay::Get() const {
wpi_setErrorWithContext(status, getHALErrorMessage(status));
}
void Relay::ValueChanged(::std::shared_ptr<ITable> source, const std::string &key,
void Relay::ValueChanged(std::shared_ptr<ITable> source, const std::string &key,
EntryValue value, bool isNew) {
std::string *val = (std::string *)value.ptr;
if (*val == "Off")
@@ -230,9 +230,9 @@ void Relay::StopLiveWindowMode() {
std::string Relay::GetSmartDashboardType() const { return "Relay"; }
void Relay::InitTable(::std::shared_ptr<ITable> subTable) {
void Relay::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Relay::GetTable() const { return m_table; }
std::shared_ptr<ITable> Relay::GetTable() const { return m_table; }

26
wpilibc/wpilibC++Devices/src/RobotDrive.cpp
View File

@@ -23,7 +23,7 @@ const int32_t RobotDrive::kMaxNumberOfMotors;
[[deprecated]]
static auto make_shared_nodelete(SpeedController *ptr) {
return ::std::shared_ptr<SpeedController>(ptr, NullDeleter<SpeedController>());
return std::shared_ptr<SpeedController>(ptr, NullDeleter<SpeedController>());
}
/*
@@ -58,8 +58,8 @@ void RobotDrive::InitRobotDrive() {
*/
RobotDrive::RobotDrive(uint32_t leftMotorChannel, uint32_t rightMotorChannel) {
InitRobotDrive();
m_rearLeftMotor = ::std::make_shared<Talon>(leftMotorChannel);
m_rearRightMotor = ::std::make_shared<Talon>(rightMotorChannel);
m_rearLeftMotor = std::make_shared<Talon>(leftMotorChannel);
m_rearRightMotor = std::make_shared<Talon>(rightMotorChannel);
SetLeftRightMotorOutputs(0.0, 0.0);
}
@@ -80,10 +80,10 @@ RobotDrive::RobotDrive(uint32_t leftMotorChannel, uint32_t rightMotorChannel) {
RobotDrive::RobotDrive(uint32_t frontLeftMotor, uint32_t rearLeftMotor,
uint32_t frontRightMotor, uint32_t rearRightMotor) {
InitRobotDrive();
m_rearLeftMotor = ::std::make_shared<Talon>(rearLeftMotor);
m_rearRightMotor = ::std::make_shared<Talon>(rearRightMotor);
m_frontLeftMotor = ::std::make_shared<Talon>(frontLeftMotor);
m_frontRightMotor = ::std::make_shared<Talon>(frontRightMotor);
m_rearLeftMotor = std::make_shared<Talon>(rearLeftMotor);
m_rearRightMotor = std::make_shared<Talon>(rearRightMotor);
m_frontLeftMotor = std::make_shared<Talon>(frontLeftMotor);
m_frontRightMotor = std::make_shared<Talon>(frontRightMotor);
SetLeftRightMotorOutputs(0.0, 0.0);
}
@@ -120,8 +120,8 @@ RobotDrive::RobotDrive(SpeedController &leftMotor,
m_rearRightMotor = make_shared_nodelete(&rightMotor);
}
RobotDrive::RobotDrive(::std::shared_ptr<SpeedController> leftMotor,
::std::shared_ptr<SpeedController> rightMotor) {
RobotDrive::RobotDrive(std::shared_ptr<SpeedController> leftMotor,
std::shared_ptr<SpeedController> rightMotor) {
InitRobotDrive();
if (leftMotor == nullptr || rightMotor == nullptr) {
wpi_setWPIError(NullParameter);
@@ -174,10 +174,10 @@ RobotDrive::RobotDrive(SpeedController &frontLeftMotor,
m_rearRightMotor = make_shared_nodelete(&rearRightMotor);
}
RobotDrive::RobotDrive(::std::shared_ptr<SpeedController> frontLeftMotor,
::std::shared_ptr<SpeedController> rearLeftMotor,
::std::shared_ptr<SpeedController> frontRightMotor,
::std::shared_ptr<SpeedController> rearRightMotor) {
RobotDrive::RobotDrive(std::shared_ptr<SpeedController> frontLeftMotor,
std::shared_ptr<SpeedController> rearLeftMotor,
std::shared_ptr<SpeedController> frontRightMotor,
std::shared_ptr<SpeedController> rearRightMotor) {
InitRobotDrive();
if (frontLeftMotor == nullptr || rearLeftMotor == nullptr ||
frontRightMotor == nullptr || rearRightMotor == nullptr) {

6
wpilibc/wpilibC++Devices/src/Servo.cpp
View File

@@ -95,7 +95,7 @@ float Servo::GetAngle() const {
return (float)GetPosition() * GetServoAngleRange() + kMinServoAngle;
}
void Servo::ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void Servo::ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
Set(value.f);
}
@@ -120,9 +120,9 @@ void Servo::StopLiveWindowMode() {
std::string Servo::GetSmartDashboardType() const { return "Servo"; }
void Servo::InitTable(::std::shared_ptr<ITable> subTable) {
void Servo::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Servo::GetTable() const { return m_table; }
std::shared_ptr<ITable> Servo::GetTable() const { return m_table; }

6
wpilibc/wpilibC++Devices/src/Solenoid.cpp
View File

@@ -99,7 +99,7 @@ bool Solenoid::IsBlackListed() const {
return (value != 0);
}
void Solenoid::ValueChanged(::std::shared_ptr<ITable> source, const std::string& key,
void Solenoid::ValueChanged(std::shared_ptr<ITable> source, const std::string& key,
EntryValue value, bool isNew) {
Set(value.b);
}
@@ -126,9 +126,9 @@ void Solenoid::StopLiveWindowMode() {
std::string Solenoid::GetSmartDashboardType() const { return "Solenoid"; }
void Solenoid::InitTable(::std::shared_ptr<ITable> subTable) {
void Solenoid::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Solenoid::GetTable() const { return m_table; }
std::shared_ptr<ITable> Solenoid::GetTable() const { return m_table; }

12
wpilibc/wpilibC++Devices/src/Ultrasonic.cpp
View File

@@ -99,8 +99,8 @@ void Ultrasonic::Initialize() {
*/
Ultrasonic::Ultrasonic(uint32_t pingChannel, uint32_t echoChannel,
DistanceUnit units)
: m_pingChannel(::std::make_shared<DigitalOutput>(pingChannel)),
m_echoChannel(::std::make_shared<DigitalInput>(echoChannel)),
: m_pingChannel(std::make_shared<DigitalOutput>(pingChannel)),
m_echoChannel(std::make_shared<DigitalInput>(echoChannel)),
m_counter(m_echoChannel) {
m_units = units;
Initialize();
@@ -164,8 +164,8 @@ Ultrasonic::Ultrasonic(DigitalOutput &pingChannel, DigitalInput &echoChannel,
* determine the range.
* @param units The units returned in either kInches or kMilliMeters
*/
Ultrasonic::Ultrasonic(::std::shared_ptr<DigitalOutput> pingChannel,
::std::shared_ptr<DigitalInput> echoChannel,
Ultrasonic::Ultrasonic(std::shared_ptr<DigitalOutput> pingChannel,
std::shared_ptr<DigitalInput> echoChannel,
DistanceUnit units)
: m_pingChannel(pingChannel),
m_echoChannel(echoChannel),
@@ -345,9 +345,9 @@ void Ultrasonic::StopLiveWindowMode() {}
std::string Ultrasonic::GetSmartDashboardType() const { return "Ultrasonic"; }
void Ultrasonic::InitTable(::std::shared_ptr<ITable> subTable) {
void Ultrasonic::InitTable(std::shared_ptr<ITable> subTable) {
m_table = subTable;
UpdateTable();
}
::std::shared_ptr<ITable> Ultrasonic::GetTable() const { return m_table; }
std::shared_ptr<ITable> Ultrasonic::GetTable() const { return m_table; }

2
wpilibc/wpilibC++IntegrationTests/src/AnalogLoopTest.cpp
View File

@@ -108,7 +108,7 @@ TEST_F(AnalogLoopTest, AsynchronusInterruptWorks) {
trigger.SetLimitsVoltage(2.0f, 3.0f);
// Given an interrupt handler that sets an int to 12345
::std::shared_ptr<AnalogTriggerOutput> triggerOutput = trigger.CreateOutput(kState);
std::shared_ptr<AnalogTriggerOutput> triggerOutput = trigger.CreateOutput(kState);
triggerOutput->RequestInterrupts(InterruptHandler, &param);
triggerOutput->EnableInterrupts();

2
wpilibc/wpilibC++IntegrationTests/src/FakeEncoderTest.cpp
View File

@@ -20,7 +20,7 @@ class FakeEncoderTest : public testing::Test {
Encoder *m_encoder;
AnalogTrigger *m_indexAnalogTrigger;
::std::shared_ptr<AnalogTriggerOutput> m_indexAnalogTriggerOutput;
std::shared_ptr<AnalogTriggerOutput> m_indexAnalogTriggerOutput;
virtual void SetUp() override {
m_outputA = new DigitalOutput(TestBench::kLoop2OutputChannel);

6
wpilibc/wpilibC++Sim/include/AnalogInput.h
View File

@@ -43,13 +43,13 @@ public:
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
uint32_t m_channel;
SimFloatInput* m_impl;
int64_t m_accumulatorOffset;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

6
wpilibc/wpilibC++Sim/include/AnalogPotentiometer.h
View File

@@ -58,9 +58,9 @@ public:
* Live Window code, only does anything if live window is activated.
*/
virtual std::string GetSmartDashboardType() const override;
virtual void InitTable(::std::shared_ptr<ITable> subtable) override;
virtual void InitTable(std::shared_ptr<ITable> subtable) override;
virtual void UpdateTable() override;
virtual ::std::shared_ptr<ITable> GetTable() const override;
virtual std::shared_ptr<ITable> GetTable() const override;
/**
* AnalogPotentiometers don't have to do anything special when entering the LiveWindow.
@@ -75,7 +75,7 @@ public:
private:
double m_scale, m_offset;
AnalogInput* m_analog_input;
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
bool m_init_analog_input;
/**

6
wpilibc/wpilibC++Sim/include/Counter.h
View File

@@ -77,8 +77,8 @@ public:
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
virtual std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
protected:
// TODO: [Not Supported] DigitalSource *m_upSource; ///< What makes the counter count up.
// TODO: [Not Supported] DigitalSource *m_downSource; ///< What makes the counter count down.
@@ -89,5 +89,5 @@ private:
bool m_allocatedDownSource; ///< Was the downSource allocated locally?
uint32_t m_index; ///< The index of this counter.
::std::shared_ptr<ITable> m_table;
std::shared_ptr<ITable> m_table;
};

6
wpilibc/wpilibC++Sim/include/DigitalInput.h
View File

@@ -28,13 +28,13 @@ public:
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(::std::shared_ptr<ITable> subTable) override;
::std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
private:
uint32_t m_channel;
bool m_lastValue;
SimDigitalInput *m_impl;
::std::shared_ptr<ITable> m_table = nullptr;
std::shared_ptr<ITable> m_table = nullptr;
};

Some files were not shown because too many files have changed in this diff Show More