dock – VS Code Icon not updated in Bug Sur

dock – VS Code Icon not updated in Bug Sur – Ask Different

Is there an updated tutorial (2021) for GSA Search Engine Ranker? โ€” ๐Ÿ‘‰ GSA SEO and Marketing Forum ๐Ÿ‘ˆ

I realize that many things from the old tutorials are no longer having the same effect in 2021. A good tutorial post would be welcome, in a single topic, for all users of GSA products in 2021.

Tagged:

  • gsaranker

wordpress – CDN (CloudFlare) not updated

A friend of mine in France has this website (www.artnum3d.com) in WordPress, hosted by IONOS, and it seems to run in a CDN (CloudFlare). Part of the site that’s not in WP runs in an iframe. He applied some changes to both the WP and non-WP parts, but neither is visible when reloading the website in a browser, so somehow the CDN isn’t updated with the changes made to the sources. What’s more bizarre is that even after 4 days the changes haven’t been applied. Disclaimer: he knows nothing about CDNs, and I only have a vague idea of how it’s supposed to work.

Could someone please explain how it can be that changes don’t get pushed to CloudFlare? Does one have to configure WP or CF in any way, e.g. how often it should check for updates? What can we check? What can we do? Who can we ask to help us in getting this solved?

unity – How can I change the curved meeting points in my waypoints system so it will be updated in run time?

The post is a bit long but all the scripts are connected.

I have a simple waypoints system.

The first script is moving along LineRenderer line/s positions :

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class MoveOnCurvedLines : MonoBehaviour
{
    public LineRenderer lineRenderer;
    public float speed;
    public bool go = false;
    public bool moveToFirstPositionOnStart = false;
    public float rotSpeed;
    public bool random = false;
    public int currentCurvedLinePointIndex;

    private Vector3() positions;
    private Vector3() pos;
    private int index = 0;
    private bool goForward = true;
    private List<GameObject> curvedLinePoints = new List<GameObject>();
    private int numofposbetweenpoints;
    private bool getPositions = false;
    int randomIndex;
    int curvedPointsIndex;

    // Start is called before the first frame update
    void Start()
    {
        curvedLinePoints = GameObject.FindGameObjectsWithTag("Curved Line Point").ToList();

        if (curvedLinePoints != null && curvedLinePoints.Count > 0)
        {
            transform.rotation = curvedLinePoints(1).transform.rotation;
        }
    }

    Vector3() GetLinePointsInWorldSpace()
    {
        positions = new Vector3(lineRenderer.positionCount);
        //Get the positions which are shown in the inspector 
        lineRenderer.GetPositions(positions);


        //the points returned are in world space
        return positions;
    }

    // Update is called once per frame
    void Update()
    {
        if (lineRenderer.positionCount > 0 && getPositions == false)
        {
            pos = GetLinePointsInWorldSpace();
            numofposbetweenpoints = curvedLinePoints.Count;

            if (moveToFirstPositionOnStart == true)
            {
                transform.position = pos(index);
            }

            getPositions = true;
        }

        if (go == true && lineRenderer.positionCount > 0)
        {
            Move();
        }

        var dist = Vector3.Distance(transform.position, curvedLinePoints(curvedPointsIndex).transform.position);
        if (dist < 0.1f)
        {
            if (curvedPointsIndex < curvedLinePoints.Count - 1)
                curvedPointsIndex++;

            currentCurvedLinePointIndex = curvedPointsIndex;
        }
    }

    int counter = 0;
    int c = 1;
    void Move()
    {
        Vector3 newPos = transform.position;
        float distanceToTravel = speed * Time.deltaTime;

        bool stillTraveling = true;
        while (stillTraveling)
        {
            Vector3 oldPos = newPos;

            newPos = Vector3.MoveTowards(oldPos, pos(index), distanceToTravel);

            distanceToTravel -= Vector3.Distance(newPos, oldPos);
            if (newPos == pos(index)) // Vector3 comparison is approximate so this is ok
            {
                // when you hit a waypoint:
                if (goForward)
                {
                    bool atLastOne = index >= pos.Length - 1;
                    if (!atLastOne)
                    {
                        index++;
                        counter++;
                        if (counter == numofposbetweenpoints)
                        {
                            c++;
                            
                            counter = 0;
                        }
                        if (c == curvedLinePoints.Count - 1)
                        {
                            c = 0;
                        }
                    }
                    else { index--; goForward = false; }
                }
                else
                { // going backwards:
                    bool atFirstOne = index <= 0;
                    if (!atFirstOne)
                    {
                        index--;

                        counter++;
                        if (counter == numofposbetweenpoints)
                        {
                            c++;
                            
                            counter = 0;
                        }
                        if (c == curvedLinePoints.Count - 1)
                        {
                            c = 0;
                        }
                    }
                    else { index++; goForward = true; }
                }
            }
            else
            {
                stillTraveling = false;
            }
        }

        transform.position = newPos;
    }
}

The second script is creating the lines :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GenerateLines : MonoBehaviour
{
    public GameObject linesWaypointsPrefab;
    public int amountOfLines = 30;
    public int minRandRange, maxRandRange;
    public bool randomPositions = false;
    public bool generateNewPositions = false;

    private List<Vector3> linesWaypoints = new List<Vector3>();
    private Transform waypointsLinesParent;

    // Start is called before the first frame update
    void Awake()
    {
        waypointsLinesParent = GameObject.Find("Curved Lines").transform;

        if (generateNewPositions || (linesWaypoints.Count == 0 && amountOfLines > 0))
        {
            GenerateLinesWaypoints();
        }
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    private void GenerateLinesWaypoints()
    {
        for (int i = 0; i < amountOfLines; i++)
        {
            if (randomPositions)
            {
                var randPosX = UnityEngine.Random.Range(minRandRange, maxRandRange);
                var randPosY = UnityEngine.Random.Range(minRandRange, maxRandRange);
                var randPosZ = UnityEngine.Random.Range(minRandRange, maxRandRange);

                if(linesWaypointsPrefab != null)
                {
                    var LineWaypoint = Instantiate(linesWaypointsPrefab, 
                        new Vector3(randPosX, randPosY, randPosZ), Quaternion.identity, waypointsLinesParent);

                    LineWaypoint.name = "Curved Line Point";
                    LineWaypoint.tag = "Curved Line Point";
                }
            }
            else
            {
                if (linesWaypointsPrefab != null)
                {
                    var LineWaypoint = Instantiate(linesWaypointsPrefab,
                        new Vector3(i, i, i), Quaternion.identity, waypointsLinesParent);

                    LineWaypoint.name = "Curved Line Point";
                    LineWaypoint.tag = "Curved Line Point";
                }
            }
        }
    }
}

And last the script that should update in real time in run time the curved line/s positions and the lines positions between each curved point :

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

(RequireComponent( typeof(LineRenderer) ))
public class CurvedLineRenderer : MonoBehaviour 
{
    //PUBLIC
    public float lineSegmentSize = 0.15f;
    public float lineWidth = 0.1f;
    (Tooltip("Enable this to set a custom width for the line end"))
    public bool useCustomEndWidth = false;
    (Tooltip("Custom width for the line end"))
    public float endWidth = 0.1f;
    (Header("Gizmos"))
    public bool showGizmos = true;
    public float gizmoSize = 0.1f;
    public Color gizmoColor = new Color(1,0,0,0.5f);
    //PRIVATE
    private CurvedLinePoint() linePoints = new CurvedLinePoint(0);
    private Vector3() linePositions = new Vector3(0);
    private Vector3() linePositionsOld = new Vector3(0);

    // Update is called once per frame
    public void Update () 
    {
        if (ResetLineRendererPositions.hasReseted == false)
        {
            GetPoints();
            SetPointsToLine();
        }
    }

    public void GetPoints()
    {
        //find curved points in children
        linePoints = this.GetComponentsInChildren<CurvedLinePoint>();

        //add positions
        linePositions = new Vector3(linePoints.Length);
        for (int i = 0; i < linePoints.Length; i++)
        {
            linePositions(i) = linePoints(i).transform.position;
        }
    }

    public void SetPointsToLine()
    {
        //create old positions if they dont match
        if( linePositionsOld.Length != linePositions.Length )
        {
            linePositionsOld = new Vector3(linePositions.Length);
        }

        //check if line points have moved
        bool moved = false;
        for( int i = 0; i < linePositions.Length; i++ )
        {
            //compare
            if( linePositions(i) != linePositionsOld(i) )
            {
                moved = true;
            }
        }

        //update if moved
        if( moved == true )
        {
            LineRenderer line = this.GetComponent<LineRenderer>();

            //get smoothed values
            Vector3() smoothedPoints = LineSmoother.SmoothLine( linePositions, lineSegmentSize );

            //set line settings
            line.positionCount = smoothedPoints.Length;
            line.SetPositions( smoothedPoints );
            line.startWidth = lineWidth;
            line.endWidth = useCustomEndWidth ? endWidth : lineWidth;
        }
    }

    void OnDrawGizmosSelected()
    {
        Update();
    }

    void OnDrawGizmos()
    {
        if( linePoints.Length == 0 )
        {
            GetPoints();
        }

        //settings for gizmos
        foreach( CurvedLinePoint linePoint in linePoints )
        {
            linePoint.showGizmo = showGizmos;
            linePoint.gizmoSize = gizmoSize;
            linePoint.gizmoColor = gizmoColor;
        }
    }
}

The result in the end is some cubes in this case 5 that are connected with lines and a transform that move on the positions of the lines not between the curved points(Cubes) but moving between the positions of the lines :

Result

The problem is with the last script. When the game is running and then when I’m selecting one of the curved points(Cube) and drag it around in the scene window I see it changing it’s position and the line also change but in fact it’s not changing the positions of the line and the position of the curved point in the moving script the first script.

The moving platform is keep moving on the old positions as before and never moving on the new positions.

In this screenshot I moved the fourth curved point(Cube) dragged it around to the right top but the platform is still moving on the old line positions of the fourth curved point(Cube) position it was before I moved it.

Moved one of the Cubes(Curved Point) at run time but the transform(platform) is keep moving on the old positions of the old line and not the new positions on the line after moved the cube

I want to do that when I change the curved points(Cubes) and it’s changing also the lines positions that it will update the transform that should move on this positions.

If I’m not mistaken the last script should do it but it’s not.

In the last script in the Update hasReseted is false all the time :

public void Update () 
    {
        if (ResetLineRendererPositions.hasReseted == false)
        {
            GetPoints();
            SetPointsToLine();
        }
    }

even if I set for a second the hasReseted to true and then to false again and it’s clearing the LineRenderer all lines and positions and re generating them over again the transform platform will keep moving on the old positions.

How do I know what was updated on Whatsapp web?

When Whatsapp Web is updated how can I know what were the updates ? is there a changelog somewhere ?

Please note that I’m asking specifically about Whatsapp Web and not ‘normal’ Whatsapp for mobile or Whatsapp for computers.

c++ – “observer pointer” meant to stay updated when the pointed object is moved in memory

I wasn’t sure about how to name it, maybe “follow_ptr”, “self_updating_ptr”, or “stalking_ptr” or something on those lines. For now it’s called Identifier.

What I’m trying to achieve is a pointer wrapper which will always refer to the same object even when that object is moved in memory (vector resizes is a quite frequent example, also algorithms like std::remove_if that can move elements around).


EDIT:
One requirement is to allow storing objects in sequential containers (like vector and deque) without losing sequential storage as one would by using unique_ptr or shared_ptr. This whole system is not meant to take care about ownership.

It’s my bad for using the term “smart pointer in the original title”, it’s smart in the sense that it follows the pointed object as opposed to an observer pointer which wouldn’t do that.


A requirement is that the object is stored within an “Identified” class. That class is necessary to keep all the Identifiers updated.

The trick is having a double indirection, where a raw pointer living in the heap will point to the object to be stalked:

#include <memory>
#include <stdexcept>

template <typename T>
class Identifier;
template <typename T>
class Identified;

// A pointer to an identified object. This object lives in the heap and is used to share information with all identifiers about the object moving in memory.
template <typename T>
class Inner_identifier
    {
    public:
        Inner_identifier() = default;
        Inner_identifier(T* identified) noexcept : identified{identified} {}

        Inner_identifier(const Inner_identifier& copy) = delete;
        Inner_identifier& operator=(const Inner_identifier& copy) = delete;

        Inner_identifier(Inner_identifier&& move) = delete;
        Inner_identifier& operator=(Inner_identifier&& move) = delete;

        T* identified{nullptr};
    };

The Identifier, or stalker, acts as an in-between a smart pointer and an optional. The idea is that if Identifiers outlive an object, they’re still valid (assuming the user checks with has_value before using them, like with an optional).

I’m unsure if I should just delete the default constructor, so that it’s always certain that an Identifier’s pointer to the Inner_identifier is always valid, and I can get rid of some checks. For now I’ve left it just to make writing the example simpler.

template <typename T>
class Identifier
    {
    public:
        Identifier() = default;
        Identifier(Identified<T>& identified) : inner_identifier{identified.inner_identifier} {}
        Identifier& operator=(Identified<T>& identified) { inner_identifier = identified.inner_identifier; return *this; }

        Identifier(const Identifier& copy) = default;
        Identifier& operator=(const Identifier& copy) = default;

        Identifier(Identifier&& move) = default;
        Identifier& operator=(Identifier&& move) = default;


        const T& operator* () const { check_all(); return *inner_identifier->identified; }
              T& operator* ()       { check_all(); return *inner_identifier->identified; }
        const T* operator->() const { check_all(); return  inner_identifier->identified; }
              T* operator->()       { check_all(); return  inner_identifier->identified; }

        const T* get() const { check_initialized(); return inner_identifier->identified; }
              T* get()       { check_initialized(); return inner_identifier->identified; }

        bool has_value() const noexcept { return inner_identifier && inner_identifier->identified != nullptr; }
        explicit operator bool() const noexcept { return has_value(); }

    private:
        std::shared_ptr<Inner_identifier<T>> inner_identifier{nullptr};

        void check_initialized() const
            {
#ifndef NDEBUG
            if (!inner_identifier) { throw std::runtime_error{"Trying to use an uninitialized Identifier."}; }
#endif
            }

        void check_has_value() const
            {
#ifndef NDEBUG
            if (inner_identifier->identified == nullptr) { throw std::runtime_error{"Trying to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            }

        void check_all() const { check_initialized(); check_has_value(); }
    };

Finally the Identified class, which holds the instance of the object to be pointed to by one or more Identifiers. It is responsible for updating the Inner_identifier whenever it is moved around in memory with either move constructor or move assignment. On the opposite the copy constructor makes sure that the new copy has its own new Inner_identifier and all the existing Identifiers still work with the instance being copied from. Upon destruction, the Inner_identifier is nullified but it will keep existing for reference as long as at least one Identifier to the now defunct object still exists (hence the internal shared_ptrs)

template <typename T>
class Identified
    {
    friend class Identifier<T>;
    public:
        template <typename ...Args>
        Identified(Args&&... args) : object{std::forward<Args>(args)...}, inner_identifier{std::make_shared<Inner_identifier<T>>(&object)} {}
        
        Identified(Identified& copy) : Identified{static_cast<const Identified&>(copy)} {}

        Identified(const Identified& copy) : object{copy.object}, inner_identifier{std::make_shared<Inner_identifier<T>>(&object)} {}
        Identified& operator=(const Identified& copy) { object = copy.object; return *this; } //Note: no need to reassign the pointer, already points to current instance

        Identified(Identified&& move) noexcept : object{std::move(move.object)}, inner_identifier{std::move(move.inner_identifier)} { inner_identifier->identified = &object; }
        Identified& operator=(Identified&& move) noexcept { object = std::move(move.object); inner_identifier = std::move(move.inner_identifier); inner_identifier->identified = &object; return *this; }

        ~Identified() { if (inner_identifier) { inner_identifier->identified = nullptr; } }
        
        const T& operator* () const { return *get(); }
              T& operator* ()       { return *get(); }
        const T* operator->() const { return  get(); }
              T* operator->()       { return  get(); }

        const T* get() const
            {
#ifndef NDEBUG
            if (!inner_identifier || inner_identifier->identified == nullptr) { throw std::runtime_error{"Attempting to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            return &object;
            }

        T* get()
            {
#ifndef NDEBUG
            if (!inner_identifier || inner_identifier->identified == nullptr) { throw std::runtime_error{"Attempting to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            return &object;
            }

        T object;
    private:
        std::shared_ptr<Inner_identifier<T>> inner_identifier;
    };

On top of criticisms, I’d like some advice on naming. If I were to call the Identifier “follow_ptr”, “self_updating_ptr”, or “stalking_ptr”, I’ve no idea how to call the other two classes.

Aside for the first capital letter of the classes, does the interface feel “standard” enough?

Here is an usage example, compile in debug mode for the exceptions:

#include <stdexcept>
#include <iostream>
#include <vector>
#include <algorithm>

struct Base
    {
    int tmp; bool enabled = true; bool alive = true;
    Base(int tmp) : tmp(tmp) {}
    virtual volatile void f() { std::cout << "Base::f" << tmp << std::endl; };
    void g() { std::cout << "Base::g" << tmp << std::endl; };
    };
struct TmpA : public Base
    {
    TmpA(int tmp) : Base(tmp) {}
    virtual volatile void f() override { std::cout << "TmpA::f" << tmp << std::endl; };
    void g() { std::cout << "TmpA::g" << tmp << std::endl;/**/ };
    };
 
int main()
    {
    //Create empty identifiers
    Identifier<TmpA> idn;
    Identifier<TmpA> id1;
    Identifier<TmpA> id5;

    std::vector<Identified<TmpA>> vec;

    if (true)
        {
        //Create some data and assign iit to identifiers
        Identified<TmpA> identified_a1{1};
        Identified<TmpA> identified_will_die{0};

        idn = identified_will_die;
        id1 = identified_a1;
        id5 = vec.emplace_back(5);

        //Move some identified objects around, this also causes the vector to grow, moving the object Identified by id5.
        vec.emplace_back(std::move(identified_a1));
        }

    std::cout << " _______________________________________________ " << std::endl;
    std::cout << "vec(0): " << " "; try { vec(0)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "vec(1): " << " "; try { vec(1)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id1:    " << " "; try { id1->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id5:    " << " "; try { id5->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "null:   " << " "; try { idn->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }

    //Move some identified objects around
    std::partition(vec.begin(), vec.end(), ()(Identified<TmpA>& idobj) { return idobj->tmp > 2; });
    
    std::cout << " _______________________________________________ " << std::endl;
    std::cout << "vec(0): " << " "; try { vec(0)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "vec(1): " << " "; try { vec(1)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id1:    " << " "; try { id1->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id5:    " << " "; try { id5->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "null:   " << " "; try { idn->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    }

c++ – “Smart pointer” meant to stay updated when the pointed object is moved in memory

I wasn’t sure about how to name it, maybe “follow_ptr”, “self_updating_ptr”, or “stalking_ptr” or something on those lines. For now it’s called Identifier.

What I’m trying to achieve is a pointer wrapper which will always refer to the same object even when that object is moved in memory (vector resizes is a quite frequent example, also algorithms like std::remove_if that can move elements around).

A requirement is that the object is stored within an “Identified” class. That class is necessary to keep all the Identifiers updated.

The trick is having a double indirection, where a raw pointer living in the heap will point to the object to be stalked:

#include <memory>
#include <stdexcept>

template <typename T>
class Identifier;
template <typename T>
class Identified;

// A pointer to an identified object. This object lives in the heap and is used to share information with all identifiers about the object moving in memory.
template <typename T>
class Inner_identifier
    {
    public:
        Inner_identifier() = default;
        Inner_identifier(T* identified) noexcept : identified{identified} {}

        Inner_identifier(const Inner_identifier& copy) = delete;
        Inner_identifier& operator=(const Inner_identifier& copy) = delete;

        Inner_identifier(Inner_identifier&& move) = delete;
        Inner_identifier& operator=(Inner_identifier&& move) = delete;

        T* identified{nullptr};
    };

The Identifier, or stalker, acts as an in-between a smart pointer and an optional. The idea is that if Identifiers outlive an object, they’re still valid (assuming the user checks with has_value before using them, like with an optional).

I’m unsure if I should just delete the default constructor, so that it’s always certain that an Identifier’s pointer to the Inner_identifier is always valid, and I can get rid of some checks. For now I’ve left it just to make writing the example simpler.

template <typename T>
class Identifier
    {
    public:
        Identifier() = default;
        Identifier(Identified<T>& identified) : inner_identifier{identified.inner_identifier} {}
        Identifier& operator=(Identified<T>& identified) { inner_identifier = identified.inner_identifier; return *this; }

        Identifier(const Identifier& copy) = default;
        Identifier& operator=(const Identifier& copy) = default;

        Identifier(Identifier&& move) = default;
        Identifier& operator=(Identifier&& move) = default;


        const T& operator* () const { check_all(); return *inner_identifier->identified; }
              T& operator* ()       { check_all(); return *inner_identifier->identified; }
        const T* operator->() const { check_all(); return  inner_identifier->identified; }
              T* operator->()       { check_all(); return  inner_identifier->identified; }

        const T* get() const { check_initialized(); return inner_identifier->identified; }
              T* get()       { check_initialized(); return inner_identifier->identified; }

        bool has_value() const noexcept { return inner_identifier && inner_identifier->identified != nullptr; }
        explicit operator bool() const noexcept { return has_value(); }

    private:
        std::shared_ptr<Inner_identifier<T>> inner_identifier{nullptr};

        void check_initialized() const
            {
#ifndef NDEBUG
            if (!inner_identifier) { throw std::runtime_error{"Trying to use an uninitialized Identifier."}; }
#endif
            }

        void check_has_value() const
            {
#ifndef NDEBUG
            if (inner_identifier->identified == nullptr) { throw std::runtime_error{"Trying to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            }

        void check_all() const { check_initialized(); check_has_value(); }
    };

Finally the Identified class, which holds the instance of the object to be pointed to by one or more Identifiers. It is responsible for updating the Inner_identifier whenever it is moved around in memory with either move constructor or move assignment. On the opposite the copy constructor makes sure that the new copy has its own new Inner_identifier and all the existing Identifiers still work with the instance being copied from. Upon destruction, the Inner_identifier is nullified but it will keep existing for reference as long as at least one Identifier to the now defunct object still exists (hence the internal shared_ptrs)

template <typename T>
class Identified
    {
    friend class Identifier<T>;
    public:
        template <typename ...Args>
        Identified(Args&&... args) : object{std::forward<Args>(args)...}, inner_identifier{std::make_shared<Inner_identifier<T>>(&object)} {}
        
        Identified(Identified& copy) : Identified{static_cast<const Identified&>(copy)} {}

        Identified(const Identified& copy) : object{copy.object}, inner_identifier{std::make_shared<Inner_identifier<T>>(&object)} {}
        Identified& operator=(const Identified& copy) { object = copy.object; return *this; } //Note: no need to reassign the pointer, already points to current instance

        Identified(Identified&& move) noexcept : object{std::move(move.object)}, inner_identifier{std::move(move.inner_identifier)} { inner_identifier->identified = &object; }
        Identified& operator=(Identified&& move) noexcept { object = std::move(move.object); inner_identifier = std::move(move.inner_identifier); inner_identifier->identified = &object; return *this; }

        ~Identified() { if (inner_identifier) { inner_identifier->identified = nullptr; } }
        
        const T& operator* () const { return *get(); }
              T& operator* ()       { return *get(); }
        const T* operator->() const { return  get(); }
              T* operator->()       { return  get(); }

        const T* get() const
            {
#ifndef NDEBUG
            if (!inner_identifier || inner_identifier->identified == nullptr) { throw std::runtime_error{"Attempting to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            return &object;
            }

        T* get()
            {
#ifndef NDEBUG
            if (!inner_identifier || inner_identifier->identified == nullptr) { throw std::runtime_error{"Attempting to retrive object from an identifier which identified object had already been destroyed."}; }
#endif
            return &object;
            }

        T object;
    private:
        std::shared_ptr<Inner_identifier<T>> inner_identifier;
    };

On top of criticisms, I’d like some advice on naming. If I were to call the Identifier “follow_ptr”, “self_updating_ptr”, or “stalking_ptr”, I’ve no idea how to call the other two classes.

Aside for the first capital letter of the classes, does the interface feel “standard” enough?

Here is an usage example, compile in debug mode for the exceptions:

int main()
    {
    //Create empty identifiers
    Identifier<TmpA> idn;
    Identifier<TmpA> id1;
    Identifier<TmpA> id5;

    std::vector<Identified<TmpA>> vec;

    if (true)
        {
        //Create some data and assign iit to identifiers
        Identified<TmpA> identified_a1{1};
        Identified<TmpA> identified_will_die{0};

        idn = identified_will_die;
        id1 = identified_a1;
        id5 = vec.emplace_back(5);

        //Move some identified objects around, this also causes the vector to grow, moving the object Identified by id5.
        vec.emplace_back(std::move(identified_a1));
        }

    std::cout << " _______________________________________________ " << std::endl;
    std::cout << "vec(0): " << " "; try { vec(0)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "vec(1): " << " "; try { vec(1)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id1:    " << " "; try { id1->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id5:    " << " "; try { id5->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "null:   " << " "; try { idn->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }

    //Move some identified objects around
    std::partition(vec.begin(), vec.end(), ()(Identified<TmpA>& idobj) { return idobj->tmp > 2; });
    
    std::cout << " _______________________________________________ " << std::endl;
    std::cout << "vec(0): " << " "; try { vec(0)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "vec(1): " << " "; try { vec(1)->f(); } catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id1:    " << " "; try { id1->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "id5:    " << " "; try { id5->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    std::cout << "null:   " << " "; try { idn->f(); }    catch (std::exception& e) { std::cout << e.what() << std::endl; }
    }

How Often Is "Contributors" Section Updated on Bitcoin.Org

Believe I have a screenshot of contributors organized by number of commits that can be found here. Does anyone know how often this list is updated? Currently I count 361 contributors on that list bit the github repo here list 786 contributors, leading me to believe it has been a while.

enter image description here

flowcharts – how to maintain updated user flows on product team walls

So far, what we do is simply take a large print out of the current feature we are working on and stick it on the wall. As brainstorming sessions and discussions happen about the feature, notes, scribbles and soon enough the printout needs to be updated with a new one as changes need to be made.

What’s the best way to maintain updated user flow without having to make a new printout every time something in it changes? i’m thinking of a more modular approach as separate printouts per screen or stickers for each UI element. but that might be too granular.

What would be the best solution for this, and are there any best practices for this already?

My bus hasn’t left Salem for several hours, no ETA updated – It’s hours behind schedule, What should I do?

I’m waiting for my bus which was scheduled to pick up an hour ago at 1am. I have been tracking it since 10pm, and its ETA hasn’t changed and it shows that the bus is stopped in Salem, hours from where I am, and this has been the status so far. However, the time of its arrival in Salem changed from 10pm to 11:15pm. According to the tracker, its just sitting in Salem. I don’t want to leave unless it shows up, but I also don’t want to remain at the bus stop for hours. There is one bus every 24 hours on this route. The call center doesn’t open until 10am. The 48 hour rule dictates that I’ll need to purchase another ticket if I don’t board this bus, regardless of the reason. Several people are waiting here for the north-bound bus in the hope it’s driver will have answers.

Any help?

DreamProxies - Cheapest USA Elite Private Proxies 100 Private Proxies 200 Private Proxies 400 Private Proxies 1000 Private Proxies 2000 Private Proxies ExtraProxies.com - Buy Cheap Private Proxies Buy 50 Private Proxies Buy 100 Private Proxies Buy 200 Private Proxies Buy 500 Private Proxies Buy 1000 Private Proxies Buy 2000 Private Proxies ProxiesLive Proxies-free.com New Proxy Lists Every Day Proxies123