public static Character UpdateCharacter(this Character character, int userId, Terraria.Player player)
{
character.UserId = userId;
character.UUID = player.ClientUUId;
character.Health = player.statLife;
character.MaxHealth = player.statLifeMax;
character.Mana = player.statMana;
character.MaxMana = player.statManaMax;
character.SpawnX = player.SpawnX;
character.SpawnY = player.SpawnY;
character.Hair = player.hair;
character.HairDye = player.hairDye;
character.HideVisual = DataEncoding.EncodeInteger(player.hideVisual);
character.Difficulty = player.difficulty;
character.HairColor = DataEncoding.EncodeColor(player.hairColor);
character.SkinColor = DataEncoding.EncodeColor(player.skinColor);
character.EyeColor = DataEncoding.EncodeColor(player.eyeColor);
character.ShirtColor = DataEncoding.EncodeColor(player.shirtColor);
character.UnderShirtColor = DataEncoding.EncodeColor(player.underShirtColor);
character.PantsColor = DataEncoding.EncodeColor(player.pantsColor);
character.ShoeColor = DataEncoding.EncodeColor(player.shoeColor);
character.AnglerQuests = player.anglerQuestsFinished;
return(character);
}
public static Character AddCharacter(this IDbConnection ctx, int playerId, Terraria.Player player)
{
Character chr = new Character()
{
PlayerId = playerId,
UUID = player.ClientUUId,
Health = player.statLife,
MaxHealth = player.statLifeMax,
Mana = player.statMana,
MaxMana = player.statManaMax,
SpawnX = player.SpawnX,
SpawnY = player.SpawnY,
Hair = player.hair,
HairDye = player.hairDye,
HideVisual = DataEncoding.EncodeInteger(player.hideVisual),
Difficulty = player.difficulty,
HairColor = DataEncoding.EncodeColorAsInt32(player.hairColor),
SkinColor = DataEncoding.EncodeColorAsInt32(player.skinColor),
EyeColor = DataEncoding.EncodeColorAsInt32(player.eyeColor),
ShirtColor = DataEncoding.EncodeColorAsInt32(player.shirtColor),
UnderShirtColor = DataEncoding.EncodeColorAsInt32(player.underShirtColor),
PantsColor = DataEncoding.EncodeColorAsInt32(player.pantsColor),
ShoeColor = DataEncoding.EncodeColorAsInt32(player.shoeColor),
AnglerQuests = player.anglerQuestsFinished
};
chr.Id = ctx.Insert(chr);
return(chr);
}
internal SmmpPacket DataLoop(byte data, int clientID)
{
_byteCache.Add(data);
string s = DataEncoding.GetString((byte[])_byteCache.ToArray(typeof(byte)));
if (!_protocol.Received)
{
SmmpProtocalHeader pheader = _protocol.IsProtocolHeader(ref _byteCache);
if (pheader != null)
{
_savedHeaderInfo = pheader;
_protocol.Received = true;
}
}
else if (_protocol.Received)
{
SmmpPacket packet = _protocol.ReadFormSmProtocol(ref _byteCache, ref _savedHeaderInfo);
if (packet != null)
{
onReceivedData(_localTcpStruct, _remoteTcpStruct, packet, null);
_protocol.Received = false;
_byteCache.Clear();
}
return(packet);
}
return(null);
}
public static Character AddCharacter(this TContext ctx, int userId, Terraria.Player player)
{
Character chr = new Character()
{
UserId = userId,
UUID = player.ClientUUId,
Health = player.statLife,
MaxHealth = player.statLifeMax,
Mana = player.statMana,
MaxMana = player.statManaMax,
SpawnX = player.SpawnX,
SpawnY = player.SpawnY,
Hair = player.hair,
HairDye = player.hairDye,
HideVisual = DataEncoding.EncodeInteger(player.hideVisual),
Difficulty = player.difficulty,
HairColor = DataEncoding.EncodeColor(player.hairColor),
SkinColor = DataEncoding.EncodeColor(player.skinColor),
EyeColor = DataEncoding.EncodeColor(player.eyeColor),
ShirtColor = DataEncoding.EncodeColor(player.shirtColor),
UnderShirtColor = DataEncoding.EncodeColor(player.underShirtColor),
PantsColor = DataEncoding.EncodeColor(player.pantsColor),
ShoeColor = DataEncoding.EncodeColor(player.shoeColor),
AnglerQuests = player.anglerQuestsFinished
};
ctx.Characters.Add(chr);
ctx.SaveChanges();
return(chr);
}
/// <summary>
/// Parameterized constructor
/// </summary>
public callback_num_atag(DataEncoding dcod, string display) : base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)dcod);
writer.Add(display, false);
}
/// <summary>
/// Initializes the application state object from the provided program parameters
/// </summary>
/// <param name="keySize">Key Size</param>
/// <param name="minValueSize">Minimum value size</param>
/// <param name="maxValueSize">Maximum value size</param>
/// <param name="initialDatasetSize">Initial number of key/value pairs</param>
/// <param name="percentGet">Percent GETs (vs PUTs) for the benchmark</param>
/// <param name="dataEncoding">Data encoding</param>
/// <param name="benchmarkDuration">Benchmark duration</param>
public ApplicationState(int keySize, int minValueSize, int maxValueSize, int initialDatasetSize, double percentGet, DataEncoding valueEncoding, double valueTargetCompressionRatio, int benchmarkDuration)
{
this.KeySize = keySize;
this.MinValueSize = minValueSize;
this.MaxValueSize = maxValueSize;
this.InitialDatasetSize = initialDatasetSize;
this.PercentGet = percentGet;
this.ValueEncoding = valueEncoding;
this.ValueTargetCompressionRatio = valueTargetCompressionRatio;
this.BenchmarkDuration = benchmarkDuration;
// Define raw data
if (valueEncoding == DataEncoding.Raw)
this.BaseValue = Encoding.UTF8.GetBytes(string.Empty.PadLeft(this.MaxValueSize, 'v'));
else
{
// Build a base value that will provide (approximately) the desired compression rate
for (int i = 1; i < this.MaxValueSize + 1; i = i + this.MaxValueSize / 1000)
{
this.BaseValue = new byte[this.MaxValueSize];
byte[] pattern = new byte[i];
this.Rand.NextBytes(pattern);
Buffer.BlockCopy(pattern, 0, this.BaseValue, 0, pattern.Length);
int compressedSize = (
valueEncoding == DataEncoding.Deflate
? this.BaseValue.Deflate()
: this.BaseValue.Gzip()
).Length;
if (1.0 - ((double)compressedSize / (double)this.MaxValueSize) < valueTargetCompressionRatio)
break;
}
}
}
/// <inheritdoc />
public override object GetDatabaseValue(IFieldProperties field, object localValue)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
switch (field.DataType)
{
case DataType.String:
{
if (localValue == null)
{
return(null);
}
if (!SupportsFullUTF8)
{
// dirty hack: check mysql 3 byte utf-8
var value = (string)localValue;
foreach (var c in value)
{
if (Encoding.UTF8.GetByteCount(new[] { c }) > 3)
{
throw new NotSupportedException("You can not store 4 byte utf-8 characters to mysql prior version 5.5.3!");
}
}
return(DataEncoding.GetBytes(value));
}
break;
}
case DataType.Double:
{
var d = Convert.ToDouble(localValue);
if (double.IsPositiveInfinity(d))
{
return(double.MaxValue);
}
return(double.IsNegativeInfinity(d) ? double.MinValue : (object)d);
}
case DataType.Single:
{
var f = Convert.ToSingle(localValue);
if (float.IsPositiveInfinity(f))
{
return(float.MaxValue);
}
return(float.IsNegativeInfinity(f) ? float.MinValue : (object)f);
}
}
return(base.GetDatabaseValue(field, localValue));
}
private void listening_thread()
{
while (true)
{
Byte[] arr_data = new Byte[BUFSIZ];
Dictionary <String, String> dict;
try
{
server_socket.Receive(arr_data);
}
catch (SocketException)
{
MessageBoxBase.Show("服务器掉线了！");
Application.Exit();
}
try
{
dict = DataEncoding.get_dictionary(arr_data);
}
catch (DataEncodingException e)
{
MessageBoxBase.Show(e.Message);
Application.Exit();
break;
}
switch (dict["identifier"])
{
default:
throw new DataEncodingException("Invalid identifier.");
case "lobby_ready":
check_ready_request(dict);
break;
case "lobby_chessmove":
check_chessmove_request(dict);
break;
case "lobby_gamestart":
check_gamestart_request(dict);
break;
case "lobby_draw":
check_draw_request(dict);
break;
case "lobby_gameend":
check_gameend_request(dict);
break;
case "lobby_exit":
MessageBoxBase.Show("你的对手已经退出了房间. 即将关闭房间.",
"对手退出房间");
this.Close();
break;
}
}
}
/// <summary>
/// Primary constructor for the data_sm PDU
/// </summary>
/// <param name="stype">Service Type</param>
/// <param name="saddr">Source Address</param>
/// <param name="daddr">Destination Address</param>
/// <param name="esm">ESM</param>
/// <param name="regDelivery">Registered Delivery</param>
/// <param name="dataCoding">Data Coding type</param>
public data_sm(string stype, address saddr, address daddr, esm_class esm,
registered_delivery regDelivery, DataEncoding dataCoding)
: this()
{
this.ServiceType = stype;
this.SourceAddress = saddr;
this.DestinationAddress = daddr;
this.EsmClass = esm;
this.RegisteredDelivery = regDelivery;
this.DataCoding = dataCoding;
}
/// <summary>
/// function to encode a byte array to a string representation.
/// </summary>
/// <returns>The string.</returns>
/// <param name="bytes">Byte array containing the value to be encoded</param>
/// <param name="encoding">Type of encoding</param>
public static String Encode(byte[] bytes, DataEncoding encoding)
{
if (encoding == DataEncoding.HEX)
{
return(HexEncode(bytes));
}
else
{
return(Base64Encode(bytes));
}
}
/// <summary>
/// function to decode a String value to a byte[] representation.
/// </summary>
/// <returns>The byte[].</returns>
/// <param name="value">String value to be decoded</param>
/// <param name="decoding">Type of decoding</param>
public static byte[] Decode(String value, DataEncoding decoding)
{
if (decoding == DataEncoding.HEX)
{
return(HexDecode(value));
}
else
{
return(Base64Decode(value));
}
}
public virtual void PrepareRequest(WebRequest request)
{
var info = RequestInfo.FromVisit(CurrentRequest);
var httpRequest = request as HttpWebRequest;
if (httpRequest != null)
{
httpRequest.UserAgent = CurrentRequest.GetVariable("UserAgent", "Colossus");
httpRequest.Referer = CurrentRequest.GetVariable("Referrer", CurrentRequest.GetVariable("Referer", ""));
}
request.Headers.AddChunked(DataEncoding.RequestDataKey, DataEncoding.EncodeHeaderValue(info));
}
public DataEncoder(DataEncoding encoding, TextWriter writer)
{
Ensure.That(encoding, "encoding").IsNotNull();
Ensure.That(writer, "writer").IsNotNull();
_encoding = encoding;
_writer = writer;
MemoryStream inputStream = new MemoryStream();
_reader = new BitReader(inputStream);
}
private static extern int SmsSendMessage(
IntPtr smshHandle,
byte[] psmsaSMSCAddress,
byte[] psmsaDestinationAddress,
byte[] pstValidityPeriod,
byte[] pbData,
int dwDataSize,
byte[] pbProviderSpecificData,
int dwProviderSpecificDataSize,
DataEncoding smsdeDataEncoding,
int dwOptions,
ref int psmsmidMessageID);
public static Character NewCharacter
(
TContext ctx,
CharacterMode mode,
string auth,
string clientUUID,
int health,
int maxHealth,
int mana,
int maxMana,
int spawnX,
int spawnY,
int hair,
byte hairDye,
bool[] hideVisual,
byte difficulty,
Microsoft.Xna.Framework.Color hairColor,
Microsoft.Xna.Framework.Color skinColor,
Microsoft.Xna.Framework.Color eyeColor,
Microsoft.Xna.Framework.Color shirtColor,
Microsoft.Xna.Framework.Color underShirtColor,
Microsoft.Xna.Framework.Color pantsColor,
Microsoft.Xna.Framework.Color shoeColor,
int anglerQuests
)
{
return(NewCharacter
(
ctx,
mode,
auth,
clientUUID,
health,
maxHealth,
mana,
maxMana,
spawnX,
spawnY,
hair,
hairDye,
DataEncoding.EncodeInteger(hideVisual),
difficulty,
DataEncoding.EncodeColor(hairColor),
DataEncoding.EncodeColor(skinColor),
DataEncoding.EncodeColor(eyeColor),
DataEncoding.EncodeColor(shirtColor),
DataEncoding.EncodeColor(underShirtColor),
DataEncoding.EncodeColor(pantsColor),
DataEncoding.EncodeColor(shoeColor),
anglerQuests
));
}
/// <inheritdoc/>
protected DataUrl(SerializationInfo serializationInfo, StreamingContext streamingContext)
: base(serializationInfo, streamingContext)
{
if (TryCreate(OriginalString, out DataUrl? tmpUrl))
{
this._mimeType = tmpUrl.MimeType;
this._encoding = tmpUrl.Encoding;
}
else
{
throw new UriFormatException(Res.NoDataUrl);
}
}
public virtual void ParseResponse(WebResponse response)
{
var data = response.Headers.GetChunked(DataEncoding.ResponseDataKey);
if (data != null)
{
LastResponse = DataEncoding.DecodeHeaderValue <TResponseInfo>(data);
}
else
{
LastResponse = new TResponseInfo();
}
LastResponse.ParseHttpResponse(response as HttpWebResponse);
}
public RemoteTunnel(string url, DataEncoding encoding = DataEncoding.Proto, int maxConnections = 2) : this(maxConnections)
{
if (url == null)
throw new ArgumentNullException();
EndPoint = new Uri(url);
var throttle = 0;
CreateConnection = ConnectionBuilderFromUri(EndPoint, out throttle);
Throttle = throttle;
switch (encoding)
{
case DataEncoding.Memcached:
CreateProtocol = (dtc) => { return new Memcached.ClientProtocol(dtc); }; break;
default:
throw new NotImplementedException(encoding.ToString());
}
}
/// <summary>
/// Returns coding scheme part for MessageWaitingIndication
/// </summary>
/// <returns></returns>
private byte GetWaitingIndication(DataEncoding dataEncoding)
{
byte result = 0x00;
// Is it Discard or Store? Store depends on alphabet encoding
if (this.Operation == MessageIndicationOperation.Discard)
{
result |= CODING_SCHEME_MESSAGE_INDICATION_DISCARD;
}
else if (this.Operation == MessageIndicationOperation.Store && dataEncoding == DataEncoding.Default7bit)
{
result |= CODING_SCHEME_MESSAGE_INDICATION_STORE_DEFAULT_ENCODING;
}
else if (this.Operation == MessageIndicationOperation.Store && dataEncoding == DataEncoding.UCS2_16bit)
{
result |= CODING_SCHEME_MESSAGE_INDICATION_STORE_UCS2_ENCODING;
}
// Activeting or Deactivating Indication
if (this.IsActive)
{
result |= CODING_SCHEME_INDICATION_ACTIVE;
}
switch (this.Type)
{
case IndicationType.Voicemail:
result |= CODING_SCHEME_INDICATION_VOICEMAIL;
break;
case IndicationType.FaxMessage:
result |= CODING_SCHEME_INDICATION_FAX;
break;
case IndicationType.EmailMessage:
result |= CODING_SCHEME_INDICATION_EMAIL;
break;
case IndicationType.OtherMessage:
result |= CODING_SCHEME_INDICATION_OTHER;
break;
}
return(result);
}
/// <summary>
/// Primary constructor for the submit_multi PDU
/// </summary>
/// <param name="stype">Service Type</param>
/// <param name="saddr">Source Address</param>
/// <param name="esm">ESM</param>
/// <param name="protid">Protocol ID</param>
/// <param name="priority">Priority</param>
/// <param name="delTime">Delivery Time</param>
/// <param name="valPeriod">Validation Period</param>
/// <param name="regDelivery">Registered Delivery</param>
/// <param name="replace">Replace If present</param>
/// <param name="dataCoding">Data Coding type</param>
/// <param name="defMsgId">Default Msg ID</param>
/// <param name="msg">Message</param>
public submit_multi(string stype, address saddr, esm_class esm, byte protid,
MessagePriority priority, SmppTime delTime, SmppTime valPeriod,
registered_delivery regDelivery, bool replace, DataEncoding dataCoding, byte defMsgId,
string msg)
: this()
{
this.ServiceType = stype;
this.SourceAddress = saddr;
this.EsmClass = esm;
this.ProtocolID = protid;
this.PriorityFlag = priority;
this.DeliveryTime = delTime;
this.ValidityPeriod = valPeriod;
this.RegisteredDelivery = regDelivery;
this.ReplaceExisting = replace;
this.DataCoding = dataCoding;
this.SmDefaultMessageID = defMsgId;
this.Message = msg;
}
/// <summary>
/// Returns TP-DCS Data coding scheme value that represents the message indication information
/// </summary>
/// <param name="dataEncoding">Data encoding used in the message</param>
/// <returns></returns>
public byte ToByte(DataEncoding dataEncoding)
{
byte dataCodingScheme = CODING_SCHEME_MESSAGE_CLASS_SPECIFIED;
// Set encoding
if (dataEncoding == DataEncoding.Default7bit)
{
dataCodingScheme |= CODING_SCHEME_DEFAULT_ENCODING;
}
else if (dataEncoding == DataEncoding.Data8bit)
{
dataCodingScheme |= CODING_SCHEME_8BIT_ENCODING;
}
else if (dataEncoding == DataEncoding.UCS2_16bit)
{
dataCodingScheme |= CODING_SCHEME_UCS2_ENCODING;
}
// Set indication
if (this.Class == SharpSMS.MessageClass.ImmediateDisplay)
{
dataCodingScheme |= CODING_SCHEME_MESSAGE_CLASS_IMMEDIATE_DISPLAY;
}
else if (this.Class == SharpSMS.MessageClass.MESpecific)
{
dataCodingScheme |= CODING_SCHEME_MESSAGE_CLASS_MESPECIFIC;
}
else if (this.Class == SharpSMS.MessageClass.SIMSpecific)
{
dataCodingScheme |= CODING_SCHEME_MESSAGE_CLASS_SIMSPECIFIC;
}
else if (this.Class == SharpSMS.MessageClass.TESpecific)
{
dataCodingScheme |= CODING_SCHEME_MESSAGE_CLASS_TESPECIFIC;
}
if (this.Operation != MessageIndicationOperation.NotSet)
{
dataCodingScheme = GetWaitingIndication(dataEncoding);
}
return(dataCodingScheme);
}
/// <summary>
/// Primary constructor for the broadcast_sm PDU
/// </summary>
/// <param name="stype">Service Type</param>
/// <param name="saddr">Source Address</param>
/// <param name="messageId">Message Id</param>
/// <param name="priority">Priority</param>
/// <param name="delTime">Delivery Time</param>
/// <param name="valPeriod">Validation Period</param>
/// <param name="replace">Replace If present</param>
/// <param name="dataCoding">Data Coding type</param>
/// <param name="defMsgId">Default Msg ID</param>
/// <param name="areaId">Geographical area ID</param>
/// <param name="contentType">Content type</param>
/// <param name="repeatCount">Repeat count</param>
/// <param name="frequency">Frequency interval</param>
public broadcast_sm(string stype, address saddr, string messageId,
MessagePriority priority, SmppTime delTime, SmppTime valPeriod,
bool replace, DataEncoding dataCoding, byte defMsgId,
broadcast_area_identifier areaId, broadcast_content_type contentType,
int repeatCount, broadcast_frequency_interval frequency)
: this()
{
this.ServiceType = stype;
this.SourceAddress = saddr;
this.PriorityFlag = priority;
this.DeliveryTime = delTime;
this.ValidityPeriod = valPeriod;
this.ReplaceExisting = replace;
this.DataCoding = dataCoding;
this.SmDefaultMessageID = defMsgId;
this.areaId_ = areaId;
this.contentType_ = contentType;
this.repNum_.Value = repeatCount;
this.freqInt_ = frequency;
}
public TileLayer(string name,
int width,
int height,
int tileWidth,
int tileHeight,
string encodedData,
DataEncoding dataEncoding = DataEncoding.CSV,
bool visible = true,
bool locked = false,
float opacity = 1.0f,
float horizontalOffset = 0.0f,
float verticalOffset = 0.0f) : base(name, visible, locked, opacity, horizontalOffset, verticalOffset)
{
Width = width;
TileWidth = tileWidth;
Height = height;
TileHeight = tileHeight;
EncodedData = encodedData;
DataEncoding = dataEncoding;
MapChunks = new List <MapChunk>();
}
public static RequestInfo ColossusInfo(this HttpContext ctx)
{
if (ctx == null)
{
return(null);
}
var info = ctx.Items[DataEncoding.RequestDataKey] as RequestInfo;
if (info == null)
{
var data = ctx.Request.Headers.GetChunked(DataEncoding.RequestDataKey);
if (data != null)
{
ctx.Items[DataEncoding.RequestDataKey] = info = DataEncoding.DecodeHeaderValue <RequestInfo>(data);
}
}
return(info);
}
private static StringBuilder DoDecompress(string inputStream, DataEncoding encoding)
{
if ("" == inputStream)
{
return(null);
}
else
{
var result = new StringBuilder();
if (null == inputStream)
{
return(result);
}
else
{
var decompressor = new Decompressor(result);
var decoder = new BitDecoder(inputStream, encoding);
decompressor.Decompress(decoder);
return(result);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataResponse"/> class.
/// </summary>
/// <param name="data">The response data.</param>
/// <param name="dataType">The response data type.</param>
/// <param name="dataEncoding">The response data encoding.</param>
/// <param name="correlationId">The response correlation identifier.</param>
/// <param name="responseId">The response identifier.</param>
/// <param name="responseTimestamp">The response timestamp.</param>
public DataResponse(
byte[] data,
string dataType,
DataEncoding dataEncoding,
Guid correlationId,
Guid responseId,
ZonedDateTime responseTimestamp)
: base(
EventType,
correlationId,
responseId,
responseTimestamp)
{
Condition.NotEmptyOrWhiteSpace(dataType, nameof(dataType));
Debug.NotDefault(correlationId, nameof(correlationId));
Debug.NotDefault(responseId, nameof(responseId));
Debug.NotDefault(responseTimestamp, nameof(responseTimestamp));
this.Data = data;
this.DataType = dataType;
this.DataEncoding = dataEncoding;
}
private static StringBuilder DoCompress(string input, DataEncoding encoding)
{
if (input == "")
{
return(null);
}
else
{
var result = new StringBuilder();
if (null == input)
{
return(result);
}
else
{
var encoder = new BitEncoder(result, encoding);
var compressor = new Compressor(encoder);
compressor.Compress(input);
compressor.MarkEndOfStream();
return(result);
}
}
}
/// <summary>
/// Initializes the application state object from the provided program parameters
/// </summary>
/// <param name="keySize">Key Size</param>
/// <param name="minValueSize">Minimum value size</param>
/// <param name="maxValueSize">Maximum value size</param>
/// <param name="initialDatasetSize">Initial number of key/value pairs</param>
/// <param name="percentGet">Percent GETs (vs PUTs) for the benchmark</param>
/// <param name="dataEncoding">Data encoding</param>
/// <param name="benchmarkDuration">Benchmark duration</param>
public ApplicationState(int keySize, int minValueSize, int maxValueSize, int initialDatasetSize, double percentGet, DataEncoding valueEncoding, double valueTargetCompressionRatio, int benchmarkDuration)
{
this.KeySize = keySize;
this.MinValueSize = minValueSize;
this.MaxValueSize = maxValueSize;
this.InitialDatasetSize = initialDatasetSize;
this.PercentGet = percentGet;
this.ValueEncoding = valueEncoding;
this.ValueTargetCompressionRatio = valueTargetCompressionRatio;
this.BenchmarkDuration = benchmarkDuration;
// Define raw data
if (valueEncoding == DataEncoding.Raw)
{
this.BaseValue = Encoding.UTF8.GetBytes(string.Empty.PadLeft(this.MaxValueSize, 'v'));
}
else
{
// Build a base value that will provide (approximately) the desired compression rate
for (int i = 1; i < this.MaxValueSize + 1; i = i + this.MaxValueSize / 1000)
{
this.BaseValue = new byte[this.MaxValueSize];
byte[] pattern = new byte[i];
this.Rand.NextBytes(pattern);
Buffer.BlockCopy(pattern, 0, this.BaseValue, 0, pattern.Length);
int compressedSize = (
valueEncoding == DataEncoding.Deflate
? this.BaseValue.Deflate()
: this.BaseValue.Gzip()
).Length;
if (1.0 - ((double)compressedSize / (double)this.MaxValueSize) < valueTargetCompressionRatio)
{
break;
}
}
}
}
private static TileLayer GenerateTileLayer(XElement element, bool isInfinate, int tileWidth, int tileHeight)
{
string name = XMLHelperFuncs.GetStringFromAttribute(element, "name");
int layerWidth = XMLHelperFuncs.GetIntFromAttribute(element, "width");
int layerHeight = XMLHelperFuncs.GetIntFromAttribute(element, "height");
// These attributes don't necisarially exist in the file.
// So if we don't we set what it's default value 'should' be.
bool visible = XMLHelperFuncs.GetBoolFromAttribute(element, "visible", true);
bool locked = XMLHelperFuncs.GetBoolFromAttribute(element, "locked");
float opacity = XMLHelperFuncs.GetFloatFromAttribute(element, "opacity", 1.0f);
float horizontalOffset = XMLHelperFuncs.GetFloatFromAttribute(element, "offsetx", 0.0f);
float verticalOffset = XMLHelperFuncs.GetFloatFromAttribute(element, "offsety", 0.0f);
TileLayer layer;
string encodedData = "";
DataEncoding dataEncoding = DataEncoding.CSV;
// The encoding attribute only exists if data isn't in XML format
if (XMLHelperFuncs.DoesAttributeExist(element.Element("data"), "encoding"))
{
string strDataEncoding = XMLHelperFuncs.GetStringFromAttribute(element.Element("data"), "encoding");
switch (strDataEncoding)
{
case ("csv"):
dataEncoding = DataEncoding.CSV;
break;
case ("base64"):
if (XMLHelperFuncs.DoesAttributeExist(element.Element("data"), "compression"))
{
if (XMLHelperFuncs.GetStringFromAttribute(element.Element("data"), "compression") == "gzip")
{
dataEncoding = DataEncoding.BASE64GZIP;
}
else if (XMLHelperFuncs.GetStringFromAttribute(element.Element("data"), "compression") == "zlib")
{
dataEncoding = DataEncoding.BASE64ZLIB;
}
else
{
//Todo: report error that compression is unknown
}
}
else
{
dataEncoding = DataEncoding.BASE64;
}
break;
default:
//Todo: report error that encoding is unkown
break;
}
}
else
{
dataEncoding = DataEncoding.XML;
}
layer = new TileLayer(name,
layerWidth,
layerHeight,
tileWidth,
tileHeight,
encodedData,
dataEncoding,
visible,
locked,
opacity,
horizontalOffset,
verticalOffset);
// Decode and add data
if (!isInfinate)
{
if (dataEncoding != DataEncoding.XML)
{
encodedData = XMLHelperFuncs.GetStringFromElement(element, "data");
layer.AddMapChunk <string>(encodedData, 0, 0, layerWidth, layerHeight, tileWidth, tileHeight, dataEncoding);
}
else
{
encodedData = "";
XElement dataElement = XMLHelperFuncs.GetElement(element, "data");
layer.AddMapChunk(dataElement, 0, 0, layerWidth, layerHeight, tileWidth, tileHeight, dataEncoding);
}
}
else
{
if (dataEncoding != DataEncoding.XML)
{
foreach (var chunkElement in XMLHelperFuncs.GetElement(element, "data").Elements())
{
int x = XMLHelperFuncs.GetIntFromAttribute(chunkElement, "x");
int y = XMLHelperFuncs.GetIntFromAttribute(chunkElement, "y");
int width = XMLHelperFuncs.GetIntFromAttribute(chunkElement, "width");
int height = XMLHelperFuncs.GetIntFromAttribute(chunkElement, "height");
string tempEncodedData = chunkElement.Value.ToString();
layer.AddMapChunk(tempEncodedData, x, y, width, height, tileWidth, tileHeight, dataEncoding);
}
}
else
{
encodedData = "";
//Todo
}
}
return(layer);
}
public void Start(DataEncoding dc, string url, int max = 0, int seeds = 0)
{
var uri = new Uri(url);
//IProtocolFactory proto = null;
switch (dc)
{
//case DataEncoding.Proto: proto = ProtocolFactory.PipeRpc; break;
//case DataEncoding.Json: proto = ProtocolFactory.JsonRpc; break;
case DataEncoding.Any: break;
default: throw new NotSupportedException();
}
Start(uri, null, seeds);
}
private static extern int SmsSendMessage ( IntPtr smshHandle, byte[] psmsaSMSCAddress, byte[] psmsaDestinationAddress, byte[] pstValidityPeriod, byte[] pbData, int dwDataSize, byte[] pbProviderSpecificData, int dwProviderSpecificDataSize, DataEncoding smsdeDataEncoding, int dwOptions, ref int psmsmidMessageID);
private void ReadDataEntries(ulong Offset)
{
if (DataArray[(uint)Offset] == 13)
{
ushort num = (ToUInt64((Offset.ForceTo <decimal>() + 3m).ForceTo <int>(), 2).ForceTo <decimal>() - 1m).ForceTo <ushort>();
int num2 = 0;
if (DataEntries != null)
{
num2 = DataEntries.Length;
DataEntries = (DataEntry[])Utils.CopyArray(DataEntries, new DataEntry[DataEntries.Length + num + 1]);
}
else
{
DataEntries = new DataEntry[num + 1];
}
int num3 = num;
for (int i = 0; i <= num3; i++)
{
ulong num4 = ToUInt64((Offset.ForceTo <decimal>() + 8m + (i * 2).ForceTo <decimal>()).ForceTo <int>(), 2);
if (decimal.Compare(Offset.ForceTo <decimal>(), 100m) != 0)
{
num4 += Offset;
}
int values = GetValues(num4.ForceTo <int>());
CalcVertical(num4.ForceTo <int>(), values);
int values2 = GetValues((num4.ForceTo <decimal>() + values.ForceTo <decimal>() - num4.ForceTo <decimal>() + 1m).ForceTo <int>());
DataEntries[num2 + i].ID = CalcVertical((num4.ForceTo <decimal>() + values.ForceTo <decimal>() - num4.ForceTo <decimal>() + 1m).ForceTo <int>(), values2);
num4 = (num4.ForceTo <decimal>() + values2.ForceTo <decimal>() - num4.ForceTo <decimal>() + 1m).ForceTo <ulong>();
values = GetValues(num4.ForceTo <int>());
values2 = values;
long value = CalcVertical(num4.ForceTo <int>(), values);
long[] array = new long[5];
int num5 = 0;
do
{
values = values2 + 1;
values2 = GetValues(values);
array[num5] = CalcVertical(values, values2);
if (array[num5] > 9)
{
if (ItIsOdd(array[num5]))
{
array[num5] = (long)Math.Round((double)(array[num5] - 13) / 2.0);
}
else
{
array[num5] = (long)Math.Round((double)(array[num5] - 12) / 2.0);
}
}
else
{
array[num5] = SQLDataTypeSize[(int)array[num5]];
}
num5++;
}while (num5 <= 4);
Encoding encoding = Encoding.Default;
decimal value2 = DataEncoding.ForceTo <decimal>();
if (!1m.Equals(value2))
{
if (!2m.Equals(value2))
{
if (3m.Equals(value2))
{
encoding = Encoding.BigEndianUnicode;
}
}
else
{
encoding = Encoding.Unicode;
}
}
else
{
encoding = Encoding.Default;
}
DataEntries[num2 + i].Type = encoding.GetString(DataArray, Convert.ToInt32(decimal.Add(new decimal(num4), new decimal(value))), (int)array[0]);
DataEntries[num2 + i].Name = encoding.GetString(DataArray, Convert.ToInt32(decimal.Add(decimal.Add(new decimal(num4), new decimal(value)), new decimal(array[0]))), (int)array[1]);
DataEntries[num2 + i].RootNum = (long)ToUInt64(Convert.ToInt32(decimal.Add(decimal.Add(decimal.Add(decimal.Add(new decimal(num4), new decimal(value)), new decimal(array[0])), new decimal(array[1])), new decimal(array[2]))), (int)array[3]);
DataEntries[num2 + i].SqlStatement = encoding.GetString(DataArray, Convert.ToInt32(decimal.Add(decimal.Add(decimal.Add(decimal.Add(decimal.Add(new decimal(num4), new decimal(value)), new decimal(array[0])), new decimal(array[1])), new decimal(array[2])), new decimal(array[3]))), (int)array[4]);
}
}
else
{
if (DataArray[(uint)Offset] != 5)
{
return;
}
int num6 = Convert.ToUInt16(decimal.Subtract(new decimal(ToUInt64(Convert.ToInt32(decimal.Add(new decimal(Offset), 3m)), 2)), 1m));
for (int j = 0; j <= num6; j++)
{
ushort num7 = (ushort)ToUInt64(Convert.ToInt32(decimal.Add(decimal.Add(new decimal(Offset), 12m), new decimal(j * 2))), 2);
if (decimal.Compare(new decimal(Offset), 100m) == 0)
{
ReadDataEntries(Convert.ToUInt64(decimal.Multiply(decimal.Subtract(new decimal(ToUInt64(num7, 4)), 1m), new decimal(PageSize))));
}
else
{
ReadDataEntries(Convert.ToUInt64(decimal.Multiply(decimal.Subtract(new decimal(ToUInt64((int)(Offset + num7), 4)), 1m), new decimal(PageSize))));
}
}
ReadDataEntries(Convert.ToUInt64(decimal.Multiply(decimal.Subtract(new decimal(ToUInt64(Convert.ToInt32(decimal.Add(new decimal(Offset), 8m)), 4)), 1m), new decimal(PageSize))));
}
}
/// <summary>
/// 向对方发送数据
/// </summary>
/// <param name="byteData">数据内容</param>
/// <param name="clientID">连接标识</param>
public void SendData(string stringData, int clientID)
{
SendData(DataEncoding.GetBytes(stringData), clientID);
}
/// <summary>
/// 向对方发送字符串
/// </summary>
/// <param name="s">字符串数据</param>
/// <param name="clientID">连接标识</param>
public void SendString(string s, int clientID)
{
SendData(DataEncoding.GetBytes(s), clientID);
}
