Move CameraServer and WPILib headers into their own folder

The old headers were moved into folders because doing so avoids polluting
the system include directories.

Folder names were also normalized to lowercase.

hal/src/main/native/include/simulation/AnalogInSim.h

@@ -0,0 +1,160 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+#pragma once
+
+#ifndef __FRC_ROBORIO__
+
+#include <memory>
+#include <utility>
+
+#include "CallbackStore.h"
+#include "mockdata/AnalogInData.h"
+
+namespace frc {
+namespace sim {
+class AnalogInSim {
+ public:
+  explicit AnalogInSim(int index) { m_index = index; }
+
+  std::unique_ptr<CallbackStore> RegisterInitializedCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInInitializedCallback);
+    store->SetUid(HALSIM_RegisterAnalogInInitializedCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  bool GetInitialized() { return HALSIM_GetAnalogInInitialized(m_index); }
+  void SetInitialized(bool initialized) {
+    HALSIM_SetAnalogInInitialized(m_index, initialized);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAverageBitsCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInAverageBitsCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAverageBitsCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int GetAverageBits() { return HALSIM_GetAnalogInAverageBits(m_index); }
+  void SetAverageBits(int averageBits) {
+    HALSIM_SetAnalogInAverageBits(m_index, averageBits);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterOversampleBitsCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInOversampleBitsCallback);
+    store->SetUid(HALSIM_RegisterAnalogInOversampleBitsCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int GetOversampleBits() { return HALSIM_GetAnalogInOversampleBits(m_index); }
+  void SetOversampleBits(int oversampleBits) {
+    HALSIM_SetAnalogInOversampleBits(m_index, oversampleBits);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterVoltageCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInVoltageCallback);
+    store->SetUid(HALSIM_RegisterAnalogInVoltageCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  double GetVoltage() { return HALSIM_GetAnalogInVoltage(m_index); }
+  void SetVoltage(double voltage) {
+    HALSIM_SetAnalogInVoltage(m_index, voltage);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAccumulatorInitializedCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback,
+        &HALSIM_CancelAnalogInAccumulatorInitializedCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAccumulatorInitializedCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  bool GetAccumulatorInitialized() {
+    return HALSIM_GetAnalogInAccumulatorInitialized(m_index);
+  }
+  void SetAccumulatorInitialized(bool accumulatorInitialized) {
+    HALSIM_SetAnalogInAccumulatorInitialized(m_index, accumulatorInitialized);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAccumulatorValueCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorValueCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAccumulatorValueCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int64_t GetAccumulatorValue() {
+    return HALSIM_GetAnalogInAccumulatorValue(m_index);
+  }
+  void SetAccumulatorValue(int64_t accumulatorValue) {
+    HALSIM_SetAnalogInAccumulatorValue(m_index, accumulatorValue);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAccumulatorCountCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCountCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAccumulatorCountCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int64_t GetAccumulatorCount() {
+    return HALSIM_GetAnalogInAccumulatorCount(m_index);
+  }
+  void SetAccumulatorCount(int64_t accumulatorCount) {
+    HALSIM_SetAnalogInAccumulatorCount(m_index, accumulatorCount);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAccumulatorCenterCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback, &HALSIM_CancelAnalogInAccumulatorCenterCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAccumulatorCenterCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int GetAccumulatorCenter() {
+    return HALSIM_GetAnalogInAccumulatorCenter(m_index);
+  }
+  void SetAccumulatorCenter(int accumulatorCenter) {
+    HALSIM_SetAnalogInAccumulatorCenter(m_index, accumulatorCenter);
+  }
+
+  std::unique_ptr<CallbackStore> RegisterAccumulatorDeadbandCallback(
+      NotifyCallback callback, bool initialNotify) {
+    auto store = std::make_unique<CallbackStore>(
+        m_index, -1, callback,
+        &HALSIM_CancelAnalogInAccumulatorDeadbandCallback);
+    store->SetUid(HALSIM_RegisterAnalogInAccumulatorDeadbandCallback(
+        m_index, &CallbackStoreThunk, store.get(), initialNotify));
+    return store;
+  }
+  int GetAccumulatorDeadband() {
+    return HALSIM_GetAnalogInAccumulatorDeadband(m_index);
+  }
+  void SetAccumulatorDeadband(int accumulatorDeadband) {
+    HALSIM_SetAnalogInAccumulatorDeadband(m_index, accumulatorDeadband);
+  }
+
+  void ResetData() { HALSIM_ResetAnalogInData(m_index); }
+
+ private:
+  int m_index;
+};
+}  // namespace sim
+}  // namespace frc
+#endif  // __FRC_ROBORIO__