lleventcoro.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:5k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file   lleventcoro.cpp
  3.  * @author Nat Goodspeed
  4.  * @date   2009-04-29
  5.  * @brief  Implementation for lleventcoro.
  6.  * 
  7.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2009-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  34. // Precompiled header
  35. #include "linden_common.h"
  36. // associated header
  37. #include "lleventcoro.h"
  38. // STL headers
  39. #include <map>
  40. // std headers
  41. // external library headers
  42. // other Linden headers
  43. #include "llsdserialize.h"
  44. #include "llerror.h"
  45. #include "llcoros.h"
  46. std::string LLEventDetail::listenerNameForCoroImpl(const void* self_id)
  47. {
  48.     // First, if this coroutine was launched by LLCoros::launch(), find that name.
  49.     std::string name(LLCoros::instance().getNameByID(self_id));
  50.     if (! name.empty())
  51.     {
  52.         return name;
  53.     }
  54.     // Apparently this coroutine wasn't launched by LLCoros::launch(). Check
  55.     // whether we have a memo for this self_id.
  56.     typedef std::map<const void*, std::string> MapType;
  57.     static MapType memo;
  58.     MapType::const_iterator found = memo.find(self_id);
  59.     if (found != memo.end())
  60.     {
  61.         // this coroutine instance has called us before, reuse same name
  62.         return found->second;
  63.     }
  64.     // this is the first time we've been called for this coroutine instance
  65.     name = LLEventPump::inventName("coro");
  66.     memo[self_id] = name;
  67.     LL_INFOS("LLEventCoro") << "listenerNameForCoroImpl(" << self_id << "): inventing coro name '"
  68.                             << name << "'" << LL_ENDL;
  69.     return name;
  70. }
  71. void LLEventDetail::storeToLLSDPath(LLSD& dest, const LLSD& rawPath, const LLSD& value)
  72. {
  73.     if (rawPath.isUndefined())
  74.     {
  75.         // no-op case
  76.         return;
  77.     }
  78.     // Arrange to treat rawPath uniformly as an array. If it's not already an
  79.     // array, store it as the only entry in one.
  80.     LLSD path;
  81.     if (rawPath.isArray())
  82.     {
  83.         path = rawPath;
  84.     }
  85.     else
  86.     {
  87.         path.append(rawPath);
  88.     }
  89.     // Need to indicate a current destination -- but that current destination
  90.     // needs to change as we step through the path array. Where normally we'd
  91.     // use an LLSD& to capture a subscripted LLSD lvalue, this time we must
  92.     // instead use a pointer -- since it must be reassigned.
  93.     LLSD* pdest = &dest;
  94.     // Now loop through that array
  95.     for (LLSD::Integer i = 0; i < path.size(); ++i)
  96.     {
  97.         if (path[i].isString())
  98.         {
  99.             // *pdest is an LLSD map
  100.             pdest = &((*pdest)[path[i].asString()]);
  101.         }
  102.         else if (path[i].isInteger())
  103.         {
  104.             // *pdest is an LLSD array
  105.             pdest = &((*pdest)[path[i].asInteger()]);
  106.         }
  107.         else
  108.         {
  109.             // What do we do with Real or Array or Map or ...?
  110.             // As it's a coder error -- not a user error -- rub the coder's
  111.             // face in it so it gets fixed.
  112.             LL_ERRS("lleventcoro") << "storeToLLSDPath(" << dest << ", " << rawPath << ", " << value
  113.                                    << "): path[" << i << "] bad type " << path[i].type() << LL_ENDL;
  114.         }
  115.     }
  116.     // Here *pdest is where we should store value.
  117.     *pdest = value;
  118. }
  119. LLSD errorException(const LLEventWithID& result, const std::string& desc)
  120. {
  121.     // If the result arrived on the error pump (pump 1), instead of
  122.     // returning it, deliver it via exception.
  123.     if (result.second)
  124.     {
  125.         throw LLErrorEvent(desc, result.first);
  126.     }
  127.     // That way, our caller knows a simple return must be from the reply
  128.     // pump (pump 0).
  129.     return result.first;
  130. }
  131. LLSD errorLog(const LLEventWithID& result, const std::string& desc)
  132. {
  133.     // If the result arrived on the error pump (pump 1), log it as a fatal
  134.     // error.
  135.     if (result.second)
  136.     {
  137.         LL_ERRS("errorLog") << desc << ":" << std::endl;
  138.         LLSDSerialize::toPrettyXML(result.first, LL_CONT);
  139.         LL_CONT << LL_ENDL;
  140.     }
  141.     // A simple return must therefore be from the reply pump (pump 0).
  142.     return result.first;
  143. }