types.h File Reference

#include <map>
#include <vector>
#include <cctype>
#include <cassert>
#include <sstream>
#include <typeinfo>
#include <string.h>
#include "config.h"
#include "debugging.h"
#include "streamutil.h"
#include <unsupported/Eigen/CXX11/Tensor>
#include <inttypes.h>

Go to the source code of this file.

Classes
class	EssentiaException
struct	case_insensitive_str_cmp
class	OrderedMap< T >
class	EssentiaMap< KeyType, ValueType, Compare >
class	TypeProxy
class	Tuple2< T >
class	BufferInfo

Namespaces
	essentia
	essentia::streaming
	essentia::streaming::BufferUsage

Macros
#define	USE_TYPE_INFO(TokenType)
#define	TENSORRANK   4

Typedefs
typedef uint16_t	uint16
typedef uint32_t	uint32
typedef uint64_t	uint64
typedef int16_t	sint16
typedef int32_t	sint32
typedef int64_t	sint64
typedef unsigned int	uint
typedef float	Real
typedef EssentiaMap< std::string, std::string, string_cmp >	DescriptionMap
typedef int	ReaderID
typedef Real	AudioSample
typedef Tuple2< Real >	StereoSample
template<typename T >
using	Tensor = Eigen::Tensor< T, 4, Eigen::RowMajor >
template<typename T >
using	TensorMap = Eigen::TensorMap< Tensor< T >, 0 >
using	TensorScalar = Eigen::Tensor< Real, 0, Eigen::RowMajor >
using	Tensor1D = Eigen::Tensor< Real, 1, Eigen::RowMajor >
using	Tensor2D = Eigen::Tensor< Real, 2, Eigen::RowMajor >
using	Tensor3D = Eigen::Tensor< Real, 3, Eigen::RowMajor >

Enumerations
enum	BufferUsageType { forSingleFrames , forMultipleFrames , forAudioStream , forLargeAudioStream }

Functions
bool	case_insensitive_char_cmp (char a, char b)
bool	sameType (const std::type_info &t1, const std::type_info &t2)
std::string	nameOfType (const std::type_info &type)
std::string	nameOfType (const TypeProxy &tproxy)
bool	sameType (const TypeProxy &lhs, const TypeProxy &rhs)

Macro Definition Documentation

TENSORRANK

#define TENSORRANK   4

Macro used to define the rank (number of dimensions) of Essentia::Tensor.

USE_TYPE_INFO

#define USE_TYPE_INFO

(

TokenType

)

Value:

  virtual const std::type_info& typeInfo() const {         \
    return typeid(TokenType);                              \
  }                                                        \
  virtual const std::type_info& vectorTypeInfo() const {   \
    return typeid(std::vector<TokenType>);                 \
  }

Use this macro in classes that derive from TypeProxy to automatically make them type-aware

Typedef Documentation

sint16

typedef int16_t sint16

sint32

typedef int32_t sint32

sint64

typedef int64_t sint64

uint

typedef unsigned int uint

uint16

typedef uint16_t uint16

uint32

typedef uint32_t uint32

uint64

typedef uint64_t uint64