2008-01-31 00:42:31 +00:00
|
|
|
/*
|
2008-03-18 05:16:43 +00:00
|
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2009-06-01 06:37:14 +00:00
|
|
|
* * Neither the name of the OpenSimulator Project nor the
|
2008-03-18 05:16:43 +00:00
|
|
|
* names of its contributors may be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
2008-01-31 00:42:31 +00:00
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
using System;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
|
2012-07-25 22:11:50 +00:00
|
|
|
namespace OpenSim.Framework.Monitoring
|
2008-05-16 01:22:11 +00:00
|
|
|
{
|
2008-01-31 00:42:31 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Singleton used to provide access to statistics reporters
|
|
|
|
/// </summary>
|
|
|
|
public class StatsManager
|
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
// Subcommand used to list other stats.
|
|
|
|
public const string AllSubCommand = "all";
|
|
|
|
|
|
|
|
// Subcommand used to list other stats.
|
|
|
|
public const string ListSubCommand = "list";
|
|
|
|
|
|
|
|
// All subcommands
|
|
|
|
public static HashSet<string> SubCommands = new HashSet<string> { AllSubCommand, ListSubCommand };
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
/// <summary>
|
2012-10-11 22:28:53 +00:00
|
|
|
/// Registered stats categorized by category/container/shortname
|
2012-10-03 23:32:42 +00:00
|
|
|
/// </summary>
|
|
|
|
/// <remarks>
|
2012-10-11 22:28:53 +00:00
|
|
|
/// Do not add or remove directly from this dictionary.
|
2012-10-03 23:32:42 +00:00
|
|
|
/// </remarks>
|
2012-10-11 22:28:53 +00:00
|
|
|
public static Dictionary<string, Dictionary<string, Dictionary<string, Stat>>> RegisteredStats
|
|
|
|
= new Dictionary<string, Dictionary<string, Dictionary<string, Stat>>>();
|
2012-10-03 23:32:42 +00:00
|
|
|
|
2008-05-14 21:27:54 +00:00
|
|
|
private static AssetStatsCollector assetStats;
|
|
|
|
private static UserStatsCollector userStats;
|
2012-06-08 02:12:23 +00:00
|
|
|
private static SimExtraStatsCollector simExtraStats = new SimExtraStatsCollector();
|
2008-05-16 01:22:11 +00:00
|
|
|
|
2008-05-14 21:27:54 +00:00
|
|
|
public static AssetStatsCollector AssetStats { get { return assetStats; } }
|
|
|
|
public static UserStatsCollector UserStats { get { return userStats; } }
|
|
|
|
public static SimExtraStatsCollector SimExtraStats { get { return simExtraStats; } }
|
2008-05-16 01:22:11 +00:00
|
|
|
|
2012-10-11 23:10:51 +00:00
|
|
|
public static void RegisterConsoleCommands(ICommandConsole console)
|
2012-10-11 22:28:53 +00:00
|
|
|
{
|
|
|
|
console.Commands.AddCommand(
|
|
|
|
"General",
|
|
|
|
false,
|
|
|
|
"show stats",
|
|
|
|
"show stats [list|all|<category>]",
|
|
|
|
"Show statistical information for this server",
|
|
|
|
"If no final argument is specified then legacy statistics information is currently shown.\n"
|
|
|
|
+ "If list is specified then statistic categories are shown.\n"
|
|
|
|
+ "If all is specified then all registered statistics are shown.\n"
|
|
|
|
+ "If a category name is specified then only statistics from that category are shown.\n"
|
|
|
|
+ "THIS STATS FACILITY IS EXPERIMENTAL AND DOES NOT YET CONTAIN ALL STATS",
|
|
|
|
HandleShowStatsCommand);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static void HandleShowStatsCommand(string module, string[] cmd)
|
|
|
|
{
|
|
|
|
ICommandConsole con = MainConsole.Instance;
|
|
|
|
|
|
|
|
if (cmd.Length > 2)
|
|
|
|
{
|
|
|
|
var categoryName = cmd[2];
|
|
|
|
|
|
|
|
if (categoryName == AllSubCommand)
|
|
|
|
{
|
|
|
|
foreach (var category in RegisteredStats.Values)
|
|
|
|
{
|
|
|
|
OutputCategoryStatsToConsole(con, category);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (categoryName == ListSubCommand)
|
|
|
|
{
|
|
|
|
con.Output("Statistic categories available are:");
|
|
|
|
foreach (string category in RegisteredStats.Keys)
|
|
|
|
con.OutputFormat(" {0}", category);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Dictionary<string, Dictionary<string, Stat>> category;
|
|
|
|
if (!RegisteredStats.TryGetValue(categoryName, out category))
|
|
|
|
{
|
|
|
|
con.OutputFormat("No such category as {0}", categoryName);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
OutputCategoryStatsToConsole(con, category);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Legacy
|
|
|
|
con.Output(SimExtraStats.Report());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static void OutputCategoryStatsToConsole(
|
|
|
|
ICommandConsole con, Dictionary<string, Dictionary<string, Stat>> category)
|
|
|
|
{
|
|
|
|
foreach (var container in category.Values)
|
|
|
|
{
|
|
|
|
foreach (Stat stat in container.Values)
|
|
|
|
{
|
2012-10-11 22:58:37 +00:00
|
|
|
con.Output(stat.ToConsoleString());
|
2012-10-11 22:28:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 16:22:58 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Start collecting statistics related to assets.
|
|
|
|
/// Should only be called once.
|
2008-05-16 01:22:11 +00:00
|
|
|
/// </summary>
|
2008-05-14 21:53:40 +00:00
|
|
|
public static AssetStatsCollector StartCollectingAssetStats()
|
2008-01-31 00:42:31 +00:00
|
|
|
{
|
2008-05-14 21:27:54 +00:00
|
|
|
assetStats = new AssetStatsCollector();
|
2008-05-16 01:22:11 +00:00
|
|
|
|
2008-05-14 21:53:40 +00:00
|
|
|
return assetStats;
|
2008-01-31 00:42:31 +00:00
|
|
|
}
|
2008-05-16 01:22:11 +00:00
|
|
|
|
2008-01-31 00:42:31 +00:00
|
|
|
/// <summary>
|
2008-02-04 16:22:58 +00:00
|
|
|
/// Start collecting statistics related to users.
|
|
|
|
/// Should only be called once.
|
2008-05-16 01:22:11 +00:00
|
|
|
/// </summary>
|
2008-05-14 21:53:40 +00:00
|
|
|
public static UserStatsCollector StartCollectingUserStats()
|
2008-02-04 16:22:58 +00:00
|
|
|
{
|
2008-05-14 21:27:54 +00:00
|
|
|
userStats = new UserStatsCollector();
|
2008-05-16 01:22:11 +00:00
|
|
|
|
2008-05-14 21:53:40 +00:00
|
|
|
return userStats;
|
2008-05-16 01:22:11 +00:00
|
|
|
}
|
2012-10-03 23:32:42 +00:00
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Registers a statistic.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name='stat'></param>
|
|
|
|
/// <returns></returns>
|
2012-10-03 23:32:42 +00:00
|
|
|
public static bool RegisterStat(Stat stat)
|
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
Dictionary<string, Dictionary<string, Stat>> category = null, newCategory;
|
|
|
|
Dictionary<string, Stat> container = null, newContainer;
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
lock (RegisteredStats)
|
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
// Stat name is not unique across category/container/shortname key.
|
|
|
|
// XXX: For now just return false. This is to avoid problems in regression tests where all tests
|
|
|
|
// in a class are run in the same instance of the VM.
|
|
|
|
if (TryGetStat(stat, out category, out container))
|
2012-10-03 23:32:42 +00:00
|
|
|
return false;
|
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
// We take a copy-on-write approach here of replacing dictionaries when keys are added or removed.
|
|
|
|
// This means that we don't need to lock or copy them on iteration, which will be a much more
|
|
|
|
// common operation after startup.
|
|
|
|
if (container != null)
|
|
|
|
newContainer = new Dictionary<string, Stat>(container);
|
|
|
|
else
|
|
|
|
newContainer = new Dictionary<string, Stat>();
|
|
|
|
|
|
|
|
if (category != null)
|
|
|
|
newCategory = new Dictionary<string, Dictionary<string, Stat>>(category);
|
|
|
|
else
|
|
|
|
newCategory = new Dictionary<string, Dictionary<string, Stat>>();
|
2012-10-03 23:32:42 +00:00
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
newContainer[stat.ShortName] = stat;
|
|
|
|
newCategory[stat.Container] = newContainer;
|
|
|
|
RegisteredStats[stat.Category] = newCategory;
|
2012-10-03 23:32:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Deregister a statistic
|
|
|
|
/// </summary>>
|
|
|
|
/// <param name='stat'></param>
|
|
|
|
/// <returns></returns
|
2012-10-03 23:32:42 +00:00
|
|
|
public static bool DeregisterStat(Stat stat)
|
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
Dictionary<string, Dictionary<string, Stat>> category = null, newCategory;
|
|
|
|
Dictionary<string, Stat> container = null, newContainer;
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
lock (RegisteredStats)
|
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
if (!TryGetStat(stat, out category, out container))
|
2012-10-03 23:32:42 +00:00
|
|
|
return false;
|
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
newContainer = new Dictionary<string, Stat>(container);
|
2012-10-23 01:44:15 +00:00
|
|
|
newContainer.Remove(stat.ShortName);
|
2012-10-11 22:28:53 +00:00
|
|
|
|
|
|
|
newCategory = new Dictionary<string, Dictionary<string, Stat>>(category);
|
|
|
|
newCategory.Remove(stat.Container);
|
|
|
|
|
|
|
|
newCategory[stat.Container] = newContainer;
|
|
|
|
RegisteredStats[stat.Category] = newCategory;
|
2012-10-03 23:32:42 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2012-10-11 22:28:53 +00:00
|
|
|
|
|
|
|
public static bool TryGetStats(string category, out Dictionary<string, Dictionary<string, Stat>> stats)
|
|
|
|
{
|
|
|
|
return RegisteredStats.TryGetValue(category, out stats);
|
|
|
|
}
|
|
|
|
|
|
|
|
public static bool TryGetStat(
|
|
|
|
Stat stat,
|
|
|
|
out Dictionary<string, Dictionary<string, Stat>> category,
|
|
|
|
out Dictionary<string, Stat> container)
|
|
|
|
{
|
|
|
|
category = null;
|
|
|
|
container = null;
|
|
|
|
|
|
|
|
lock (RegisteredStats)
|
|
|
|
{
|
|
|
|
if (RegisteredStats.TryGetValue(stat.Category, out category))
|
|
|
|
{
|
|
|
|
if (category.TryGetValue(stat.Container, out container))
|
|
|
|
{
|
|
|
|
if (container.ContainsKey(stat.ShortName))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-03 23:32:42 +00:00
|
|
|
}
|
|
|
|
|
2012-10-23 00:50:05 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Stat type.
|
|
|
|
/// </summary>
|
|
|
|
/// <remarks>
|
|
|
|
/// A push stat is one which is continually updated and so it's value can simply by read.
|
|
|
|
/// A pull stat is one where reading the value triggers a collection method - the stat is not continually updated.
|
|
|
|
/// </remarks>
|
|
|
|
public enum StatType
|
|
|
|
{
|
|
|
|
Push,
|
|
|
|
Pull
|
|
|
|
}
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Verbosity of stat.
|
|
|
|
/// </summary>
|
|
|
|
/// <remarks>
|
|
|
|
/// Info will always be displayed.
|
|
|
|
/// </remarks>
|
|
|
|
public enum StatVerbosity
|
|
|
|
{
|
|
|
|
Debug,
|
|
|
|
Info
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Holds individual static details
|
|
|
|
/// </summary>
|
|
|
|
public class Stat
|
|
|
|
{
|
|
|
|
/// <summary>
|
|
|
|
/// Category of this stat (e.g. cache, scene, etc).
|
|
|
|
/// </summary>
|
|
|
|
public string Category { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Containing name for this stat.
|
|
|
|
/// FIXME: In the case of a scene, this is currently the scene name (though this leaves
|
|
|
|
/// us with a to-be-resolved problem of non-unique region names).
|
|
|
|
/// </summary>
|
|
|
|
/// <value>
|
|
|
|
/// The container.
|
|
|
|
/// </value>
|
|
|
|
public string Container { get; private set; }
|
|
|
|
|
2012-10-23 00:50:05 +00:00
|
|
|
public StatType StatType { get; private set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Action used to update this stat when the value is requested if it's a pull type.
|
|
|
|
/// </summary>
|
|
|
|
public Action<Stat> PullAction { get; private set; }
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
public StatVerbosity Verbosity { get; private set; }
|
|
|
|
public string ShortName { get; private set; }
|
|
|
|
public string Name { get; private set; }
|
|
|
|
public string Description { get; private set; }
|
2012-10-04 00:27:40 +00:00
|
|
|
public virtual string UnitName { get; private set; }
|
2012-10-03 23:32:42 +00:00
|
|
|
|
2012-10-23 00:50:05 +00:00
|
|
|
public virtual double Value
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
|
|
|
// Asking for an update here means that the updater cannot access this value without infinite recursion.
|
|
|
|
// XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being
|
|
|
|
// called by the pull action and just return the value.
|
|
|
|
if (StatType == StatType.Pull)
|
|
|
|
PullAction(this);
|
|
|
|
|
|
|
|
return m_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
set
|
|
|
|
{
|
|
|
|
m_value = value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private double m_value;
|
2012-10-03 23:32:42 +00:00
|
|
|
|
2012-10-11 22:28:53 +00:00
|
|
|
/// <summary>
|
|
|
|
/// Constructor
|
|
|
|
/// </summary>
|
|
|
|
/// <param name='shortName'>Short name for the stat. Must not contain spaces. e.g. "LongFrames"</param>
|
|
|
|
/// <param name='name'>Human readable name for the stat. e.g. "Long frames"</param>
|
2012-10-23 00:50:05 +00:00
|
|
|
/// <param name='description'>Description of stat</param>
|
2012-10-11 22:28:53 +00:00
|
|
|
/// <param name='unitName'>
|
|
|
|
/// Unit name for the stat. Should be preceeded by a space if the unit name isn't normally appeneded immediately to the value.
|
|
|
|
/// e.g. " frames"
|
|
|
|
/// </param>
|
|
|
|
/// <param name='category'>Category under which this stat should appear, e.g. "scene". Do not capitalize.</param>
|
|
|
|
/// <param name='container'>Entity to which this stat relates. e.g. scene name if this is a per scene stat.</param>
|
2012-10-23 00:50:05 +00:00
|
|
|
/// <param name='type'>Push or pull</param>
|
|
|
|
/// <param name='pullAction'>Pull stats need an action to update the stat on request. Push stats should set null here.</param>
|
2012-10-11 22:28:53 +00:00
|
|
|
/// <param name='verbosity'>Verbosity of stat. Controls whether it will appear in short stat display or only full display.</param>
|
2012-10-03 23:32:42 +00:00
|
|
|
public Stat(
|
2012-10-23 00:50:05 +00:00
|
|
|
string shortName,
|
|
|
|
string name,
|
|
|
|
string description,
|
|
|
|
string unitName,
|
|
|
|
string category,
|
|
|
|
string container,
|
|
|
|
StatType type,
|
|
|
|
Action<Stat> pullAction,
|
|
|
|
StatVerbosity verbosity)
|
2012-10-03 23:32:42 +00:00
|
|
|
{
|
2012-10-11 22:28:53 +00:00
|
|
|
if (StatsManager.SubCommands.Contains(category))
|
|
|
|
throw new Exception(
|
|
|
|
string.Format("Stat cannot be in category '{0}' since this is reserved for a subcommand", category));
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
ShortName = shortName;
|
|
|
|
Name = name;
|
2012-10-23 00:50:05 +00:00
|
|
|
Description = description;
|
2012-10-03 23:32:42 +00:00
|
|
|
UnitName = unitName;
|
|
|
|
Category = category;
|
|
|
|
Container = container;
|
2012-10-23 00:50:05 +00:00
|
|
|
StatType = type;
|
|
|
|
|
|
|
|
if (StatType == StatType.Push && pullAction != null)
|
|
|
|
throw new Exception("A push stat cannot have a pull action");
|
|
|
|
else
|
|
|
|
PullAction = pullAction;
|
|
|
|
|
2012-10-03 23:32:42 +00:00
|
|
|
Verbosity = verbosity;
|
|
|
|
}
|
2012-10-11 22:58:37 +00:00
|
|
|
|
|
|
|
public virtual string ToConsoleString()
|
|
|
|
{
|
|
|
|
return string.Format(
|
|
|
|
"{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName);
|
|
|
|
}
|
2008-01-31 00:42:31 +00:00
|
|
|
}
|
2012-10-04 00:27:40 +00:00
|
|
|
|
|
|
|
public class PercentageStat : Stat
|
|
|
|
{
|
2012-11-15 02:02:59 +00:00
|
|
|
public long Antecedent { get; set; }
|
|
|
|
public long Consequent { get; set; }
|
2012-10-04 00:27:40 +00:00
|
|
|
|
|
|
|
public override double Value
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
2012-11-15 02:02:59 +00:00
|
|
|
// Asking for an update here means that the updater cannot access this value without infinite recursion.
|
|
|
|
// XXX: A slightly messy but simple solution may be to flick a flag so we can tell if this is being
|
|
|
|
// called by the pull action and just return the value.
|
|
|
|
if (StatType == StatType.Pull)
|
|
|
|
PullAction(this);
|
|
|
|
|
|
|
|
long c = Consequent;
|
2012-10-04 00:27:40 +00:00
|
|
|
|
|
|
|
// Avoid any chance of a multi-threaded divide-by-zero
|
|
|
|
if (c == 0)
|
|
|
|
return 0;
|
|
|
|
|
2012-10-11 23:26:15 +00:00
|
|
|
return (double)Antecedent / c * 100;
|
2012-10-04 00:27:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
set
|
|
|
|
{
|
2012-11-15 02:02:59 +00:00
|
|
|
throw new InvalidOperationException("Cannot set value on a PercentageStat");
|
2012-10-04 00:27:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public PercentageStat(
|
2012-10-23 00:50:05 +00:00
|
|
|
string shortName,
|
|
|
|
string name,
|
|
|
|
string description,
|
|
|
|
string category,
|
|
|
|
string container,
|
|
|
|
StatType type,
|
|
|
|
Action<Stat> pullAction,
|
|
|
|
StatVerbosity verbosity)
|
|
|
|
: base(shortName, name, description, "%", category, container, type, pullAction, verbosity) {}
|
2012-10-11 22:58:37 +00:00
|
|
|
|
|
|
|
public override string ToConsoleString()
|
2012-10-04 00:27:40 +00:00
|
|
|
{
|
2012-10-11 22:58:37 +00:00
|
|
|
return string.Format(
|
2012-10-11 23:26:15 +00:00
|
|
|
"{0}.{1}.{2} : {3:0.##}{4} ({5}/{6})",
|
2012-10-11 22:58:37 +00:00
|
|
|
Category, Container, ShortName, Value, UnitName, Antecedent, Consequent);
|
2012-10-04 00:27:40 +00:00
|
|
|
}
|
|
|
|
}
|
2012-06-08 02:12:23 +00:00
|
|
|
}
|