 CLAM::Add< DataType > | |
 CLAM::Application | |
  CLAM::BaseAudioApplication | |
   CLAM::AudioApplication | |
   CLAM::Win32ConsoleApp | |
 CLAM::DynamicType::AttributePositionBase< NAttrib > | |
 CLAM::AudioDevice | This is the abstract base class for an audio device |
  CLAM::RtAAudioDevice | |
 CLAM::AudioDeviceList | This abstract class allows you to retrieve a list of all available devices (strings) for a certain architecture |
  CLAM::RtAAudioDeviceList | |
 CLAM::AudioFile | |
  CLAM::AudioFileSource | |
  CLAM::AudioFileTarget | |
 CLAM::AudioManager | This class takes care of all the creation of the registration of AudioIn and AudioOut objects, and the creation of AudioDevice objects required |
 CLAM::AudioPlayer | |
 CLAM::BaseMemOp | Class used as base for all operators with memory, useful to define array of operators |
  CLAM::CenterOfGravity< 1, abs, T, U > | |
   CLAM::CentroidTmpl< abs, T, U > | Centroid is 1st order center of gravity |
  CLAM::BiasedPoweredSum< s, abs, T, U > | Class Function that computes Sum((x(i)-mean)^n) using std::accumulate and BiasedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::CenterOfGravity< o, abs, T, U > | Class Function that computes 'oth' order Center of Gravity using WeightedPoweredSum Class Function |
  CLAM::CentralMoment< o, abs, T, U > | Class Function that computes 'oth' order CentralMoment using BiasedPoweredSum Class Function |
  CLAM::ComplexMaxElement< abs, T > | Class Function that computes Max(x(i)) using std::accumulate and ComplexMax<T> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::ComplexMinElement< abs, T > | Class Function that computes Min(x(i)) using std::accumulate and ComplexMin<T> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::CrossCenterOfGravity< o, abs, T, U > | Special CenterOfGravity using 2ond sequence as indexing sequence |
  CLAM::CrossWeightedPoweredSum< s, abs, T > | Class Function that computes Sum(x(i)^n * y(i)) using std::accumulate and WeightedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::GeometricMeanTmpl< T, U > | Class Function that computes Geometric Mean using InnerProduct class function |
  CLAM::InnerProductTmpl< T > | Class Function for computing product of all data in vector |
  CLAM::KurtosisTmpl< abs, T, U > | Class Function that computes Kurtosis Excess using Variance and 4th order central moment |
  CLAM::LogSumTmpl< T > | Class Function for computing logarithmic sum of all data in vector using |
  CLAM::Moment< o, abs, T, U > | Class Function that computes 'oth' order Moment using PoweredSum Class Function |
  CLAM::PoweredSum< s, abs, T > | Class Function that computes Sum(x(i)^n) using std::accumulate and Power<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::RMSTmpl< T, U > | RMS is the square root of the Energy |
  CLAM::SkewTmpl< abs, T, U > | Class Function that computes Skewness using Standard Deviation and 3rd order central moment |
  CLAM::StandardDeviationTmpl< abs, T, U > | Class Function to compute StandardDeviation |
  CLAM::WeightedPoweredSum< s, abs, T > | Class Function that computes Sum(i*x(i)^n) using std::accumulate and WeightedPower<T,s> BinaryOp It also has associated memory so operation is not performed more than necessary |
  CLAM::Moment< 1, abs, T, U > | |
   CLAM::MeanTmpl< abs, T, U > | Mean is 1st order Moment |
  CLAM::PoweredSum< 1, abs, T > | |
   CLAM::SumTmpl< abs, T > | Class Function that computes Sum(x(i)) using std::accumulate and NoPower<T> BinaryOp |
  CLAM::PoweredSum< 2, abs, T > | |
   CLAM::SquaredSumTmpl< abs, T > | Class Function that computes Sum(x(i)^2) using std::accumulate and Square<T> BinaryOp |
   CLAM::SquaredSumTmpl< false, T > | |
    CLAM::EnergyTmpl< T > | Energy is just the squared sum |
  CLAM::PoweredSum< 3, abs, T > | |
   CLAM::CubedSumTmpl< abs, T > | Class Function that computes Sum(x(i)^3) using std::accumulate and Cube<T> BinaryOp |
  CLAM::PoweredSum< o, abs, T > | |
  CLAM::WeightedPoweredSum< 1, abs, T > | |
   CLAM::WeightedSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)) using std::accumulate and WeightedNoPower<T> BinaryOp |
  CLAM::WeightedPoweredSum< 2, abs, T > | |
   CLAM::WeightedSquaredSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)^2)using std::accumulate and WeightedSquare<T> BinaryOp |
  CLAM::WeightedPoweredSum< 3, abs, T > | |
   CLAM::WeightedCubedSumTmpl< abs, T > | Class Function that computes Sum(i*x(i)^3) using std::accumulate and WeightedCube<T> BinaryOp |
  CLAM::WeightedPoweredSum< o, abs, T > | |
 CLAM::BiasedPower< s, abs, T, U > | Binary Operator for use with std::accumulate, for computing Sum((x(i)-k)^n) |
 CLAM::BufferedSDIFFileReader | BufferedSDIFFileReader is an SDIFFileReader that preloads some SDIF frames into an internal buffer so that real-time audio applications won't stall while waiting for disk reading operations |
  CLAM::LoopingSDIFFileReader | This class extends the length of an SDIFFile indefinitely by looping between its frames |
 CALLBACK_INFO | |
 Simac::ChordCorrelator | Correlates PCP's with different ideal chord PCP's |
 Simac::ChordExtractor | |
 Simac::ChordCorrelator::ChordModePatterns | |
 Simac::ChordCorrelator::ChordPattern | |
 Simac::ChordSegmentator | ChordSegmentator divides the analysed audio data into segments characterized by different chords |
 MIDI::ChunkType | |
 CLAM::CircularBuffer< T > | Generic container-like circular buffer class |
 CLAM::CircularBuffer< TData > | |
  CLAM::AudioCircularBuffer | Specialization of the CircularBuffer class for the case of Audio chunks |
 Simac::CircularPeakPicking | This processing takes a vector of scalars magnitudes and returns a list of peaks found considering that the first and last bins are neighbors |
 Simac::CircularPeaksToPCP | This processing constructs a PCP doing the weighted histogram of the energy of a set of circular chromatic peaks |
 Simac::CircularPeakTunner | This processing takes an array of circular peaks with position at pitch units [0,12) and corrects them to be tunned given a tunning center and a reference tune |
 CLAM_FFT_IMPLEMENTATION | |
  CLAM::FFT | |
  CLAM::IFFT | |
 CLAM::AudioCodecs::Codec | A codec implements a file audio format support |
  CLAM::AudioCodecs::MpegCodec | |
  CLAM::AudioCodecs::OggVorbisCodec | Codec inplementation for the Ogg Vorbis audio file format |
  CLAM::AudioCodecs::PCMCodec | |
 CLAM::ComplexMax< abs, T > | Binary Operator for use with std::accumulate, for computing Max(x(i)) |
 CLAM::ComplexMin< abs, T > | Binary Operator for use with std::accumulate, for computing Min(x(i)) |
 CLAM::ComplexTmpl< T > | |
 CLAM::ComplexToPolarCnv< T > | |
 CLAM::Component | Abstract class for objects that can have subitems to be stored on a storage |
  CLAM::Array< TData > | |
  CLAM::Array< TIndex > | |
   CLAM::IndexArray | |
  CLAM::AbstractAttribute | Defines the interface for an Attribute definition in a DescriptionScheme |
   CLAM::Attribute< AttributeType > | This class is the concrete implementation for AbstractAttribute for a given type of attributes |
  CLAM::Array< T > | |
  CLAM::AttributePool | A container for the values for a single attribute along the scope |
  CLAM::BPFTmpl< TX, TY > | |
  CLAM::ConnectionDefinitionAdapter | |
  CLAM::ControlTraceData | |
  CLAM::ControlTraceEvent | |
  CLAM::DescriptionDataPool | Contains the extracted data for a given description process |
  CLAM::DescriptionScheme | The description scheme defines the set of attributes (Attribute) to be used for feature extraction systems |
  CLAM::DynamicType | This class implements a type that is dynamic |
   CLAM::AudioFileHeader | |
   CLAM::AudioTextDescriptors | |
   CLAM::ControlConfig | |
   CLAM::ProcessingConfig | This is an abstract class which serves as interface for configuration classes used as processing object construction arguments, which must derive from it |
    CLAM::ADSRConfig | |
    CLAM::AudioAmplifierConfig | AudioAmplifier configuration object |
    CLAM::AudioAmplifierConfig | AudioAmplifier configuration object |
    CLAM::AudioIOConfig | Configuration of the AudioIn and AudioOut classes |
    CLAM::AudioMixerConfig | |
    CLAM::AudioWindowingConfig | |
    CLAM::AutoPannerConfig | |
    CLAM::BinaryAudioOpConfig | |
    CLAM::BinaryControlOpConfig | |
    CLAM::CepstralTransformConfig | |
    CLAM::CircularShiftConfig | |
    CLAM::CleanTracksConfig | Config class for the CleanTracks Processing |
    CLAM::Control2DataConfig | Configuration for the Control2Data PO |
    CLAM::ControlComparisonConfig | |
    CLAM::ControlFadeConfig | |
    CLAM::ControlIntervalMapperConfig | |
    CLAM::ControllerConfig | Configuration for the Controller PO |
    CLAM::ControlMapperConfig | |
    CLAM::ControlPrinterConfig | |
    CLAM::ControlPrinterTypedConfig | |
    CLAM::ControlScalerConfig | |
    CLAM::ControlSelectorConfig | |
    CLAM::ControlSinkConfig | |
    CLAM::ControlSourceConfig | |
    CLAM::ControlSumConfig | |
    CLAM::ControlTraceReaderConfig | |
    CLAM::ControlTraceWriterConfig | |
    CLAM::DescriptorComputationConfig | |
    CLAM::DispatcherConfig | |
    CLAM::EnvelopeGeneratorConfig | |
    CLAM::EnvExtractorConfig | |
    CLAM::EnvModulatorConfig | |
    CLAM::ERB_SpaceGenConfig | |
    CLAM::FDFilterGenConfig | Configuration class for SpectralFilterGen class |
    CLAM::FFTConfig | Configuration class for FFT classes |
    CLAM::FlagControlConfig | |
    CLAM::FrameAdderConfig | |
    CLAM::FrameInterpConfig | |
    CLAM::FrameTransformationConfig | |
    CLAM::Fundamental2ControlConfig | |
    CLAM::FundFreqDetectConfig | Config class for FundFreqDetect Processing |
    CLAM::IFFTConfig | Config class for the IFFT Processing |
    CLAM::LPCConfig | |
    CLAM::MelFilterBankConfig | |
    CLAM::MIDIClockerConfig | Configuration of the MIDIClocker class |
    CLAM::MIDIDispatcherConfig | |
    CLAM::MIDIFileIOConfig | |
    CLAM::MIDIIOConfig | Configuration of the MIDIIn and MIDIOut classes |
    CLAM::MIDIKeyboardConfig | |
    CLAM::MonoAudioFileReaderConfig | Configuration class for the CLAM::MonoAudioFileReader processing object |
    CLAM::MonoAudioFileWriterConfig | Configuration class for the CLAM::MonoAudioFileWriter processing object |
    CLAM::MultiChannelAudioFileReaderConfig | |
    CLAM::MultiChannelAudioFileWriterConfig | Configuration class for the CLAM::MultiChannelAudioFileWriter processing object |
    CLAM::NormalizationConfig | Normalization is a CLAM implementation of 3 normalization's algorithms |
    CLAM::NullProcessingConfig | |
    CLAM::OscillatorConfig | |
    CLAM::OutControlSenderConfig | |
    CLAM::OverlapAddConfig | Config class for the OverlapAdd Processing |
    CLAM::PeaksAdConfig | |
    CLAM::PeaksInterpConfig | |
    CLAM::PhaseManagementConfig | Config class for the PhaseManagement Processing |
    CLAM::SDIFInConfig | |
    CLAM::SDIFOutConfig | |
    CLAM::SegmentatorConfig | Config class for the Segmentator Processing |
    CLAM::SegmentSMSMorphConfig | |
    CLAM::SegmentSMSTimeStretchConfig | |
    CLAM::SegmentTransformationConfig | Configuration class for all SegmentTransformations |
    CLAM::SimpleOscillatorConfig | |
    CLAM::SinTrackingConfig | Config class for the SinTracking Processing |
    CLAM::SMSAnalysisConfig | |
    CLAM::SMSHarmonizerConfig | The Harmonizer configuration object |
    CLAM::SMSMorphConfig | |
    CLAM::SMSSynthesisConfig | |
    CLAM::SMSTimeStretchConfig | |
    CLAM::SMSTransformationChainConfig | Configuration for a SMSTransformationChain |
    CLAM::SMSTransformationChaineeConfig | Special Processing config that can be used inside a SMSTransformationChainConfig |
    CLAM::SpecAdder2Config | |
    CLAM::SpecAdderConfig | |
    CLAM::SpecInterpConfig | |
    CLAM::SpecSubstracter2Config | |
    CLAM::SpectralAnalysisConfig | Configuration class for Spectral Analysis class It includes specific parameters: HopSize, ZeroPadding, Sampling Rate and FFTSize |
    CLAM::SpectralEnvelopeApplyConfig | Configuration class for SpectralEnvelopeApply objects |
    CLAM::SpectralEnvelopeExtractConfig | Config class for the SpectralEnvelopeExtract Processing |
    CLAM::SpectralPeakDetectConfig | Configuration class for SpectralPeakDetect objects |
    CLAM::SpectralSynthesisConfig | Config class for the SpectralSynthesis Processing |
    CLAM::SynthSineSpectrumConfig | Config class for the SynthSineSpectrum Processing |
    CLAM::TokenDelayConfig | Configuration of the TokenDelay processing object |
    CLAM::TonalAnalysisConfig | |
    CLAM::TopLevelProcessingConfig | |
    CLAM::WaveGeneratorConfig | |
    CLAM::WindowGeneratorConfig | |
    CLAM::ZeroPadderConfig | |
   CLAM::ProcessingData | Interface classe for every concrete processing data (data that flows through the processing objs.) |
    CLAM::Audio | Audio class with the Data Buffer, information about it (SampleRate, BeginTime), and methods to insert and get Audio chunks |
    CLAM::DescriptorTmpl< abs > | Abstract class for all descriptors |
     CLAM::AudioDescriptors | |
     CLAM::FrameDescriptors | |
     CLAM::SegmentDescriptors | |
     CLAM::SpectralDescriptors | |
     CLAM::SpectralPeakDescriptors | |
    CLAM::Envelope | Envelope class |
    CLAM::EnvelopeDescriptors | |
    CLAM::Frame | Processing Data class to encapsulate a frame and all its related information |
    CLAM::Fundamental | Class Fundamental, used to manage the bins candidates to be fundamental frequencies, and their errors |
    CLAM::LPModel | |
    CLAM::MediaTime | Media Time type definition * This type propose a flexible way of defining * the temporal location of an audio segment * Types: {begin, end}, {begin, duration} * This type is thought to be used to define * some kind of probability when defining segment* boundaries * |
    CLAM::MelCepstrum | |
    CLAM::Melody | Class Melody, used to store the melodic description of an AudioSegment @see SegmentDescriptors @see FFHDescriptors @see DistributionDescriptors @see Key |
    CLAM::MelSpectrum | |
    CLAM::MIDIEvent | |
    CLAM::MIDIMelody | Class Melody, used to store the melodic description of a MIDI stream/file @see SegmentDescriptors |
    CLAM::MIDINote | Used to store note information coming from a MIDI stream/file |
    CLAM::MIDISong | |
    CLAM::MIDITrack | |
    CLAM::MorphologicalFrameDescriptors | |
    CLAM::MorphologicalSegmentDescriptors | |
    CLAM::Note | Used to store note information |
    CLAM::PeriodogramPeak | |
    CLAM::PitchNote | Pitch note type definition = pitch + octave |
    CLAM::Segment | Processing Data class to encapsulate a CLAM segment |
    CLAM::SpectralPeak | Class SpectralPeak is a basic spectral domain Processing Data class |
    CLAM::SpectralPeakArray | This processing data class offers an interface for storing an array of spectral peaks while maintaining efficient data access |
    CLAM::Spectrum | Spectrum is a ProcessingData class that allows the following representations: Mag/Phase, Complex, Polar and Break Point Function (BPF) |
   CLAM::ProcessingDataConfig | Base class of ProcessingData settings, all the configurations of ProcessingData objects will be derived of this |
    CLAM::EnvelopeConfig | Configuration class for Envelope data objects |
    CLAM::SpectrumConfig | The Spectrum configuration object |
   CLAM::SampleMetadata | This class should be used to hold meta information about a sound sample |
   CLAM::SimpleLoopMetadata | This object represents the start and end points of a loop |
  CLAM::Enum | Instances of this class represents objects that can adquire a symbolic value from a limited set of symbolic values |
   CLAM::EAudioFileCodec | |
   CLAM::EAudioFileEncoding | |
   CLAM::EAudioFileEndianess | |
   CLAM::EAudioFileFormat | |
   CLAM::EFDFilterGenControls | |
   CLAM::EFDFilterType | Simple filter types, more to be added |
   CLAM::EInterpolation | Interpolation Enumeration to use for specifying the type of interpolation used |
   CLAM::ELoopPointUnits | PhaseGeneration Enumeration to use for specifying the type of phase generation used |
   CLAM::EnumTypedTypes | |
   CLAM::EOscillatorControls | |
   CLAM::EPhaseGeneration | PhaseGeneration Enumeration to use for specifying the type of phase generation used |
   CLAM::EPitch | |
   CLAM::EScale | Interpolation Enumeration to use for specifying the type of scale used (linear or log) |
   CLAM::EWaveType | |
   CLAM::EWindowNormalize | |
   CLAM::EWindowType | |
   CLAM::OutControlSenderConfig::EControlRepresentation | |
   CLAM::OutControlSenderConfig::EMapping | |
  CLAM::FlagsBase | Abstract class from which any Flag<N> instantiation is derived |
   CLAM::Flags< N > | Instances of this class represents objects containing a set of booleans values (flags) that can be accessed by their symbolic name |
   CLAM::Flags< 4 > | |
    CLAM::SpecTypeFlags | This class tells which formats are instantiated in a Spectrum |
  CLAM::InformationTextAdapter | |
  CLAM::List< T > | |
  CLAM::Network | |
  CLAM::Polymorphic< FactoryType > | This class is an utility class to hold polymorphic pointers as attributes on DynamicTypes and simplify the problem of the XML Loading of abstract XML Schema types |
  CLAM::ProcessingDefinitionAdapter | |
  CLAM::ScopePool | A container for the attributes values along the differents contexts of a single scope |
  CLAM::Segmentation | |
   CLAM::ContiguousSegmentation | |
   CLAM::DiscontinuousSegmentation | |
   CLAM::UnsizedSegmentation | |
  CLAM::XMLComponentAdapter | This class adapts to the XMLable interface any object that is a CLAM::Component |
  CLAM::XMLIterableAdapter< T > | This class adapts to the XMLable interface any STL like container of basic objects or CLAM::Component's |
 CLAM::Condition | |
 CLAM::RecursiveMutex::ConditionVar | |
 CLAM::ConfigurationVisitor | |
  CLAM::ConfigurationGetter< Configuration, Builder > | A DynamicType attribute visitor that builds a widget for each attribute using a user interface builder |
  CLAM::ConfigurationSetter< Configuration, Builder > | A DynamicType attribute visitor that takes the attribute values from an a 'Builder' which implements the RetrieveValue |
 CLAM::Network::Connection | |
 SigSlot::Connection | Class that model connections between signals and slots |
 SigSlot::ConnectionHandler< SignalType > | Handler for a given Signal connections |
 Simac::ConstantQFolder | The ConstantQFolder takes a ConstantQ transform and folds its bins into a single Octave to create a Chromagram |
 Simac::ConstantQTransform | ConstantQTransform extract a ConstantQ spectrum using Blankertz's paper algorithm |
 CLAM::ControlArray< ControlT > | This class wrapps a vector (array) of Controls and gives its Controls automatic names at construction |
 Creator | |
  CLAM::FactoryRegistrator< TheFactoryType, ConcreteProductType >::ConcreteCreator | |
 CLAM::Factory< AbstractProductType >::Creator | Abstract class for Creator objects which are stored in the Factory::Registry |
  CLAM::LadspaWrapperBufferCreator | |
  CLAM::LadspaWrapperCreator | |
 CLAM::DataUtil | This class simply holds a few miscellaneous utility methods that are used by multiple classes, but don't fit very well in any class |
 CLAM::DefaultTypeInfo | |
  CLAM::BasicCTypeInfo | C native types TypeInfo base class |
  CLAM::ContainerTypeInfo | |
  CLAM::TypeInfo< T > | |
 CLAM::DescriptionScope | |
 CLAM::Err | Base class for the exception handling classes |
  CLAM::ErrAssertionFailed | The exception thrown when an assertion fails |
  CLAM::ErrDynamicType | Derived class of the Err base class Handles DynamicType errors |
  CLAM::ErrFactory | Error type thrown by Factory classes (Factory, FactoryRegistry) |
  CLAM::ErrFormat | Derived class of the Err base class
Handles format errors |
  CLAM::ErrNotFound | |
  CLAM::ErrOpenFile | Derived class of the Err base class Handles errors in files openings |
  CLAM::ErrOutOfMemory | Derived class of the Err base class Handles memories errors |
  CLAM::ErrProcessingObj | Derived class of the Err base class Handles errors in Processing Object Routines |
   CLAM::ErrSoundFileIO | |
    CLAM::UnavailableSoundFile | |
    CLAM::UnsupportedSoundFileFormat | |
    CLAM::UnsupportedSoundFileSampleEncoding | |
  CLAM::LockError | |
  CLAM::SchemaError | A description scope defines a set of attributes which have the same ocurrences |
  CLAM::ThreadResourceError | |
  CLAM::XmlStorageErr | |
  SndPcmError | |
 MIDI::Reader::Error | |
 MIDI::Event | |
  MIDI::MetaEvent | |
  MIDI::SysExEvent | |
 CLAM::WaveGenerator::EWaveType_eSine | |
 CLAM::Factory< AbstractProductType > | Factory usage example |
 CLAM::Factory< Processing > | |
  CLAM::ProcessingFactory | |
 CLAM::FactoryRegistrator< TheFactoryType, ConcreteProductType > | This class provides a convenient way to add items (creators) into a factory |
 SDIF::File | |
 CLAM::FileSystem | |
 CLAM::Filename::Filter | Item of a Filename filter definition |
 CLAM::FlowControl | |
  CLAM::BasicFlowControl | |
  CLAM::NaiveFlowControl | |
  CLAM::PushFlowControl | |
  CLAM::StaticFlowControl | |
 FourierTransform | |
 SDIF::Frame | SDIF data is stored in frames, that contain number of matrices |
 SDIF::FrameHeader | Base header for all frames |
  SDIF::DataFrameHeader | An extension of FrameHeader, that is used for data frames |
 CLAM::Network::Geometry | |
 SDIF::GetType< T > | |
 SDIF::GetType< CLAM::TByte > | |
 SDIF::GetType< CLAM::TFloat32 > | |
 SDIF::GetType< CLAM::TFloat64 > | |
 SDIF::GetType< CLAM::TInt32 > | |
 SDIF::GetType< CLAM::TInt64 > | |
 SDIF::GetType< TUTF8byte > | |
 CLAM::GreaterThan< x, y > | |
 HandlerBase | |
  CLAM::XercesDomReader | Controls the Xerces-C DOM parser |
 CLAM::Hook< AttributeType > | |
  CLAM::ReadHook< AttributeType > | |
   CLAM::ReadRangedHook< AttributeType > | |
  CLAM::WriteHook< AttributeType > | |
 CLAM::IllegalValue | |
 CLAM::InControlBase | Base class for an inwards control connector |
  CLAM::InControl< ControlDataType > | An InControl receives values of the template type in an asyncronous pace |
   CLAM::TypedInControl< ControlDataType > | Transition class, use InControl instead |
 CLAM::InControlPublisher | |
 CLAM::InControlRegistry | |
 CLAM::InformationText | |
 CLAM::InPortBase | |
  CLAM::InPort< Token > | |
  CLAM::InPortPublisher< Token > | |
  CLAM::InPort< Fundamental > | |
  CLAM::InPort< SpectralPeakArray > | |
  CLAM::InPort< Spectrum > | |
  CLAM::InPort< TData > | |
   CLAM::AudioInPort | |
  CLAM::InPortPublisher< TData > | |
   CLAM::AudioInPortPublisher | |
 CLAM::InPortRegistry | |
 CLAM::ContiguousSegmentation::InsertedOutOfBounds | |
 CLAM::DiscontinuousSegmentation::InsertedOutOfBounds | |
 CLAM::Segmentation::InsertedOutOfBounds | |
 CLAM::UnsizedSegmentation::InsertedOutOfBounds | |
 Simac::InstantTunningEstimator | This processing estimates the most probable tunning of a set of chromatic peaks |
 CLAM::IntervalAmplitudeAverages | Internal class |
 CLAM::LadspaLibrary | A LadspaLibrary represents a pool of ladspa plugins descriptors |
 CLAM::LadspaNetworkExporter | |
 CLAM::LadspaProcessingExporter< ProcessingType > | |
 CLAM::LibXmlDomDocumentHandler | XML implementation backend for the libxml++ library |
 CLAM::LibXmlDomReader | Controls the libxml++ DOM parser |
 CLAM::LibXmlDomReadingContext | Keeps the booking when loading one LibXml DOM single element into CLAM data |
 CLAM::LibXmlDomWriter | Controls the libxml++ DOM serializer |
 CLAM::LibXmlDomWritingContext | Keeps the booking when mapping CLAM data into a single libxml++ DOM element |
 CLAM::Hidden::LockOps< MutexType > | |
 CLAM::LogPlusTmpl< T > | Binary Operator for use with std::accumulate, for computing Product(x(i)) |
 CLAM::Mapping | |
  CLAM::LinearMapping | |
  CLAM::NoteToFreqMapping | |
  CLAM::ValueToRatioMapping | |
 CLAM::MappingFactory | |
  CLAM::LinearMappingFactory | |
  CLAM::NoteToFreqMappingFactory | |
  CLAM::ValueToRatioMappingFactory | |
 SDIF::Matrix | Contains frame data for an SDIF frame |
  SDIF::ConcreteMatrix< T > | |
 SDIF::MatrixHeader | The header for each Matrix |
 CLAM::MatrixTmpl< T > | |
 MIDI::Message | |
 CLAM::MIDI::MessageInfo | |
 CLAM::MIDI | |
 CLAM::MIDIDevice | This is the abstract base class for an midi device |
 CLAM::MIDIDeviceList | This abstract class allows you to retrieve a list of all available devices (strings) for a certain architecture |
 CLAM::MIDIManager | This class takes care of all the creation of the registration of MIDIIn and MIDIOut objects, and the creation of MIDIDevice objects required |
 CLAM::DiscontinuousSegmentation::MissplacedOffset | |
 CLAM::DiscontinuousSegmentation::MissplacedOnset | |
 CLAM::AudioCodecs::MpegBitstream | |
 CLAM::Multiply< DataType > | |
 CLAM::Mutex | From the www.boost.org docs: A mutex (short for mutual-exclusion) object is used to serializes access to a resource shared between multiple threads |
 CLAM::NetworkPlayer | A NetworkPlayer is an object that controls the playback of a Network providing a high level transport like interface |
  CLAM::JACKNetworkPlayer | |
  CLAM::MonoOfflineNetworkPlayer | |
  CLAM::OfflineNetworkPlayer | |
  CLAM::PANetworkPlayer | |
 CLAM::NullDomDocumentHandler | Dummy implementation of a DomDocumentHandler when XML is disabled |
  CLAM::DomDocumentHandler | This class subclasses from the proper DomDocumentHandler depending on the build time configuration 'xmlbackend' option |
 CLAM::NullDomReadingContext | Dummy implementation of a DomDocumentReadingContext when XML is disabled |
 CLAM::NullDomWritingContext | Dummy implementation of a DomDocumentWritingContext when XML is disabled |
 CLAM::O< order > | Auxiliary class to define the order of a moment at compile time |
 CLAM::DiscontinuousSegmentation::OffsetMissing | |
 SDIF::OpeningsFrame | A special kind of frame at the beginning of each SDIF file |
 OriginalFunction | |
  CLAM::TabFunct< OriginalFunction > | Precalculated (tabulated) functor, for dealing with efficient version of expensive functions (with its associated cost in space and precision) |
 CLAM::OutControlBase | Base class for an outwards control connector |
  CLAM::OutControl< ControlDataType > | Processing typed out control template class |
   CLAM::OutControlPublisher | |
   CLAM::TypedOutControl< ControlDataType > | |
 CLAM::OutControlRegistry | |
 CLAM::OutPortBase | |
  CLAM::OutPort< Token > | |
  CLAM::OutPortPublisher< Token > | |
  CLAM::OutPort< TData > | |
   CLAM::AudioOutPort | |
  CLAM::OutPortPublisher< TData > | |
   CLAM::AudioOutPortPublisher | |
 CLAM::OutPortRegistry | |
 Simac::PCPSmother | |
 CLAM::PhantomBuffer< T > | |
 CLAM::PhantomBuffer< TData > | |
 CLAM::PointTmpl< TX, TY > | |
 CLAM::PolarTmpl< T > | |
 CLAM::AudioBufferSource::Port | |
 CLAM::AudioBufferSink::Port | |
 CLAM::AudioSink::Port | |
 CLAM::AudioSource::Port | |
 CLAM::Pow< o > | |
 CLAM::Pow< 0 > | |
 CLAM::Pow< 1 > | |
 CLAM::Pow< s > | |
 CLAM::Power< s, abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^n) |
 CLAM::Power< 1, abs, T > | |
  CLAM::NoPowerTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^1) |
 CLAM::Power< 2, abs, T > | |
  CLAM::SquareTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^2) |
 CLAM::Power< 3, abs, T > | |
  CLAM::CubeTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(x(i)^3) |
 CLAM::PoweredProduct< s, T > | Binary Operator for use with std::inner_product |
 CLAM::Processing | The base class for all the CLAM processing object classes |
  CLAM::ADSR | |
  CLAM::AudioAmplifier | Time-domain audio gain |
  CLAM::AudioBufferAmplifier | Time-domain audio gain |
  CLAM::AudioBufferMixer | |
  CLAM::AudioBufferSink | |
  CLAM::AudioBufferSource | |
  CLAM::AudioFileMemoryLoader | |
  CLAM::AudioIn | This class is the interface to an input of an AudioDevice |
  CLAM::AudioMixer | |
  CLAM::AudioOut | This class is the interface to an output of an AudioDevice |
  CLAM::AudioSink | |
  CLAM::AudioSource | |
  CLAM::AutoPanner | |
  CLAM::BinaryAudioOp< BinOp > | |
  CLAM::BinaryControlOp< BinOp > | |
  CLAM::CepstralTransform | This class performs the cepstral transform on a set of filterbank coefficients in order to obtain the corresponding Mel Frequency Cepstral Coefficients (MFCC) |
  CLAM::CircularShift | This Processing class takes an input audio buffer and shifts it to get zero-phase conditions in the STFT |
  CLAM::CleanTracks | |
  CLAM::Control2Data | This processing object is mainly an aggregate of input control data It works by asynchronously receiving messages, keeping them enqueued and synchronously converting them to a Processing Data, at Do() time |
   CLAM::MIDI2Melody | This processing is a particular control-to-data converter that takes in MIDI control events and converts them into a MIDIMelody processing data |
  CLAM::ControlComparison | |
  CLAM::ControlFade | |
  CLAM::ControlIntervalMapper | |
  CLAM::Controller | This processing object is mainly an aggregate of out controls, that can be connected with other POs in controls, as usual |
  CLAM::ControlMapper | |
  CLAM::ControlPiano | |
  CLAM::ControlPrinter | |
  CLAM::ControlPrinterTyped | |
  CLAM::ControlScaler | |
  CLAM::ControlSelector | |
  CLAM::ControlSink | |
  CLAM::ControlSource | |
  CLAM::ControlSum | |
  CLAM::ControlTraceReader | |
  CLAM::ControlTraceWriter | |
  CLAM::DescriptorComputation | This Processing class only calls the Compute operation of Descriptor passed to the Do |
  CLAM::Dispatcher | |
  CLAM::EnvelopeExtractor | |
  CLAM::EnvelopeGenerator | |
  CLAM::EnvelopeModulator | |
  CLAM::ERB_SpaceGen | |
  CLAM::FDCombFilter | Basic Frequency domain Comb Filter |
  CLAM::FDFilterGen | Frequency Domain Filter Generator |
  CLAM::FFT_base | Abstract base class for FFT classes |
   CLAM::FFT_fftw3 | Implementation of the FFT using the Fastest Fourier Transform of the West version 3 |
   CLAM::FFT_numrec | Implementation of the FFT using the algorithm in Numerical Recipies in C |
   CLAM::FFT_ooura | Implementation of the FFT using the algorithm from Takuya OOURA in C |
  CLAM::FlagControl | |
  CLAM::FrameTransformation | |
   CLAM::FrameTransformationTmpl< T > | |
   CLAM::SegmentSMSHarmonizer | |
   CLAM::SMSDeesser | |
   CLAM::SMSFreqShift | |
   CLAM::SMSGenderChange | |
   CLAM::SMSHarmonizer | Many voices harmonizer using the SMS model |
   CLAM::SMSOddEvenHarmonicRatio | |
   CLAM::SMSPitchDiscretization | |
   CLAM::SMSPitchShift | Pitch shift with timbre preservation using the SMS model |
   CLAM::SMSResidualGain | |
   CLAM::SMSSineFilter | |
   CLAM::SMSSinusoidalGain | |
   CLAM::SMSSpectralShapeShift | Pitch shift with timbre preservation using the SMS model |
   CLAM::SMSTranspose | |
   CLAM::FrameTransformationTmpl< Spectrum > | |
    CLAM::Deesser | |
    CLAM::FreqShift | |
    CLAM::HumRemover | |
    CLAM::NoSpectralTransformation | |
    CLAM::OscillatingSpectralNotch | |
    CLAM::Partializer | |
    CLAM::Peakalizer | |
    CLAM::RandomPhase | |
    CLAM::Robotization | |
    CLAM::SampleAndHold | |
    CLAM::SpectralAmplitudeModulation | |
    CLAM::SpectralAverage | |
    CLAM::SpectralCombDelta | |
    CLAM::SpectralCombTriang | |
    CLAM::SpectralDelay | |
    CLAM::SpectralExciter | |
    CLAM::SpectralFocus | Pitch shift with timbre preservation using the SMS model |
    CLAM::SpectralGate | |
    CLAM::SpectralLimiter | |
    CLAM::SpectralNotch | |
    CLAM::SpectralPhaseModulation | |
    CLAM::SpectralReject | |
    CLAM::SpectralReverse | |
    CLAM::SpectralRingModulation | |
    CLAM::SpectralShapeShift | Pitch shift with timbre preservation using the SMS model |
    CLAM::SpectralSpread | Pitch shift with timbre preservation using the SMS model |
    CLAM::ThreeBandAM | |
    CLAM::ThreeBandCompressor | Limits the spectrum magnitude to different threshold for each of three bands |
    CLAM::ThreeBandFilter | Amplifies the spectrum magnitude to different gain for each of three bands |
    CLAM::ThreeBandGate | |
    CLAM::Vocoder | |
  CLAM::Fund2MIDI | Converts fundamental to a MIDI note value |
  CLAM::Fundamental2Control | |
  CLAM::FundFreqDetect | This class estimates a fundamental frequency value in the spectral domain for one single spectral Frame |
  CLAM::IFFT_base | Abstract base class for IFFT classes |
   CLAM::IFFT_fftw3 | Implementation of the IFFT using the Fastest Fourier in the West version 3 |
   CLAM::IFFT_ooura | Implementation of the IFFT using the algorithm from Takuya OOURA in C |
  CLAM::LadspaWrapper | |
  CLAM::LadspaWrapperBuffer | |
  CLAM::LPC_AutoCorrelation | |
  CLAM::MelFilterBank | This class performs filterbank analysis for Mel Frequency Cepstrum Coefficients (MFCC) computation |
  CLAM::MIDIClocker | This class is the interface to an input of an MIDIDevice |
  CLAM::MIDIDispatcher | |
  CLAM::MIDIFileReader | |
  CLAM::MIDIFileWriter | |
  CLAM::MIDIIn | This class is the interface to an input of an MIDIDevice |
   CLAM::MIDIInControl | |
  CLAM::MIDIKeyboard | |
  CLAM::MIDIOut | This class is the interface to an input of an MIDIDevice |
   CLAM::MIDIOutControl | |
  CLAM::MonoAudioFileReader | |
  CLAM::MonoAudioFileWriter | |
  CLAM::MultiChannelAudioFileReader | |
  CLAM::MultiChannelAudioFileWriter | |
  CLAM::Normalization | |
  CLAM::OutControlSender | |
  CLAM::OverlapAdd | Configuration class for Overlapp Add Processing |
  CLAM::PhaseManagement | The PhaseManagement Class takes care about either |
  CLAM::PortMonitor< TheDataType, ThePortType > | A processing that allows other (GUI) thread to monitor a port in a thread safe way |
  CLAM::ProcessingComposite | Abstract class for processing object agregates |
   CLAM::AudioWindowing | Processing class for performing a STFT |
   CLAM::FrameAdder | This class performs the interpolation of two Frame processing data objects |
   CLAM::FrameInterpolator | This class performs the interpolation of two Frame processing data objects |
   CLAM::Instrument | |
   CLAM::SinusoidalSynthesis | This is a processing object class that performs a sinusoidal resynthesis given a set of spectral peaks |
   CLAM::SMSAnalysis | Class that encapsulates all the building blocks of the SegmentAnalysis example |
   CLAM::SMSAnalysisCore | Class that encapsulates all the building blocks of the SegmentAnalysis example |
   CLAM::SMSSynthesis | This is the processing object class we are using to group several other processing objects |
   CLAM::SMSTransformationChain | Using Segment as the type for * input and output ports |
   CLAM::SpectralAnalysis | Processing class for performing a STFT |
   CLAM::SpectralSynthesis | This is the processing object class we are using to group several other processing objects |
   CLAM::TopLevelProcessing | Top level processing object composite |
  CLAM::SDIFIn | |
  CLAM::SDIFInStreaming | |
  CLAM::SDIFOut | |
  CLAM::Segmentator | |
  CLAM::SegmentTransformation | |
   CLAM::SegmentSMSMorph | |
   CLAM::SegmentSMSTimeStretch | |
   CLAM::SMSTransformationChainIO | Pitch shift with timbre preservation using the SMS model |
  CLAM::SimpleOscillator | |
   CLAM::Oscillator | |
  CLAM::SinTracking | Processing which does sinusoidal peak tracking (or continuation) |
  CLAM::SMSMorph | Morph using the SMS model |
  CLAM::SMSTimeStretch | Time Stretch using the SMS model |
  CLAM::SpectralEnvelopeApply | Applies an existing spectral envelope to incoming spectral peaks or spectrum |
  CLAM::SpectralEnvelopeExtract | Configuration class for SpectralEnvelopeExtract objects |
  CLAM::SpectralPeakArrayAdder | This class performs the interpolation of two SpectralPeakArray processing data objects |
  CLAM::SpectralPeakArrayInterpolator | This class performs the interpolation of two SpectralPeakArray processing data objects |
  CLAM::SpectralPeakDetect | This class is dedicated to find magnitude SpectralPeaks in a given spectral frame |
  CLAM::SpectrumAdder | This class performs the sum of N Spectrum processing data objects |
  CLAM::SpectrumAdder2 | This calss performs the sum of two Spectrum processing data objects |
  CLAM::SpectrumInterpolator | This calss performs the interpolation of two Spectrum processing data objects |
  CLAM::SpectrumProduct | This class performs the product of two Spectrum processing data objects |
  CLAM::SpectrumSubstracter2 | This calss performs the substraction of two Spectrum processing data objects |
  CLAM::SynthSineSpectrum | Configuration class for the SynthSineSpectrum Processing |
  CLAM::TokenDelay< T > | A Processing Object that delays a certain number of ProcessingDataObjects wherever the specific object it is |
  CLAM::TonalAnalysis | |
  CLAM::WaveGenerator | |
  CLAM::WindowGenerator | This class can be used for generating Windows and for zeropadding the windowed data |
  CLAM::ZeroPadder | |
  CLAM::PortMonitor< Audio, AudioInPort > | |
   CLAM::AudioBuffPortMonitor | |
   CLAM::AudioPortMonitor | |
  CLAM::PortMonitor< Fundamental > | |
   CLAM::FundamentalPortMonitor | |
   CLAM::FundTrackPortMonitor | |
  CLAM::PortMonitor< SpectralPeakArray > | |
   CLAM::PeaksPortMonitor | |
   CLAM::SinTracksPortMonitor | |
  CLAM::PortMonitor< Spectrum > | |
   CLAM::SpecgramPortMonitor | |
   CLAM::SpectrumPortMonitor | |
 CLAM::Network::ProcessingAndGeometry | |
 CLAM::Hidden::ProcessingClass2LadspaBase | |
 CLAM::ProcessingDataPlugin | |
 CLAM::ProcessingKernel | |
 CLAM::ProductTmpl< T > | Binary Operator for use with std::accumulate, for computing Product(x(i)) |
 CLAM::RangeView | |
 MIDI::Reader | |
 CLAM::RecursiveMutex | |
 CLAM::RecursiveTimedMutex | |
 CLAM::RecursiveTryMutex | |
 CLAM::Region | |
  CLAM::ReadingRegion< WritingRegion > | |
  CLAM::WritingRegion< Token, DataStructure > | |
  CLAM::ReadingRegion< WritingRegion< TData, PhantomBuffer > > | |
  CLAM::WritingRegion< TData > | |
 CLAM::ProcessingDataPlugin::Registrator< DataType > | |
 CLAM::Factory< AbstractProductType >::Registry | This class is an implementation class of the Factory |
 RtAudio | Realtime audio i/o C++ class |
 RtAudio::RTAUDIO_DEVICE | The public device information structure for passing queried values |
 RtError | Exception handling class for RtAudio |
 CLAM::RulerTicks | |
 RunTimeLibraryLoader | |
  RunTimeFaustLibraryLoader | |
  RunTimeLadspaLibraryLoader | |
 CLAM::Hidden::ScopedLock< MutexType > | |
 CLAM::Hidden::ScopedTimedLock< TimedMutexType > | |
 CLAM::Hidden::ScopedTryLock< TryMutexType > | |
 CLAM::SDIFFileReader | |
 CLAM::Search< U, T > | |
 CLAM::SearchArray< T > | |
 Simac::SemitoneCenterFinder | |
 CLAM::SGuide | Config class for the SinTracking Processing |
 SigSlot::Signal | Abstract 'Event Dispatcher' |
  SigSlot::Signalv0 | |
  SigSlot::Signalv0 | |
  SigSlot::Signalv1< ParmType1 > | |
  SigSlot::Signalv1< ParmType1 > | |
  SigSlot::Signalv2< ParmType1, ParmType2 > | |
  SigSlot::Signalv2< ParmType1, ParmType2 > | |
  SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 > | |
  SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 > | |
  SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 > | |
  SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 > | |
 SigSlot::Slot | The receiver of a Signal |
  SigSlot::Slotv0 | |
  SigSlot::Slotv1< ParmType1 > | |
  SigSlot::Slotv2< ParmType1, ParmType2 > | |
  SigSlot::Slotv3< ParmType1, ParmType2, ParmType3 > | |
  SigSlot::Slotv4< ParmType1, ParmType2, ParmType3, ParmType4 > | |
 SndPcm | |
 MIDI::Song | |
 MIDI::SongPlayer | |
 StaticBool< b > | |
 CLAM::StaticCycleBranch | |
 CLAM::StatMemory< T > | An StatMemory may hold a T value and remembers whether it has been set or is not initialized |
 CLAM::StatsTmpl< abs, T, U, initOrder > | Class to hold basic statistics related to an array of arbitrary data |
 CLAM::StdList< T > | This declaration is necessary for VC7 compatibility |
 CLAM::StdVector< T > | |
 CLAM::Storable | Interface for objects to be stored on a Storage |
  CLAM::XMLable | Interface for objects to be stored on a XMLStorage |
   CLAM::BasicXMLable | Abstract class that defines some common implementation issues for many XMLables that contains as member variables the XML name and whether is an XML element or not |
    CLAM::XMLAdapter< T > | This class adapts to the XMLable interface any basic object |
    CLAM::XMLArrayAdapter< T > | This class adapts to the XMLable interface any array of basic objects |
    CLAM::XMLComponentAdapter | This class adapts to the XMLable interface any object that is a CLAM::Component |
    CLAM::XMLIterableAdapter< T > | This class adapts to the XMLable interface any STL like container of basic objects or CLAM::Component's |
 CLAM::Storage | The abstract class for storages |
  CLAM::XmlStorage | Provides XML format storage for CLAM Component's |
 SDIF::Storage | Storage is an abstract class, that is passed to File, used to handle every read frame |
  SDIF::Collection | A special Storage to store Frames in a linked list |
 CLAM::STrajectory | |
 SDIF::Stream | SDIF has a notion of streams: each frame contains a stream id |
 CLAM::AudioCodecs::Stream | Streams provide I/O to and from an audio file of a given format |
  CLAM::AudioCodecs::MpegAudioStream | |
  CLAM::AudioCodecs::OggVorbisAudioStream | |
  CLAM::AudioCodecs::PCMAudioStream | |
 CLAM::StreamImpl< Token, DataStructure > | |
 CLAM::StreamImpl< TData, PhantomBuffer > | |
 CLAM::StreamImpl< Token, PhantomBuffer > | |
 CLAM::DynamicType::TAttr | |
 SigSlot::Signalv2< ParmType1, ParmType2 >::tCallback | |
 SigSlot::Signalv3< ParmType1, ParmType2, ParmType3 >::tCallback | |
 SigSlot::Signalv0::tCallback | |
 SigSlot::Signalv1< ParmType1 >::tCallback | |
 SigSlot::ConnectionHandler< SignalType >::tCallback | Inner type for ConnectionHandler |
 SigSlot::Signalv4< ParmType1, ParmType2, ParmType3, ParmType4 >::tCallback | |
 CLAM::TDescriptorsParams | |
 CLAM::DynamicType::TDynInfo | |
 MIDI::Tempo | |
 CLAM::Enum::tEnumValue | |
 CLAM::Text | This class represents an string that can contain any kind of separators |
  CLAM::DirectoryName | This class is a base class for configuration fields representing file names |
  CLAM::Filename | This class is a base class for configuration fields representing file names |
   CLAM::InFilename | Input file name configuration field |
    CLAM::AudioInFilename | |
    CLAM::ControlTraceInFilename | |
    CLAM::InSDIFFilename | |
   CLAM::OutFilename | Output file name configuration field |
    CLAM::AudioOutFilename | |
    CLAM::ControlTraceOutFilename | |
 CLAM::FlagsBase::tFlagValue | The type of the name table rows |
 CLAM::Thread | |
  CLAM::PooledThread | |
 CLAM::ThreadPool | This is a simple variety of thread pool |
 CLAM::TimedMutex | |
 CLAM::AudioDevice::TInfo | This class is used to respond to device information request using the GetInfo method |
 CLAM::MIDIDevice::TInfo | This class is used to respond to device information request using the GetInfo method |
 MIDI::Track | |
 TraverseDirectory | |
 CLAM::TryMutex | |
 SDIF::TUTF8byte | |
 SDIF::TypeId | Used to store the Frame and Matrix types, a 4-byte identifier |
 CLAM::WaveFunctor< WaveType > | |
 CLAM::WeightedPower< s, abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^n) |
 CLAM::WeightedPower< 1, abs, T > | |
  CLAM::WeightedNoPowerTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^1) |
 CLAM::WeightedPower< 2, abs, T > | |
  CLAM::WeightedSquareTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^2) |
 CLAM::WeightedPower< 3, abs, T > | |
  CLAM::WeightedCubeTmpl< abs, T > | Binary Operator for use with std::accumulate, for computing Sum(i*x(i)^3) |
 MIDI::Writer | |
 CLAM::XercesDomDocumentHandler | XML implementation backend for the Xerces-C library |
 CLAM::XercesDomReadingContext | Keeps the booking when loading a single Xerces-C DOM element into CLAM data |
 CLAM::XercesDomWriter | Controls the Xerces-C DOM serializer |
 CLAM::XercesDomWritingContext | Keeps the booking when mapping CLAM data into a single Xerces-C DOM element |
 CLAM::XercesInitializer | Ensures that Xerces-C library initialization and termination occurs once and only when needed |
 CLAM::XercesLocal2Unicode | Converts local encoding char* into Xerces Unicode String |
 CLAM::XercesUnicode2Local | Converts Xerces Unicode String into local encoding char* |
 CLAM::XmlAttribute | An scoped XML writer object that inserts on construction an XML atribute to the last open XML element |
 CLAM::XmlContent | An scoped XML writer object inserting plain content to the current XML level |
 CLAM::XmlElement | An scoped XML writer object that opens a new element on construction and closes it on destruction |
 CLAM::XmlFragment | This is the first scoped object you should create for a XML fragment |
 CLAM::XmlWriteContext | This class provides primitives to write an XML document to a target stream and to keep track of the writting state |
 CLAM::xtime | |
 int | |
 ProperInPort * | |
 TData * | |
 unsigned | |