AttentionValue.h

Go to the documentation of this file.

/*
 * opencog/atomspace/AttentionValue.h
 *
 * Copyright (C) 2002-2007 Novamente LLC
 * All Rights Reserved
 *
 * Written by Tony Lofthouse <tony_lofthouse@btinternet.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * 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 GNU Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _OPENCOG_ATTENTION_VALUE_H
#define _OPENCOG_ATTENTION_VALUE_H

#include <string>
#include <limits.h>

#include <opencog/atomspace/Handle.h>

namespace opencog
{
class AttentionValue;
typedef std::shared_ptr<AttentionValue> AttentionValuePtr;
#define createAV std::make_shared<AttentionValue>

class AttentionValue
    : public std::enable_shared_from_this<AttentionValue>
{
public:
    typedef short sti_t;   
    typedef short lti_t;   
    typedef short vlti_t;  

    static const int DISPOSABLE = 0; 

    // CLASS CONSTANTS
    static const sti_t DEFAULTATOMSTI;   
    static const lti_t DEFAULTATOMLTI;   
    static const vlti_t DEFAULTATOMVLTI; 

    static const sti_t MAXSTI = SHRT_MAX;
    static const lti_t MAXLTI = SHRT_MAX;
    static const sti_t MINSTI = SHRT_MIN;
    static const lti_t MINLTI = SHRT_MIN;

    static AttentionValuePtr DEFAULT_AV() {
        static AttentionValuePtr instance = createAV();
        return instance;
    }

private:

    //CLASS FIELDS
    sti_t m_STI;   
    lti_t m_LTI;   
    vlti_t m_VLTI; 
    static AttentionValuePtr m_defaultAV; 

    void  decaySTI();

    friend class ImportanceIndex; // The index can change the STI.

public:
    AttentionValue(sti_t STI = DEFAULTATOMSTI,
                   lti_t LTI = DEFAULTATOMLTI,
                   vlti_t VLTI = DEFAULTATOMVLTI)
        : m_STI(STI), m_LTI(LTI), m_VLTI(VLTI<0 ? 0 : VLTI) {}

    ~AttentionValue() {}

    sti_t getSTI() const { return m_STI; }
    float getScaledSTI() const { return (((float) m_STI) + 32768) / 65534; }

    lti_t getLTI() const { return m_LTI; }

    vlti_t getVLTI() const { return m_VLTI; }

    // @param none
    std::string toString() const;

    // @param none
    AttentionValuePtr clone() const { return createAV(m_STI, m_LTI, m_VLTI); }
    AttentionValue* rawclone() const { return new AttentionValue(m_STI, m_LTI, m_VLTI); }

    // @param none
    bool operator==(const AttentionValue& av) const {
        return (m_STI == av.getSTI() && m_LTI == av.getLTI() && m_VLTI == av.getVLTI());
    }
    inline bool operator!=(const AttentionValue& rhs) const
         { return !(*this == rhs); }

    struct STISort : public AtomComparator  {
        STISort() {};
        virtual bool test(const AtomPtr&, const AtomPtr&) const;
    };

    struct LTIAndTVAscendingSort : public AtomComparator  {
        LTIAndTVAscendingSort() {};
        virtual bool test(const AtomPtr&, const AtomPtr&) const;
    };

    struct LTIThenTVAscendingSort : public AtomComparator {
        LTIThenTVAscendingSort() {};
        virtual bool test(const AtomPtr&, const AtomPtr&) const;
    };
};


} // namespace opencog 

#endif // _OPENCOG_ATTENTION_VALUE_H