SomethingRef.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/nil_generator.hpp>
//#include <duds/general/LanguageTaggedString.hpp>
//#include <duds/GenericValue.hpp>
#include <memory>

namespace duds {

using std::shared_ptr;
using std::weak_ptr;

template <class ST = Something>
class SomethingWeakRef {
    boost::uuids::uuid someId;
    weak_ptr<ST> wp;
public:
    SomethingWeakRef() = default;
    SomethingWeakRef(const SomethingRef &) = default;
    SomethingWeakRef(const weak_ptr<ST> &s) {
        shared_ptr<ST> sp = s.lock();
        if (!sp) {
            throw std::runtime_error();  // FIX THIS!!!!
        }
        someId = sp->uuid();
        wp = s;
    }
    SomethingWeakRef(const shared_ptr<ST> &s) {
        if (!s) {
            throw std::runtime_error();  // FIX THIS!!!!
        }
        someId = s->uuid();
        wp = s;
    }
    const boost::uuids::uuid &uuid() const {
        return someId;
    }
    const weak_ptr<ST> weak() const {
        return wp;
    }
    bool expired() const noexcept {
        return wp.expired();
    }
    shared_ptr<ST> lock() const noexcept {
        return wp.lock();
    }
    void reset() noexcept {
        someId = boost::uuids::nil_uuid();
        wp.reset();
    }
    template <class S>
    bool operator < (const S &s) const {
        return someId < s.uuid();
    }
    template <class S>
    bool operator > (const S &s) const {
        return someId > s.uuid();
    }
    template <class S>
    bool operator <= (const S &s) const {
        return someId <= s.uuid();
    }
    template <class S>
    bool operator >= (const S &s) const {
        return someId >= s.uuid();
    }
    template <class S>
    bool operator == (const S &s) const {
        return someId == s.uuid();
    }
    template <class S>
    bool operator != (const S &s) const {
        return someId != s.uuid();
    }
};

template <class ST = Something>
class SomethingRef {
    shared_ptr<ST> sp;
public:
    SomethingRef() = default;
    SomethingRef(const SomethingRef &) = default;
    SomethingRef(const shared_ptr<ST> &s) {
        if (!s) {
            throw std::runtime_error();  // FIX THIS!!!!
        }
        sp = s;
    }
    const boost::uuids::uuid &uuid() const {
        return sp->uuid();
    }
    const shared_ptr<ST> shared() const {
        return sp;
    }
    ST *get() const {
        return sp.get();
    }
    bool operator bool() const noexcept {
        return sp;
    }
    void reset() noexcept {
        someId = boost::uuids::nil_uuid();
        sp.reset();
    }
    template <class S>
    bool operator < (const S &s) const {
        return sp->uuid() < s.uuid();
    }
    template <class S>
    bool operator > (const S &s) const {
        return sp->uuid() > s.uuid();
    }
    template <class S>
    bool operator <= (const S &s) const {
        return sp->uuid() <= s.uuid();
    }
    template <class S>
    bool operator >= (const S &s) const {
        return sp->uuid() >= s.uuid();
    }
    template <class S>
    bool operator == (const S &s) const {
        return sp->uuid() == s.uuid();
    }
    template <class S>
    bool operator != (const S &s) const {
        return sp->uuid() != s.uuid();
    }
};

template<class C>
struct CompareSharedContent {
    bool operator() (const std::shared_ptr<C> &l,
    const std::shared_ptr<C> &r) const {
        // get arguments
        const C *pl = l.get();
        const C *pr = r.get();
        // have left?
        if (pl) {
            // have right, too?
            if (pr) {
                // have both arguments, so do the compare
                return *pl < *pr;
            }
        }
        // have one or less of the arguments; compare by pointer address
        return pl < pr;
    }
};

// this is asking for trouble
typedef std::set< const std::shared_ptr<Something>, CompareSharedContent<Something> >
    SomethingSet;

}