开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llparcel.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：35k
源码类别：

游戏引擎

开发平台：

C++ Builder

llparcel.cpp：源码内容
  1. /** 
  2.  * @file llparcel.cpp
  3.  * @brief A land parcel.
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "indra_constants.h"
  36. #include <iostream>
  38. #include "llparcel.h"
  39. #include "llstreamtools.h"
  41. #include "llmath.h"
  42. #include "llsd.h"
  43. #include "llsdutil.h"
  44. #include "lltransactiontypes.h"
  45. #include "lltransactionflags.h"
  46. #include "llsdutil_math.h"
  47. #include "message.h"
  48. #include "u64.h"
  50. static const F32 SOME_BIG_NUMBER = 1000.0f;
  51. static const F32 SOME_BIG_NEG_NUMBER = -1000.0f;
  52. static const std::string PARCEL_OWNERSHIP_STATUS_STRING[LLParcel::OS_COUNT+1] =
  53. {
  54.     "leased",
  55.     "lease_pending",
  56.     "abandoned",
  57.     "none"
  58. };
  60. // NOTE: Adding parcel categories also requires updating:
  61. // * floater_directory.xml category combobox
  62. // * floater_about_land.xml category combobox
  63. // * Web site "create event" tools
  64. // DO NOT DELETE ITEMS FROM THIS LIST WITHOUT DEEPLY UNDERSTANDING WHAT YOU'RE DOING.
  65. //
  66. static const std::string PARCEL_CATEGORY_STRING[LLParcel::C_COUNT] =
  67. {
  68.     "none",
  69.     "linden",
  70.     "adult",
  71.     "arts",
  72.     "store", // "business" legacy name
  73.     "educational",
  74.     "game",  // "gaming" legacy name
  75.     "gather", // "hangout" legacy name
  76.     "newcomer",
  77.     "park",
  78.     "home",  // "residential" legacy name
  79.     "shopping",
  80.     "stage",
  81.     "other",
  82. };
  83. static const std::string PARCEL_CATEGORY_UI_STRING[LLParcel::C_COUNT + 1] =
  84. {
  85.     "None",
  86.     "Linden Location",
  87.     "Adult",
  88.     "Arts and Culture",
  89.     "Business",
  90.     "Educational",
  91.     "Gaming",
  92.     "Hangout",
  93.     "Newcomer Friendly",
  94.     "Parks and Nature",
  95.     "Residential",
  96.     "Shopping",
  97.     "Stage",
  98.     "Other",
  99.     "Any",  // valid string for parcel searches
  100. };
  102. static const std::string PARCEL_ACTION_STRING[LLParcel::A_COUNT + 1] =
  103. {
  104.     "create",
  105.     "release",
  106.     "absorb",
  107.     "absorbed",
  108.     "divide",
  109.     "division",
  110.     "acquire",
  111.     "relinquish",
  112.     "confirm",
  113.     "unknown"
  114. };
  118. //const char* revert_action_to_string(LLParcel::ESaleTimerExpireAction action);
  119. //LLParcel::ESaleTimerExpireAction revert_string_to_action(const char* s);
  120. const std::string& category_to_ui_string(LLParcel::ECategory category);
  121. LLParcel::ECategory category_ui_string_to_category(const std::string& s);
  123. LLParcel::LLParcel()
  124. {
  125.     init(LLUUID::null, TRUE, FALSE, FALSE, 0, 0, 0, 0, 0, 1.f, 0);
  126. }
  129. LLParcel::LLParcel(const LLUUID &owner_id,
  130.                    BOOL modify, BOOL terraform, BOOL damage,
  131.                    time_t claim_date, S32 claim_price_per_meter,
  132.                    S32 rent_price_per_meter, S32 area, S32 sim_object_limit, F32 parcel_object_bonus,
  133.                    BOOL is_group_owned)
  134. {
  135.     init( owner_id, modify, terraform, damage, claim_date,
  136.           claim_price_per_meter, rent_price_per_meter, area, sim_object_limit, parcel_object_bonus,
  137.           is_group_owned);
  138. }
  141. // virtual
  142. LLParcel::~LLParcel()
  143. {
  144.     // user list cleaned up by LLDynamicArray destructor.
  145. }
  147. void LLParcel::init(const LLUUID &owner_id,
  148.                     BOOL modify, BOOL terraform, BOOL damage,
  149.                     time_t claim_date, S32 claim_price_per_meter,
  150.                     S32 rent_price_per_meter, S32 area, S32 sim_object_limit, F32 parcel_object_bonus,
  151.                     BOOL is_group_owned)
  152. {
  153. mID.setNull();
  154. mOwnerID = owner_id;
  155. mGroupOwned = is_group_owned;
  156. mClaimDate = claim_date;
  157. mClaimPricePerMeter = claim_price_per_meter;
  158. mRentPricePerMeter = rent_price_per_meter;
  159. mArea = area;
  160. mDiscountRate = 1.0f;
  161. mDrawDistance = 512.f;
  163. mUserLookAt.setVec(0.0f, 0.f, 0.f);
  164. // Default to using the parcel's landing point, if any.
  165. mLandingType = L_LANDING_POINT;
  167. // *FIX: if owner_id != null, should be owned or sale pending,
  168. // investigate init callers.
  169. mStatus = OS_NONE;
  170. mCategory = C_NONE;
  171. mAuthBuyerID.setNull();
  172. //mBuyerID.setNull();
  173. //mJoinNeighbors = 0x0;
  174. mSaleTimerExpires.setTimerExpirySec(0);
  175. mSaleTimerExpires.stop();
  176. mGraceExtension = 0;
  177. //mExpireAction = STEA_REVERT;
  178. //mRecordTransaction = FALSE;
  180. mAuctionID = 0;
  181. mInEscrow = false;
  183. mParcelFlags = PF_DEFAULT;
  184. setParcelFlag(PF_CREATE_OBJECTS,  modify);
  185. setParcelFlag(PF_ALLOW_TERRAFORM, terraform);
  186. setParcelFlag(PF_ALLOW_DAMAGE,    damage);
  188. mSalePrice = 10000;
  189. setName(LLStringUtil::null);
  190. setDesc(LLStringUtil::null);
  191. setMusicURL(LLStringUtil::null);
  192. setMediaURL(LLStringUtil::null);
  193. setMediaDesc(LLStringUtil::null);
  194. setMediaType(LLStringUtil::null);
  195. mMediaID.setNull();
  196. mMediaAutoScale = 0;
  197. mMediaLoop = TRUE;
  198. mObscureMedia = 1;
  199. mObscureMusic = 1;
  200. mMediaWidth = 0;
  201. mMediaHeight = 0;
  202. setMediaCurrentURL(LLStringUtil::null);
  203. mMediaURLFilterEnable = FALSE;
  204. mMediaURLFilterList = LLSD::emptyArray();
  205. mMediaAllowNavigate = TRUE;
  206. mMediaURLTimeout = 0.0f;
  207. mMediaPreventCameraZoom = FALSE;
  209. mGroupID.setNull();
  211. mPassPrice = PARCEL_PASS_PRICE_DEFAULT;
  212. mPassHours = PARCEL_PASS_HOURS_DEFAULT;
  214. mAABBMin.setVec(SOME_BIG_NUMBER, SOME_BIG_NUMBER, SOME_BIG_NUMBER);
  215. mAABBMax.setVec(SOME_BIG_NEG_NUMBER, SOME_BIG_NEG_NUMBER, SOME_BIG_NEG_NUMBER);
  217. mLocalID = 0;
  219. //mSimWidePrimCorrection = 0;
  220. setMaxPrimCapacity((S32)(sim_object_limit * area / (F32)(REGION_WIDTH_METERS * REGION_WIDTH_METERS)));
  221. setSimWideMaxPrimCapacity(0);
  222. setSimWidePrimCount(0);
  223. setOwnerPrimCount(0);
  224. setGroupPrimCount(0);
  225. setOtherPrimCount(0);
  226. setSelectedPrimCount(0);
  227. setTempPrimCount(0);
  228. setCleanOtherTime(0);
  229.     setRegionPushOverride(FALSE);
  230.     setRegionDenyAnonymousOverride(FALSE);
  231.     setRegionDenyAgeUnverifiedOverride(FALSE);
  232. setParcelPrimBonus(parcel_object_bonus);
  234. setPreviousOwnerID(LLUUID::null);
  235. setPreviouslyGroupOwned(FALSE);
  236. }
  238. void LLParcel::overrideOwner(const LLUUID& owner_id, BOOL is_group_owned)
  239. {
  240.     // Override with system permission (LLUUID::null)
  241.     // Overridden parcels have no group
  242.     mOwnerID = owner_id;
  243.     mGroupOwned = is_group_owned;
  244.     if(mGroupOwned)
  245.     {
  246.         mGroupID = mOwnerID;
  247.     }
  248.     else
  249.     {
  250.         mGroupID.setNull();
  251.     }
  252.     mInEscrow = false;
  253. }
  255. void LLParcel::overrideParcelFlags(U32 flags)
  256. {
  257.     mParcelFlags = flags;
  258. }
  259. void LLParcel::setName(const std::string& name)
  260. {
  261.     // The escaping here must match the escaping in the database
  262.     // abstraction layer.
  263.     mName = name;
  264.     LLStringFn::replace_nonprintable_in_ascii(mName, LL_UNKNOWN_CHAR);
  265. }
  267. void LLParcel::setDesc(const std::string& desc)
  268. {
  269.     // The escaping here must match the escaping in the database
  270.     // abstraction layer.
  271.     mDesc = desc;
  272.     mDesc = rawstr_to_utf8(mDesc);
  273. }
  275. void LLParcel::setMusicURL(const std::string& url)
  276. {
  277.     mMusicURL = url;
  278.     // The escaping here must match the escaping in the database
  279.     // abstraction layer.
  280.     // This should really filter the url in some way. Other than
  281.     // simply requiring non-printable.
  282.     LLStringFn::replace_nonprintable_in_ascii(mMusicURL, LL_UNKNOWN_CHAR);
  283. }
  285. void LLParcel::setMediaURL(const std::string& url)
  286. {
  287.     mMediaURL = url;
  288.     // The escaping here must match the escaping in the database
  289.     // abstraction layer if it's ever added.
  290.     // This should really filter the url in some way. Other than
  291.     // simply requiring non-printable.
  292.     LLStringFn::replace_nonprintable_in_ascii(mMediaURL, LL_UNKNOWN_CHAR);
  293. }
  295. void LLParcel::setMediaDesc(const std::string& desc)
  296. {
  297. // The escaping here must match the escaping in the database
  298. // abstraction layer.
  299. mMediaDesc = desc;
  300. mMediaDesc = rawstr_to_utf8(mMediaDesc);
  301. }
  302. void LLParcel::setMediaType(const std::string& type)
  303. {
  304. // The escaping here must match the escaping in the database
  305. // abstraction layer.
  306. mMediaType = type;
  307. mMediaType = rawstr_to_utf8(mMediaType);
  309. // This code attempts to preserve legacy movie functioning
  310. if(mMediaType.empty() && ! mMediaURL.empty())
  311. {
  312. setMediaType(std::string("video/vnd.secondlife.qt.legacy"));
  313. }
  314. }
  315. void LLParcel::setMediaWidth(S32 width)
  316. {
  317. mMediaWidth = width;
  318. }
  319. void LLParcel::setMediaHeight(S32 height)
  320. {
  321. mMediaHeight = height;
  322. }
  324. void LLParcel::setMediaCurrentURL(const std::string& url)
  325. {
  326.     mMediaCurrentURL = url;
  327.     // The escaping here must match the escaping in the database
  328.     // abstraction layer if it's ever added.
  329.     // This should really filter the url in some way. Other than
  330.     // simply requiring non-printable.
  331.     LLStringFn::replace_nonprintable_in_ascii(mMediaCurrentURL, LL_UNKNOWN_CHAR);
  333. }
  335. void LLParcel::setMediaURLResetTimer(F32 time)
  336. {
  337. mMediaResetTimer.start();
  338. mMediaResetTimer.setTimerExpirySec(time);
  339. }
  341. void LLParcel::setMediaURLFilterList(LLSD list)
  342. {
  343. // sanity check LLSD
  344. // must be array of strings
  345. if (!list.isArray())
  346. {
  347. return;
  348. }
  350. for (S32 i = 0; i < list.size(); i++)
  351. {
  352. if (!list[i].isString())
  353. return;
  354. }
  356. // can't be too big
  357. const S32 MAX_SIZE = 50;
  358. if (list.size() > MAX_SIZE)
  359. {
  360. LLSD new_list = LLSD::emptyArray();
  362. for (S32 i = 0; i < llmin(list.size(), MAX_SIZE); i++)
  363. {
  364. new_list.append(list[i]);
  365. }
  367. list = new_list;
  368. }
  370. mMediaURLFilterList = list;
  371. }
  373. // virtual
  374. void LLParcel::setLocalID(S32 local_id)
  375. {
  376.     mLocalID = local_id;
  377. }
  379. void LLParcel::setAllParcelFlags(U32 flags)
  380. {
  381.     mParcelFlags = flags;
  382. }
  384. void LLParcel::setParcelFlag(U32 flag, BOOL b)
  385. {
  386.     if (b)
  387.     {
  388.         mParcelFlags |= flag;
  389.     }
  390.     else
  391.     {
  392.         mParcelFlags &= ~flag;
  393.     }
  394. }
  397. BOOL LLParcel::allowModifyBy(const LLUUID &agent_id, const LLUUID &group_id) const
  398. {
  399.     if (agent_id == LLUUID::null)
  400.     {
  401.         // system always can enter
  402.         return TRUE;
  403.     }
  404.     else if (isPublic())
  405.     {
  406.         return TRUE;
  407.     }
  408.     else if (agent_id == mOwnerID)
  409.     {
  410.         // owner can always perform operations
  411.         return TRUE;
  412.     }
  413.     else if (mParcelFlags & PF_CREATE_OBJECTS)
  414.     {
  415.         return TRUE;
  416.     }
  417.     else if ((mParcelFlags & PF_CREATE_GROUP_OBJECTS)
  418.              && group_id.notNull() )
  419.     {
  420.         return (getGroupID() == group_id);
  421.     }
  422.     
  423.     return FALSE;
  424. }
  426. BOOL LLParcel::allowTerraformBy(const LLUUID &agent_id) const
  427. {
  428.     if (agent_id == LLUUID::null)
  429.     {
  430.         // system always can enter
  431.         return TRUE;
  432.     }
  433.     else if(OS_LEASED == mStatus)
  434.     {
  435.         if(agent_id == mOwnerID)
  436.         {
  437.             // owner can modify leased land
  438.             return TRUE;
  439.         }
  440.         else
  441.         {
  442.             // otherwise check other people
  443.             return mParcelFlags & PF_ALLOW_TERRAFORM;
  444.         }
  445.     }
  446.     else
  447.     {
  448.         return FALSE;
  449.     }
  450. }
  453. bool LLParcel::isAgentBlockedFromParcel(LLParcel* parcelp,
  454.                                         const LLUUID& agent_id,
  455.                                         const std::vector<LLUUID>& group_ids,
  456.                                         const BOOL is_agent_identified,
  457.                                         const BOOL is_agent_transacted,
  458.                                         const BOOL is_agent_ageverified)
  459. {
  460.     S32 current_group_access = parcelp->blockAccess(agent_id, LLUUID::null, is_agent_identified, is_agent_transacted, is_agent_ageverified);
  461.     S32 count;
  462.     bool is_allowed = (current_group_access == BA_ALLOWED) ? true: false;
  463.     LLUUID group_id;
  464.     
  465.     count = group_ids.size();
  466.     for (int i = 0; i < count && !is_allowed; i++)
  467.     {
  468.         group_id = group_ids[i];
  469.         current_group_access = parcelp->blockAccess(agent_id, group_id, is_agent_identified, is_agent_transacted, is_agent_ageverified);
  470.         
  471.         if (current_group_access == BA_ALLOWED) is_allowed = true;
  472.     }
  473.     
  474.     return !is_allowed;
  475. }
  477. BOOL LLParcel::isAgentBanned(const LLUUID& agent_id) const
  478. {
  479. // Test ban list
  480. if (mBanList.find(agent_id) != mBanList.end())
  481. {
  482. return TRUE;
  483. }
  484.     
  485.     return FALSE;
  486. }
  488. S32 LLParcel::blockAccess(const LLUUID& agent_id, const LLUUID& group_id,
  489.                           const BOOL is_agent_identified,
  490.                           const BOOL is_agent_transacted,
  491.                           const BOOL is_agent_ageverified) const
  492. {
  493.     // Test ban list
  494.     if (isAgentBanned(agent_id))
  495.     {
  496.         return BA_BANNED;
  497.     }
  498.     
  499.     // Always allow owner on (unless he banned himself, useful for
  500.     // testing). We will also allow estate owners/managers in if they 
  501.     // are not explicitly banned.
  502.     if (agent_id == mOwnerID)
  503.     {
  504.         return BA_ALLOWED;
  505.     }
  506.     
  507.     // Special case when using pass list where group access is being restricted but not 
  508.     // using access list.  In this case group members are allowed only if they buy a pass.
  509.     // We return BA_NOT_IN_LIST if not in list
  510.     BOOL passWithGroup = getParcelFlag(PF_USE_PASS_LIST) && !getParcelFlag(PF_USE_ACCESS_LIST) 
  511.     && getParcelFlag(PF_USE_ACCESS_GROUP) && !mGroupID.isNull() && group_id == mGroupID;
  512.     
  513.     
  514.     // Test group list
  515.     if (getParcelFlag(PF_USE_ACCESS_GROUP)
  516.         && !mGroupID.isNull()
  517.         && group_id == mGroupID
  518.         && !passWithGroup)
  519.     {
  520.         return BA_ALLOWED;
  521.     }
  522.     
  523.     // Test access list
  524.     if (getParcelFlag(PF_USE_ACCESS_LIST) || passWithGroup )
  525.     {
  526.         if (mAccessList.find(agent_id) != mAccessList.end())
  527.         {
  528.             return BA_ALLOWED;
  529.         }
  530.         
  531.         return BA_NOT_ON_LIST; 
  532.     }
  533.     
  534.     // If we're not doing any other limitations, all users
  535.     // can enter, unless
  536.     if (  !getParcelFlag(PF_USE_ACCESS_GROUP)
  537.                  && !getParcelFlag(PF_USE_ACCESS_LIST))
  538.     { 
  539.         //If the land is group owned, and you are in the group, bypass these checks
  540.         if(getIsGroupOwned() && group_id == mGroupID)
  541.         {
  542.             return BA_ALLOWED;
  543.         }
  544.         
  545.         // Test for "payment" access levels
  546.         // Anonymous - No Payment Info on File
  547.         if(getParcelFlag(PF_DENY_ANONYMOUS) && !is_agent_identified && !is_agent_transacted)
  548.         {
  549.             return BA_NO_ACCESS_LEVEL;
  550.         }
  551.         // AgeUnverified - Not Age Verified
  552.         if(getParcelFlag(PF_DENY_AGEUNVERIFIED) && !is_agent_ageverified)
  553.         {
  554. return BA_NOT_AGE_VERIFIED;
  555.         }
  556.     
  557.         return BA_ALLOWED;
  558.     }
  559.     
  560.     return BA_NOT_IN_GROUP;
  561.     
  562. }
  565. void LLParcel::setArea(S32 area, S32 sim_object_limit)
  566. {
  567.     mArea = area;
  568.     setMaxPrimCapacity((S32)(sim_object_limit * area / (F32)(REGION_WIDTH_METERS * REGION_WIDTH_METERS)));
  569. }
  571. void LLParcel::setDiscountRate(F32 rate)
  572. {
  573.     // this is to make sure that the rate is at least sane - this is
  574.     // not intended to enforce economy rules. It only enfoces that the
  575.     // rate is a scaler between 0 and 1.
  576.     mDiscountRate = llclampf(rate);
  577. }
  580. //-----------------------------------------------------------
  581. // File input and output
  582. //-----------------------------------------------------------
  584. BOOL LLParcel::importAccessEntry(std::istream& input_stream, LLAccessEntry* entry)
  585. {
  586.     skip_to_end_of_next_keyword("{", input_stream);
  587.     while (input_stream.good())
  588.     {
  589.         skip_comments_and_emptyspace(input_stream);
  590.         std::string line, keyword, value;
  591.         get_line(line, input_stream, MAX_STRING);
  592.         get_keyword_and_value(keyword, value, line);
  593.         
  594.         if ("}" == keyword)
  595.         {
  596.             break;
  597.         }
  598.         else if ("id" == keyword)
  599.         {
  600.             entry->mID.set( value );
  601.         }
  602.         else if ("name" == keyword)
  603.         {
  604.             // deprecated
  605.         }
  606.         else if ("time" == keyword)
  607.         {
  608.             S32 when;
  609.             LLStringUtil::convertToS32(value, when);
  610.             entry->mTime = when;
  611.         }
  612.         else if ("flags" == keyword)
  613.         {
  614.             U32 setting;
  615.             LLStringUtil::convertToU32(value, setting);
  616.             entry->mFlags = setting;
  617.         }
  618.         else
  619.         {
  620.             llwarns << "Unknown keyword in parcel access entry section: <" 
  621.             << keyword << ">" << llendl;
  622.         }
  623.     }
  624.     return input_stream.good();
  625. }
  627. BOOL LLParcel::importMediaURLFilter(std::istream& input_stream, std::string& url)
  628. {
  629. skip_to_end_of_next_keyword("{", input_stream);
  631. while(input_stream.good())
  632. {
  633. skip_comments_and_emptyspace(input_stream);
  634. std::string line, keyword, value;
  635. get_line(line, input_stream, MAX_STRING);
  636. get_keyword_and_value(keyword, value, line);
  638. if ("}" == keyword)
  639. {
  640. break;
  641. }
  642. else if ("url" == keyword)
  643. {
  644. url = value;
  645. }
  646. else
  647. {
  648. llwarns << "Unknown keyword in parcel media url filter section: <"
  649. << keyword << ">" << llendl;
  650. }
  651. }
  652. return input_stream.good();
  653. }
  655. // Assumes we are in a block "ParcelData"
  656. void LLParcel::packMessage(LLMessageSystem* msg)
  657. {
  658.     msg->addU32Fast( _PREHASH_ParcelFlags, getParcelFlags() );
  659.     msg->addS32Fast( _PREHASH_SalePrice, getSalePrice() );
  660.     msg->addStringFast( _PREHASH_Name,  getName() );
  661.     msg->addStringFast( _PREHASH_Desc,  getDesc() );
  662.     msg->addStringFast( _PREHASH_MusicURL,  getMusicURL() );
  663.     msg->addStringFast( _PREHASH_MediaURL,  getMediaURL() );
  664.     msg->addU8 ( "MediaAutoScale", getMediaAutoScale () );
  665.     msg->addUUIDFast( _PREHASH_MediaID,  getMediaID() );
  666.     msg->addUUIDFast( _PREHASH_GroupID,  getGroupID() );
  667.     msg->addS32Fast( _PREHASH_PassPrice, mPassPrice );
  668.     msg->addF32Fast( _PREHASH_PassHours, mPassHours );
  669.     msg->addU8Fast(  _PREHASH_Category,  (U8)mCategory);
  670.     msg->addUUIDFast( _PREHASH_AuthBuyerID, mAuthBuyerID);
  671.     msg->addUUIDFast( _PREHASH_SnapshotID, mSnapshotID);
  672.     msg->addVector3Fast(_PREHASH_UserLocation, mUserLocation);
  673.     msg->addVector3Fast(_PREHASH_UserLookAt, mUserLookAt);
  674.     msg->addU8Fast(  _PREHASH_LandingType, (U8)mLandingType);
  675. }
  677. // Assumes we are in a block "ParcelData"
  678. void LLParcel::packMessage(LLSD& msg)
  679. {
  680. // used in the viewer, the sim uses it's own packer
  681. msg["local_id"] = getLocalID();
  682. msg["parcel_flags"] = ll_sd_from_U32(getParcelFlags());
  683. msg["sale_price"] = getSalePrice();
  684. msg["name"] = getName();
  685. msg["description"] = getDesc();
  686. msg["music_url"] = getMusicURL();
  687. msg["media_url"] = getMediaURL();
  688. msg["media_desc"] = getMediaDesc();
  689. msg["media_type"] = getMediaType();
  690. msg["media_width"] = getMediaWidth();
  691. msg["media_height"] = getMediaHeight();
  692. msg["auto_scale"] = getMediaAutoScale();
  693. msg["media_loop"] = getMediaLoop();
  694. msg["media_current_url"] = getMediaCurrentURL();
  695. msg["obscure_media"] = getObscureMedia();
  696. msg["obscure_music"] = getObscureMusic();
  697. msg["media_id"] = getMediaID();
  698. msg["media_allow_navigate"] = getMediaAllowNavigate();
  699. msg["media_prevent_camera_zoom"] = getMediaPreventCameraZoom();
  700. msg["media_url_timeout"] = getMediaURLTimeout();
  701. msg["media_url_filter_enable"] = getMediaURLFilterEnable();
  702. msg["media_url_filter_list"] = getMediaURLFilterList();
  703. msg["group_id"] = getGroupID();
  704. msg["pass_price"] = mPassPrice;
  705. msg["pass_hours"] = mPassHours;
  706. msg["category"] = (U8)mCategory;
  707. msg["auth_buyer_id"] = mAuthBuyerID;
  708. msg["snapshot_id"] = mSnapshotID;
  709. msg["user_location"] = ll_sd_from_vector3(mUserLocation);
  710. msg["user_look_at"] = ll_sd_from_vector3(mUserLookAt);
  711. msg["landing_type"] = (U8)mLandingType;
  713. }
  716. void LLParcel::unpackMessage(LLMessageSystem* msg)
  717. {
  718. std::string buffer;
  720.     msg->getU32Fast( _PREHASH_ParcelData,_PREHASH_ParcelFlags, mParcelFlags );
  721.     msg->getS32Fast( _PREHASH_ParcelData,_PREHASH_SalePrice, mSalePrice );
  722.     msg->getStringFast( _PREHASH_ParcelData,_PREHASH_Name, buffer );
  723.     setName(buffer);
  724.     msg->getStringFast( _PREHASH_ParcelData,_PREHASH_Desc, buffer );
  725.     setDesc(buffer);
  726.     msg->getStringFast( _PREHASH_ParcelData,_PREHASH_MusicURL, buffer );
  727.     setMusicURL(buffer);
  728.     msg->getStringFast( _PREHASH_ParcelData,_PREHASH_MediaURL, buffer );
  729.     setMediaURL(buffer);
  730.     
  731.     // non-optimized version
  732.     msg->getU8 ( "ParcelData", "MediaAutoScale", mMediaAutoScale );
  733.     
  734.     msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_MediaID, mMediaID );
  735.     msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_GroupID, mGroupID );
  736.     msg->getS32Fast( _PREHASH_ParcelData,_PREHASH_PassPrice, mPassPrice );
  737.     msg->getF32Fast( _PREHASH_ParcelData,_PREHASH_PassHours, mPassHours );
  738.     U8 category;
  739.     msg->getU8Fast(  _PREHASH_ParcelData,_PREHASH_Category, category);
  740.     mCategory = (ECategory)category;
  741.     msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_AuthBuyerID, mAuthBuyerID);
  742.     msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_SnapshotID, mSnapshotID);
  743.     msg->getVector3Fast(_PREHASH_ParcelData,_PREHASH_UserLocation, mUserLocation);
  744.     msg->getVector3Fast(_PREHASH_ParcelData,_PREHASH_UserLookAt, mUserLookAt);
  745.     U8 landing_type;
  746.     msg->getU8Fast(  _PREHASH_ParcelData,_PREHASH_LandingType, landing_type);
  747.     mLandingType = (ELandingType)landing_type;
  749. // New Media Data
  750. // Note: the message has been converted to TCP
  751. if(msg->has("MediaData"))
  752. {
  753. msg->getString("MediaData", "MediaDesc", buffer);
  754. setMediaDesc(buffer);
  755. msg->getString("MediaData", "MediaType", buffer);
  756. setMediaType(buffer);
  757. msg->getS32("MediaData", "MediaWidth", mMediaWidth);
  758. msg->getS32("MediaData", "MediaHeight", mMediaHeight);
  759. msg->getU8 ( "MediaData", "MediaLoop", mMediaLoop );
  760. msg->getU8 ( "MediaData", "ObscureMedia", mObscureMedia );
  761. msg->getU8 ( "MediaData", "ObscureMusic", mObscureMusic );
  762. }
  763. else
  764. {
  765. setMediaType(std::string("video/vnd.secondlife.qt.legacy"));
  766. setMediaDesc(std::string("No Description available without Server Upgrade"));
  767. mMediaLoop = true;
  768. mObscureMedia = true;
  769. mObscureMusic = true;
  770. }
  772. if(msg->getNumberOfBlocks("MediaLinkSharing") > 0)
  773. {
  774. msg->getString("MediaLinkSharing", "MediaCurrentURL", buffer);
  775. setMediaCurrentURL(buffer);
  776. msg->getU8 ( "MediaLinkSharing", "MediaAllowNavigate", mMediaAllowNavigate );
  777. msg->getU8 ( "MediaLinkSharing", "MediaURLFilterEnable", mMediaURLFilterEnable );
  778. msg->getU8 ( "MediaLinkSharing", "MediaPreventCameraZoom", mMediaPreventCameraZoom );
  779. msg->getF32( "MediaLinkSharing", "MediaURLTimeout", mMediaURLTimeout);
  780. }
  781. else
  782. {
  783. setMediaCurrentURL(LLStringUtil::null);
  784. }
  786. }
  788. void LLParcel::packAccessEntries(LLMessageSystem* msg,
  789.  const std::map<LLUUID,LLAccessEntry>& list)
  790. {
  791.     access_map_const_iterator cit = list.begin();
  792.     access_map_const_iterator end = list.end();
  793.     
  794.     if (cit == end)
  795.     {
  796.         msg->nextBlockFast(_PREHASH_List);
  797.         msg->addUUIDFast(_PREHASH_ID, LLUUID::null );
  798.         msg->addS32Fast(_PREHASH_Time, 0 );
  799.         msg->addU32Fast(_PREHASH_Flags, 0 );
  800.         return;
  801.     }
  802.     
  803.     for ( ; cit != end; ++cit)
  804.     {
  805.         const LLAccessEntry& entry = (*cit).second;
  806.         
  807.         msg->nextBlockFast(_PREHASH_List);
  808.         msg->addUUIDFast(_PREHASH_ID,  entry.mID );
  809.         msg->addS32Fast(_PREHASH_Time,  entry.mTime );
  810.         msg->addU32Fast(_PREHASH_Flags, entry.mFlags );
  811.     }
  812. }
  815. void LLParcel::unpackAccessEntries(LLMessageSystem* msg,
  816.                                    std::map<LLUUID,LLAccessEntry>* list)
  817. {
  818.     LLUUID id;
  819.     S32 time;
  820.     U32 flags;
  821.     
  822.     S32 i;
  823.     S32 count = msg->getNumberOfBlocksFast(_PREHASH_List);
  824.     for (i = 0; i < count; i++)
  825.     {
  826.         msg->getUUIDFast(_PREHASH_List, _PREHASH_ID, id, i);
  827.         msg->getS32Fast(  _PREHASH_List, _PREHASH_Time, time, i);
  828.         msg->getU32Fast(  _PREHASH_List, _PREHASH_Flags, flags, i);
  829.         
  830.         if (id.notNull())
  831.         {
  832.             LLAccessEntry entry;
  833.             entry.mID = id;
  834.             entry.mTime = time;
  835.             entry.mFlags = flags;
  836.             
  837.             (*list)[entry.mID] = entry;
  838.         }
  839.     }
  840. }
  843. void LLParcel::expirePasses(S32 now)
  844. {
  845.     access_map_iterator itor = mAccessList.begin();
  846.     while (itor != mAccessList.end())
  847.     {
  848.         const LLAccessEntry& entry = (*itor).second;
  849.         
  850.         if (entry.mTime != 0 && entry.mTime < now)
  851.         {
  852.             mAccessList.erase(itor++);
  853.         }
  854.         else
  855.         {
  856.             ++itor;
  857.         }
  858.     }
  859. }
  862. bool LLParcel::operator==(const LLParcel &rhs) const
  863. {
  864.     if (mOwnerID != rhs.mOwnerID)
  865.         return FALSE;
  866.     
  867.     if (mParcelFlags != rhs.mParcelFlags)
  868.         return FALSE;
  869.     
  870.     if (mClaimDate != rhs.mClaimDate)
  871.         return FALSE;
  872.     
  873.     if (mClaimPricePerMeter != rhs.mClaimPricePerMeter)
  874.         return FALSE;
  875.     
  876.     if (mRentPricePerMeter != rhs.mRentPricePerMeter)
  877.         return FALSE;
  878.     
  879.     return TRUE;
  880. }
  882. // Calculate rent
  883. S32 LLParcel::getTotalRent() const
  884. {
  885.     return (S32)floor(0.5f + (F32)mArea * (F32)mRentPricePerMeter * (1.0f - mDiscountRate));
  886. }
  888. F32 LLParcel::getAdjustedRentPerMeter() const
  889. {
  890.     return ((F32)mRentPricePerMeter * (1.0f - mDiscountRate));
  891. }
  893. LLVector3 LLParcel::getCenterpoint() const
  894. {
  895.     LLVector3 rv;
  896.     rv.mV[VX] = (getAABBMin().mV[VX] + getAABBMax().mV[VX]) * 0.5f;
  897.     rv.mV[VY] = (getAABBMin().mV[VY] + getAABBMax().mV[VY]) * 0.5f;
  898.     rv.mV[VZ] = 0.0f;
  899.     return rv;
  900. }
  902. void LLParcel::extendAABB(const LLVector3& box_min, const LLVector3& box_max)
  903. {
  904.     // Patch up min corner of AABB
  905.     S32 i;
  906.     for (i=0; i<3; i++)
  907.     {
  908.         if (box_min.mV[i] < mAABBMin.mV[i])
  909.         {
  910.             mAABBMin.mV[i] = box_min.mV[i];
  911.         }
  912.     }
  913.     
  914.     // Patch up max corner of AABB
  915.     for (i=0; i<3; i++)
  916.     {
  917.         if (box_max.mV[i] > mAABBMax.mV[i])
  918.         {
  919.             mAABBMax.mV[i] = box_max.mV[i];
  920.         }
  921.     }
  922. }
  924. BOOL LLParcel::addToAccessList(const LLUUID& agent_id, S32 time)
  925. {
  926. if (mAccessList.size() >= (U32) PARCEL_MAX_ACCESS_LIST)
  927. {
  928. return FALSE;
  929. }
  930. if (agent_id == getOwnerID())
  931. {
  932. // Can't add owner to these lists
  933. return FALSE;
  934. }
  935. access_map_iterator itor = mAccessList.begin();
  936. while (itor != mAccessList.end())
  937. {
  938. const LLAccessEntry& entry = (*itor).second;
  939. if (entry.mID == agent_id)
  940. {
  941. if (time == 0 || (entry.mTime != 0 && entry.mTime < time))
  942. {
  943. mAccessList.erase(itor++);
  944. }
  945. else
  946. {
  947. // existing one expires later
  948. return FALSE;
  949. }
  950. }
  951. else
  952. {
  953. ++itor;
  954. }
  955. }
  956.     
  957.     removeFromBanList(agent_id);
  958.     
  959.     LLAccessEntry new_entry;
  960.     new_entry.mID  = agent_id;
  961.     new_entry.mTime  = time;
  962.     new_entry.mFlags = 0x0;
  963.     mAccessList[new_entry.mID] = new_entry;
  964.     return TRUE;
  965. }
  967. BOOL LLParcel::addToBanList(const LLUUID& agent_id, S32 time)
  968. {
  969. if (mBanList.size() >= (U32) PARCEL_MAX_ACCESS_LIST)
  970. {
  971. // Not using ban list, so not a rational thing to do
  972. return FALSE;
  973. }
  974. if (agent_id == getOwnerID())
  975. {
  976. // Can't add owner to these lists
  977. return FALSE;
  978. }
  979.     
  980.     access_map_iterator itor = mBanList.begin();
  981.     while (itor != mBanList.end())
  982.     {
  983.         const LLAccessEntry& entry = (*itor).second;
  984.         if (entry.mID == agent_id)
  985.         {
  986.             if (time == 0 || (entry.mTime != 0 && entry.mTime < time))
  987.             {
  988.                 mBanList.erase(itor++);
  989.             }
  990.             else
  991.             {
  992.                 // existing one expires later
  993.                 return FALSE;
  994.             }
  995.         }
  996.         else
  997.         {
  998.             ++itor;
  999.         }
  1000.     }
  1001.     
  1002.     removeFromAccessList(agent_id);
  1003.     
  1004.     LLAccessEntry new_entry;
  1005.     new_entry.mID  = agent_id;
  1006.     new_entry.mTime  = time;
  1007.     new_entry.mFlags = 0x0;
  1008.     mBanList[new_entry.mID] = new_entry;
  1009.     return TRUE;
  1010. }
  1012. BOOL remove_from_access_array(std::map<LLUUID,LLAccessEntry>* list,
  1013.                               const LLUUID& agent_id)
  1014. {
  1015.     BOOL removed = FALSE;
  1016.     access_map_iterator itor = list->begin();
  1017.     while (itor != list->end())
  1018.     {
  1019.         const LLAccessEntry& entry = (*itor).second;
  1020.         if (entry.mID == agent_id)
  1021.         {
  1022.             list->erase(itor++);
  1023.             removed = TRUE;
  1024.         }
  1025.         else
  1026.         {
  1027.             ++itor;
  1028.         }
  1029.     }
  1030.     return removed;
  1031. }
  1033. BOOL LLParcel::removeFromAccessList(const LLUUID& agent_id)
  1034. {
  1035.     return remove_from_access_array(&mAccessList, agent_id);
  1036. }
  1038. BOOL LLParcel::removeFromBanList(const LLUUID& agent_id)
  1039. {
  1040.     return remove_from_access_array(&mBanList, agent_id);
  1041. }
  1043. // static
  1044. const std::string& LLParcel::getOwnershipStatusString(EOwnershipStatus status)
  1045. {
  1046.     return ownership_status_to_string(status);
  1047. }
  1049. // static
  1050. const std::string& LLParcel::getCategoryString(ECategory category)
  1051. {
  1052.     return category_to_string(category);
  1053. }
  1055. // static
  1056. const std::string& LLParcel::getCategoryUIString(ECategory category)
  1057. {
  1058.     return category_to_ui_string(category);
  1059. }
  1061. // static
  1062. LLParcel::ECategory LLParcel::getCategoryFromString(const std::string& string)
  1063. {
  1064.     return category_string_to_category(string);
  1065. }
  1067. // static
  1068. LLParcel::ECategory LLParcel::getCategoryFromUIString(const std::string& string)
  1069. {
  1070.     return category_ui_string_to_category(string);
  1071. }
  1073. // static
  1074. const std::string& LLParcel::getActionString(LLParcel::EAction action)
  1075. {
  1076.     S32 index = 0;
  1077.     if((action >= 0) && (action < LLParcel::A_COUNT))
  1078.     {
  1079.         index = action;
  1080.     }
  1081.     else
  1082.     {
  1083.         index = A_COUNT;
  1084.     }
  1085.     return PARCEL_ACTION_STRING[index];
  1086. }
  1088. BOOL LLParcel::isSaleTimerExpired(const U64& time)
  1089. {
  1090.     if (mSaleTimerExpires.getStarted() == FALSE)
  1091.     {
  1092.         return FALSE;
  1093.     }
  1094.     BOOL expired = mSaleTimerExpires.checkExpirationAndReset(0.0);
  1095.     if (expired)
  1096.     {
  1097.         mSaleTimerExpires.stop();
  1098.     }
  1099.     return expired;
  1100. }
  1102. BOOL LLParcel::isMediaResetTimerExpired(const U64& time)
  1103. {
  1104.     if (mMediaResetTimer.getStarted() == FALSE)
  1105.     {
  1106.         return FALSE;
  1107.     }
  1108.     BOOL expired = mMediaResetTimer.checkExpirationAndReset(0.0);
  1109.     if (expired)
  1110.     {
  1111.         mMediaResetTimer.stop();
  1112.     }
  1113.     return expired;
  1114. }
  1117. void LLParcel::startSale(const LLUUID& buyer_id, BOOL is_buyer_group)
  1118. {
  1119. // TODO -- this and all Sale related methods need to move out of the LLParcel 
  1120. // base class and into server-side-only LLSimParcel class
  1121. setPreviousOwnerID(mOwnerID);
  1122. setPreviouslyGroupOwned(mGroupOwned);
  1124. mOwnerID = buyer_id;
  1125. mGroupOwned = is_buyer_group;
  1126. if(mGroupOwned)
  1127. {
  1128. mGroupID = mOwnerID;
  1129. }
  1130. else
  1131. {
  1132. mGroupID.setNull();
  1133. }
  1134. mSaleTimerExpires.start();
  1135. mSaleTimerExpires.setTimerExpirySec(DEFAULT_USEC_SALE_TIMEOUT / SEC_TO_MICROSEC);
  1136. mStatus = OS_LEASE_PENDING;
  1137. mClaimDate = time(NULL);
  1138. setAuctionID(0);
  1139. // clear the autoreturn whenever land changes hands
  1140. setCleanOtherTime(0);
  1141. }
  1143. void LLParcel::expireSale(
  1144. U32& type,
  1145. U8& flags,
  1146. LLUUID& from_id,
  1147. LLUUID& to_id)
  1148. {
  1149.     mSaleTimerExpires.setTimerExpirySec(0.0);
  1150.     mSaleTimerExpires.stop();
  1151.     setPreviousOwnerID(LLUUID::null);
  1152.     setPreviouslyGroupOwned(FALSE);
  1153.     setSellWithObjects(FALSE);
  1154.     type = TRANS_LAND_RELEASE;
  1155.     mStatus = OS_NONE;
  1156.     flags = pack_transaction_flags(mGroupOwned, FALSE);
  1157.     mAuthBuyerID.setNull();
  1158.     from_id = mOwnerID;
  1159.     mOwnerID.setNull();
  1160.     to_id.setNull();
  1161. }
  1163. void LLParcel::completeSale(
  1164. U32& type,
  1165. U8& flags,
  1166. LLUUID& to_id)
  1167. {
  1168. mSaleTimerExpires.setTimerExpirySec(0.0);
  1169. mSaleTimerExpires.stop();
  1170. mStatus = OS_LEASED;
  1171. type = TRANS_LAND_SALE;
  1172. flags = pack_transaction_flags(mGroupOwned, mGroupOwned);
  1173. to_id = mOwnerID;
  1174. mAuthBuyerID.setNull();
  1176. // Purchased parcels are assumed to no longer be for sale.
  1177. // Otherwise someone can snipe the sale.
  1178. setForSale(FALSE);
  1179. setAuctionID(0);
  1181. // Turn off show directory, since it's a recurring fee that
  1182. // the buyer may not want.
  1183. setParcelFlag(PF_SHOW_DIRECTORY, FALSE);
  1185. //should be cleared on sale.
  1186. mAccessList.clear();
  1187. mBanList.clear();
  1188. }
  1190. void LLParcel::clearSale()
  1191. {
  1192. mSaleTimerExpires.setTimerExpirySec(0.0);
  1193. mSaleTimerExpires.stop();
  1194. if(isPublic())
  1195. {
  1196. mStatus = OS_NONE;
  1197. }
  1198. else
  1199. {
  1200. mStatus = OS_LEASED;
  1201. }
  1202. mAuthBuyerID.setNull();
  1203. setForSale(FALSE);
  1204. setAuctionID(0);
  1205. setPreviousOwnerID(LLUUID::null);
  1206. setPreviouslyGroupOwned(FALSE);
  1207. setSellWithObjects(FALSE);
  1208. }
  1210. BOOL LLParcel::isPublic() const
  1211. {
  1212.     return (mOwnerID.isNull());
  1213. }
  1215. BOOL LLParcel::isBuyerAuthorized(const LLUUID& buyer_id) const
  1216. {
  1217.     if(mAuthBuyerID.isNull())
  1218.     {
  1219.         return TRUE;
  1220.     }
  1221.     return (mAuthBuyerID == buyer_id);
  1222. }
  1224. void LLParcel::clearParcel()
  1225. {
  1226. overrideParcelFlags(PF_DEFAULT);
  1227. setName(LLStringUtil::null);
  1228. setDesc(LLStringUtil::null);
  1229. setMediaURL(LLStringUtil::null);
  1230. setMediaType(LLStringUtil::null);
  1231. setMediaID(LLUUID::null);
  1232.     setMediaDesc(LLStringUtil::null);
  1233. setMediaAutoScale(0);
  1234. setMediaLoop(TRUE);
  1235. mObscureMedia = 1;
  1236. mObscureMusic = 1;
  1237. mMediaWidth = 0;
  1238. mMediaHeight = 0;
  1239. setMediaCurrentURL(LLStringUtil::null);
  1240. setMediaURLFilterList(LLSD::emptyArray());
  1241. setMediaURLFilterEnable(FALSE);
  1242. setMediaAllowNavigate(TRUE);
  1243. setMediaPreventCameraZoom(FALSE);
  1244. setMediaURLTimeout(0.0f);
  1245. setMusicURL(LLStringUtil::null);
  1246. setInEscrow(FALSE);
  1247. setAuthorizedBuyerID(LLUUID::null);
  1248. setCategory(C_NONE);
  1249. setSnapshotID(LLUUID::null);
  1250. setUserLocation(LLVector3::zero);
  1251. setUserLookAt(LLVector3::x_axis);
  1252. setLandingType(L_LANDING_POINT);
  1253. setAuctionID(0);
  1254. setGroupID(LLUUID::null);
  1255. setPassPrice(0);
  1256. setPassHours(0.f);
  1257. mAccessList.clear();
  1258. mBanList.clear();
  1259. //mRenterList.reset();
  1260. }
  1262. void LLParcel::dump()
  1263. {
  1264.     llinfos << "parcel " << mLocalID << " area " << mArea << llendl;
  1265.     llinfos << "  name <" << mName << ">" << llendl;
  1266.     llinfos << "  desc <" << mDesc << ">" << llendl;
  1267. }
  1269. const std::string& ownership_status_to_string(LLParcel::EOwnershipStatus status)
  1270. {
  1271.     if(status >= 0 && status < LLParcel::OS_COUNT)
  1272.     {
  1273.         return PARCEL_OWNERSHIP_STATUS_STRING[status];
  1274.     }
  1275.     return PARCEL_OWNERSHIP_STATUS_STRING[LLParcel::OS_COUNT];
  1276. }
  1278. LLParcel::EOwnershipStatus ownership_string_to_status(const std::string& s)
  1279. {
  1280.     for(S32 i = 0; i < LLParcel::OS_COUNT; ++i)
  1281.     {
  1282.         if(s == PARCEL_OWNERSHIP_STATUS_STRING[i])
  1283.         {
  1284.             return (LLParcel::EOwnershipStatus)i;
  1285.         }
  1286.     }
  1287.     return LLParcel::OS_NONE;
  1288. }
  1290. //const char* revert_action_to_string(LLParcel::ESaleTimerExpireAction action)
  1291. //{
  1292. // S32 index = 0;
  1293. // if(action >= 0 && action < LLParcel::STEA_COUNT)
  1294. // {
  1295. //  index = action;
  1296. // }
  1297. // return PARCEL_SALE_TIMER_ACTION[index];
  1298. //}
  1299.     
  1300. //LLParcel::ESaleTimerExpireAction revert_string_to_action(const char* s)
  1301. //{
  1302. // for(S32 i = 0; i < LLParcel::STEA_COUNT; ++i)
  1303. // {
  1304. //  if(0 == strcmp(s, PARCEL_SALE_TIMER_ACTION[i]))
  1305. //  {
  1306. //  return (LLParcel::ESaleTimerExpireAction)i;
  1307. //  }
  1308. // }
  1309. // return LLParcel::STEA_REVERT;
  1310. //}
  1311.     
  1312. const std::string& category_to_string(LLParcel::ECategory category)
  1313. {
  1314.     S32 index = 0;
  1315.     if((category >= 0) && (category < LLParcel::C_COUNT))
  1316.     {
  1317.         index = category;
  1318.     }
  1319.     return PARCEL_CATEGORY_STRING[index];
  1320. }
  1322. const std::string& category_to_ui_string(LLParcel::ECategory category)
  1323. {
  1324.     S32 index = 0;
  1325.     if((category >= 0) && (category < LLParcel::C_COUNT))
  1326.     {
  1327.         index = category;
  1328.     }
  1329.     else
  1330.     {
  1331.         // C_ANY = -1 , but the "Any" string is at the end of the list
  1332.         index = ((S32) LLParcel::C_COUNT);
  1333.     }
  1334.     return PARCEL_CATEGORY_UI_STRING[index];
  1335. }
  1337. LLParcel::ECategory category_string_to_category(const std::string& s)
  1338. {
  1339.     for(S32 i = 0; i < LLParcel::C_COUNT; ++i)
  1340.     {
  1341.         if(s == PARCEL_CATEGORY_STRING[i])
  1342.         {
  1343.             return (LLParcel::ECategory)i;
  1344.         }
  1345.     }
  1346.     llwarns << "Parcel category outside of possibilities " << s << llendl;
  1347.     return LLParcel::C_NONE;
  1348. }
  1350. LLParcel::ECategory category_ui_string_to_category(const std::string& s)
  1351. {
  1352.     for(S32 i = 0; i < LLParcel::C_COUNT; ++i)
  1353.     {
  1354.         if(s == PARCEL_CATEGORY_UI_STRING[i])
  1355.         {
  1356.             return (LLParcel::ECategory)i;
  1357.         }
  1358.     }
  1359.     // "Any" is a valid category for searches, and
  1360.     // is a distinct option from "None" and "Other"
  1361.     return LLParcel::C_ANY;
  1362. }