Feature.h

Go to the documentation of this file.

#ifndef _FEATURE_H
#define _FEATURE_H

#include "../util/defines.h"

#include <time.h>
#include <assert.h>
#ifndef _SYMBIAN
#endif


#if defined(_WINDOWS) || defined(_WIN32_WCE)
# ifdef _FEATURE_EXPORT
#  define FEATURE_EXPORT __declspec(dllexport)
#  ifdef _FEATURE_EXPORT_CLASS
#   define FEATURE_EXPORT_CLASS __declspec(dllexport)
#  endif // _FEATURE_EXPORT_CLASS
# else // _FEATURE_EXPORT
#  define FEATURE_EXPORT __declspec(dllimport)
#  ifdef _FEATURE_EXPORT_CLASS
#   define FEATURE_EXPORT_CLASS __declspec(dllimport)
#  endif // _FEATURE_EXPORT_CLASS
# endif // _FEATURE_EXPORT
#elif defined(_LINUX) // _WINDOWS or _WIN32_WCE
# define FEATURE_EXPORT
# define FEATURE_EXPORT_CLASS
#elif defined(_SYMBIAN)
# ifdef _FEATURE_EXPORT
#  define FEATURE_EXPORT EXPORT_C
#  ifdef _FEATURE_EXPORT_CLASS
#   define FEATURE_EXPORT_CLASS EXPORT_C
#  endif // _FEATURE_EXPORT_CLASS
# else // _FEATURE_EXPORT
#  define FEATURE_EXPORT IMPORT_C
#  ifdef _FEATURE_EXPORT_CLASS
#   define FEATURE_EXPORT_CLASS IMPORT_C
#  endif // _FEATURE_EXPORT_CLASS
# endif // _FEATURE_EXPORT
#endif // _WINDOWS or _WIN32_WCE

#ifndef FEATURE_EXPORT_CLASS
# define FEATURE_EXPORT_CLASS
#endif


#ifdef _SYMBIAN
// for Symbian OS, static variables are not supported in DLLs, we have to use Thread Local Storage for that
/*
#define EXPORT_FEATURE(provider) \
        void INIT_EXPORT library_initialize() { Dll::SetTls(NULL); } \
        void FINI_EXPORT library_finalize() { if (Dll::Tls() != NULL) delete (provider*) (Dll::Tls()); } \
        extern "C" FEATURE_EXPORT FeatureProvider* getProvider(providerparams &params) { if (Dll::Tls() == NULL) Dll::SetTls((TAny*) new provider(params)); return (provider*) Dll::Tls(); }*/
// there is no support for loading DLLs by now anyways
#define EXPORT_FEATURE(provider)
#else // _SYMBIAN

#define EXPORT_FEATURE(provider) \
 \
        static provider *fp; \
        void INIT_EXPORT library_initialize() { fp = NULL; } \
        void FINI_EXPORT library_finalize() { if (fp != NULL) delete fp; } \
 \
        extern "C" FEATURE_EXPORT FeatureProvider* getProvider(providerparams &params) { if (fp == NULL) fp = new provider(params); return fp; }
#endif // _SYMBIAN

class Feature;

typedef parametermap providerparams;

typedef parametermap featureparams;

typedef pair<time_t, Feature*> aggregatefeature;

typedef list<aggregatefeature> aggregatelist;

typedef map<unsigned long, double> membershiplist;

extern "C" {
        void library_initialize();
        void library_finalize();
}

class Feature {
        public:
                typedef enum { boolean, nominal, ordinal, numerical_discrete, numerical_continuous } FeatureType;

        protected:
                const bool externalize;

                Feature(bool ext) : externalize(ext) {}

                Feature() : externalize(false) {}

        public:
                virtual ~Feature() {}

                virtual FeatureType getType() const = 0;

                virtual const string getName() const = 0;

                virtual double getPosition() const = 0;

                bool isExternalizable() { return externalize; }

                virtual double getDistance(Feature *f) const = 0;

                virtual void moveTowards(Feature *f, double factor) = 0;

                virtual Feature* clone() const = 0;

                virtual string serialize() const = 0;

                virtual void unserialize(string value) = 0;

                virtual void aggregate(aggregatelist samples) = 0;

#if _DEBUG_FEATURES

                virtual string toString() const = 0;
#endif
};

class PersistantFeature : public Feature {
        private:
                bool valid;

        protected:
                PersistantFeature() : Feature(true) { valid = true; }

        public:
                virtual featureparams write() const = 0;
                
                virtual void read(featureparams *param) = 0;

                void invalidate() { valid = false; }
                
                void validate() { valid = true; }
                
                bool isValid() { return valid; }
};

typedef vector<Feature*> featurevector;

class FeatureProvider {
        private:
                stringvector *features;
                string name;

        protected:
                FeatureProvider(string name, stringvector *features) {
                        this->name = name;
                        this->features = features;
                }
                
        public:
                virtual ~FeatureProvider() {}

                virtual Feature* getFeature(string name) const = 0;

                virtual Feature* getSample(string name) const = 0;

                virtual void nextSample(clock_t checkpoint) = 0;

                string getName() const
                {
                        return name;
                }

                stringvector* getFeatureList() const
                {
                        return features;
                }
};

typedef FeatureProvider* (*getProvider_t) (const providerparams &params);

#endif // _FEATURE_H

---