public bool Remove(ISendable sendable)
{
lock (mutex)
{
return components.Remove(sendable);
}
}
private void attachConversationID(ISendable sendable)
{
if (sendable is IConversational)
{
((IConversational)sendable).ConversationID = ID;
}
}
/// <summary>
/// Maps the specified key to the specified value in this table.
/// </summary>
/// <remarks>The key cannot be null.</remarks>
/// <param name="key">The Key</param>
/// <param name="data">The Value</param>
/// <exception cref="ArgumentNullException">If key is null.</exception>
public static void PutData(string key, ISendable data)
{
ITable dataTable = s_table.GetSubTable(key);
dataTable.PutString("~TYPE~", data.SmartDashboardType);
data.InitTable(dataTable);
s_tablesToData.Add(dataTable, data);
}
private void AttachConversationId(ISendable sendable)
{
if (sendable is IConversational)
{
((IConversational)sendable).ConversationID = Id;
}
}
public void Add(ISendable sendable, string moduleType, int moduleNumber, int channel)
{
lock (mutex)
{
GetOrAdd(sendable).SetName(moduleType, moduleNumber, channel);
}
}
public void CommandList(IInvocationContext context, IMessage message)
{
ISendable target = context.Raiser;
if (context.User.Permissions != UserPermission.BotOwner)
{
target = context.User;
}
StringBuilder sb = new StringBuilder();
foreach (
var cmd in
_commandRegistry.CommandAttributes.OrderBy(x => x.Name)
.Where(x => x.MinimumPermissionLevel <= context.User.Permissions))
{
string args = string.Empty;
if (!string.IsNullOrEmpty(cmd.Arguments))
{
args = string.Join(" ", cmd.Arguments.Split('|').Select(x => $"[{x.Trim()}]"));
}
sb.AppendLine($"{"." + cmd.Name + " " + args}");
}
target.Send(context.OriginClient.Features.HasFlag(ClientFeature.Markdown)
? Message.Create($"```css\n{sb.ToString()}\n```")
: Message.Create(sb.ToString()));
}
public void Update(ISendable sendable)
{
if (components.TryGetValue(sendable, out var comp))
{
comp.Builder.TriggerUpdateTable();
}
}
public object? SetData(ISendable sendable, int handle, object? data)
{
if (handle < 0)
{
throw new ArgumentOutOfRangeException(nameof(handle), "Handle must be 0 or greater");
}
lock (mutex)
{
if (!components.TryGetValue(sendable, out var comp))
{
return null;
}
object? rv = null;
if (comp.Data == null)
{
comp.Data = new object?[handle + 1];
}
else if (handle < comp.Data.Length)
{
rv = comp.Data[handle];
}
else
{
object?[] copy = new object?[handle + 1];
comp.Data.CopyTo(copy.AsSpan());
comp.Data = copy;
}
comp.Data[handle] = data;
return rv;
}
}
public bool Contains(ISendable sendable)
{
lock (mutex)
{
return components.TryGetValue(sendable, out _);
}
}
public MessageAct(MessageType type, GameObject sender, ISendable receiver, object message, float delay = 0.0f)
{
this.sender = sender;
this.receiver = receiver;
this.delay = delay;
this.message = message;
this.type = type;
}
public void Send(string address, ISendable data)
{
_encoder.Clear();
_encoder.Append(address);
_encoder.Append("," + data.Format());
_encoder.Append(data.Data());
_socket.Send(_encoder.Buffer, _encoder.Length, SocketFlags.None);
}
/// <summary>
/// Sends an object to given client.
/// </summary>
/// <param name="client">ID of a client to send the data to</param>
/// <param name="data">Object to be sent</param>
public void Send(int client, ISendable data)
{
var buffer = new byte[data.ByteLength() + 1];
buffer[0] = data.Identifier();
data.GetBytes().CopyTo(buffer, 1);
_sockets[client].Send(buffer);
}
public static void Run()
{
string message = "新年快乐！过节费5000.";
ISendable greetTool = SendToolFactory.GetInstance();
GreetMessageService service = new GreetMessageService(greetTool);
service.Greet(message);
}
/// <summary>
/// Maps the specified key to the specified value in this table.
/// </summary>
/// <remarks>The key cannot be null.</remarks>
/// <param name="key">The key to map the <see cref="ISendable"/> to.</param>
/// <param name="data">The <see cref="ISendable"/> to map.</param>
public static void PutData(string key, ISendable data)
{
ITable dataTable = s_table.GetSubTable(key);
dataTable.PutString("~TYPE~", data.SmartDashboardType);
data.InitTable(dataTable);
s_tablesToData.Add(dataTable, data);
}
public ComplexWidget Add(string title, ISendable sendable)
{
CheckTitle(title);
var widget = new ComplexWidget(m_container, title, sendable);
m_components.Add(widget);
return(widget);
}
public void Add(ISendable sendable, string name)
{
lock (mutex)
{
var comp = GetOrAdd(sendable);
comp.Name = name;
}
}
public void AddLW(ISendable sendable, string moduleType, int moduleNumber, int channel)
{
lock (mutex)
{
var comp = GetOrAdd(sendable);
comp.SetName(moduleType, moduleNumber, channel);
comp.LiveWindow = true;
}
}
public void AddLW(ISendable sendable, string name)
{
lock (mutex)
{
var comp = GetOrAdd(sendable);
comp.Name = name;
comp.LiveWindow = true;
}
}
public ISendable <ITransmittable> Create(ISendable <ITransmittable> input, Moderator moderator)
{
if (input is ISendable <PublicMessage> )
{
var publicMessage = (ISendable <PublicMessage>)input;
return(new SendablePrivateMessage(publicMessage.Transmission.Text, moderator));
}
return(input);
}
static void Main(string[] args)
{
string message = "新年快乐！过节费5000.";
ISendable emailsend = new EmailHelper();
ISendable greetTool = SendToolFactory.GetInstance();
GreetMessageService service = new GreetMessageService(greetTool);
service.Greet(message);
}
public IMessageConsumer <T> GetConsumer <T>(ISendable <T> service) where T : Message
{
var consumers = GetConsumerTypes <T>().ToList();
var consumer = consumers.Select(handler =>
(IMessageConsumer <T>)Activator.CreateInstance(handler, new[] { service })).FirstOrDefault();
return(consumer);
}
public void Add(ISendable sendable, string subsystem, string name)
{
lock (mutex)
{
var comp = GetOrAdd(sendable);
comp.Name = name;
comp.Subsystem = subsystem;
}
}
public CallbackData(ISendable sendable, string name, string subsystem, ISendable? parent, object? data, SendableBuilderImpl builder)
{
Sendable = sendable;
Name = name;
Subsystem = subsystem;
Parent = parent;
Data = data;
Builder = builder;
}
public Telegram(object sender, ISendable receiver, MessageType mes,
double delayTime, object extraInfo)
{
Sender = sender;
Receiver = receiver;
Mes = mes;
DelayTime = delayTime;
ExtraInfo = extraInfo;
}
/// <summary>
/// Send a packet to all InSim objects.
/// </summary>
/// <param name="packet">The packet to send.</param>
public void Send(ISendable packet)
{
foreach (var conn in connections)
{
if (conn.InSim.IsConnected)
{
conn.InSim.Send(packet);
}
}
}
public void DisableLiveWindow(ISendable sendable)
{
lock (mutex)
{
if (components.TryGetValue(sendable, out var comp))
{
comp.LiveWindow = false;
}
}
}
public void SetName(ISendable sendable, string name)
{
lock (mutex)
{
if (components.TryGetValue(sendable, out var comp))
{
comp.Name = name;
}
}
}
public void SetSubsystem(ISendable sendable, string subsystem)
{
lock (mutex)
{
if (components.TryGetValue(sendable, out var comp))
{
comp.Subsystem = subsystem;
}
}
}
public void SetName(ISendable sendable, string moduleType, int moduleNumber, int channel)
{
lock (mutex)
{
if (components.TryGetValue(sendable, out var comp))
{
comp.SetName(moduleType, moduleNumber, channel);
}
}
}
public void RaiseOutgoing(ISendable target, IMessage message)
{
if (target == null || message == null)
{
return;
}
Log.Trace($"[OUT ({message.Attachments?.Count})] {message?.Text}");
Sent?.Invoke(this, new MessageSentEventArgs(target, message));
}
public ComplexWidget Add(ISendable sendable)
{
var name = SendableRegistry.Instance.GetName(sendable);
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentOutOfRangeException(nameof(sendable), "Sendable must have a name");
}
return(Add(name, sendable));
}
void Send(ISendable sendable)
{
LastOutOpcode = sendable.Command;
sendable.Send(stream);
}
public void sendData(ISendable data)
{
if (this.connectionHandeler != null)
this.connectionHandeler.sendPacket(data);
}
public void AppendClass(ISendable sendableClass)
{
sendableClass.AppendToPacket(this);
}
/// <summary>
/// Sends a packet to the server if its connected
/// </summary>
/// <param name="packet"></param>
public void sendData(ISendable packet)
{
connection.sendData(packet.getPacket() as ClientOutgoingPacket);
}
public void Write(int fieldNumber,ISendable sendable)
{
Write(fieldNumber,sendable.GetProtoBufferBytes());
}
private void HandleSend(ISendable packet) {
if (socket.IsConnected) {
socket.Send(packet.GetBuffer());
}
}
