pool.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2021  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Essentia
 *
 * Essentia is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation (FSF), either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */
 
#ifndef ESSENTIA_POOL_H
#define ESSENTIA_POOL_H
 
#include "types.h"
#include "threading.h"
#include "utils/tnt/tnt.h"
#include "essentiautil.h"
 
namespace essentia {
 
// standard map and not EssentiaMap because we want a new element
// to be automatically created when it doesn't exist
#define PoolOf(type) std::map<std::string, std::vector<type > >
 
typedef std::string DescriptorName;
 
class Pool {
 
 protected:
  // maps for single values:
  std::map<std::string, Real> _poolSingleReal;
  std::map<std::string, std::string> _poolSingleString;
  std::map<std::string, std::vector<Real> > _poolSingleVectorReal;  
  std::map<std::string, std::vector<std::string> > _poolSingleVectorString;
  std::map<std::string, Tensor<Real> > _poolSingleTensorReal;
 
  // maps for vectors of values:
  PoolOf(Real) _poolReal;
  PoolOf(std::vector<Real>) _poolVectorReal;
  PoolOf(std::string) _poolString;
  PoolOf(std::vector<std::string>) _poolVectorString;
  PoolOf(TNT::Array2D<Real>) _poolArray2DReal;
  PoolOf(Tensor<Real>) _poolTensorReal;
  PoolOf(StereoSample) _poolStereoSample;
 
  // WARNING: this function assumes that all sub-pools are locked
  std::vector<std::string> descriptorNamesNoLocking() const;
 
   void validateKey(const std::string& name);
 
 
 public:
 
  mutable Mutex mutexReal, mutexVectorReal, mutexString, mutexVectorString,
                mutexArray2DReal, mutexStereoSample,
                mutexSingleReal, mutexSingleString, mutexSingleVectorReal,
                mutexSingleVectorString, mutexTensorReal, mutexSingleTensorReal;
 
  void add(const std::string& name, const Real& value, bool validityCheck = false);
 
  void add(const std::string& name, const std::vector<Real>& value, bool validityCheck = false);
 
  void add(const std::string& name, const std::string& value, bool validityCheck = false);
 
  void add(const std::string& name, const std::vector<std::string>& value, bool validityCheck = false);
 
  void add(const std::string& name, const TNT::Array2D<Real>& value, bool validityCheck = false);
 
  void add(const std::string& name, const Tensor<Real>& value, bool validityCheck = false);
 
  void add(const std::string& name, const StereoSample& value, bool validityCheck = false);
 
  template <typename T>
  void append(const std::string& name, const std::vector<T>& values);
 
  void set(const std::string& name, const Real& value, bool validityCheck=false);
 
  void set(const std::string& name, const std::vector<Real>& value, bool validityCheck=false);
 
  void set(const std::string& name, const std::string& value, bool validityCheck=false);
 
  void set(const std::string& name, const std::vector<std::string>& value, bool validityCheck=false);
 
  void set(const std::string& name, const Tensor<Real>& value, bool validityCheck=false);
 
  void merge(Pool& p, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<Real>& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<std::vector<Real> >& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<std::string>& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<std::vector<std::string> >& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<TNT::Array2D<Real> >& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<Tensor<Real> >& value, const std::string& type="");
 
  void merge(const std::string& name, const std::vector<StereoSample>& value, const std::string& type="");
 
  void mergeSingle(const std::string& name, const Real& value, const std::string& type="");
  void mergeSingle(const std::string& name, const std::vector<Real>& value, const std::string& type="");
  void mergeSingle(const std::string& name, const std::string& value, const std::string& type="");
  void mergeSingle(const std::string& name, const std::vector<std::string>& value, const std::string& type="");
  void mergeSingle(const std::string& name, const Tensor<Real> & value, const std::string& type="");
  void remove(const std::string& name);
 
  void removeNamespace(const std::string& ns);
 
  template <typename T>
  const T& value(const std::string& name) const;
 
  template <typename T>
  bool contains(const std::string& name) const;
 
  std::vector<std::string> descriptorNames() const;
 
  std::vector<std::string> descriptorNames(const std::string& ns) const;
 
  const PoolOf(Real)& getRealPool() const { return _poolReal; }
 
  const PoolOf(std::vector<Real>)& getVectorRealPool() const { return _poolVectorReal; }
 
  const PoolOf(std::string)& getStringPool() const { return _poolString; }
 
  const PoolOf(std::vector<std::string>)& getVectorStringPool() const { return _poolVectorString; }
 
  const PoolOf(TNT::Array2D<Real>)& getArray2DRealPool() const { return _poolArray2DReal; }
 
  const PoolOf(Tensor<Real>)& getTensorRealPool() const { return _poolTensorReal; }
 
  const PoolOf(StereoSample)& getStereoSamplePool() const { return _poolStereoSample; }
 
  const std::map<std::string, Real>& getSingleRealPool() const { return _poolSingleReal; }
 
  const std::map<std::string, std::string>& getSingleStringPool() const { return _poolSingleString; }
 
  const std::map<std::string, std::vector<Real> >& getSingleVectorRealPool() const { return _poolSingleVectorReal; }
 
  const std::map<std::string, std::vector<std::string> >& getSingleVectorStringPool() const { return _poolSingleVectorString; }
 
  const std::map<std::string, Tensor<Real> >& getSingleTensorRealPool() const { return _poolSingleTensorReal; }
 
  void checkIntegrity() const;
 
  void clear();
 
  bool isSingleValue(const std::string& name);
};
 
 
// make doxygen skip the macros
 
// T& Pool::value(const DescriptorName& name)
#define SPECIALIZE_VALUE(type, tname)                                          \
template <>                                                                    \
inline const type& Pool::value(const std::string& name) const {                \
  MutexLocker lock(mutex##tname);                                              \
  std::map<std::string,type >::const_iterator result = _pool##tname.find(name);\
  if (result == _pool##tname.end()) {                                          \
    std::ostringstream msg;                                                    \
    msg << "Descriptor name '" << name << "' of type "                         \
        << nameOfType(typeid(type)) << " not found";                           \
    throw EssentiaException(msg);                                              \
  }                                                                            \
  return result->second;                                                       \
}
 
SPECIALIZE_VALUE(Real, SingleReal);
SPECIALIZE_VALUE(std::string, SingleString);
//SPECIALIZE_VALUE(std::vector<std::string>, String);
SPECIALIZE_VALUE(std::vector<std::vector<Real> >, VectorReal);
SPECIALIZE_VALUE(std::vector<std::vector<std::string> >, VectorString);
SPECIALIZE_VALUE(std::vector<TNT::Array2D<Real> >, Array2DReal);
SPECIALIZE_VALUE(std::vector<Tensor<Real> >, TensorReal);
SPECIALIZE_VALUE(Tensor<Real>, SingleTensorReal);
SPECIALIZE_VALUE(std::vector<StereoSample>, StereoSample);
 
// This value function is not under the macro above because it needs to check
// in two separate sub-pools (poolReal and poolSingleVectorReal)
template<>
inline const std::vector<Real>& Pool::value(const std::string& name) const {
  std::map<std::string, std::vector<Real> >::const_iterator result;
  {
    MutexLocker lock(mutexReal);
    result = _poolReal.find(name);
    if (result != _poolReal.end()) {
      return result->second;
    }
  }
 
  {
    MutexLocker lock(mutexSingleVectorReal);
    result = _poolSingleVectorReal.find(name);
    if (result != _poolSingleVectorReal.end()) {
      return result->second;
    }
  }
 
  std::ostringstream msg;
  msg << "Descriptor name '" << name << "' of type "
      << nameOfType(typeid(std::vector<Real>)) << " not found";
  throw EssentiaException(msg);
}
 
// This value function is not under the macro above because it needs to check
// in two separate sub-pools (poolString and poolSingleVectorString)
template<>
inline const std::vector<std::string>& Pool::value(const std::string& name) const {
  std::map<std::string, std::vector<std::string> >::const_iterator result;
  {
    MutexLocker lock(mutexString);
    result = _poolString.find(name);
    if (result != _poolString.end()) {
      return result->second;
    }
  }
 
  {
    MutexLocker lock(mutexSingleVectorString);
    result = _poolSingleVectorString.find(name);
    if (result != _poolSingleVectorString.end()) {
      return result->second;
    }
  }
 
  std::ostringstream msg;
  msg << "Descriptor name '" << name << "' of type "
      << nameOfType(typeid(std::vector<std::string>)) << " not found";
  throw EssentiaException(msg);
}
 
// bool Pool::contains(const DescriptorName& name)
#define SPECIALIZE_CONTAINS(type, tname)                                       \
template <>                                                                    \
inline bool Pool::contains<type>(const std::string& name) const {              \
  MutexLocker lock(mutex##tname);                                              \
  std::map<std::string,type >::const_iterator result = _pool##tname.find(name);\
  if (result == _pool##tname.end()) {                                          \
    return false;                                                              \
  }                                                                            \
  return true;                                                                 \
}
 
SPECIALIZE_CONTAINS(Real, SingleReal);
SPECIALIZE_CONTAINS(std::string, SingleString);
//SPECIALIZE_CONTAINS(std::vector<std::string>, String);
SPECIALIZE_CONTAINS(std::vector<std::vector<Real> >, VectorReal);
SPECIALIZE_CONTAINS(std::vector<std::vector<std::string> >, VectorString);
SPECIALIZE_CONTAINS(std::vector<TNT::Array2D<Real> >, Array2DReal);
SPECIALIZE_CONTAINS(std::vector<Tensor<Real> >, TensorReal);
SPECIALIZE_CONTAINS(Tensor<Real> , SingleTensorReal);
SPECIALIZE_CONTAINS(std::vector<StereoSample>, StereoSample);
 
// This value function is not under the macro above because it needs to check
// in two separate sub-pools (poolReal and poolSingleVectorReal)
template<>
inline bool Pool::contains<std::vector<Real> >(const std::string& name) const {
  std::map<std::string, std::vector<Real> >::const_iterator result;
  {
    MutexLocker lock(mutexReal);
    result = _poolReal.find(name);
    if (result != _poolReal.end()) {
      return true;
    }
  }
 
  {
    MutexLocker lock(mutexSingleVectorReal);
    result = _poolSingleVectorReal.find(name);
    if (result != _poolSingleVectorReal.end()) {
      return true;
    }
  }
 
  return false;
}
 
 
// This value function is not under the macro above because it needs to check
// in two separate sub-pools (poolString and poolSingleVectorString)
template<>
inline bool Pool::contains<std::vector<std::string> >(const std::string& name) const {
  std::map<std::string, std::vector<std::string> >::const_iterator result;
  {
    MutexLocker lock(mutexString);
    result = _poolString.find(name);
    if (result != _poolString.end()) {
      return true;
    }
  }
 
  {
    MutexLocker lock(mutexSingleVectorString);
    result = _poolSingleVectorString.find(name);
    if (result != _poolSingleVectorString.end()) {
      return true;
    }
  }
 
  return false;
}
 
// Used to get a lock over all sub-pools, make sure to update this when adding
// a new sub-pool
#define GLOBAL_LOCK                                         \
MutexLocker lockReal(mutexReal);                            \
MutexLocker lockVectorReal(mutexVectorReal);                \
MutexLocker lockString(mutexString);                        \
MutexLocker lockVectorString(mutexVectorString);            \
MutexLocker lockArray2DReal(mutexArray2DReal);              \
MutexLocker lockTensorReal(mutexTensorReal);              \
MutexLocker lockStereoSample(mutexStereoSample);            \
MutexLocker lockSingleReal(mutexSingleReal);                \
MutexLocker lockSingleString(mutexSingleString);            \
MutexLocker lockSingleVectorReal(mutexSingleVectorReal);    \
MutexLocker lockSingleVectorString(mutexSingleVectorString);\
MutexLocker lockSingleTensorReal(mutexSingleTensorReal);
 
 
 
template<typename T>
inline void Pool::append(const std::string& name, const std::vector<T>& values) {
  throw EssentiaException("Pool::append not implemented for type: ", nameOfType(typeid(T)));
}
 
#define SPECIALIZE_APPEND(type, tname)                                                \
template <>                                                                           \
inline void Pool::append(const std::string& name, const std::vector<type>& values) {  \
  {                                                                                   \
    MutexLocker lock(mutex##tname);                                                   \
    PoolOf(type)::iterator result = _pool##tname.find(name);                          \
    if (result != _pool##tname.end()) {                                               \
                                                                                      \
      std::vector<type>& v = result->second;                                          \
      int vsize = v.size();                                                           \
      v.resize(vsize + values.size());                                                \
      fastcopy(&v[vsize], &values[0], values.size());                                 \
      return;                                                                         \
    }                                                                                 \
  }                                                                                   \
                                                                                      \
  GLOBAL_LOCK                                                                         \
  validateKey(name);                                                                  \
  _pool##tname[name] = values;                                                        \
}
 
 
SPECIALIZE_APPEND(Real, Real);
SPECIALIZE_APPEND(std::vector<Real>, VectorReal);
SPECIALIZE_APPEND(std::string, String);
SPECIALIZE_APPEND(std::vector<std::string>, VectorString);
SPECIALIZE_APPEND(StereoSample, StereoSample);
 
 
} // namespace essentia
 
#endif // ESSENTIA_POOL_H