public void Serialize <T>(IStreamWriter writer, T valueObj, object contextObject)
{
Type type = typeof(T);
//todo: can be optimized with static generic caching
Serialize(writer, valueObj, type, contextObject);
}
public static void WriteTypeMetaInfo(IStreamWriter writer, ITypeStructure typeItem, bool writeTypeMetaPrefix = true)
{
if (writeTypeMetaPrefix)
{
writer.WriteUInt8(ValueItem.TypeMetaInfo);
}
writer.WriteUInt8(SingleTypeDescr);
Type type = typeItem.RuntimeType;
writer.WriteString(type.Assembly.GetName().Name);
writer.WriteString(type.FullName);
short itemCount = (short)typeItem.Items.Count;
writer.WriteInt16(itemCount);
for (int i = 0; i < itemCount; i++)
{
var memberItem = typeItem.Items[i];
writer.WriteInt16((short)memberItem.Type); // ItemType Enum
writer.WriteUInt32(memberItem.TypeId); // TypeId (Type Hash)
writer.WriteString(memberItem.Name); // Property Name
writer.WriteBool(memberItem.IsNullable); // Nullable Flag
}
}
public TvdbV2(ITvdbSeries series, ITvdbSearch search, ITvdbUpdate update, IStreamWriter streamWriter)
{
this.series = series;
this.search = search;
this.update = update;
this.streamWriter = streamWriter;
}
public void printNewspaper(IStreamWriter streamWriter)
{
for (int i = 0; i < Pages.Count; i++)
{
Pages[i].printPage(streamWriter);
}
}
public static void SerializeConnect(IStreamWriter writer, ConnectCommand connect)
{
VersionSerializer.SerializeVersion(writer, connect.ProtocolVersion);
var realm = connect.Realm;
writer.WriteString(realm);
}
public async void Generete_Test()
{
List <string> expectedData = new List <string>
{
@"f\bla\ra\t.dat",
@"books\csharp\csharp.pdf",
@"proj\tools\utils.cpp",
@"proj\timer\main.cpp"
};
int expectedLength = 4;
IDirectory iDirectory = Substitute.For <IDirectory>();
iDirectory.GetFilesAsync("", SearchOption.AllDirectories).Returns(expectedData);
IFileFilter iFileFilter = Substitute.For <IFileFilter>();
iFileFilter.GetFilteredFiles(iDirectory).Returns(expectedData.ToArray());
ResultGenerator resultGenerator = new ResultGenerator(iDirectory, iFileFilter);
IStreamWriter actual = await resultGenerator.Generate();
Assert.Equal(expectedLength, actual.Data.Length);
Assert.Equal(expectedData.ToArray(), actual.Data);
}
private static void WriteString(IStreamWriter writer, string data)
{
if (data == null)
{
writer.Write(NullLengthFlag); // String length
}
else
{
var sLen = data.Length;
if (sLen == 0)
{
writer.Write(0); // String length
}
else
{
if (sLen > MaxAllowedStringLength)
{
throw new Exception(SerializationErrors.StringLengthExceededAllowedLimit);
}
var bytes = Encoding.UTF8.GetBytes(data);
var bLen = bytes.Length;
writer.Write(bLen); // Byte array length
if (bLen > 1)
{
writer.Write(sLen);
}
writer.Write(bytes);
}
}
}
public async Task Connect(IStreamWriter writer)
{
var tags = new [] { "first", "second", "third" };
await Task.Run(async() =>
{
for (; ;)
{
_logger.Information(
"Pushing tags '{tags}'",
string.Join(", ", tags.Select(_ => _)));
var dataPoints = tags.Select(_ => new TagDataPoint(
(Tag)_,
//Value = (Measurement<float>)_random.NextDouble()
//Value = (Measurement<double>)_random.NextDouble()
//Value = new Vector2 { X = (float)_random.NextDouble(), Y = (float)_random.NextDouble() }
new Vector3 {
X = (float)_random.NextDouble(), Y = (float)_random.NextDouble(), Z = (float)_random.NextDouble()
}
));
await writer.Write(dataPoints);
await Task.Delay(1000);
}
});
}
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
writer.WriteUInt8((byte)value);
});
}
public void SetInputStream(EncoderNode encoder, int index)
{
System.Diagnostics.Debug.Assert(mEncoderInput == null);
mEncoderInput = encoder.GetInputSink(index);
if (mEncoderInput == null)
encoder.SetInputSource(index, this);
}
private static void WriteIfBufferIsFull(IStreamWriter <T> dataWriter, T[] buffer, ref int numSlicesBuffered)
{
if (numSlicesBuffered == buffer.Length)
{
dataWriter.Write(buffer, 0, numSlicesBuffered);
numSlicesBuffered = 0;
}
}
public static void SerializeStreamData(IStreamWriter stream, StreamDataCommand command)
{
ChannelIdSerializer.SerializeChannelId(stream, command.Channel);
StreamOffsetSerializer.SerializeStreamOffset(stream, command.Offset);
stream.WriteBool(command.IsAtEndPosition);
stream.WriteLength((ushort)command.Payload.Length);
stream.WriteOctets(command.Payload);
}
public void Serialize(IStreamWriter writer, object obj, Type type, object contextObject)
{
serializeContext.Reset(contextObject);
IValueItem structure = GetByType(type, serializeContext);
structure.WriteValue(writer, serializeContext, obj);
}
public ExperimentHistory(string filePath, IStreamWriter streamWriter, Experiment experiment)
{
_filePath = filePath;
_streamWriter = streamWriter;
_experiment = experiment;
_data = new List<Tuple<Game, Users>>();
}
public void SetInputStream(EncoderNode encoder, int index)
{
mConnectionOutputToEncoderInput = encoder.GetInputSink(index);
if (mConnectionOutputToEncoderInput == null)
{
encoder.SetInputSource(index, this);
}
}
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
TimeSpan time = (TimeSpan)value;
writer.WriteInt64(time.Ticks);
});
}
public void TestInititalize()
{
_streamFactoryMock = Substitute.For <IStreamFactory>();
_streamFactoryMock.Create().Returns(new MemoryStream());
_dateTimeProviderMock = Substitute.For <IDateTimeProvider>();
_dateTimeProviderMock.UtcNow.Returns(DateTime.UtcNow.ToString());
_streamWriterMock = Substitute.For <IStreamWriter>();
}
public override void SetOutputSink(int index, IStreamWriter stream)
{
if (index != 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
mStream.SetOutputSink(stream);
}
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
Guid guid = (Guid)value;
var seg = new ArraySegment <byte>(guid.ToByteArray());
writer.WriteBytes(seg);
});
}
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
DateTime dt = (DateTime)value;
writer.WriteInt64(dt.Ticks);
});
}
protected void SetUp()
{
mocks = new Mockery();
mockStreamWriter = mocks.NewMock <IStreamWriter>();
mockDateTime = mocks.NewMock <IDateTime>();
exceptionStorer = new ExceptionStorer();
workerThreadLoopCompleteSignal = new AutoResetEvent(false);
testFileMetricLogger = new FileMetricLogger('|', new LoopingWorkerThreadBufferProcessor(10, true), true, mockStreamWriter, mockDateTime, exceptionStorer);
}
/// <summary>
/// Writes the value.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The value.</param>
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
string stringValue = (string)value;
writer.WriteString(stringValue);
});
}
private static void SaveBunnies(IStreamWriter streamWriter, IList <IBunny> bunnies)
{
using (streamWriter)
{
foreach (var bunny in bunnies)
{
streamWriter.WriteLine(bunny.ToString());
}
}
}
public void SetInputStream(EncoderNode encoder, int index)
{
System.Diagnostics.Debug.Assert(mEncoderInput == null);
mEncoderInput = encoder.GetInputSink(index);
if (mEncoderInput == null)
{
encoder.SetInputSource(index, this);
}
}
private static async Task GenerateResultToFile()
{
IDirectory iDirectory = new FileManager(startDirectory);
IFileFilter iFileFilter = new FilterManager(filterBy);
ResultGenerator resultGenerator = new ResultGenerator(iDirectory, iFileFilter);
IStreamWriter sWriter = await resultGenerator.Generate();
sWriter.WriteToFile(resultFile);
}
public static void Write <T>(this IStreamWriter <T> writer, IInStream <T> inStream, T[] buffer)
{
using (var reader = inStream.GetReader())
{
while (!reader.Eos)
{
int numSlicesRead = reader.Read(buffer, 0, buffer.Length);
writer.Write(buffer, 0, numSlicesRead);
}
}
}
/// <summary>
/// Write enum type meta infos
/// </summary>
/// <param name="writer"></param>
/// <param name="type"></param>
public static void WriteTypeMetaInfo(IStreamWriter writer, Type type)
{
writer.WriteUInt8(ValueItem.TypeMetaInfo);
writer.WriteUInt8(SingleTypeDescr);
writer.WriteString(type.Assembly.GetName().Name);
writer.WriteString(type.FullName);
// Write 0 items (only type specification in case of enum)
writer.WriteInt16(0);
}
public void Write(IStreamWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
writer.Write(Major.ToBytes());
writer.Write(MajorRevision.ToBytes());
writer.Write(Minor.ToBytes());
writer.Write(MinorRevision.ToBytes());
writer.Write(ProcessId.ToBytes());
}
public override void SetOutputSink(int index, IStreamWriter stream)
{
if (index != 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (stream == null)
throw new ArgumentNullException(nameof(stream));
if (mOutput != null)
throw new InvalidOperationException();
mOutput = stream;
}
public void SetFileProperties(IFileProperties fileInfo)
{
try
{
_extendedStreamReader = _fileHelper.GetExtendedStreamReader(_originalFileProperties.OriginalFilePath);
}
catch (System.IO.DirectoryNotFoundException)
{
//if we can't find the directory, we read from the embedded base64 in the sdlxliff file
_extendedStreamReader = _fileHelper.GetExtendedStreamReader(_originalFileProperties.DependencyFiles.First().CurrentFilePath);
}
_streamWriter = _fileHelper.GetStreamWriter(_nativeFileProperties.OutputFilePath);
_lineParsingSession = _lineParser.StartLineParsingSession();
}
public override void WriteValue(IStreamWriter writer, ISerializeContext context, object value)
{
NullableWrite(writer, value, () =>
{
decimal decVal = (decimal)value;
int[] bits = Decimal.GetBits(decVal);
writer.WriteInt32(bits[0]);
writer.WriteInt32(bits[1]);
writer.WriteInt32(bits[2]);
writer.WriteInt32(bits[3]);
});
}
public void Queue(IStreamWriter writer, bool isReliable)
{
Assert.NotNull(writer, "writer");
if (isReliable)
{
reliable.Enqueue(writer);
}
else
{
unreliable.Enqueue(writer);
}
Context.NetworkQueue.Add(this);
}
public void WriteToRequest(IStreamWriter writer)
{
if (_contentLength < 0) GetLength();
_content.Position = 0;
writer.Write(_content);
foreach (var file in _upload.Files)
{
writer.Write(file.Header, 0, file.Header.Length);
var stream = file.GetStream(_async);
writer.Write(stream);
writer.Promise.Always(() => stream.Dispose());
writer.Write(13, 10);
}
writer.Write(_finalBytes, 0, _finalBytes.Length);
}
private void WriteRows(IStreamWriter writer,
Person person)
{
var row = new object[1, 8];
row[0, 0] = person.FirstName;
row[0, 1] = person.SecondName;
row[0, 2] = person.LastName;
row[0, 3] = person.Sex;
row[0, 4] = person.YearOfBirth;
row[0, 5] = person.Education;
row[0, 6] = person.Profession;
row[0, 7] = person.HasExperienceInSport;
writer.Write(row);
}
private void WriteHeader(IStreamWriter writer)
{
// Вывести заголовок
var header = new object[1, 8];
header[0, 0] = "Имя";
header[0, 1] = "Отчество";
header[0, 2] = "Фамилия";
header[0, 3] = "Пол";
header[0, 4] = "Год рождения";
header[0, 5] = "Образование";
header[0, 6] = "Профессия";
header[0, 7] = "Опыт занятия спортом";
writer.Write(header);
}
private static void WriteBytes(IStreamWriter writer, byte[] data)
{
if (data == null)
{
writer.Write(NullLengthFlag);
}
else
{
var bLen = data.Length;
writer.Write(bLen);
if (bLen > 0)
{
writer.Write(data);
}
}
}
public Task EncodeAsync(IStreamReader input, IStreamWriter output, CancellationToken ct = default(CancellationToken))
{
lock (mSyncObject)
{
if (mDisposeTask != null)
throw new OperationCanceledException();
// TODO: make this wait async as well
while (mRunning)
{
Monitor.Wait(mSyncObject);
if (mDisposeTask != null)
throw new OperationCanceledException();
}
mRunning = true;
}
var task = Task.Run(async delegate {
var result = mEncoder.Lzma2Enc_Encode(new AsyncOutputProvider(output), new AsyncInputProvider(input), null);
if (result != LZMA.Master.LZMA.SZ_OK)
throw new InvalidOperationException();
await output.CompleteAsync().ConfigureAwait(false);
});
mEncoderTask = task.ContinueWith(delegate {
lock (mSyncObject)
{
System.Diagnostics.Debug.Assert(mRunning);
mRunning = false;
Monitor.PulseAll(mSyncObject);
}
}, CancellationToken.None, TaskContinuationOptions.DenyChildAttach, TaskScheduler.Default);
return task;
}
public PersonInfoSaver(string filePath, IStreamWriter streamWriter)
{
this.filePath = filePath;
this.streamWriter = streamWriter;
}
private static void WriteHeader(IStreamWriter writer, List<Question> questions)
{
// Вывести заголовок
var questionCount = questions.Count;
var header = new object[1, 30 + questionCount];
header[0, 0] = "Дата удара";
header[0, 1] = "Время удара";
header[0, 2] = "Игра";
header[0, 3] = "Номер удара в игре";
header[0, 4] = "Попадание";
header[0, 5] = "Баллы";
header[0, 6] = "Промах игрока, м";
header[0, 7] = "Промах игрока, с (задержка удара)";
header[0, 8] = "Задержка реакции игрока, с";
header[0, 9] = "Позиция шара, м";
header[0, 10] = "Размер шара, м";
header[0, 11] = "Позиция лунки, м";
header[0, 12] = "Размер лунки, м";
header[0, 13] = "Баллы при попадании";
header[0, 14] = "Баллы при промахе";
header[0, 15] = "Цвет цели";
header[0, 16] = "Скорость мяча, м/с";
header[0, 17] = "Задержка удара, с";
header[0, 18] = "Баллы в начале игры";
header[0, 19] = "Показывать баллы";
header[0, 20] = "Показывать ошибку";
header[0, 21] = "Звук";
header[0, 22] = "Соревнование";
header[0, 23] = "Попадание соперника";
header[0, 24] = "Баллы соперника";
header[0, 25] = "Промах соперника, м";
header[0, 26] = "Вероятность попадания при попадании игрока";
header[0, 27] = "Вероятность попадания при промахе игрока";
header[0, 28] = "Показывать баллы соперника";
header[0, 29] = "Ошибка игрока, м";
for (int i = 0; i < questionCount; i++)
{
header[0, 30 + i] = questions[i].Id;
}
writer.Write(header);
}
private static void WriteRows(IStreamWriter writer, List<Tuple<Game, Users>> data, List<Question> questions)
{
var questionCount = questions.Count;
foreach (var item in data)
{
var game = item.Item1;
var users = item.Item2;
var strikeNumber = 0;
var user = users.FirstOrDefault(t => t.UserInfo.UserType == UserTypeEnum.User);
if (user == null) throw new NullReferenceException("user");
var bot = users.FirstOrDefault(t => t.UserInfo.UserType == UserTypeEnum.Bot);
var rows = new object[user.Strikes.Count, 30 + questionCount];
var i = 0;
foreach (var userStrike in user.Strikes)
{
var strikeInfo = userStrike.StrikeInfo;
rows[i, 0] = userStrike.DateTime.ToShortDateString();
rows[i, 1] = userStrike.DateTime.ToLongTimeString();
rows[i, 2] = game.Title;
rows[i, 3] = ++strikeNumber;
rows[i, 4] = userStrike.IsHit;
rows[i, 5] = userStrike.GetScore();
rows[i, 6] = userStrike.MissDistance;
rows[i, 7] = userStrike.MissTime;
rows[i, 8] = Math.Round(userStrike.BeforeStrikeTimeSpan.TotalSeconds, 3);
rows[i, 9] = userStrike.StartBallPosition.X;
rows[i, 10] = strikeInfo.Ball.Size;
rows[i, 11] = userStrike.StartHolePosition.X;
rows[i, 12] = strikeInfo.Hole.Size;
rows[i, 13] = strikeInfo.Hole.HitScore;
rows[i, 14] = strikeInfo.Hole.MissScore;
rows[i, 15] = strikeInfo.Hole.Color;
rows[i, 16] = strikeInfo.Model.Velocity;
rows[i, 17] = strikeInfo.Model.Delay;
rows[i, 18] = user.UserInfo.Score;
rows[i, 19] = game.ShowUserScore;
rows[i, 20] = game.ShowError;
rows[i, 21] = game.PlaySounds;
rows[i, 22] = game.Type == GameTypeEnum.Competition;
if (bot != null)
{
var userStrikeIndex = user.Strikes.IndexOf(userStrike);
if (bot.Strikes.Count > userStrikeIndex)
{
var botStrike = bot.Strikes[userStrikeIndex];
rows[i, 23] = botStrike.IsHit;
rows[i, 24] = botStrike.GetScore();
rows[i, 25] = botStrike.MissDistance;
var uniformRandomCompetitor = strikeInfo.CompetitorModel as UniformCompetitorModel;
if (uniformRandomCompetitor != null)
{
rows[i, 26] = uniformRandomCompetitor.BotHitProbabilityIfUserHit;
rows[i, 27] = uniformRandomCompetitor.BotHitProbabilityIfUserMiss;
}
rows[i, 28] = game.ShowBotScore;
}
}
rows[i, 29] = userStrike.ErrorDistance;
// Запись ответов на вопросы
for (int j = 0; j < questionCount; j++)
{
var id = questions[j].Id;
var response = userStrike.Responses.FirstOrDefault(t => t.QuestionId == id);
if (response != null)
{
rows[i, 30 + j] = response.Value;
}
}
i++;
}
writer.Write(rows);
}
}
public XmlDocumentWriter(IStreamWriter streamWriter)
{
_streamWriter = streamWriter;
}
internal AsyncOutputProvider(IStreamWriter stream)
{
mStream = stream;
}
public void Queue(IStreamWriter writer, bool isReliable)
{
Assert.NotNull(writer, "writer");
if (isReliable)
{
reliable.Enqueue(writer);
}
else
{
unreliable.Enqueue(writer);
}
Context.NetworkQueue.Add(this);
}
public override void SetOutputSink(int index, IStreamWriter stream)
{
throw new InternalFailureException();
}
public override void SetOutputSink(int index, IStreamWriter stream)
{
if (index != 0)
throw new ArgumentOutOfRangeException(nameof(index));
mStream.SetOutputSink(stream);
}
public void SetOutputSink(IStreamWriter output)
{
System.Diagnostics.Debug.Assert(mOutput == null && output != null);
mOutput = output;
}
public void SetInputStream(EncoderNode encoder, int index)
{
mConnectionOutputToEncoderInput = encoder.GetInputSink(index);
if (mConnectionOutputToEncoderInput == null)
encoder.SetInputSource(index, this);
}
public abstract void SetOutputSink(int index, IStreamWriter stream);
