lltrustnet.h

Go to the documentation of this file.

#ifndef LL_LLTRUSTNET_H
#define LL_LLTRUSTNET_H

#include <map>
#include "llviewercommunication.h"
#include "llviewerprecompiledheaders.h"
#include "lluuid.h"
#include "lltimer.h"

typedef enum e_trustnet_operation
{
        TN_UNKNOWN,
        TN_GET_SCORE,
        TN_EXPLAIN,
        TN_RATE
} ETrustNetOperation;

typedef enum e_trustnet_result
{
        TN_OK,
        TN_TIMEOUT,
        TN_INTERNAL_ERROR,
        TN_ERROR
} ETrustNetResult;

typedef void(*trustnet_callback_t)(ETrustNetOperation operation, ETrustNetResult result, const LLUUID &avatar, void *user_data);


class LLTrustNet;
class LLTrustNetAvatarData;

class LLTrustNetCallbackEntry
{
public:
        LLTrustNetCallbackEntry(trustnet_callback_t cb = NULL, void *ud = NULL): callback(cb), user_data(ud) {}

        trustnet_callback_t callback;
        void *user_data;
};

typedef enum e_trustnet_state
{
        TRUSTNET_NO_ADAPTER,
        TRUSTNET_NO_CONNECTION,
        TRUSTNET_CONNECTING,
        TRUSTNET_LOGGING_IN,
        TRUSTNET_LOGIN_ERROR,
        TRUSTNET_CONNECTED
} ETrustNetState;

typedef enum e_trustnet_datum_state
{
        TNS_UNKNOWN,
        TNS_FETCHING,
        TNS_RETRIEVED
} ETrustNetDatumState;


class LLTrustNetRequest
{
public:
        LLTrustNetRequest() {}
        virtual LLString asString() { return ""; }
        virtual ~LLTrustNetRequest() {}
};

class LLTrustNetScoreRequest : public LLTrustNetRequest
{
public:
        LLTrustNetScoreRequest(const LLUUID &id, const LLString &name, const LLString &type = "behavior") : mID(id), mName(name),  mType(type) {}
        virtual LLString asString();
private:
        LLUUID mID;
        LLString mName;
        LLString mType;
};

class LLTrustNetRateRequest : public LLTrustNetRequest
{
public:
        LLTrustNetRateRequest(const LLUUID &id, const LLString &name, const LLString &type = "behavior", U32 score = 0, const LLString &comment = "")
        : mID(id), mName(name),  mType(type), mScore(score), mComment(comment) {}
        virtual LLString asString();
private:
        LLUUID mID;
        LLString mName;
        LLString mType;
        U32 mScore;
        LLString mComment;
};

class LLTrustNetExplainRequest : public LLTrustNetRequest
{
public:
        LLTrustNetExplainRequest(const LLUUID &id, const LLString &name) : mID(id), mName(name) {}
        virtual LLString asString() { return "Explain|" + mName + "|" + mID.asString(); }
private:
        LLUUID mID;
        LLString mName;
};

class LLTrustNetDatum
{

public:
        LLTrustNetDatum() : mOperation(TN_UNKNOWN),  mState(TNS_UNKNOWN), mParent(NULL) {}

        void addCallback(trustnet_callback_t callback, void *user_data = NULL);

        F32 getAge() const { return mTimer.getElapsedTimeF32(); }

        ETrustNetDatumState getState() const { return mState; }

protected:
        friend class LLTrustNet;
        void setState(ETrustNetDatumState s) { mState = s; }

        void setParent(const LLTrustNetAvatarData *p) { mParent = p; }

protected:
        void notify(ETrustNetResult result = TN_OK);

        void updated(ETrustNetResult state = TN_OK) { mTimer.start(); setState(TNS_RETRIEVED); notify(state); }

        ETrustNetOperation mOperation;
private:
        std::queue<LLTrustNetCallbackEntry> mCallbacks;
        LLTimer mTimer;

        ETrustNetDatumState mState;

        const LLTrustNetAvatarData *mParent;
};

class LLTrustNetScore : public LLTrustNetDatum
{
public:
        LLTrustNetScore(const F32 score = 0.0f, const LLString comment = "");

        void set(F32 score, const LLString &comment = "") { mScore = score; mComments = comment; updated(); }
        F32 mScore;
        LLString mComments;
private:

};

class LLTrustNetAvatarData
{
public:
        std::map<LLString, LLTrustNetScore> mScores;

        void setAvatar(const LLUUID& av) { mAvatar = av;}
        LLUUID getAvatar() const { return mAvatar; }
protected:
        LLUUID mAvatar;
        
};





class LLTrustNet
{
public:
        LLTrustNet();

        F32 getScore(const LLUUID& avatar, const LLString& type);

        ETrustNetDatumState getScoreState(const LLUUID& avatar, const LLString& type);

        LLColor4 getScoreColor(const LLUUID& avatar, const LLString& type);

        void processRequests();

        ETrustNetState getConnectionState() const { return mConnectionState; }

        LLString getConnectionStateString() const;

        static void viewerCommCallback(LLString& data, LLViewerCircuit& circuit, void* userdata);
protected:
        void setScore(const LLUUID &avatar, const LLString& type, F32 score);

        LLTrustNetScore getScoreData(const LLUUID& avatar, const LLString& type);

        LLViewerCircuit *mCircuit;
        std::map<LLUUID, LLTrustNetAvatarData> mCache;
        std::deque<LLTrustNetRequest*> mQueue;
        ETrustNetState mConnectionState;
};

extern LLTrustNet* gTrustNet;

#endif

---