Compiler not recognising overloaded method - c++14

Question

I have some code which is laid out in a specific way (I won't go into the reasons why now) and doesn't compile due to the compiler not seeing the overloaded method.
I've tried all ways of accessing the method and iterators but no such luck.
My code it located here: https://godbolt.org/z/-esVdc and reproduced here for your convenience.
#include <vector>
#include <map>
#include <ctime>
template<typename Value>
class AccessorDetail final
{
public:
using Container = std::deque<Value>;
using ContainerIter = typename std::deque<Value>::iterator;
struct Candle final
{
Container open;
Container high;
Container low;
Container close;
};
using Timeframe = int;
using CandleContainer = std::vector<Candle>;
AccessorDetail(const int timeframe) {};
~AccessorDetail() {};
constexpr auto data() noexcept -> auto&
{
return data_;
}
constexpr auto data() const noexcept -> const auto&
{
return data_;
}
auto erase(const int applied_price, const int timeframe, const ContainerIter start, const ContainerIter finish) -> int
{
switch (applied_price)
{
PRICE_OPEN: data_.at(timeframe).get().open.erase(start, finish); break;
PRICE_HIGH: data_.at(timeframe).get().high.erase(start, finish); break;
PRICE_LOW: data_.at(timeframe).get().low.erase(start, finish); break;
PRICE_CLOSE: data_.at(timeframe).get().close.erase(start, finish); break;
}
return 0;
}
private:
std::map<Timeframe, std::reference_wrapper<Candle>> data_;
CandleContainer candles_;
};
template<typename T, typename U>
struct TimeSeriesData final
{
static_assert(std::is_floating_point<T>::value, "");
static_assert(std::is_integral<U>::value, "");
T price_0;
U time;
};
class DataAccessor
{
public:
DataAccessor(const int timeframe): detail_(timeframe) {};
~DataAccessor() {};
constexpr auto detail() noexcept -> auto&
{
return detail_;
}
constexpr auto detail() const noexcept -> const auto&
{
return detail_;
}
private:
AccessorDetail<TimeSeriesData<double, std::time_t>> detail_;
};
auto main() -> int
{
DataAccessor data_{1};
auto start = data_.detail().data().begin();
auto finish = data_.detail().data().end();
data_.detail().erase(0, 1, start, finish);
}
It should compile but instead I'm seeing the follow error in Visual Studio:
Error C2664 'int AccessorDetail<TimeSeriesData<double,time_t>>::erase(const int,const int,const std::_Deque_iterator<std::_Deque_val<std::_Deque_simple_types<_Ty>>>,const std::_Deque_iterator<std::_Deque_val<std::_Deque_simple_types<_Ty>>>)': cannot convert argument 3 from 'std::_Tree_iterator<std::_Tree_val<std::_Tree_simple_types<_Ty>>>' to 'const std::_Deque_iterator<std::_Deque_val<std::_Deque_simple_types<_Ty>>>'
on this line: data_.detail().erase(0, 1, start, finish);
What am I doing wrong please?

Answer 1

Your iterators start and finish are of type std::map<Timeframe, std::reference_wrapper<Candle>>::iterator. Yet, the erase method expects iterators of type std::deque<Value>::iterator. These types are incompatible, so the compiler is right to refuse compilation.
Your use of auto hides the types from the reader of the code. This is a disadvantage of auto.

Answer 2

There were several errors...no case on the switch in the erase method and not correctly addressing the correct level of the hierarchy in order to initialise the start and finish iterators. Code here: https://godbolt.org/z/aWhFTc and here:
#include <deque>
#include <vector>
#include <map>
#include <ctime>
template<typename Value>
class AccessorDetail final
{
public:
using Container = std::deque<Value>;
using ContainerIter = typename std::deque<Value>::iterator;
struct Candle final
{
Container open;
Container high;
Container low;
Container close;
};
using Timeframe = int;
using CandleContainer = std::vector<Candle>;
AccessorDetail(const int timeframe) {};
~AccessorDetail() {};
constexpr auto data() noexcept -> auto&
{
return data_;
}
constexpr auto data() const noexcept -> const auto&
{
return data_;
}
auto erase(const int applied_price, const int timeframe, const ContainerIter start, const ContainerIter finish) -> int
{
switch (applied_price)
{
case 0: data_.at(timeframe).get().open.erase(start, finish); break;
case 1: data_.at(timeframe).get().high.erase(start, finish); break;
case 2: data_.at(timeframe).get().low.erase(start, finish); break;
case 3: data_.at(timeframe).get().close.erase(start, finish); break;
}
return 0;
}
private:
std::map<Timeframe, std::reference_wrapper<Candle>> data_;
CandleContainer candles_;
};
template<typename T, typename U>
struct TimeSeriesData final
{
static_assert(std::is_floating_point<T>::value, "");
static_assert(std::is_integral<U>::value, "");
T price_0;
U time;
};
class DataAccessor
{
public:
DataAccessor(const int timeframe): detail_(timeframe) {};
~DataAccessor() {};
constexpr auto detail() noexcept -> auto&
{
return detail_;
}
constexpr auto detail() const noexcept -> const auto&
{
return detail_;
}
private:
AccessorDetail<TimeSeriesData<double, std::time_t>> detail_;
};
auto main() -> int
{
DataAccessor data_{1};
auto timeframe = int{1};
auto start = data_.detail().data().at(timeframe).get().open.begin();
auto finish = data_.detail().data().at(timeframe).get().open.end();
data_.detail().erase(0, 1, start, finish);
}