public WorldObjectBase(int descriptorLength)
{
descriptors = new DescriptorData(descriptorLength);
// Use 'this' for mono compatibility.
this.ObjectData = new ObjectData();
}
public SelectCursorPathTool(AdventureData adventureData, int t)
: base(createResources(adventureData, t), createAssetInfoArray(t), Controller.ACTION_CUSTOM, 0)
{
this.adventureData = adventureData;
this.t = t;
this.type = DescriptorData.getCursorTypeString(t);
}
public static void WriteToBuffer(this DescriptorData d, string txt, int length)
{
if (d == null)
{
throw new ArgumentNullException(nameof(d));
}
if (string.IsNullOrEmpty(d.outbuf))
{
return;
}
var len = length;
if (len <= 0)
{
len = txt.Length;
}
if (d.outtop == 0 && !d.fcommand)
{
d.outbuf = "\r\n" + d.outbuf;
d.outtop = 2;
}
d.outtop += len;
d.outbuf = txt;
}
public static void ShowTitle(this DescriptorData d)
{
var ch = d.Character;
if (ch.PlayerData.Flags.IsSet(PCFlags.NoIntro))
{
d.WriteToBuffer("Press enter...", 0);
}
else
{
if (ch.Act.IsSet((int)PlayerFlags.Rip))
{
ch.SendRIPTitle();
}
else if (ch.Act.IsSet((int)PlayerFlags.Ansi))
{
ch.SendANSITitle();
}
else
{
ch.SendASCIITitle();
}
}
d.ConnectionStatus = ConnectionTypes.PressEnter;
}
protected static AssetInformation[] createAssetInfoArray(int t)
{
string type = DescriptorData.getCursorTypeString(t);
AssetInformation[] array = new AssetInformation[1];
array[0] = new AssetInformation("", type, true, AssetsConstants.CATEGORY_CURSOR, AssetsController.FILTER_NONE);
return(array);
}
private static void CheckStateIsNot(EntityStates state, DescriptorData descriptorData, string errorMessage, string argumentName)
{
if (descriptorData.State == state)
{
throw new TaupoInvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "{0} {1} is in {2} state.", errorMessage, argumentName, state));
}
}
private void ApplyResponseAndUpdateState(DescriptorData descriptor, KeyValuePair <IHttpRequest, HttpResponseData> pair)
{
this.ApplyResponseToDescriptor(descriptor, pair.Value);
if (!pair.Value.StatusCode.IsError())
{
this.UpdateDescriptorState(descriptor);
}
}
private static void ConnectUser(ITcpUser user)
{
var descrip = new DescriptorData(9999, 9999, 9999)
{
User = user
};
db.DESCRIPTORS.Add(descrip);
}
public static void SendTo(this DescriptorData d, string txt)
{
if (d == null || string.IsNullOrEmpty(txt))
{
return;
}
d.WriteToBuffer(color.colorize(txt, d), 0);
}
/// <summary>
/// Converts a string with color tokens into the desired output tokens
/// using the Character's desired preferences
/// </summary>
/// <param name="txt"></param>
/// <param name="d"></param>
/// <returns></returns>
public static string colorize(string txt, DescriptorData d)
{
if (string.IsNullOrEmpty(txt) || d == null)
{
return(string.Empty);
}
// TODO finish this
return(string.Empty);
}
public static void display_prompt(DescriptorData d)
{
var ch = d.Character;
var och = d.Original ?? d.Character;
var buffer = string.Empty;
var ansi = !och.IsNpc() && och.Act.IsSet((int)PlayerFlags.Ansi);
const string helpstart = "<Type HELP START>";
if (ch == null)
{
LogManager.Instance.Bug("Null ch");
return;
}
string prompt;
if (!ch.IsNpc() && !ch.PlayerData.Flags.IsSet(PCFlags.HelpStart))
{
prompt = helpstart;
}
else if (!ch.IsNpc() && ch.SubState != CharacterSubStates.None &&
!ch.PlayerData.SubPrompt.IsNullOrEmpty())
{
prompt = ch.PlayerData.SubPrompt;
}
else if (ch.IsNpc() || (ch.CurrentFighting == null && ch.PlayerData.Prompt.IsNullOrEmpty()))
{
prompt = default_prompt(ch);
}
else if (ch.CurrentFighting != null)
{
prompt = ch.PlayerData.FPrompt.IsNullOrEmpty()
? default_fprompt(ch)
: ch.PlayerData.FPrompt;
}
else
{
prompt = ch.PlayerData.Prompt;
}
if (ansi)
{
prompt = prompt.Insert(0, AnsiCodes.Reset.GetName());
d.prevcolor = Convert.ToChar(0x08);
}
// Clear out old color stuff
{
// TODO
}
ch.SendTo(buffer);
}
public CursorsWindow(Rect rect, GUIContent content, GUIStyle style, params GUILayoutOption[] options)
: base(rect, content, style)
{
Options = options;
ButtonContent = new GUIContent("Cursors");
cursors = new List <CursorInfo>();
foreach (var cursor in DescriptorData.getCursorTypes())
{
cursors.Add(new CursorInfo(cursor));
}
}
public ButtonsWindow(Rect rect, GUIContent content, GUIStyle style, params GUILayoutOption[] options)
: base(rect, content, style)
{
Options = options;
ButtonContent = new GUIContent("Buttons");
buttons = new List <ButtonInfo>();
foreach (var button in DescriptorData.getActionTypes())
{
buttons.Add(new ButtonInfo(button));
}
}
private void UpdateResponse(DataServiceResponseData responseData, DescriptorData descriptor, HttpResponseData response)
{
var operationResponse = new ChangeOperationResponseData(descriptor);
operationResponse.StatusCode = (int)response.StatusCode;
foreach (var header in response.Headers)
{
operationResponse.Headers.Add(header.Key, header.Value);
}
responseData.Add(operationResponse);
}
public virtual object Clone()
{
//TODO the keepShowing is now no included due to decide the final situation
DescriptorData dd = (DescriptorData)this.MemberwiseClone();
if (buttons != null)
{
dd.buttons = new List <CustomButton>();
foreach (CustomButton cb in buttons)
{
dd.buttons.Add((CustomButton)cb.Clone());
}
}
dd.commentaries = commentaries;
if (contents != null)
{
dd.contents = new List <ChapterSummary>();
foreach (ChapterSummary cs in contents)
{
dd.contents.Add((ChapterSummary)cs.Clone());
}
}
if (cursors != null)
{
dd.cursors = new List <CustomCursor>();
foreach (CustomCursor cc in cursors)
{
dd.cursors.Add((CustomCursor)cc.Clone());
}
}
if (arrows != null)
{
dd.arrows = new List <CustomArrow>();
foreach (CustomArrow ca in arrows)
{
dd.arrows.Add((CustomArrow)ca.Clone());
}
}
dd.description = (description != null ? description : null);
dd.graphicConfig = graphicConfig;
dd.guiCustomized = guiCustomized;
dd.guiType = guiType;
dd.playerMode = playerMode;
dd.playerName = (playerName != null ? playerName : null);
dd.title = (title != null ? title : null);
dd.inventoryPosition = inventoryPosition;
return(dd);
}
private void VerifyDescriptor(DescriptorData expected, Descriptor actual, int responseOrder)
{
EntityDescriptorData entityDescriptorData = expected as EntityDescriptorData;
LinkDescriptorData linkDescriptorData = expected as LinkDescriptorData;
StreamDescriptorData streamDescriptorData = expected as StreamDescriptorData;
if (entityDescriptorData != null)
{
EntityDescriptor entityDescriptor = actual as EntityDescriptor;
this.Assert.IsNotNull(entityDescriptor, GetVerificationFailureMessage(responseOrder, "Unexpected descriptor type:\r\nExpected: {0}\r\nActual: {1}\r\nExpected descriptor data: {2}.", typeof(EntityDescriptor).Name, actual.GetType().Name, entityDescriptorData));
this.Assert.AreSame(
entityDescriptorData.Entity,
entityDescriptor.Entity,
GetVerificationFailureMessage(responseOrder, "Entity verification failed for the entity descriptor data: {0}.", expected));
}
else if (linkDescriptorData != null)
{
LinkDescriptor linkDescriptor = actual as LinkDescriptor;
this.Assert.IsNotNull(linkDescriptor, GetVerificationFailureMessage(responseOrder, "Unexpected descriptor type:\r\nExpected: {0}\r\nActual: {1}\r\nExpected descriptor data: {2}.", typeof(LinkDescriptor).Name, actual.GetType().Name, linkDescriptorData));
bool notMatch = linkDescriptorData.SourceDescriptor.Entity != linkDescriptor.Source ||
(linkDescriptorData.TargetDescriptor == null && linkDescriptor.Target != null) ||
(linkDescriptorData.TargetDescriptor != null && linkDescriptorData.TargetDescriptor.Entity != linkDescriptor.Target) ||
linkDescriptorData.SourcePropertyName != linkDescriptor.SourceProperty;
this.Assert.IsFalse(notMatch, GetVerificationFailureMessage(responseOrder, "Link verification failed.\r\nExpected: {0}\r\nActual: {1}", linkDescriptorData, linkDescriptor.ToTraceString()));
}
else
{
#if WINDOWS_PHONE
throw new TaupoNotSupportedException("StreamDescriptors are not supported on Windows Phone");
#else
ExceptionUtilities.CheckObjectNotNull(streamDescriptorData, "Expected was not an entity, link, or stream descriptor: {0}", expected);
StreamDescriptor streamDescriptor = actual as StreamDescriptor;
this.Assert.IsNotNull(streamDescriptor, GetVerificationFailureMessage(responseOrder, "Unexpected descriptor type:\r\nExpected: {0}\r\nActual: {1}\r\nExpected descriptor data: {2}.", typeof(StreamDescriptor).Name, actual.GetType().Name, streamDescriptorData));
this.Assert.AreEqual(streamDescriptorData.State.ToProductEnum(), streamDescriptor.State, GetVerificationFailureMessage(responseOrder, "Stream descriptor state verification failed."));
this.Assert.AreEqual(streamDescriptorData.Name, streamDescriptor.StreamLink.Name, GetVerificationFailureMessage(responseOrder, "Stream descriptor name verification failed."));
this.Assert.AreEqual(streamDescriptorData.ETag, streamDescriptor.StreamLink.ETag, GetVerificationFailureMessage(responseOrder, "Stream descriptor etag verification failed."));
this.Assert.AreEqual(streamDescriptorData.ContentType, streamDescriptor.StreamLink.ContentType, GetVerificationFailureMessage(responseOrder, "Stream descriptor content type verification failed."));
this.Assert.AreEqual(streamDescriptorData.EditLink, streamDescriptor.StreamLink.EditLink, GetVerificationFailureMessage(responseOrder, "Stream descriptor edit link verification failed."));
this.Assert.AreEqual(streamDescriptorData.SelfLink, streamDescriptor.StreamLink.SelfLink, GetVerificationFailureMessage(responseOrder, "Stream descriptor self link verification failed."));
#endif
}
}
/**
* Loads the descriptor of the current ZIP adventure loaded
*
* @return The descriptor data of the game
*/
public static DescriptorData loadDescriptorData(InputStreamCreator isCreator, List <Incidence> incidences)
{
DescriptorData descriptorData = null;
if (Loader.adventureData != null)
{
descriptorData = Loader.adventureData;
}
else
{
try
{
// Set the adventure handler
DescriptorHandler descriptorParser = new DescriptorHandler(isCreator);
//factory.setValidating(false);
//SAXParser saxParser = factory.newSAXParser();
// Read and close the inputstrea
string descriptorIS = isCreator.buildInputStream("descriptor.xml");
//saxParser.parse(descriptorIS, descriptorParser);
//descriptorIS.close();
descriptorParser.Parse(descriptorIS);
// Store the adventure data
descriptorData = descriptorParser.getGameDescriptor();
}
catch (Exception e) { Debug.LogError(e); }
//catch (ParserConfigurationException e)
//{
// incidences.add(Incidence.createDescriptorIncidence(Language.GetText("Error.LoadDescriptor.SAX"), e));
//}
//catch (SAXException e)
//{
// incidences.add(Incidence.createDescriptorIncidence(Language.GetText("Error.LoadDescriptor.SAX"), e));
//}
//catch (IOException e)
//{
// incidences.add(Incidence.createDescriptorIncidence(Language.GetText("Error.LoadDescriptor.IO"), e));
//}
//catch (IllegalArgumentException e)
//{
// incidences.add(Incidence.createDescriptorIncidence(Language.GetText("Error.LoadDescriptor.NoDescriptor"), e));
//}
}
return(descriptorData);
}
public static void WriteToPager(this DescriptorData d, string txt, int length)
{
var len = length <= 0 ? txt.Length : length;
if (len == 0)
{
return;
}
if (string.IsNullOrEmpty(d.PageBuffer))
{
d.PageSize = Program.MAX_STRING_LENGTH;
d.PageBuffer = new string('\0', d.PageSize);
}
if (string.IsNullOrEmpty(d.PagePoint))
{
d.PagePoint = d.PageBuffer;
d.PageTop = 0;
d.PageCommand = "";
}
if (d.PageTop == 0 && !d.fcommand)
{
var bufferArray = d.PageBuffer.ToCharArray();
bufferArray[0] = '\r';
bufferArray[1] = '\n';
d.PageTop = 2;
d.PageBuffer = bufferArray.ToString();
}
//int pagerOffset = d.PagePoint - d.PageBuffer;
while (d.PageTop + len >= d.PageSize)
{
if (d.PageSize > Program.MAX_STRING_LENGTH * 16)
{
LogManager.Instance.Bug("Pager overflow. Ignoring.\r\n");
d.PageTop = 0;
d.PagePoint = string.Empty;
d.PageBuffer = string.Empty;
d.PageSize = Program.MAX_STRING_LENGTH;
return;
}
d.PageSize *= 2;
// recreate?
}
// TODO finish this
}
private ChangeData CreateChangeData(DescriptorData descriptorData, IDictionary <object, IEnumerable <NamedValue> > propertyValuesBeforeSave)
{
var entityDescriptorData = descriptorData as EntityDescriptorData;
if (entityDescriptorData != null)
{
IEnumerable <NamedValue> propertyValues;
ExceptionUtilities.Assert(propertyValuesBeforeSave.TryGetValue(entityDescriptorData.Entity, out propertyValues), "Could not find property values for descriptor: {0}", entityDescriptorData);
return(EntityChangeData.Create(entityDescriptorData, propertyValues));
}
var linkDescriptorData = descriptorData as LinkDescriptorData;
ExceptionUtilities.CheckObjectNotNull(linkDescriptorData, "Descriptor was neither an entity nor a link");
return(LinkChangeData.Create(linkDescriptorData));
}
private static void SetContentIDHeader(DescriptorData descriptor, ExpectedClientRequest expectedRequest, bool isBatch)
{
if (isBatch)
{
expectedRequest.Headers[HttpHeaders.ContentId] = descriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture);
var entityDescriptorData = descriptor as EntityDescriptorData;
if (entityDescriptorData != null && entityDescriptorData.Identity == null)
{
entityDescriptorData.Identity = new Uri("$" + descriptor.ChangeOrder, UriKind.Relative);
entityDescriptorData.EditLink = entityDescriptorData.Identity;
}
}
else
{
expectedRequest.Headers[HttpHeaders.ContentId] = null;
}
}
public void deleteCursor(int type)
{
string typeS = DescriptorData.getCursorTypeString(type);
int position = -1;
for (int i = 0; i < adventureData.getCursors().Count; i++)
{
if (adventureData.getCursors()[i].getType().Equals(typeS))
{
position = i;
break;
}
}
if (position >= 0)
{
Controller.getInstance().addTool(new DeleteCursorTool(adventureData, position));
}
}
private void ApplyResponseToDescriptor(DescriptorData descriptor, HttpResponseData response)
{
var entityDescriptor = descriptor as EntityDescriptorData;
var streamDescriptor = descriptor as StreamDescriptorData;
if (entityDescriptor != null)
{
if (entityDescriptor.IsMediaLinkEntry && entityDescriptor.DefaultStreamState == EntityStates.Modified)
{
// in this case (and only this case), the response headers apply to the stream itself
entityDescriptor.DefaultStreamDescriptor.UpdateFromHeaders(response.Headers);
}
else
{
entityDescriptor.UpdateFromHeaders(response.Headers);
}
if (response.StatusCode != HttpStatusCode.NoContent)
{
var entityInstance = response.DeserializeAndCast <EntityInstance>(this.parent.FormatSelector);
entityDescriptor.UpdateFromPayload(entityInstance, this.contextData.BaseUri);
}
if (entityDescriptor.IsMediaLinkEntry && entityDescriptor.DefaultStreamState != EntityStates.Unchanged)
{
this.VerifyStreamClosed(entityDescriptor.DefaultStreamDescriptor);
}
}
else
{
if (streamDescriptor != null)
{
streamDescriptor.UpdateFromHeaders(response.Headers);
this.VerifyStreamClosed(streamDescriptor);
}
else
{
ExceptionUtilities.Assert(descriptor is LinkDescriptorData, "Descriptor is of unexpected type '{0}'", descriptor.GetType());
}
}
}
protected static ResourcesUni createResources(AdventureData adventureData, int t)
{
string type = DescriptorData.getCursorTypeString(t);
ResourcesUni resources = new ResourcesUni();
bool introduced = false;
for (int i = 0; i < adventureData.getCursors().Count; i++)
{
if (adventureData.getCursors()[i].getType().Equals(type) && adventureData.getCursors()[i].getPath() != null)
{
resources.addAsset(type, adventureData.getCursors()[i].getPath());
introduced = true;
break;
}
}
if (!introduced)
{
resources.addAsset(type, null);
}
return(resources);
}
public string getCursorPath(int type)
{
return(getCursorPath(DescriptorData.getCursorTypeString(type)));
}
public bool isCursorTypeAllowed(string type)
{
return(isCursorTypeAllowed(DescriptorData.getCursorTypeIndex(type)));
}
/// <summary>
/// Test an archive for integrity/validity
/// </summary>
/// <param name="testData">Perform low level data Crc check</param>
/// <param name="strategy">The <see cref="TestStrategy"></see> to apply.</param>
/// <param name="resultHandler">The <see cref="ZipTestResultHandler"></see> handler to call during testing.</param>
/// <returns>true if all tests pass, false otherwise</returns>
/// <exception cref="ObjectDisposedException">The object has already been closed.</exception>
public bool TestArchive(bool testData, TestStrategy strategy, ZipTestResultHandler resultHandler)
{
if (isDisposed_) {
throw new ObjectDisposedException("ZipFile");
}
TestStatus status = new TestStatus(this);
if ( resultHandler != null ) {
resultHandler(status, null);
}
HeaderTest test = testData ? (HeaderTest.Header | HeaderTest.Extract) : HeaderTest.Header;
bool testing = true;
try {
int entryIndex = 0;
while ( testing && (entryIndex < Count) ) {
if ( resultHandler != null ) {
status.SetEntry(this[entryIndex]);
status.SetOperation(TestOperation.EntryHeader);
resultHandler(status, null);
}
try {
TestLocalHeader(this[entryIndex], test);
}
catch(ZipException ex) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status,
string.Format("Exception during test - '{0}'", ex.Message));
}
if ( strategy == TestStrategy.FindFirstError ) {
testing = false;
}
}
if ( testing && testData && this[entryIndex].IsFile ) {
if ( resultHandler != null ) {
status.SetOperation(TestOperation.EntryData);
resultHandler(status, null);
}
Crc32 crc = new Crc32();
using (Stream entryStream = this.GetInputStream(this[entryIndex]))
{
byte[] buffer = new byte[4096];
long totalBytes = 0;
int bytesRead;
while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0)
{
crc.Update(buffer, 0, bytesRead);
if (resultHandler != null)
{
totalBytes += bytesRead;
status.SetBytesTested(totalBytes);
resultHandler(status, null);
}
}
}
if (this[entryIndex].Crc != crc.Value) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status, "CRC mismatch");
}
if ( strategy == TestStrategy.FindFirstError ) {
testing = false;
}
}
if (( this[entryIndex].Flags & (int)GeneralBitFlags.Descriptor) != 0 ) {
ZipHelperStream helper = new ZipHelperStream(baseStream_);
DescriptorData data = new DescriptorData();
helper.ReadDataDescriptor(this[entryIndex].LocalHeaderRequiresZip64, data);
if (this[entryIndex].Crc != data.Crc) {
status.AddError();
}
if (this[entryIndex].CompressedSize != data.CompressedSize) {
status.AddError();
}
if (this[entryIndex].Size != data.Size) {
status.AddError();
}
}
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.EntryComplete);
resultHandler(status, null);
}
entryIndex += 1;
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.MiscellaneousTests);
resultHandler(status, null);
}
// TODO: the 'Corrina Johns' test where local headers are missing from
// the central directory. They are therefore invisible to many archivers.
}
catch (Exception ex) {
status.AddError();
if ( resultHandler != null ) {
resultHandler(status, string.Format("Exception during test - '{0}'", ex.Message));
}
}
if ( resultHandler != null ) {
status.SetOperation(TestOperation.Complete);
status.SetEntry(null);
resultHandler(status, null);
}
return (status.ErrorCount == 0);
}
/**
* Constructor
*/
public DescriptorHandler(InputStreamCreator isCreator)
{
currentstring = string.Empty;
gameDescriptor = new DescriptorData();
this.isCreator = isCreator;
}
public static int colorcode(string src, string dst, DescriptorData d, int dstlen, int vislen)
{
// TODO
return(0);
}
/// <summary>
/// Calculates expected data for a request during DataServiceContext.SaveChanges for a particular descriptor.
/// </summary>
/// <param name="contextData">The context data</param>
/// <param name="propertyValuesBeforeSave">The property values of the tracked client objects before the call to SaveChanges</param>
/// <param name="descriptorData">The descriptor data</param>
/// <param name="options">The save changes options</param>
/// <returns>The expected client request</returns>
public ExpectedClientRequest CalculateRequest(DataServiceContextData contextData, IDictionary <object, IEnumerable <NamedValue> > propertyValuesBeforeSave, DescriptorData descriptorData, SaveChangesOptions options)
{
ExceptionUtilities.CheckArgumentNotNull(contextData, "contextData");
ExceptionUtilities.CheckArgumentNotNull(descriptorData, "descriptorData");
ExceptionUtilities.CheckArgumentNotNull(propertyValuesBeforeSave, "propertyValuesBeforeSave");
var linkDescriptorData = descriptorData as LinkDescriptorData;
var entityDescriptorData = descriptorData as EntityDescriptorData;
var streamDescriptorData = descriptorData as StreamDescriptorData;
ExpectedClientRequest request = null;
if (linkDescriptorData != null)
{
if (linkDescriptorData.WillTriggerSeparateRequest())
{
request = this.CreateLinkRequest(linkDescriptorData, options);
}
}
else if (entityDescriptorData != null)
{
if (entityDescriptorData.State == EntityStates.Added)
{
request = this.CreateEntityInsertRequest(contextData, propertyValuesBeforeSave, entityDescriptorData, options);
}
else if (entityDescriptorData.State == EntityStates.Modified)
{
request = this.CreateEntityUpdateRequest(contextData, propertyValuesBeforeSave, entityDescriptorData, options);
}
else if (entityDescriptorData.State == EntityStates.Deleted)
{
request = this.CreateEntityDeleteRequest(entityDescriptorData, options);
}
}
else if (streamDescriptorData != null)
{
if (streamDescriptorData.State == EntityStates.Added)
{
request = this.CreateStreamInsertRequest(contextData, streamDescriptorData, options);
}
else if (streamDescriptorData.State == EntityStates.Modified)
{
request = this.CreateStreamUpdateRequest(streamDescriptorData, options);
}
}
if (request != null)
{
request.Headers[HttpHeaders.MaxDataServiceVersion] = ToClientHeaderFormat(contextData.MaxProtocolVersion);
// perform sanity checks
var missingHeaders = headersThatWillBeGenerated.Where(h => !request.Headers.ContainsKey(h)).ToArray();
ExceptionUtilities.Assert(missingHeaders.Length == 0, "Generated request was missing headers: {0}", string.Join(", ", missingHeaders));
ExceptionUtilities.CheckObjectNotNull(request.Uri, "Generated request was missing a Uri");
// sanity check: Client sends content-type header for delete request
if (request.GetEffectiveVerb() == HttpVerb.Delete)
{
ExceptionUtilities.Assert(
request.Headers[HttpHeaders.ContentType] == null,
"Incorrect expectation: client should never send ContentType header for DELETE requests.");
}
}
return(request);
}
/**
* Constructor
*/
public DescriptorHandler(InputStreamCreator isCreator)
{
currentstring = string.Empty;
gameDescriptor = new DescriptorData();
this.isCreator = isCreator;
}
public static bool pager_output(DescriptorData d)
{
// TODO
return(false);
}
public static void set_pager_input(DescriptorData d, string argument)
{
d.PageCommand = argument.Trim();
}
