<Yorlik>
hkaiser: That link doesan't list hpx for me - I think it's bound to certain credentials / organization membership
<hkaiser>
ok, you'll have to register with cicleci to see things, I believe
<hkaiser>
but I'll let you know once it's done
<Yorlik>
You don't have to - I can just check for myself - it's not urgent.
<Yorlik>
Thanks anyways :D
<gonidelis[m]>
hkaiser: K-ballo I am working on making the Sentinel struct to hold the sentinel value. Do you think that the proper syntax would be from `Iterator<std::int64_t, 100>{0}, Sentinel<int64_t>{}` to `Iterator<std::int64_t>{0}, Sentinel<int64_t, 100>{}`or to `Iterator<std::int64_t>{0}, Sentinel<int64_t>{100}` ?
<K-ballo>
`Iterator<std::int64_t>{0}` for sure, as the goal is to move the sentinel value into the sentinel
<gonidelis[m]>
Question: on this implementation `Iterator<std::int64_t, 100>{0}` , `100` is a non-type parameter to the template while `0` is a member initialization (`state(initState)`). Is there any particular reason for that kind of implementation? I mean, why not make `100` (which is the `stopValue`) be accepted as a member too? Or vice versa: why not pass `0` as a non-type parameter to the tamplate?
<gonidelis[m]>
K-ballo: Thanks. You mean `Sentinel<int64_t>{100}` ?
<K-ballo>
no, I haven't made any remark wrt how the sentinel should look.. either way would work, and as you noticed the current implementation is a bit odd at how it does it
<gonidelis[m]>
So, there is no particular reason on why should I choos either way (memb-init-list) or the other (template non-type parameter)....
<gonidelis[m]>
choose^^
<gonidelis[m]>
ok just fixed it!!! (that's a boost :D) The Sentinel now accepts the stopValue. The test works correctly after the change. Could I share it with you somehow before making any new commits? I think it's better for the change to be commited along with the `is_sentinel_for` which I am working on right now...
<gonidelis[m]>
I want to share in order to accept some feedback (I now that the changes are minor, but still....)
<K-ballo>
the change should be its own commit, but sure do share
<hkaiser>
gonidelis[m]: feel free to create a separate PR for this change - might be a good exercise for you on how to do that
<gonidelis[m]>
Ok I will try to publish the change to you through some github branch of mine first
<gonidelis[m]>
My only doubt is wether the variable `Value stop` is misleading. Should I change its name?
<gonidelis[m]>
*I need some guidance on what's going on between branches and build dirs. Let's say I make a change on my_branch. Do I have to `git checkout my_branch` in order for the changes to be compiled? Does this mean that a git branch might be able to run some test while some other git branch might fail on the same test?
<rori>
I'm using `git worktree` so that you have one main hpx source directory where you are on a specific branch, and you can add a wortree on that repo pointing to another folder following another branch, it doesn't copy the .git files from the main source directory so that is pretty optimized, and you can then have 2 build directories compiling 2 different branches
<rori>
You go in your hpx source directory and run `git wtadd <branch_name>`
<rori>
I would change the `Value` template parameter to `ValueType` maybe..
<gonidelis[m]>
rori_[m]: Thank you... I 'll change that ;)
<hkaiser>
gonidelis[m]: LGTM
nikunj has quit [Ping timeout: 260 seconds]
<K-ballo>
gonidelis[m]: sentinel's `stop` value being public looks weak to me, considering the iterator's `state` is protected.. I think I can see why though
<hkaiser>
make it const
<K-ballo>
that would break assignability, and no longer satisfy Sentinel
<K-ballo>
otherwise, not bad
<hkaiser>
K-ballo: fair
<gonidelis[m]>
K-ballo: I had it protected at first but Iterator could not see it then... So should I add const??
<gonidelis[m]>
hkaiser:
<K-ballo>
of course, that's the point of protected
<hkaiser>
make it private and expose it through a const member function
<gonidelis[m]>
hkaiser: oh ok. That sounds great...
<gonidelis[m]>
Theoretically speaking. What's the thread in this way that is implemented?
<K-ballo>
thread?
<gonidelis[m]>
threat ^^
<K-ballo>
theoretically you can modify the sentinel value after you've passed over it
<K-ballo>
not any real threat as the sentinel has no invariants, and it will most likely just be copied anyways
<gonidelis[m]>
1. Why should the exposing function should be const?
<gonidelis[m]>
2. Do we need a function in order to be able to change the sentinel value too?
<hkaiser>
Yorlik: stable should be ready for you now
<Yorlik>
hkaiser: Nice ! Thank you !
rtohid has joined #ste||ar
bita_ has joined #ste||ar
<gonidelis[m]>
Is `concept` a keyword in c++ ?
<hkaiser>
gonidelis[m]: only in c++20
<gonidelis[m]>
So that means I cannot use it right?
<hkaiser>
right
<hkaiser>
hpx relies on c++14
<gonidelis[m]>
yeah you are right...
<gonidelis[m]>
thanks
<gonidelis[m]>
!
<gonidelis[m]>
I am trying to figure out how to implement is_sentinel_for (http://eel.is/c++draft/iterator.concept.sentinel). Do we have something that I can use for "weakly-equality-comparable-with" ?
<gonidelis[m]>
Or do I have to handwrite it from scratch?