value.h

/* @file value.h
   concurrency helpers DiagStr, Guarded
*/

#pragma once

#include "spin_lock.h"

namespace mongo {

    template <typename T, SimpleMutex& BY>
    class Guarded {
        T _val;
    public:
        T& ref(const SimpleMutex::scoped_lock& lk) {
            dassert( &lk.m() == &BY );
            return _val;
        }
    };

    // todo: rename this to ThreadSafeString or something
    class DiagStr {
        mutable SpinLock m;
        string _s;
    public:
        DiagStr(const DiagStr& r) : _s(r.get()) { }
        DiagStr(const string& r) : _s(r) { }
        DiagStr() { }
        bool empty() const { 
            scoped_spinlock lk(m);
            return _s.empty();
        }
        string get() const { 
            scoped_spinlock lk(m);
            return _s;
        }
        void set(const char *s) {
            scoped_spinlock lk(m);
            _s = s;
        }
        void set(const string& s) { 
            scoped_spinlock lk(m);
            _s = s;
        }
        operator string() const { return get(); }
        void operator=(const string& s) { set(s); }
        void operator=(const DiagStr& rhs) { 
            set( rhs.get() );
        }

        // == is not defined.  use get() == ... instead.  done this way so one thinks about if composing multiple operations
        bool operator==(const string& s) const; 
    };

}