private static IReadOnlyList <byte> ConvertHexToBinary(IReadOnlyList <byte> bytes)
{
var result = new List <byte>(bytes.Count / 2);
var last = '\0';
var offset = 0;
for (var i = 0; i < bytes.Count; i++)
{
var c = (char)bytes[i];
if (!ReadHelper.IsHex(c))
{
// TODO: do I need to assert this must be whitespace?
continue;
}
if (offset == 1)
{
result.Add(HexToken.Convert(last, c));
offset = 0;
}
else
{
offset++;
}
last = c;
}
return(result);
}
private bool checkObjectKeys(IRandomAccessRead source, CosObjectKey objectKey, long offset)
{
// there can't be any object at the very beginning of a pdf
if (offset < MINIMUM_SEARCH_OFFSET)
{
return(false);
}
long objectNr = objectKey.Number;
long objectGen = objectKey.Generation;
long originOffset = source.GetPosition();
string objectString = ObjectHelper.createObjectString(objectNr, objectGen);
try
{
source.Seek(offset);
if (ReadHelper.IsString(source, OtherEncodings.StringAsLatin1Bytes(objectString)))
{
// everything is ok, return origin object key
source.Seek(originOffset);
return(true);
}
}
catch (InvalidOperationException exception)
{
// Swallow the exception, obviously there isn't any valid object number
}
finally
{
source.Seek(originOffset);
}
// no valid object number found
return(false);
}
public KeyValuePair <string, int>[] ReadWordsWithFrequencyTest(string[] lines)
{
var input = new StringReader(String.Join(Environment.NewLine, lines));
Console.SetIn(input);
return(ReadHelper.ReadWordsWithFrequency().ToArray());
}
public long CheckXRefOffset(long startXRefOffset, bool isLenientParsing)
{
// repair mode isn't available in non-lenient mode
if (!isLenientParsing)
{
return(startXRefOffset);
}
source.Seek(startXRefOffset);
ReadHelper.SkipSpaces(source);
if (source.Peek() == 'x' && ReadHelper.IsString(source, "xref"))
{
return(startXRefOffset);
}
if (startXRefOffset > 0)
{
if (CheckXRefStreamOffset(source, startXRefOffset, true, pool))
{
return(startXRefOffset);
}
return(CalculateXRefFixedOffset(startXRefOffset));
}
// can't find a valid offset
return(-1);
}
private CosBase ReadNormalObjectStream(IRandomAccessRead reader, CosBase currentBase, long offset,
bool isLenientParsing,
out string endObjectKey)
{
if (currentBase is PdfDictionary dictionary)
{
PdfRawStream stream = streamParser.Parse(reader, dictionary, isLenientParsing, null);
currentBase = stream;
}
else
{
// this is not legal
// the combination of a dict and the stream/endstream
// forms a complete stream object
throw new InvalidOperationException($"Stream not preceded by dictionary (offset: {offset}).");
}
ReadHelper.SkipSpaces(reader);
endObjectKey = ReadHelper.ReadLine(reader);
// we have case with a second 'endstream' before endobj
if (!endObjectKey.StartsWith("endobj") && endObjectKey.StartsWith("endstream"))
{
endObjectKey = endObjectKey.Substring(9).Trim();
if (endObjectKey.Length == 0)
{
// no other characters in extra endstream line
// read next line
endObjectKey = ReadHelper.ReadLine(reader);
}
}
return(currentBase);
}
private void BfSearchForXRefTables()
{
if (bfSearchXRefTablesOffsets == null)
{
// a pdf may contain more than one xref entry
bfSearchXRefTablesOffsets = new List <long>();
long originOffset = source.GetPosition();
source.Seek(MinimumSearchOffset);
// search for xref tables
while (!source.IsEof())
{
if (ReadHelper.IsString(source, "xref"))
{
long newOffset = source.GetPosition();
source.Seek(newOffset - 1);
// ensure that we don't read "startxref" instead of "xref"
if (ReadHelper.IsWhitespace(source))
{
bfSearchXRefTablesOffsets.Add(newOffset);
}
source.Seek(newOffset + 4);
}
source.Read();
}
source.Seek(originOffset);
}
}
private static async Task MainAsync(string[] args, TestData testData)
{
var configHelper = new ConfigureHelper();
var cfg = await configHelper.CreateAndConfigureClient();
// Initialize a client using the validate configuration
using (var client = new XConnectClient(cfg))
{
try
{
var FilterByTime = new Tutorial4();
await FilterByTime.ExecuteAsync(client);
var createHelper = new CreateHelper();
Contact newKnownContact = createHelper.CreateNewContact(testData.NewContact);
var updateHelper = new UpdateHelper();
updateHelper.PopulatePersonalInformationFacet(client, newKnownContact);
client.AddContact(newKnownContact);
updateHelper.RecordInteractionFacet(client, newKnownContact);
// Submit contact and interaction - a total of two operations (three)
await client.SubmitAsync();
var reportingHelper = new ReportingHelpers();
reportingHelper.DisplayResults(client);
var readHelper = new ReadHelper();
Contact existingContact = await readHelper.RetrieveExistingContactAsync(client);
if (existingContact != null)
{
reportingHelper.DisplayExistingContactData(existingContact);
var existingContactFacetData = readHelper.RetrieveExistingContactFacetData(client, existingContact);
reportingHelper.DisplayExistingContactFacetData(existingContactFacetData);
reportingHelper.ReportInteractionsForExistingContact(existingContact, client);
}
else
{
Console.WriteLine("ExistingContact is null");
}
ReportingHelpers.EnterToProceed();
}
catch (XdbExecutionException ex)
{
// deal with exception
}
}
}
static int[] EnterNumbers(IReader reader, IWriter writer)
{
writer.WriteLine("Enter 2 numbers: ");
var input = ReadHelper.GetInputRow(reader);
return(ReadHelper.SplitInput(input, 2, " ").Select(e => ReadHelper.ParseIntSave(e, "Number")).ToArray());
}
public string[] ReadUserWordsTest(string[] lines)
{
var input = new StringReader(String.Join(Environment.NewLine, lines));
Console.SetIn(input);
return(ReadHelper.ReadUserWords().ToArray());
}
private void SetStudentsCount()
{
_writer.WriteLine("Enter students count: ");
var input = ReadHelper.GetInputRow(_reader);
_students = new Student[ReadHelper.ParseIntSave(input, "Students Count")];
}
/// <summary>
/// Attempts to read the <see cref="TableSubsectionDefinition"/> from the current line of the source.
/// </summary>
public static bool TryRead(ILog log, IRandomAccessRead source, out TableSubsectionDefinition definition)
{
definition = default(TableSubsectionDefinition);
var line = ReadHelper.ReadLine(source);
var parts = line.Split(Splitters, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
return(false);
}
try
{
var firstObjectId = long.Parse(parts[0]);
var objectCount = int.Parse(parts[1]);
definition = new TableSubsectionDefinition(firstObjectId, objectCount);
return(true);
}
catch (Exception ex)
{
log.Error(
$"The format for the subsection definition was invalid, expected [long] [int], instead got '{line}'", ex);
return(false);
}
}
private void BruteForceSearchForTables(IInputBytes bytes)
{
if (bfSearchXRefTablesOffsets != null)
{
return;
}
// a pdf may contain more than one xref entry
bfSearchXRefTablesOffsets = new List <long>();
var startOffset = bytes.CurrentOffset;
bytes.Seek(MinimumSearchOffset);
// search for xref tables
while (bytes.MoveNext() && !bytes.IsAtEnd())
{
if (ReadHelper.IsString(bytes, "xref"))
{
var newOffset = bytes.CurrentOffset;
bytes.Seek(newOffset - 1);
// ensure that we don't read "startxref" instead of "xref"
if (ReadHelper.IsWhitespace(bytes.CurrentByte))
{
bfSearchXRefTablesOffsets.Add(newOffset);
}
bytes.Seek(newOffset + 4);
}
}
bytes.Seek(startOffset);
}
private static OperationType EnterOperation(IReader reader, IWriter writer)
{
writer.WriteLine("Enter operation: ");
var input = ReadHelper.GetInputRow(reader);
OperationType operation;
switch (input)
{
case "+":
operation = OperationType.Add;
break;
case "-":
operation = OperationType.Subtract;
break;
case "*":
operation = OperationType.Multiplay;
break;
default:
throw new ArgumentException();
}
return(operation);
}
/// <inheritdoc />
public bool TryTokenize(byte currentByte, IInputBytes inputBytes, out IToken token)
{
token = null;
if (currentByte != '/')
{
return(false);
}
var builder = new StringBuilder();
while (inputBytes.MoveNext())
{
if (ReadHelper.IsWhitespace(inputBytes.CurrentByte) ||
inputBytes.CurrentByte == '{' ||
inputBytes.CurrentByte == '<' ||
inputBytes.CurrentByte == '/' ||
inputBytes.CurrentByte == '[' ||
inputBytes.CurrentByte == '(')
{
break;
}
builder.Append((char)inputBytes.CurrentByte);
}
token = NameToken.Create(builder.ToString());
return(true);
}
public TagInfo()
{
Name = new string(TRB._f.ReadChars(4));
Offset = TRB._f.ReadUInt32();
Flag = TRB._f.ReadUInt32();
FullName = ReadHelper.ReadStringFromOffset(TRB.sections[0].SectionOffset + TRB._f.ReadUInt32());
}
private void ProviderLoop()
{
WriteHelper.PrintAvaibleCommands();
var choosenCommand = ReadHelper.GetCommandFromUser();
CommandManager <IGameCommand> .GetInstance(System.Reflection.Assembly.GetExecutingAssembly()).Execute(choosenCommand);
}
private void SetCourcesCount()
{
_writer.WriteLine("Enter course count:");
var input = ReadHelper.GetInputRow(_reader);
_cources = new Course[ReadHelper.ParseIntSave(input, "Course count")];
}
public int Insert_Soa_Trans(List <FileInfo> logFiles, ServiceHelper sh)
{
string query = string.Empty;
int total = 0;
List <string> soatransactionId = new List <string>();
foreach (FileInfo file in logFiles)
{
string id = ReadHelper.GetTransactionId_StreamReader(file);
DateTime modifiedDate = file.LastWriteTime;
if (id != null || id != string.Empty)
{
OracleParameter[] parameters = new OracleParameter[]
{
new OracleParameter("SERVICE_NAME", sh.ServiceName),
new OracleParameter("TRANSID", id),
new OracleParameter("TRANSTIME", modifiedDate)
};
query = string.Format("INSERT into SOA_TRANSACTION (ID, SERVICE, TRANSACTION_ID, TRANSACTION_TIME)" +
"(SELECT SQ_SOA_TRANSACTION.NEXTVAL ID, " +
":SERVICE_NAME SERVICE, " +
":TRANSID TRANSACTION_ID, " +
":TRANSTIME TRANSACTION_TIME " +
"FROM DUAL)");
ExecNonQuery(query, parameters);
PrintHelper.Trace(string.Format(Messages.TransactionId_SUCCESS, id));
total++;
}
}
return(total);
}
public async Task <JsonResult> GetLogMessage()
{
var data = ReadHelper.Read();
await _hubContext.Clients.All.SendAsync("ReceiveLog", data);
return(new JsonResult(0));
}
public void IsEndOfLine_LineFeed()
{
const char c = '\n';
var result = ReadHelper.IsEndOfLine(c);
Assert.True(result);
}
private Complex ReadComplexNumber()
{
var input = ReadHelper.GetInputRow(_reader);
var parts = ReadHelper.SplitInput(input, 2, _inputDelimiter);
return(new Complex(ReadHelper.ParseIntSave(parts[0], "Complex number real part"),
ReadHelper.ParseIntSave(parts[1], "Complex number imaginary part")));
}
public MatLibInfo(BinaryReader sectFile)
{
fileOffset = sectFile.ReadUInt32();
unk1 = sectFile.ReadUInt32();
unk2 = sectFile.ReadUInt32();
file = ReadHelper.ReadStringFromOffset(sectFile, fileOffset);
}
public void IsEndOfLine_CarriageReturn()
{
const char c = '\r';
var result = ReadHelper.IsEndOfLine(c);
Assert.True(result);
}
public IReadOnlyList <CosObject> Parse(PdfRawStream stream, CosObjectPool pool)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
//need to first parse the header.
var numberOfObjects = stream.Dictionary.GetIntOrDefault(CosName.N);
var objectNumbers = new List <long>(numberOfObjects);
var streamObjects = new List <CosObject>(numberOfObjects);
var bytes = stream.Decode(filterProvider);
var reader = new RandomAccessBuffer(bytes);
for (int i = 0; i < numberOfObjects; i++)
{
long objectNumber = ObjectHelper.ReadObjectNumber(reader);
// skip offset
ReadHelper.ReadLong(reader);
objectNumbers.Add(objectNumber);
}
CosObject obj;
CosBase cosObject;
int objectCounter = 0;
while ((cosObject = baseParser.Parse(reader, pool)) != null)
{
obj = new CosObject(cosObject);
obj.SetGenerationNumber(0);
if (objectCounter >= objectNumbers.Count)
{
log.Error("/ObjStm (object stream) has more objects than /N " + numberOfObjects);
break;
}
obj.SetObjectNumber(objectNumbers[objectCounter]);
streamObjects.Add(obj);
// According to the spec objects within an object stream shall not be enclosed
// by obj/endobj tags, but there are some pdfs in the wild using those tags
// skip endobject marker if present
if (!reader.IsEof() && reader.Peek() == 'e')
{
ReadHelper.ReadLine(reader);
}
objectCounter++;
}
return(streamObjects);
}
public TextureInfo(uint offset)
{
Flag = Trb.SectFile.ReadUInt32();
FileNameOffset = offset + Trb.SectFile.ReadUInt32();
FileName = ReadHelper.ReadStringFromOffset(Trb.SectFile, FileNameOffset);
DdsSize = Trb.SectFile.ReadUInt32();
DdsOffset = offset + Trb.SectFile.ReadUInt32();
RawImage = ReadHelper.ReadFromOffset(Trb.SectFile, DdsSize, DdsOffset);
Dds = new DDSImage(RawImage);
}
public bool TryTokenize(byte currentByte, IInputBytes inputBytes, out IToken token)
{
token = null;
if (ReadHelper.IsWhitespace(currentByte))
{
return(false);
}
var builder = stringBuilder;
builder.Append((char)currentByte);
while (inputBytes.MoveNext())
{
if (ReadHelper.IsWhitespace(inputBytes.CurrentByte))
{
break;
}
if (inputBytes.CurrentByte == '<' || inputBytes.CurrentByte == '[' ||
inputBytes.CurrentByte == '/' || inputBytes.CurrentByte == ']' ||
inputBytes.CurrentByte == '>' || inputBytes.CurrentByte == '(' ||
inputBytes.CurrentByte == ')')
{
break;
}
builder.Append((char)inputBytes.CurrentByte);
}
var text = builder.ToString();
builder.Clear();
switch (text)
{
case "true":
token = BooleanToken.True;
break;
case "false":
token = BooleanToken.False;
break;
case "null":
token = NullToken.Instance;
break;
default:
token = OperatorToken.Create(text);
break;
}
return(true);
}
public static List <BaseMenu> GetMenuList()
{
string json = ReadHelper.Read(Application.StartupPath + "\\menu.json");
if (string.IsNullOrEmpty(json))
{
throw new ArgumentNullException("菜单json字符串为空！");
}
return(JsonHelper.Json2List <BaseMenu>(json));
}
public Tag()
{
Name = new string(TRB._f.ReadChars(4));
Zero = TRB._f.ReadUInt32();
RelocationDataCount = TRB._f.ReadUInt16();
Size = TRB._f.ReadUInt16();
Zero2 = TRB._f.ReadUInt32();
FullName = ReadHelper.ReadStringFromOffset(TRB._f.ReadUInt32() + TRB.sections[0].SectionOffset);
Hash = TRB._f.ReadUInt32();
Zero3 = TRB._f.ReadUInt32();
Zero4 = TRB._f.ReadUInt32();
}
private Command ReadCommand()
{
var input = ReadHelper.GetInputRow(_reader);
var command = _commands.FirstOrDefault(c => c.Name.Equals(input, StringComparison.CurrentCultureIgnoreCase));
if (command == null)
{
throw new ArgumentException("Input must be valid command!");
}
return(command);
}
private void BruteForceSearchForEndOfFileMarker(IInputBytes source)
{
if (lastEndOfFileMarker != null)
{
return;
}
long startOffset = source.CurrentOffset;
source.Seek(MINIMUM_SEARCH_OFFSET);
while (!source.IsAtEnd())
{
// search for EOF marker
if (ReadHelper.IsString(source, "%%EOF"))
{
long tempMarker = source.CurrentOffset;
if (tempMarker >= source.Length)
{
lastEndOfFileMarker = tempMarker;
break;
}
try
{
source.Seek(tempMarker + 5);
// check if the following data is some valid pdf content
// which most likely indicates that the pdf is linearized,
// updated or just cut off somewhere in the middle
ReadHelper.SkipSpaces(source);
ObjectHelper.ReadObjectNumber(source);
ObjectHelper.ReadGenerationNumber(source);
}
catch (Exception)
{
// save the EOF marker as the following data is most likely some garbage
lastEndOfFileMarker = tempMarker;
}
}
source.MoveNext();
}
source.Seek(startOffset);
// no EOF marker found
if (lastEndOfFileMarker == null)
{
lastEndOfFileMarker = long.MaxValue;
}
}
