vos/metaobjects/misc/talkative.cc

Go to the documentation of this file.

/* $Id: talkative.cc,v 1.39 2003/07/23 00:17:27 reed Exp $ */

/* This file was generated by otd2cpp.pl

    Copyright (C) 2002 Reed Hedges <reed@interreality.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA


*/

#include <time.h>
#include <vos/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>
#include "talkative.hh"

/* initialize static class members */
const unsigned short Talkative::UNSPECIFIED = 0x0;
const unsigned short Talkative::PUBLIC = 0x1;
const unsigned short Talkative::PRIVATE = 0x2;
const unsigned short Talkative::AUTO = 0x4;
const unsigned short Talkative::FROM_APP = 0x8;
const unsigned short Talkative::SYSTEM = 0x8;

/* Constructors and Destructors */
Talkative::Talkative(MetaObject* superobject) : MetaObject(superobject) {
    defaultPropertyAC = &NoPropertyAccessControl::static_;
}


LocalTalkative::LocalTalkative(MetaObject* superobject) :
    Talkative(superobject), MetaObject(superobject),
    replyto(NULL), replynonce("")
{
    addMessageHandler<LocalTalkative>("misc:say", this, &LocalTalkative::handle_say);
}

LocalTalkative::~LocalTalkative() {
    if(replyto)
        replyto->release(); // acquired in handle_say
}

RemoteTalkative::RemoteTalkative(MetaObject* superobject) : Talkative(superobject), MetaObject(superobject) {
}


/* initialize default PAC */
void Talkative::initialize() {
    initialize(&NoPropertyAccessControl::static_);
}

void Talkative::initialize(PropertyAccessControl* ac) {
    defaultPropertyAC = ac;
}


/* generator for factory */
MetaObject* LocalTalkative::new_LocalTalkative(MetaObject* so, const string& type) {
    LocalTalkative* lt = new LocalTalkative(so);
    lt->set_voice(VOS_TALK_NO_VOICE, VOS_TALK_VOICE_DATATYPE);
    return lt;
}


/* Return type string ("talkative") */
const string Talkative::getType() {
    return string("misc:talkative");
}

/* Register extenders with libvos MetaFactory */
void Talkative::registerExtenders() {
    static bool done = false;
    if(! done) {
    LocalSite::addLocalObjectExtension(typeid(LocalTalkative).name(), &LocalTalkative::new_LocalTalkative);
    LocalSite::addLocalObjectExtension(typeid(Talkative).name(), &LocalTalkative::new_LocalTalkative);
    LocalSite::addLocalObjectExtension("misc:talkative", &LocalTalkative::new_LocalTalkative);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteTalkative).name(), &RemoteTalkative::new_RemoteTalkative);
    RemoteSite::addRemoteObjectExtension(typeid(Talkative).name(), &RemoteTalkative::new_RemoteTalkative);
    RemoteSite::addRemoteObjectExtension("misc:talkative", &RemoteTalkative::new_RemoteTalkative);
    done = true;
    }
}


/* Get and set Subproperties and other Subobjects : */

string Talkative::get_voice() {
    string s;
    rREF(Vobject&, v, findObject("misc:voice"),
        Property* p = meta_cast<Property*>(&v);
        if(!p) throw bad_cast();
        p->read(s);
    );
    return s;
}

string Talkative::get_voice_datatype() {
    string s;
    rREF(Vobject&, v, findObject("misc:voice"),
        Property* p = meta_cast<Property*>(&v);
        if(!p) throw bad_cast();
        s = p->getDataType();
    );
    return s;
}

void Talkative::set_voice(const string& value, const string& datatype, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = defaultPropertyAC;
    LOG("talkative", 5, "setting voice to " << value);
    Property::setProperty(*this, "misc:voice", value, datatype, ac);
}

/* generator for factory */

MetaObject* RemoteTalkative::new_RemoteTalkative(MetaObject* superobject, const string& type) {
    return new RemoteTalkative(superobject);
}

/* Local Actuators: */

/* Do say. */

void LocalTalkative::do_say(TalkMessage& m) {

    if(!listeners.empty()) {
        for(ListenerList::const_iterator i = listeners.begin();
            i != listeners.end(); i++)
        {
            if(*i)
                (*i)->notifyTalkMessage(m);
        }
        return;
    }

    // otherwise, just print it out as a log message
    string s("[");
    bool prevFlags = false;
    if(m.scope & PUBLIC) {
        s += "PUBLIC";
        prevFlags = true;
    }
    if(m.scope & PRIVATE) {
        if(prevFlags)
            s += ",";
        s += "PRIVATE";
        prevFlags = true;
    }
    if(m.scope & AUTO) {
        if(prevFlags)
            s += ",";
        s += "AUTO";
        prevFlags = true;
    }
    if(m.scope & FROM_APP) {
        if(prevFlags)
            s+= ",";
        s += "INTERNAL";
        prevFlags = true;
    }
    if(m.reply_nonce != "") {
        if(prevFlags)
            s += ",";
        s += " in reply to: " + m.reply_nonce;
        prevFlags = true;
    }
    if(!prevFlags)
        s = "";
    else
        s += "]";

    std::string stime = "";
    if(m.time != -1) {
        time_t now = time(NULL);
        char* ct = ctime(&now);
        ct[strlen(ct)] = '\0';  // ctime puts a \n on the end... annoying...
        stime = string(" (Sent ") + ctime(&now) + ")";
    }


    LOG("chat message", m.priority, "<" << m.sender.getName()  << "> " << s << " " << m.text << stime);
}


/* Send a say message from this object, to whatever object sent us the last message. */
void LocalTalkative::reply_to_last(const string& text, const int priority) {
    if(replyto != NULL) {
        TalkMessage msg(*this, text, PRIVATE, priority, time(NULL), replynonce);
        replyto->do_say(msg);
    } else {
        throw NoSuchObjectError("Nobody to send reply message to!");
    }
}

/* Send a say message from this object to all children of 'parent' that are talkative. */
///@todo optimize this. (perhaps use a child listener to world to only store talkative objects...)
void LocalTalkative::say_to_all(const string& text, Vobject& parent, const int priority, const string& replynonce) {
    const Vobject::ChildList& children = parent.getChildren();
    TalkMessage m(*this, text, PUBLIC, priority, time(NULL), replynonce);
    for(Vobject::ChildList::const_iterator p = children.begin(); p != children.end(); p++) {
        if(Talkative* t = meta_cast<Talkative*>((*p)->child)) {
            t->do_say(m);
        }
    }
}

/* Message Handlers:  */


    /* Handle message say */

void LocalTalkative::handle_say(Message* m) {

    vRef<Vobject> sender = Vobject::findObjectFromRoot(m->getFrom());
    Talkative* t = meta_cast<Talkative*>(&sender);
    if(!t) throw bad_cast();

    TalkMessage msg(*t);

    msg.text = m->getField("text").value;
    try {
        msg.reply_nonce = m->getField("reply-to").value;
    } catch(Message::NoSuchFieldError) {
        msg.reply_nonce = "";
    }
    try {
        msg.scope = strtoul(m->getField("scope").value.c_str(), NULL, 10);
        msg.scope &= ~FROM_APP;
    } catch(Message::NoSuchFieldError) {
        msg.scope = UNSPECIFIED;
    }
    try {
        msg.priority = strtoul(m->getField("priority").value.c_str(), NULL, 10);
    } catch(Message::NoSuchFieldError) {
        msg.priority = 0;
    }
    try {
        msg.time = strtol(m->getField("time").value.c_str(), NULL, 10);
    } catch (Message::NoSuchFieldError) {
        msg.time = -1;
    }

    msg.this_nonce = m->getNonce();

    do_say(msg);

    // remember who sent us this message in case we want to reply (note: only works if we are recieving a message from remote objects. but since do_say may be overridden, and never called, we do this here.  we also know the message nonce here.)
    if(replyto) {
        replyto->release();
    }
    replynonce = m->getNonce();
    replyto = t;
    replyto->acquire(); // released on next call to handle_say

}

/* Remote Actuators: */

/* Do say. */

void RemoteTalkative::do_say(TalkMessage& msg) {
    vRef<Message> m = new  Message();

    m->setType("message");
    m->setMethod("misc:say");
    m->setFrom(msg.sender.getURL().getString());
    m->setTo(getURL().getString());
    if(msg.reply_nonce != "")
        m->insertField(-1, "reply-to", msg.reply_nonce);
    m->insertField(-1, "text", msg.text);

    char sc[24];
    snprintf(sc, sizeof(sc), "%u", msg.scope);
    m->insertField(-1, "scope", sc);

    char pr[24];
    snprintf(pr, sizeof(pr), "%u", msg.priority);
    m->insertField(-1, "priority", pr);

    if(msg.time == -1)
        msg.time = time(NULL);
    char tm[64];
    snprintf(tm, sizeof(tm), "%ld", msg.time);
    m->insertField(-1, "time", tm);

    sendMessage(&m);
}



void Talkative::do_say(const std::string& text, Talkative& sender, const unsigned short
scope, const int priority, const std::string& replynonce, const std::string& thisnonce) {
            TalkMessage msg(sender, text, scope, priority, time(NULL), replynonce, thisnonce);
            do_say(msg);
    }


void LocalTalkative::addTalkListener(TalkListener* l) {
    listeners.push_back(l);
    RefCounted* rc = dynamic_cast<RefCounted*>(l);
    if(rc)
        rc->acquire();  // released by removeTalkListener
        // TODO add excise listener?
}

void LocalTalkative::removeTalkListener(TalkListener* l) {
    bool found = false;
    // XXX is this safe to delete like this?
    for(ListenerList::iterator i = listeners.begin(); i != listeners.end();
        i++)
    {
        if( (*i) == l ) {
            found = true;
            listeners.erase(i);
        }
    }
    if(!found) return;
    RefCounted* rc = dynamic_cast<RefCounted*>(l);
    if(rc)
        rc->release();  // acquired by addTalkListener
        // TODO: remove excise listener?
}

---