Attribute.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
// This header file originally came from the ROSE project, which is released under a BSD license that requires the following
// notification. All subsequent modifications are licensed as described in Sawyer's top-level "LICENSE" file.
//
//    License for original version:               Revised BSD License (non-advertising clause)
//    License for original version: 
//    License for original version: This software is distributed under the revised Berkeley Software Distribution 
//    License for original version: (BSD) license by Lawrence Livermore National Laboratory LLNL (managed by the 
//    License for original version: University of California).  The revised BSD license is the same as the original
//    License for original version: BSD license, but without the famous advertising clause that was a problem 
//    License for original version: historically (see www.gnu.org/philosophy/bsd.html for details). Our goal
//    License for original version: has been to select as liberal a license as possible for the ROSE project.
//    License for original version: 
//    License for original version: Copyright (c) 2005, 2006, 2007, Regents of the University of California
//    License for original version: All rights reserved.
//    License for original version: 
//    License for original version: Revised BSD License:
//    License for original version: 
//    License for original version: Redistribution and use in source and binary forms, with or without modification, 
//    License for original version: are permitted provided that the following conditions are met:
//    License for original version: 
//    License for original version:     * Redistributions of source code must retain the above copyright notice, 
//    License for original version:       this list of conditions and the following disclaimer.
//    License for original version:     * Redistributions in binary form must reproduce the above copyright notice, 
//    License for original version:       this list of conditions and the following disclaimer in the documentation 
//    License for original version:       and/or other materials provided with the distribution.
//    License for original version:     * Neither the name of the University of California nor the names of its 
//    License for original version:       contributors may be used to endorse or promote products derived from 
//    License for original version:       this software without specific prior written permission.
//    License for original version: 
//    License for original version: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
//    License for original version: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
//    License for original version: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
//    License for original version: IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
//    License for original version: INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
//    License for original version: BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
//    License for original version: DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 
//    License for original version: OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
//    License for original version: OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
//    License for original version: OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef Sawyer_Attribute_H
#define Sawyer_Attribute_H
 
#include <boost/any.hpp>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <Sawyer/Exception.h>
#include <Sawyer/Map.h>
#include <Sawyer/Optional.h>
#include <Sawyer/Sawyer.h>
#include <Sawyer/Synchronization.h>
#include <string>
#include <vector>
 
namespace Sawyer {
 
namespace Attribute {
 
typedef size_t Id;
 
SAWYER_EXPORT extern const Id INVALID_ID;
 
SAWYER_EXPORT Id declare(const std::string &name);
 
SAWYER_EXPORT Id declareMaybe(const std::string &name);
 
SAWYER_EXPORT Id id(const std::string &name);
 
SAWYER_EXPORT const std::string& name(Id);
 
class SAWYER_EXPORT DoesNotExist: public Exception::NotFound {
public:
    ~DoesNotExist() throw () {}
 
    explicit DoesNotExist(const std::string &attrName)
        : Exception::NotFound(attrName + " does not exist in object") {}
};
 
class SAWYER_EXPORT AlreadyExists: public Exception::AlreadyExists {
public:
    ~AlreadyExists() throw () {}
 
    AlreadyExists(const std::string &attrName, Id id)
        : Exception::AlreadyExists(attrName + " is already a declared attribute (id=" +
                                   boost::lexical_cast<std::string>(id) + ")") {}
};
 
typedef boost::bad_any_cast WrongQueryType;
 
template<class SyncTag = SAWYER_THREAD_TAG>
class Storage {
public:
    typedef SynchronizationTraits<SyncTag> Sync;
 
private:
    typedef Sawyer::Container::Map<Id, boost::any> AttrMap;
    AttrMap values_;
    mutable typename Sync::Mutex mutex_;
 
public:
    Storage() {}
    ~Storage() {}                                       // possibly required for MSVC linking
 
    Storage(const Storage &other) {
        typename Sync::LockGuard lock(other.mutex_);
        values_ = other.values_;
    }
 
    Storage& operator=(const Storage &other) {
        typename Sync::LockGuard2 lock(mutex_, other.mutex_);
        values_ = other.values_;
        return *this;
    }
 
    bool attributeExists(Id id) const {
        typename Sync::LockGuard lock(mutex_);
        return values_.exists(id);
    }
    
    void eraseAttribute(Id id) {
        typename Sync::LockGuard lock(mutex_);
        values_.erase(id);
    }
 
    void clearAttributes() {
        typename Sync::LockGuard lock(mutex_);
        values_.clear();
    }
 
    template<typename T>
    void setAttribute(Id id, const T &value) {
        typename Sync::LockGuard lock(mutex_);
        values_.insert(id, boost::any(value));
    }
 
    template<typename T>
    bool setAttributeMaybe(Id id, const T &value) {
        typename Sync::LockGuard lock(mutex_);
        if (!values_.exists(id)) {
            values_.insert(id, boost::any(value));
            return true;
        }
        return false;
    }
 
    template<typename T>
    T getAttribute(Id id) const {
        typename Sync::LockGuard lock(mutex_);
        AttrMap::ConstNodeIterator found = values_.find(id);
        if (found == values_.nodes().end()) {
            std::string name = Attribute::name(id);
            if (name.empty()) {
                throw DoesNotExist("attribute id " + boost::lexical_cast<std::string>(id) + " [not declared]");
            } else {
                throw DoesNotExist(name);
            }
        }
        checkBoost();
        return boost::any_cast<T>(values_.getOptional(id).orDefault());
    }
 
    template<typename T>
    Sawyer::Optional<T> getAttributeMaybe(const Id id) const {
        typename Sync::LockGuard lock(mutex_);
        checkBoost();
        if (const auto foundAny = values_.getOptional(id)) {
            return boost::any_cast<T>(*foundAny);
        } else {
            return Sawyer::Nothing();
        }
    }
 
    template<typename T>
    T attributeOrElse(Id id, const T &dflt) const {
        typename Sync::LockGuard lock(mutex_);
        checkBoost();
        return boost::any_cast<T>(values_.getOptional(id).orElse(dflt));
    }
 
    template<typename T>
    T attributeOrDefault(Id id) const {
        typename Sync::LockGuard lock(mutex_);
        AttrMap::ConstNodeIterator found = values_.find(id);
        if (found == values_.nodes().end())
            return T();
        return boost::any_cast<T>(found->value());
    }
 
    template<typename T>
    Sawyer::Optional<T> optionalAttribute(Id id) const {
        typename Sync::LockGuard lock(mutex_);
        AttrMap::ConstNodeIterator found = values_.find(id);
        if (found == values_.nodes().end())
            return Sawyer::Nothing();
        return boost::any_cast<T>(found->value());
    }
 
    size_t nAttributes() const {
        typename Sync::LockGuard lock(mutex_);
        return values_.size();
    }
 
    std::vector<Id> attributeIds() const {
        typename Sync::LockGuard lock(mutex_);
        std::vector<Id> retval;
        retval.reserve(values_.size());
        BOOST_FOREACH (Id id, values_.keys())
            retval.push_back(id);
        return retval;
    }
};
 
} // namespace
} // namespace
 
#endif