mlConstantString.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2016, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_CONSTANT_STRING_H
#define ML_CONSTANT_STRING_H
 
 
#include "mlUtilsSystem.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <string>
#include <boost/functional/hash.hpp>
#include <ThirdPartyWarningsRestore.h>
 
ML_UTILS_START_NAMESPACE
 
class ConstantString;
 
class ConstantStringValue
{
public:
  friend class ConstantString;
 
  ConstantStringValue() : _hash(0),_refCount(0) {
  }
 
  ConstantStringValue(const std::string& value) :_value(value), _refCount(0) {
    boost::hash<std::string> hasher;
    _hash = hasher(_value);
  }
 
  void incRefCount() const
  {
    _refCount++;
  }
 
  void decRefCount() const
  {
    _refCount--;
    if (_refCount == 0) {
      delete this;
    }
  }
 
  size_t getHash() const { return _hash; }
 
protected:
  ~ConstantStringValue() {
  };
 
private:
  std::string _value;
  size_t _hash;
  mutable MLuint32 _refCount;
};
 
class ConstantString
{
public:
  ConstantString() :_value(nullptr) {
  }
  ConstantString(const std::string& value) {
    if (!value.empty()) {
      _value = new ConstantStringValue(value);
      _value->incRefCount();
    } else {
      _value = nullptr;
    }
  }
  ConstantString(const ConstantString& other) {
    _value = other._value;
    if (_value) {
      _value->incRefCount();
    }
  }
 
  void operator=(const ConstantString& other) {
    if (_value != other._value) {
      if (_value) {
        _value->decRefCount();
      }
      _value = other._value;
      if (_value) {
        _value->incRefCount();
      }
    }
  }
 
  ~ConstantString()
  {
    if (_value) {
      _value->decRefCount();
      _value = nullptr;
    }
  }
 
  bool operator<(const ConstantString& other) const {
    return toString() < other.toString();
  }
 
  bool operator==(const ConstantString& other) const {
    if (other._value == _value) {
      // same string pointers
      return true;
    } else {
      if (_value && other._value) {
        // first compare the hashes
        if (_value->getHash() == other._value->getHash()) {
          // compare the real strings...
          return _value->_value == other._value->_value;
        } else {
          return false;
        }
      } else if (!_value && !other._value) {
        // both null
        return true;
      } else {
        // one null, one different
        return false;
      }
    }
  }
 
  operator std::string() const {
    if (_value) {
      return _value->_value;
    } else {
      return std::string();
    }
  }
 
  operator const std::string&() const {
    if (_value) {
      return _value->_value;
    } else {
      return _emptyString;
    }
  }
 
  const std::string& toString() const {
    if (_value) {
      return _value->_value;
    } else {
      return _emptyString;
    }
  }
 
  bool empty() const {
    return _value == nullptr;
  }
 
  size_t getHash() const {
    if (_value) {
      return _value->getHash();
    } else {
      return 0;
    }
  }
 
private:
  ConstantStringValue* _value;
 
  static ML_UTILS_EXPORT std::string _emptyString;
};
 
inline std::size_t hash_value(ConstantString const& b)
{
  return b.getHash();
}
 
ML_UTILS_END_NAMESPACE
 
#endif