/// <summary>
/// Renders a tokens representation (or interpolated lambda result) escaping the
/// result
/// </summary>
/// <param name="writer">The writer to write the token to</param>
/// <param name="context">The context to discover values from</param>
/// <param name="partials">The partial templates available to the token</param>
/// <param name="originalTemplate">The original template</param>
/// <returns>The rendered token result that has been escaped</returns>
public string Render(Writer writer, Context context, IDictionary<string, string> partials, string originalTemplate)
{
var value = context.Lookup(Value);
value = InterpolateLambdaValueIfPossible(value, writer, context, partials);
return value != null ? WebUtility.HtmlEncode(value.ToString()) : null;
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
if (writer.CanWrite(input))
writer.Write(input);
else
base.Read(input, reader, writer, optionsOverride);
}
public Time(Writer writer)
: base("!time")
{
this.writer = writer;
nz = TimeZoneInfo.FindSystemTimeZoneById("New Zealand Standard Time");
eu = TimeZoneInfo.FindSystemTimeZoneById("Central European Standard Time");
}
public override void WriteNodes(Writer writer) {
for (int i = 0; i < Prisoners.Count; i++) {
Informant informant = Prisoners[i];
informant.Label = "[i " + i + "]";
writer.WriteNode(informant);
}
}
public override void WriteNodes(Writer writer) {
foreach (var prisoner in PenaltyList) {
foreach (Penalty penalty in prisoner.Value) {
writer.WriteNode(penalty);
}
}
}
public Config(Writer writer, Format fmt, GetConfig get_new_config)
{
m_fmt = fmt;
m_get_new_config = get_new_config ?? no_new_config;
file = new VectFormatter(writer);
file.seperator = fmt.line_spacing > 0 ? "" : " ";
file.seperator_spacing = fmt.line_spacing;
file.footer_spacing = 1;
top_vect = new_vect(writer, fmt.format_vect, "#(", "TV");
vect = new_vect(writer, fmt.format_vect, "#(", "V");
vect_cdr = new_vect(writer, fmt.format_vect, " . #(", "-V");
cons = new_cons(writer, fmt.do_abbrev, true, "C");
top_cons = new_cons(writer, fmt.do_abbrev, true, "TC");
vect_cons = new_cons(writer, fmt.do_abbrev, fmt.format_vect, "VC");
head_cons = new_cons(writer, fmt.do_abbrev, fmt.format_head, "HC");
vect_cons_cdr = new_cons_cdr(writer, fmt.format_vect, fmt.dot_cdr, fmt.dot_nil, "-VC");
head_cons_cdr = new_cons_cdr(writer, fmt.format_head, fmt.dot_cdr, fmt.dot_nil, "-HC");
appl_cons_cdr = new_cons_cdr(writer, fmt.format_appl, fmt.dot_cdr, fmt.dot_nil, "-AC");
data_cons_cdr = new_cons_cdr(writer, fmt.format_data, fmt.dot_cdr, fmt.dot_nil, "-DC");
atom = new AtomFormatter(writer);
atom_cdr = new AtomFormatter(writer);
atom_cdr.header = " . ";
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
if (ReferenceStructure(input, reader, optionsOverride))
return;
reader.AddReference();
writer.Write(input);
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
if ((optionsOverride.EnumSerialization ?? reader.Options.EnumSerialization) == EnumSerialization.AsString)
writer.Write(input.ToString());
else
writer.Write((int)input);
}
public override void WriteNodes(Writer writer) {
for (int i = 0; i < Prisoners.Count; i++) {
Digger digger = Prisoners[i];
digger.Label = "[i " + i + "]";
writer.WriteNode(digger);
}
}
public override byte[] Build()
{
MemoryStream temp = new MemoryStream(128);
Writer writer = new Writer(temp);
writer.Seek(0x62, SeekOrigin.Begin);
writer.WriteString(Login, Encoding.ASCII);
writer.Seek(0x70, SeekOrigin.Begin);
writer.WriteString(Password, Encoding.ASCII);
MemoryStream ms = new MemoryStream(168);
writer = new Writer(ms);
writer.Write(Id);
writer.Write(Encrypt(temp.GetBuffer()));
writer.Write(SessionId);
writer.Write(GameGuard);
ulong chk = Utils.CheckSum(ms.GetBuffer(), 160);
writer.Write((byte)(chk & 0xff));
writer.Write((byte)(chk >> 0x08 & 0xff));
writer.Write((byte)(chk >> 0x10 & 0xff));
writer.Write((byte)(chk >> 0x18 & 0xff));
writer.Write((Int32)0);
return ms.GetBuffer();
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
if (ReferenceStructure(input, reader, optionsOverride))
return;
if (ShouldWriteTypeIdentifier(reader.Options, optionsOverride))
writer.BeginStructure(CurrentTypeResolver.GetTypeIdentifier(Type), reader.GetType());
else
writer.BeginStructure(Type);
for (int i = 0; i < AllSerializableProperties.Length; i++)
{
PropertyDefinition property = AllSerializableProperties[i];
if (property.MatchesPropertyFilter(reader.Options))
{
writer.AddProperty(property.SerializedName);
reader.PropertyStack.Push(property);
object value = property.GetFrom(input);
property.Read(value, reader, writer);
reader.PropertyStack.Pop();
}
}
writer.EndStructure();
}
public void Save()
{
Writer a = new Writer(Guid.NewGuid().ToString());
s1.Save(a);
s1.Flush();
Assert.IsTrue(a.Id > 0);
}
/// <summary>
/// Renders a tokens representation if the value (or interpolated value result)
/// is truthy
/// </summary>
/// <param name="writer">The writer to write the token to</param>
/// <param name="context">The context to discover values from</param>
/// <param name="partials">The partial templates available to the token</param>
/// <param name="originalTemplate">The original template</param>
/// <returns>The rendered result of the token if the resolved value is not truthy</returns>
public string Render(Writer writer, Context context, IDictionary<string, string> partials, string originalTemplate)
{
var value = context.Lookup(Value);
value = InterpolateLambdaValueIfPossible(value, writer, context, partials);
return !context.IsTruthyValue(value) ? writer.RenderTokens(ChildTokens, context, partials, originalTemplate) : null;
}
/// <summary>
/// Renders a tokens representation (or interpolated lambda result)
/// </summary>
/// <param name="writer">The writer to write the token to</param>
/// <param name="context">The context to discover values from</param>
/// <param name="partials">The partial templates available to the token</param>
/// <param name="originalTemplate">The original template</param>
/// <returns>The rendered token result</returns>
public string Render(Writer writer, Context context, IDictionary<string, string> partials, string originalTemplate)
{
var value = context.Lookup(Value);
value = InterpolateLambdaValueIfPossible(value, writer, context, partials);
return value?.ToString();
}
public static int Main(string[] args)
{
string directory = args[0];
string outfilename = args[1];
Directory d = new Directory();
uint nfiles = d.Load( directory, true );
if(nfiles == 0) return 1;
//System.Console.WriteLine( "Files:\n" + d.toString() );
// Implement fast path ?
// Scanner s = new Scanner();
string descriptor = "My_Descriptor";
FilenamesType filenames = d.GetFilenames();
gdcm.DICOMDIRGenerator gen = new DICOMDIRGenerator();
gen.SetFilenames( filenames );
gen.SetDescriptor( descriptor );
if( !gen.Generate() )
{
return 1;
}
gdcm.FileMetaInformation.SetSourceApplicationEntityTitle( "GenerateDICOMDIR" );
gdcm.Writer writer = new Writer();
writer.SetFile( gen.GetFile() );
writer.SetFileName( outfilename );
if( !writer.Write() )
{
return 1;
}
return 0;
}
public static int Main(string[] args)
{
gdcm.FileMetaInformation.SetSourceApplicationEntityTitle( "My Reformat App" );
// http://www.oid-info.com/get/1.3.6.1.4.17434
string THERALYS_ORG_ROOT = "1.3.6.1.4.17434";
gdcm.UIDGenerator.SetRoot( THERALYS_ORG_ROOT );
System.Console.WriteLine( "Root dir is now: " + gdcm.UIDGenerator.GetRoot() );
string filename = args[0];
string outfilename = args[1];
Reader reader = new Reader();
reader.SetFileName( filename );
if( !reader.Read() )
{
System.Console.WriteLine( "Could not read: " + filename );
return 1;
}
UIDGenerator uid = new UIDGenerator(); // helper for uid generation
FileDerivation fd = new FileDerivation();
// For the pupose of this execise we will pretend that this image is referencing
// two source image (we need to generate fake UID for that).
string ReferencedSOPClassUID = "1.2.840.10008.5.1.4.1.1.7"; // Secondary Capture
fd.AddReference( ReferencedSOPClassUID, uid.Generate() );
fd.AddReference( ReferencedSOPClassUID, uid.Generate() );
// Again for the purpose of the exercise we will pretend that the image is a
// multiplanar reformat (MPR):
// CID 7202 Source Image Purposes of Reference
// {"DCM",121322,"Source image for image processing operation"},
fd.SetPurposeOfReferenceCodeSequenceCodeValue( 121322 );
// CID 7203 Image Derivation
// { "DCM",113072,"Multiplanar reformatting" },
fd.SetDerivationCodeSequenceCodeValue( 113072 );
fd.SetFile( reader.GetFile() );
// If all Code Value are ok the filter will execute properly
if( !fd.Derive() )
{
return 1;
}
gdcm.FileMetaInformation fmi = reader.GetFile().GetHeader();
// The following three lines make sure to regenerate any value:
fmi.Remove( new gdcm.Tag(0x0002,0x0012) );
fmi.Remove( new gdcm.Tag(0x0002,0x0013) );
fmi.Remove( new gdcm.Tag(0x0002,0x0016) );
Writer writer = new Writer();
writer.SetFileName( outfilename );
writer.SetFile( fd.GetFile() );
if( !writer.Write() )
{
System.Console.WriteLine( "Could not write: " + outfilename );
return 1;
}
return 0;
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
IDictionary dictionary = input as IDictionary;
if (dictionary == null) return;
if (ReferenceStructure(input, reader, optionsOverride))
return;
if (ShouldWriteTypeIdentifier(reader.Options, optionsOverride))
writer.BeginStructure(CurrentTypeResolver.GetTypeIdentifier(Type), reader.GetType());
else
writer.BeginStructure(Type);
foreach (object key in dictionary.Keys)
{
// Convert.ToString is in case the keys are numbers, which are represented
// as strings when used as keys, but can be indexed with numbers in JavaScript
string name = Convert.ToString(key, CultureInfo.InvariantCulture);
object value = dictionary[key];
writer.AddProperty(name);
ValueTypeDef.ReadObject(value, reader, writer, PartialOptions.Default);
}
writer.EndStructure();
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET:
//ORIGINAL LINE: public VCFWriter(final File location, final OutputStream output, final net.sf.samtools.SAMSequenceDictionary refDict, final boolean enableOnTheFlyIndexing, boolean doNotWriteGenotypes, final boolean allowMissingFieldsInHeader)
public VCFWriter(File location, OutputStream output, SAMSequenceDictionary refDict, bool enableOnTheFlyIndexing, bool doNotWriteGenotypes, bool allowMissingFieldsInHeader) : base(writerName(location, output), location, output, refDict, enableOnTheFlyIndexing)
{
this.doNotWriteGenotypes = doNotWriteGenotypes;
this.allowMissingFieldsInHeader = allowMissingFieldsInHeader;
this.charset = Charset.forName("ISO-8859-1");
this.writer = new OutputStreamWriter(lineBuffer, charset);
}
/// <summary>
/// Copies brand information.
/// </summary>
public void Run()
{
var reader = new Reader(sourceFileName);
Information information = reader.Read();
var writer = new Writer(targetFileName);
writer.Write(information);
}
public void CaptureConversions(File file, Action<Writer> action)
{
file.WriteTextTo(tw =>
{
var w = new Writer(tw, _cache);
action(w);
});
}
public Writer Update(Writer writer)
{
var wr = _context.Writers.FirstOrDefault(cp => cp.Id == writer.Id);
if (wr == null) throw new ArgumentException();
_context.Entry(writer).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
return wr;
}
public void Writes_List()
{
var el = this.ParseSingle("(a b c)");
Writer writer = new Writer();
string s = writer.Write(el);
Assert.AreEqual("(A B C)", s);
}
public void SaveTest()
{
var context = new Context();
var esentInstance = EsentInstanceService.Service.EsentInstance;
var writer = new Writer(esentInstance);
var result = writer.Save<Customer>(Encoding.Unicode.GetBytes("this is my message"));
Assert.AreNotEqual(result, 23);
}
public override void WriteProperties(Writer writer) {
writer.WriteProperty("Balance", Balance);
writer.WriteProperty("LastDay", LastDay);
writer.WriteProperty("LastHour", LastHour);
writer.WriteProperty("BankLoan", BankLoan);
writer.WriteProperty("BankCreditRating", BankCreditRating);
writer.WriteProperty("Ownership", Ownership);
}
public override void Read(object input, ObjectReader reader, Writer writer, PartialOptions optionsOverride)
{
Guid? guid = input as Guid?;
if (guid == null)
writer.WriteNull();
else
writer.Write(guid.ToString());
}
public File(OnDiskFileCollection owner, uint index, string fileName)
{
_owner = owner;
_index = index;
_fileName = fileName;
_stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read, 1, FileOptions.None);
_writer = new Writer(this);
}
public void Copy(Reader reader, Writer writer)
{
char c = reader.Read();
while (c != EOF)
{
writer.Write(c);
}
}
private ObjectReader(Writer writer, ObjectParsingOptions options)
{
if (writer == null) throw new ArgumentNullException("writer");
if (options == null) throw new ArgumentNullException("options");
Options = options;
this.writer = writer;
}
public void NullController()
{
var elm = new Writer<TestElement>() { Context = contextMock.Object, Item = new TestElement() };
elm.Href("action1", null);
Assert.Equal(1, testDictionary.Count);
Assert.False(testDictionary.ContainsKey("controller"));
}
public override byte[] Build()
{
MemoryStream ms = new MemoryStream(Size);
Writer writer = new Writer(ms);
writer.Write(Id);
return ms.GetBuffer();
}
public static void WriteTagV1(Tag tag, FileInfo file)
{
using (VirtualDriveLock fileLock = new VirtualDriveLock(file.FullName, AccessObserver.AccessType.Write))
{
bool existingTag = HasTagV1(file);
long fileLength = VirtualDrive.FileLength(file.FullName);
using (Writer writer = new Writer(file))
{
if (existingTag)
{
writer.Seek(fileLength - HeaderV1.totalSize, SeekOrigin.Begin);
}
else
{
writer.Seek(fileLength, SeekOrigin.Begin);
}
tag.Write(writer);
}
}
}
public void WriteTombstone(Tombstone tombstone, SmugglerProgressBase.CountsWithLastEtag progress)
{
if (First == false)
Writer.WriteComma();
First = false;
using (tombstone)
{
_context.Write(Writer, new DynamicJsonValue
{
["Key"] = tombstone.LowerId,
[nameof(Tombstone.Type)] = tombstone.Type.ToString(),
[nameof(Tombstone.Collection)] = tombstone.Collection,
[nameof(Tombstone.Flags)] = tombstone.Flags.ToString(),
[nameof(Tombstone.ChangeVector)] = tombstone.ChangeVector,
[nameof(Tombstone.DeletedEtag)] = tombstone.DeletedEtag,
[nameof(Tombstone.Etag)] = tombstone.Etag,
[nameof(Tombstone.LastModified)] = tombstone.LastModified,
});
}
}
public async Task can_use_usercontext_with_params()
{
var schema = Schema.For(@"
type Query {
userContextWithParam(id: String): String
}
", _ => _.Types.Include <ParametersType>());
var result = await schema.ExecuteAsync(_ =>
{
_.Query = @"{ userContextWithParam(id: ""abcd"") }";
_.UserContext = new MyUserContext {
Name = "Quinn"
};
});
var expectedResult = CreateQueryResult("{ 'userContextWithParam': 'Quinn abcd' }");
var serializedExpectedResult = await Writer.WriteToStringAsync(expectedResult);
result.ShouldBe(serializedExpectedResult);
}
/// <summary>
/// Returns info related to a player's monarch, patron, and vassals.
/// </summary>
public GameEventAllegianceUpdate(Session session, Allegiance allegiance, AllegianceNode node)
: base(GameEventType.AllegianceUpdate, GameMessageGroup.UIQueue, session)
{
var startPos = Writer.BaseStream.Position;
// uint - rank - this player's rank within their allegiance
// AllegianceProfile - prof
uint rank = (node == null) ? 0 : node.Rank;
//Console.WriteLine("Rank: " + rank);
Writer.Write(rank);
var prof = new AllegianceProfile(allegiance, node);
Writer.Write(prof);
var endPos = Writer.BaseStream.Position;
var totalBytes = endPos - startPos;
//Console.WriteLine("Allegiance bytes written: " + totalBytes);
}
public override IEnumerable <object> Finish()
{
Writer.WriteCmdStart("EXEC", 0);
Writer.Flush();
// reads out an equal number of +QUEUEDs beforehand
// TODO: May need to restart if a read doesn't return an expected +QUEUEDs
// which means *some* commands may have been improperly sent
// may need to issue a DISCARD and start over.
for (int i = 0; i < ReadsQueue.Count; i++)
{
Reader.ReadQueued();
}
if (Reader.ReadMultiBulkHeader() == -1) // read-out a multi-bulk header
{
return(null);
}
return(base.Finish()); // read out all the queued reads
}
void WriteISerializable(object obj, Type type)
{
var serializable = obj as ISerializable;
WriteType(type);
var serInfo = new SerializationInfo(type, Converter);
serializable.GetObjectData(serInfo, new StreamingContext(StreamingContextStates.CrossAppDomain));
Writer.Write(serInfo.MemberCount);
var enumerator = serInfo.GetEnumerator();
while (enumerator.MoveNext())
{
Writer.Write(enumerator.Current.Name);
WriteType(enumerator.Current.ObjectType);
WriteInstance(enumerator.Current.Value);
}
}
public static void Main()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
#if DEBUG
//Reader = Console.In; Writer = Console.Out;
Reader = File.OpenText("input.txt"); Writer = File.CreateText("output.txt");
#else
Reader = Console.In; Writer = Console.Out;
#endif
Solve();
/*Thread thread = new Thread(Solve, 64 * 1024 * 1024);
* thread.CurrentCulture = CultureInfo.InvariantCulture;
* thread.Start();
* thread.Join();*/
Reader.Close();
Writer.Close();
}
public async Task can_use_inherited_usercontext()
{
var schema = Schema.For(@"
type Query {
userContext: String
}
", _ => _.Types.Include <ParametersType>());
var result = await schema.ExecuteAsync(_ =>
{
_.Query = @"{ userContext }";
_.UserContext = new ChildMyUserContext {
Name = "Quinn"
};
});
var expectedResult = CreateQueryResult("{ 'userContext': 'Quinn' }");
var serializedExpectedResult = await Writer.WriteToStringAsync(expectedResult);
result.ShouldBe(serializedExpectedResult);
}
private bool RaiseBeforeRecordFieldWrite(object target, long index, string propName, ref object value)
{
if (Writer != null && Writer.HasBeforeRecordFieldWriteSubscribed)
{
object state = value;
bool retValue = ChoFuncEx.RunWithIgnoreError(() => Writer.RaiseBeforeRecordFieldWrite(target, index, propName, ref state), true);
if (retValue)
{
value = state;
}
return(retValue);
}
else if (target is IChoNotifyRecordFieldWrite)
{
object state = value;
bool retValue = ChoFuncEx.RunWithIgnoreError(() => ((IChoNotifyRecordFieldWrite)target).BeforeRecordFieldWrite(target, index, propName, ref state), true);
if (retValue)
{
value = state;
}
return(retValue);
}
else if (CallbackRecordFieldWrite != null)
{
object state = value;
bool retValue = ChoFuncEx.RunWithIgnoreError(() => CallbackRecordFieldWrite.BeforeRecordFieldWrite(target, index, propName, ref state), true);
if (retValue)
{
value = state;
}
return(retValue);
}
return(true);
}
protected override void GenerateTable(StringBuilder sb, SqlTable table)
{
var tableName = Helper.GetSimplifiedSchemaAndTableName(table.SchemaAndTableName, DatabaseDeclaration.SchemaTableNameSeparator.ToString(CultureInfo.InvariantCulture));
sb
.Append(1, "public class ")
.Append(tableName)
.Append("Table")
.AppendLine(" : SqlTable")
.AppendLine(1, "{");
var pkColumns = table.Columns
.Where(column => column.Table.Properties.OfType <PrimaryKey>().Any(x => x.SqlColumns.Any(y => y.SqlColumn == column)))
.ToList();
foreach (var column in pkColumns)
{
var columnAnnotation = OnColumnAnnotation?.Invoke(column);
var columnComment = OnColumnComment?.Invoke(column);
var columnCreation = Writer.GetColumnCreation(column, Helper, columnAnnotation, columnComment);
sb.AppendLine(columnCreation);
}
var regularColumns = table.Columns
.Where(x => !pkColumns.Contains(x))
.ToList();
foreach (var column in regularColumns)
{
var columnAnnotation = OnColumnAnnotation?.Invoke(column);
var columnComment = OnColumnComment?.Invoke(column);
var columnCreation = Writer.GetColumnCreation(column, Helper, columnAnnotation, columnComment);
sb.AppendLine(columnCreation);
}
GenerateTableProperties(sb, table);
sb.AppendLine(1, "}");
}
private ValueTask <T> ReadAsyncCore(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled <T>(cancellationToken));
}
lock (SyncObj)
{
AssertInvariants();
// If we're already completed, nothing to read.
if (_completion.Task.IsCompleted)
{
return(Task.FromException <T>(_completion.Task.IsFaulted ? _completion.Task.Exception.InnerException : CreateInvalidCompletionException()));
}
// If there are any blocked writers, find one to pair up with
// and get its data. Writers that got canceled will remain in the queue,
// so we need to loop to skip past them.
while (_blockedWriters.Count > 0)
{
Writer <T> w = _blockedWriters.Dequeue();
if (w.Success(default(VoidResult)))
{
return(w.Item);
}
}
// No writer found to pair with. Queue the reader.
var r = Reader <T> .Create(cancellationToken);
_blockedReaders.Enqueue(r);
// And let any waiting writers know it's their lucky day.
WakeUpWaiters(_waitingWriters, true);
return(r.Task);
}
}
static private void WriteExoplanet(Exoplanet exoplanet)
{
Writer.WriteStartElement("Exoplanet");
Writer.WriteAttributeString("name", exoplanet.Name.Trim());
WriteMass(exoplanet);
WriteMassSini(exoplanet);
WriteRadius(exoplanet);
WriteOrbitalPeriod(exoplanet);
WriteSemiMajorAxis(exoplanet);
WriteEccentricity(exoplanet);
WriteAngularDistance(exoplanet);
WriteInclination(exoplanet);
WriteTzeroTr(exoplanet);
WriteTzeroTrSec(exoplanet);
WriteLambdaAngle(exoplanet);
WriteTzeroVr(exoplanet);
WriteTemperatures(exoplanet);
WriteLogG(exoplanet);
WritePublicationStatus(exoplanet);
WriteDiscovered(exoplanet);
WriteUpdated(exoplanet);
WriteOmega(exoplanet);
WriteTperi(exoplanet);
WriteDetectionType(exoplanet);
WriteMolecules(exoplanet);
WriteImpactParameter(exoplanet);
WriteVelocitySemiamplitude(exoplanet);
WriteGeometricAlbedo(exoplanet);
WriteTconj(exoplanet);
WriteMassDetectionType(exoplanet);
WriteRadiusDetectionType(exoplanet);
WriteAlternateNames(exoplanet);
WriteStar(exoplanet);
Writer.WriteEndElement();
}
public override void Compile(string path)
{
var res = new EventResource(Path.Combine(RootDirectory, path));
var cevent = new CEvent();
cevent.MinDelay = res.MinDelay;
cevent.MaxDelay = res.MaxDelay;
Writer.WriteStruct(cevent);
Writer.Write(res.Actions.Count);
foreach (var a in res.Actions)
{
var caction = new CAction();
string link = ResolveLink(path, a.Tile);
caction.LinkID = Table[link];
caction.Type = (int)a.Type;
caction.OffsetX = a.OffsetX;
caction.OffsetY = a.OffsetY;
Writer.WriteStruct(caction);
}
}
private void GenerateConversionProperties()
{
Writer.WL(@"
#region Conversion Properties
");
foreach (var unit in _quantity.Units)
{
Writer.WL($@"
/// <summary>
/// Get {_quantity.Name} in {unit.PluralName}.
/// </summary>");
Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
Writer.WL($@"
public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
");
}
Writer.WL(@"
#endregion
");
}
public async Task can_use_source_without_params()
{
var schema = Schema.For(@"
type Query {
source: Boolean
}
", _ =>
{
_.Types.Include <ParametersType>();
});
var result = await schema.ExecuteAsync(_ =>
{
_.Query = "{ source }";
_.Root = new { Hello = "World" };
});
var expectedResult = CreateQueryResult("{ 'source': true }");
var serializedExpectedResult = await Writer.WriteToStringAsync(expectedResult);
result.ShouldBe(serializedExpectedResult);
}
public static XmlElement buildMilestoneDOM(Completable.Milestone milestone, string elementName = "milestone")
{
XmlElement milestoneNode = Writer.GetDoc().CreateElement(elementName);
milestoneNode.SetAttribute("type", milestone.getType().ToString());
if (milestone.getType() != Completable.Milestone.MilestoneType.CONDITION)
{
milestoneNode.SetAttribute("targetId", milestone.getId());
}
else
{
DOMWriterUtility.DOMWrite(milestoneNode, milestone.getConditions());
}
if (milestone.getProgress() >= 0)
{
milestoneNode.SetAttribute("progress", milestone.getProgress().ToString());
}
return(milestoneNode);
}
public void WriteToLog(string inLogMessage)
{
if (!Directory.Exists(LogPath))
{
Directory.CreateDirectory(LogPath);
}
if (Writer == null)
{
Writer = new StreamWriter(LogFullPath, true);
}
Writer.Write(inLogMessage);
Writer.Flush();
_LogPathLineas++;
if (_LogPathLineas > 10000)
{
_LogPathLineas = 0;
LogFileName = LogFileName + (cnt++).ToString();
}
}
public bool TryRead(out T item)
{
lock (SyncObj)
{
AssertInvariants();
// Try to find a writer to pair with
while (_blockedWriters.Count > 0)
{
Writer <T> w = _blockedWriters.Dequeue();
if (w.Success(default(VoidResult)))
{
item = w.Item;
return(true);
}
}
}
// None found
item = default(T);
return(false);
}
//
// Phase 0: File headers
//
public ReaderContext(string fileName, Writer tracer)
{
Tracer = tracer;
FileName = fileName;
try
{
// Ideally next two lines would be atomic
LastWriteTime = File.GetLastWriteTimeUtc(fileName);
var data = File.ReadAllBytes(FileName);
fileReader = new BlobReader(data);
}
catch (IOException e)
{
throw new PEException("unable to load file: " + e.Message);
}
OffsetToStringCache = new Map <uint, string>();
StringToOffsetCache = new Map <string, uint>();
OffsetToUserStringCache = new Map <uint, string>();
UserStringToOffsetCache = new Map <string, uint>();
OffsetToSignatureCache = new Map <uint, Signature>();
SignatureToOffsetCache = new Map <Signature, uint>();
}
public void Dispose()
{
if (!_isDisposed)
{
_isDisposed = true;
try {
Reader.Dispose();
}
catch (Exception) {
}
try {
Writer.Dispose();
}
catch (Exception) {
}
try {
Stream.Dispose();
}
catch (Exception) {
}
}
}
public override void WriteChars(char [] text, int idx, int length)
{
int start = idx;
int end = idx + length;
while ((idx = IndexOfInvalid(text, start, length, true)) >= 0)
{
if (start < idx)
{
Writer.WriteChars(text, start, idx - start);
}
Writer.WriteString(String.Format(CultureInfo.InvariantCulture,
text [idx] < 0x80 ? "\\x{0:X02}" : "\\u{0:X04}",
(int)text [idx]));
length -= idx - start + 1;
start = idx + 1;
}
if (start < end)
{
Writer.WriteChars(text, start, end - start);
}
}
public void OPC_DataChanged(int clientSubscription, bool allQualitiesGood, bool noErrors, ItemValueCallback[] itemValues)
{
try
{
Writer.writeAll(this.ToString());
foreach (ItemValueCallback itemValue in itemValues)
{
if (itemValue.ResultID.Succeeded)
{
checkResponsability(itemValue);
}
else
{
Writer.writeAll("Item error");
}
}
}
catch (Exception ex)
{
Writer.writeAll("DataChanged exception. Reason: " + ex.ToString());
}
}//main one
public void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, TField value) where TBufferWriter : IBufferWriter <byte>
{
if (ReferenceCodec.TryWriteReferenceField(ref writer, fieldIdDelta, expectedType, value))
{
return;
}
var fieldType = value.GetType();
if (fieldType == CodecFieldType)
{
writer.WriteStartObject(fieldIdDelta, expectedType, fieldType);
TSurrogate surrogate = default;
ConvertToSurrogate(value, ref surrogate);
_surrogateSerializer.Serialize(ref writer, ref surrogate);
writer.WriteEndObject();
}
else
{
SerializeUnexpectedType(ref writer, fieldIdDelta, expectedType, value, fieldType);
}
}
public virtual void Flush(bool OnDestruct)
{
if (OnFlush != null)
{
OnFlush(OnDestruct);
}
if (Reader != null)
{
try {
Reader.Close();
Reader = null;
} catch { }
}
if (Writer != null)
{
try {
Writer.Close();
Writer = null;
} catch { }
}
}
/// <summary>
/// Processes a delegate element.
/// </summary>
/// <param name="element">Delegate code element.</param>
public override void VisitDelegateElement(DelegateElement element)
{
this.WriteComments(element.HeaderComments);
this.WriteAttributes(element);
WriteAccess(element.Access);
WriteMemberAttributes(element.MemberModifiers);
Writer.Write(CSharpKeyword.Delegate);
Writer.Write(' ');
Writer.Write(element.Type);
Writer.Write(' ');
Writer.Write(element.Name);
WriteTypeParameters(element);
WriteParameterList(element.Parameters);
WriteTypeParameterConstraints(element);
Writer.Write(CSharpSymbol.EndOfStatement);
}
public async Task resolves_union_references_when_union_defined_first()
{
var schema = Schema.For(@"
union Pet = Dog | Cat
enum PetKind {
CAT
DOG
}
type Query {
pet(type: PetKind = DOG): Pet
}
type Dog {
name: String!
}
type Cat {
name: String!
}
", _ =>
{
_.Types.For("Dog").IsTypeOf <Dog>();
_.Types.For("Cat").IsTypeOf <Cat>();
_.Types.Include <PetQueryType>();
});
var result = await schema.ExecuteAsync(_ =>
{
_.Query = @"{ pet { ... on Dog { name } } }";
});
var expected = @"{ 'pet': { 'name' : 'Eli' } }";
var expectedResult = CreateQueryResult(expected);
var serializedExpectedResult = await Writer.WriteToStringAsync(expectedResult);
result.ShouldBe(serializedExpectedResult);
}
private object SerializationLoop(object expected)
{
var pipe = new Pipe();
using (var session = this.sessionPool.GetSession())
{
var writer = new Writer <PipeWriter>(pipe.Writer, session);
this.serializer.Serialize(ref writer, expected);
pipe.Writer.FlushAsync().GetAwaiter().GetResult();
pipe.Writer.Complete();
}
using (var session = this.sessionPool.GetSession())
{
pipe.Reader.TryRead(out var readResult);
var reader = new Reader(readResult.Buffer, session);
var result = this.serializer.Deserialize(ref reader);
pipe.Reader.AdvanceTo(readResult.Buffer.End);
pipe.Reader.Complete();
return(result);
}
}
public async Task can_use_resolvefieldcontext_without_params()
{
var schema = Schema.For(@"
type Query {
resolve: String
}
", _ =>
{
_.Types.Include <ParametersType>();
});
var result = await schema.ExecuteAsync(_ =>
{
_.Query = "{ resolve }";
_.ExposeExceptions = true;
});
var expectedResult = CreateQueryResult("{ 'resolve': 'Resolved' }");
var serializedExpectedResult = await Writer.WriteToStringAsync(expectedResult);
result.ShouldBe(serializedExpectedResult);
}
private void BatchRunIntegers(IDatabase db)
{
var key = Me();
db.KeyDelete(key);
db.StringSet(key, 1);
Task[] tasks = new Task[InnerCount];
for (int i = 0; i < IterationCount; i++)
{
var batch = db.CreateBatch();
for (int j = 0; j < tasks.Length; j++)
{
tasks[j] = batch.StringIncrementAsync(key);
}
batch.Execute();
db.Multiplexer.WaitAll(tasks);
}
var count = (long)db.StringGet(key);
Writer.WriteLine($"tally: {count}");
}
public void WriteFellow(Player fellow)
{
Writer.WriteGuid(fellow.Guid);
Writer.Write(0u); // TODO: cpCached - Perhaps cp stored up before distribution?
Writer.Write(0u); // TODO: lumCached - Perhaps lum stored up before distribution?
Writer.Write(fellow.Level ?? 1);
Writer.Write(fellow.Health.MaxValue);
Writer.Write(fellow.Stamina.MaxValue);
Writer.Write(fellow.Mana.MaxValue);
Writer.Write(fellow.Health.Current);
Writer.Write(fellow.Stamina.Current);
Writer.Write(fellow.Mana.Current);
// todo: share loot with this fellow?
Writer.Write((uint)0x1); // TODO: shareLoot - if 0 then noSharePhatLoot, if 16(0x0010) then sharePhatLoot
Writer.WriteString16L(fellow.Name);
}
